TypeScript types

import type {
  SendResult,
  InboxItem,
  DeliveryRecord,
  RecipientPreference,
  EmailProvider,
  SkipReason,
} from "@notifykitjs/core"

import type { InferPayload, InferNotificationId } from "@notifykitjs/core"
import type { notify } from "@/lib/notifykit"

type NotificationId = InferNotificationId<typeof notify>
// → "comment_mentioned" | "order_shipped" | "team_invite"

type CommentPayload = InferPayload<typeof notify, "comment_mentioned">
// → { actorName: string; postTitle: string; postUrl: string }

function trackNotificationSent(id: NotificationId, payload: Record<string, unknown>) {
  analytics.track("notification_sent", { notificationId: id, ...payload })
}

import type { InferSendInput } from "@notifykitjs/core"
import type { notify } from "@/lib/notifykit"

type SendJob = InferSendInput<typeof notify>

async function enqueueSend(job: SendJob) {
  await queue.add("notification:send", job)
}

async function processSend(job: SendJob) {
  await notify.send(job)
}

type NotificationDefinition<Id extends string, S extends PayloadSchema> = {
  // Required
  id: Id
  payload: S
  channels: ChannelConfig[]

  // Delivery control
  digest?: DigestConfig<S>
  rateLimit?: RateLimitConfig
  fallback?: InboxChannelConfig | FallbackRule[]
  required?: boolean
  defaultChannels?: ChannelPreferenceMap

  // Metadata
  description?: string
  category?: string
  classification?: "transactional" | "product" | "marketing"
  version?: number

  // Security & validation
  redact?: readonly string[]
  validate?: (payload: unknown) => Record<string, unknown>
}

type InboxChannelConfig = {
  type: "inbox"
  title: string
  body?: string
  actionUrl?: string
}

type EmailChannelConfig = {
  type: "email"
  subject: string
  body: string
  html?: boolean
}

type SmsChannelConfig = {
  type: "sms"
  body: string
}

type WebhookChannelConfig = {
  type: "webhook"
  url: string
  headers?: Record<string, string>
}

type ChannelConfig = InboxChannelConfig | EmailChannelConfig | SmsChannelConfig | WebhookChannelConfig
type ChannelType = "inbox" | "email" | "sms" | "webhook"

type Recipient = {
  id: string
  tenantId?: string
  workspaceId?: string
  email?: string
  phone?: string
  name?: string
  quietHours?: QuietHours | null
  createdAt: Date
  updatedAt: Date
}

type QuietHours = {
  start: string    // "HH:MM" 24h format
  end: string      // "HH:MM" 24h format
  timezone?: string // IANA timezone, defaults to "UTC"
}

type InboxItem = {
  id: string
  notificationRecordId: string
  recipientId: string
  tenantId?: string
  workspaceId?: string
  notificationId: string
  title: string
  body?: string
  actionUrl?: string
  readAt?: Date | null
  archivedAt?: Date | null
  createdAt: Date
}

type DeliveryRecord = {
  id: string
  notificationRecordId: string
  recipientId: string
  tenantId?: string
  workspaceId?: string
  notificationId: string
  channel: "email" | "webhook" | "sms" | "inbox"
  provider: string
  status: "pending" | "sent" | "failed" | "skipped"
  to?: string
  subject?: string
  body?: string
  providerMessageId?: string
  error?: string
  skipReason?: SkipReason
  skipDetails?: string
  attempts: number
  createdAt: Date
  updatedAt: Date
  sentAt?: Date | null
  failedAt?: Date | null
}

type RecipientPreference = {
  recipientId: string
  tenantId?: string
  workspaceId?: string
  notificationId: string
  channels: ChannelPreferenceMap
  updatedAt: Date
}

type ChannelPreferenceMap = Partial<Record<ChannelType, boolean>>

type EmailProvider = {
  id: string
  send(input: { to: string; subject: string; body: string }): Promise<{ providerMessageId?: string }>
}

type SmsProvider = {
  id: string
  send(input: { to: string; body: string }): Promise<{ providerMessageId?: string }>
}

