Timeline

const events = await notify.timeline(recordId)
const last = events[events.length - 1]
console.log(last.event, last.message, last.metadata)

// Get timeline for a specific notification send
const events = await notify.timeline(notificationRecordId)

// Get timeline for a specific delivery
const deliveryEvents = await notify.timeline(notificationRecordId, { deliveryId })

// Example output:
// [
//   { event: "payload.validated", message: "All 3 fields valid" },
//   { event: "recipient.resolved", message: "Recipient user_123 found" },
//   { event: "preferences.resolved", message: "inbox: allowed, email: allowed" },
//   { event: "inbox.created", message: "Inbox item inb_abc created" },
//   { event: "delivery.created", message: "Email delivery del_xyz queued" },
//   { event: "delivery.attempt", message: "Attempt 1 via resend" },
//   { event: "delivery.sent", message: "Sent via resend (msg_id: ...)" },
// ]

const events = await notify.timeline(notificationRecordId)
// → [
//   { event: "payload.validated",     message: "All fields valid" },
//   { event: "recipient.resolved",    message: "Recipient user_456 found" },
//   { event: "preferences.resolved",  message: "inbox: allowed, email: allowed" },
//   { event: "quiet_hours.deferred",  message: "Email deferred until 08:00 EST" },
//   { event: "inbox.created",         message: "Inbox item created" },
// ]

const oneHourAgo = new Date(Date.now() - 60 * 60_000)
const deliveries = await notify.deliveries.list()
const recentFailures = deliveries.filter(
  d => d.status === "failed" && d.failedAt && d.failedAt > oneHourAgo
)

// Pull timeline for each to understand WHY they failed:
for (const d of recentFailures.slice(0, 10)) {
  const events = await notify.timeline(d.notificationRecordId, { deliveryId: d.id })
  const errorEvent = events.find(e => e.event === "provider.error")
  console.log(`${d.channel} to ${d.recipientId}: ${errorEvent?.message ?? "unknown"}`)
}

const deliveries = await notify.deliveries.list(undefined, undefined, 100)
const recordIds = [...new Set(deliveries.map(d => d.notificationRecordId))]

const latencies = await Promise.all(
  recordIds.map(async (id) => {
    const events = await notify.timeline(id)
    const first = events[0]?.timestamp
    const sent = events.find(e => e.event === "delivery.sent")?.timestamp
    if (!first || !sent) return null
    return { id, channel: events.find(e => e.channel)?.channel, ms: sent - first }
  })
)

const valid = latencies.filter(Boolean)
const sorted = valid.sort((a, b) => a.ms - b.ms)
const p50 = sorted[Math.floor(sorted.length * 0.5)]?.ms
const p95 = sorted[Math.floor(sorted.length * 0.95)]?.ms

console.log(`p50: ${p50}ms, p95: ${p95}ms`)

import { describe, it, expect } from "vitest"
import { notify } from "./test-setup"

describe("pipeline path verification", () => {
  it("delivers email through preferences (not forced)", async () => {
    const result = await notify.send({
      recipientId: "user_1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postUrl: "/p/1" },
    })

    const events = await notify.timeline(result.id)

    // Verify preferences were consulted (not bypassed by required)
    const prefEvent = events.find(e => e.event === "preferences.resolved")
    expect(prefEvent).toBeDefined()
    expect(prefEvent!.message).toContain("email: allowed")

    // Verify no fallback was needed
    expect(events.find(e => e.event === "fallback.triggered")).toBeUndefined()

    // Verify delivery succeeded on first attempt
    const attempts = events.filter(e => e.event === "delivery.attempt")
    expect(attempts).toHaveLength(1)
  })

  it("skips for the RIGHT reason (dedup, not rate limit)", async () => {
    // First send
    await notify.send({
      recipientId: "user_1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postUrl: "/p/1" },
      dedupeKey: "mention:p1:rey",
      dedupeWindowMs: 60_000,
    })

    // Second send — should be dedup, not rate limit
    const second = await notify.send({
      recipientId: "user_1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postUrl: "/p/1" },
      dedupeKey: "mention:p1:rey",
      dedupeWindowMs: 60_000,
    })

    const events = await notify.timeline(second.id)
    expect(events.find(e => e.event === "deduplicated")).toBeDefined()
    expect(events.find(e => e.event === "rate_limited")).toBeUndefined()
  })

  it("fallback fires after primary failure (not preference skip)", async () => {
    // Configure provider to fail for this test
    const result = await notify.send({
      recipientId: "user_1",
      notificationId: "urgent_alert",
      payload: { message: "Server down" },
    })

    const events = await notify.timeline(result.id)
    const eventTypes = events.map(e => e.event)

    // Verify the sequence: attempt → fail → fallback
    const failIdx = eventTypes.indexOf("delivery.failed")
    const fallbackIdx = eventTypes.indexOf("fallback.triggered")
    expect(failIdx).toBeGreaterThan(-1)
    expect(fallbackIdx).toBeGreaterThan(failIdx)
  })
})

export function expectEventSequence(events, expectedTypes: string[]) {
  const types = events.map(e => e.event)
  let cursor = 0
  for (const expected of expectedTypes) {
    const idx = types.indexOf(expected, cursor)
    if (idx === -1) {
      throw new Error(
        `Expected event "${expected}" after position ${cursor}, \n` +
        `but timeline only contains: [${types.slice(cursor).join(", ")}]`
      )
    }
    cursor = idx + 1
  }
}

export function expectNoEvent(events, eventType: string) {
  const found = events.find(e => e.event === eventType)
  if (found) {
    throw new Error(
      `Expected no "${eventType}" event, but found one: ${found.message}`
    )
  }
}

// Usage:
const events = await notify.timeline(result.id)
expectEventSequence(events, [
  "payload.validated",
  "preferences.resolved",
  "delivery.sent",
])
expectNoEvent(events, "fallback.triggered")

const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60_000)
const deleted = await notify.pruneTimeline(thirtyDaysAgo)
console.log(`Pruned ${deleted} timeline events`)

import { notify } from "@/lib/notifykit"
import { requireAdmin } from "@/lib/auth"

export async function GET(request: Request) {
  await requireAdmin(request)
  const url = new URL(request.url)
  const recordId = url.searchParams.get("id")!

  const events = await notify.timeline(recordId)

  // Group by phase for a clean display
  const phases = {
    validation: events.filter(e => e.event.startsWith("payload") || e.event.startsWith("recipient")),
    resolution: events.filter(e => e.event.includes("preferences") || e.event.includes("quiet_hours")),
    delivery: events.filter(e => e.event.startsWith("delivery") || e.event.startsWith("inbox")),
    fallback: events.filter(e => e.event.startsWith("fallback") || e.event === "channel.skipped"),
  }

  return Response.json({ events, phases, total: events.length })
}