type WebhookProvider = {
  id: string
  signed?: boolean
  send(input: {
    url: string
    headers: Record<string, string>
    payload: {
      notificationId: string
      recipientId: string
      tenantId?: string
      workspaceId?: string
      payload: Record<string, unknown>
      sentAt: string
    }
  }): Promise<{ providerMessageId?: string }>
}

type Queue = {
  enqueue(job: DeliveryJob, run: (job: DeliveryJob) => Promise<void>): void | Promise<void>
  drain(): Promise<void>
}

type RetryPolicy = {
  maxAttempts: number
  delayMs(attempt: number): number
}

type SecurityScope = {
  tenantId?: string
  organizationId?: string  // alias for tenantId
  workspaceId?: string
}

import type { SendResult, SkipReason } from "@notifykitjs/core"

async function sendAndLog(result: SendResult) {
  const delivered = result.deliveries.length > 0 || result.inboxItems.length > 0

  if (result.rateLimited) return "dropped_by_rate_limit"
  if (result.digested) return "buffered_in_digest"
  if (result.idempotent) return "duplicate_replay"

  const skippedEmail = result.skipped.find(s => s.channel === "email")
  if (skippedEmail) {
    switch (skippedEmail.reason) {
      case "preferences_disabled":
        break
      case "missing_address":
        await promptUserForEmail(result.notification?.recipientId)
        break
      case "missing_provider":
        logger.warn("No email provider configured")
        break
    }
  }

  const channels = result.deliveries.map(d => d.channel)
  analytics.track("notification_sent", {
    id: result.notification?.notificationId,
    channels,
    skipped: result.skipped.map(s => `${s.channel}:${s.reason}`),
  })

  return delivered ? "delivered" : "suppressed"
}

type DatabaseAdapter = {
  recipients: {
    upsert(input: UpsertRecipientInput): Promise<Recipient>
    findById(id: string): Promise<Recipient | null>
  }
  notifications: {
    create(input: NewNotificationRecord): Promise<NotificationRecord>
    findByIdempotencyKey(key: string): Promise<NotificationRecord | null>
    clearIdempotencyKey(id: string): Promise<void>
  }
  inbox: {
    create(input: NewInboxItem): Promise<InboxItem>
    listByRecipient(recipientId: string, scope?, filter?, limit?): Promise<InboxItem[]>
    markReadForRecipient(id: string, recipientId: string, scope?): Promise<MarkReadResult>
    unreadCount(recipientId: string, scope?): Promise<number>
    markAllRead(recipientId: string, scope?): Promise<number>
    archiveForRecipient(id: string, recipientId: string, scope?): Promise<InboxItemResult>
    unarchiveForRecipient(id: string, recipientId: string, scope?): Promise<InboxItemResult>
    deleteForRecipient(id: string, recipientId: string, scope?): Promise<DeleteResult>
    // plus listByNotificationRecordId(...)
  }
  deliveries: { /* create, findById, list, update, listByNotificationRecordId */ }
  preferences: { /* get, list, upsert */ }
  digests: { /* append, take, restore, list */ }
  rateLimits: { /* reserve, count */ }
  scheduledSends: { /* create, claim, complete, release, listDue, list */ }
  dedupe: { /* check, exists, prune */ }
  timeline?: { /* append, listByNotificationRecordId, listByDeliveryId, prune */ }
}

// ❌ Error: string ≠ literal union
const id = getNotificationFromConfig()
await notify.send({ recipientId: "u1", notificationId: id, payload: {} })

// ✅ Fix 1: type assertion (when validated externally)
await notify.send({
  recipientId: "u1",
  notificationId: id as InferNotificationId<typeof notify>,
  payload: getPayloadForId(id),
})

// ✅ Fix 2: typed lookup (preferred)
const NOTIFICATION_MAP = {
  comment: "comment_mentioned",
  order: "order_shipped",
} as const

await notify.send({
  recipientId: "u1",
  notificationId: NOTIFICATION_MAP.comment,
  payload: { actorName: "Rey", postUrl: "/p/1" },
})