Hooks & observability

const notify = createNotifyKit({
  // ...
  on: {
    "notification.created": ({ notification }) => {
      metrics.inc("notifications.created", {
        id: notification.notificationId,
      })
    },

    "delivery.sent": ({ delivery }) => {
      metrics.inc("delivery.sent", {
        channel: delivery.channel,
        provider: delivery.provider,
      })
    },

    "delivery.failed": ({ delivery, error }) => {
      sentry.captureException(error, {
        extra: { deliveryId: delivery.id, channel: delivery.channel },
      })
    },

    "notification.rate_limited": ({ notificationId, recipientId, limit }) => {
      logger.warn("rate limited", { notificationId, recipientId, limit })
    },
  },
})

on: {
  "delivery.sent": ({ delivery }) => {
    // Fire and forget — don't await, don't block send()
    void analyticsClient.track("email_sent", { deliveryId: delivery.id })
  },
}

on: {
  "delivery.sent": ({ delivery }) => {
    metrics.inc("notifykit.delivery.sent", { channel: delivery.channel })
    metrics.histogram("notifykit.delivery.latency_ms",
      delivery.sentAt - delivery.createdAt, { channel: delivery.channel })
  },
  "delivery.failed": ({ delivery, error }) => {
    metrics.inc("notifykit.delivery.failed", { channel: delivery.channel })
    sentry.captureException(error, { extra: { deliveryId: delivery.id } })
  },
  "notification.rate_limited": ({ notificationId }) => {
    metrics.inc("notifykit.rate_limited", { notification: notificationId })
  },
  "notification.suppressed": ({ notificationId }) => {
    metrics.inc("notifykit.suppressed", { notification: notificationId })
  },
}

// SAFE: wrap external calls in try/catch
on: {
  "delivery.sent": ({ delivery }) => {
    try {
      metrics.inc("notifykit.sent", { channel: delivery.channel })
    } catch (err) {
      // Don't let a metrics failure break sends
      console.error("Hook error (metrics):", err)
    }
  },

  "delivery.failed": ({ delivery, error }) => {
    // SAFE fire-and-forget: .catch() prevents unhandled rejection
    sentryClient.captureException(error, {
      extra: { deliveryId: delivery.id },
    }).catch(hookErr => console.error("Hook error (sentry):", hookErr))
  },
}

export const metricsHooks = {
  "delivery.sent": ({ delivery }) => {
    metrics.inc("notifykit.sent", { channel: delivery.channel })
    metrics.histogram("notifykit.latency_ms",
      delivery.sentAt - delivery.createdAt, { channel: delivery.channel })
  },
  "delivery.failed": ({ delivery }) => {
    metrics.inc("notifykit.failed", { channel: delivery.channel })
  },
}

export const errorHooks = {
  "delivery.failed": ({ delivery, error }) => {
    sentry.captureException(error, {
      tags: { channel: delivery.channel, provider: delivery.provider },
      extra: { deliveryId: delivery.id, notificationId: delivery.notificationId },
    })
  },
}

export const auditHooks = {
  "notification.created": ({ notification }) => {
    void auditLog.write("notification.sent", {
      recipientId: notification.recipientId,
      notificationId: notification.notificationId,
    })
  },
  "inbox.deleted": ({ itemId, recipientId }) => {
    void auditLog.write("inbox.deleted", { itemId, recipientId })
  },
}

import { metricsHooks } from "./hooks/metrics"
import { errorHooks } from "./hooks/errors"
import { auditHooks } from "./hooks/audit"

function mergeHooks(...hookSets) {
  const merged = {}
  for (const set of hookSets) {
    for (const [event, handler] of Object.entries(set)) {
      const prev = merged[event]
      merged[event] = prev
        ? (ctx) => { prev(ctx); handler(ctx) }
        : handler
    }
  }
  return merged
}

export const notify = createNotifyKit({
  // ...
  on: mergeHooks(metricsHooks, errorHooks, auditHooks),
})

import { metricsHooks } from "./metrics"
import { errorHooks } from "./errors"
import { auditHooks } from "./audit"

const devHooks = {
  "notification.created": ({ notification }) => {
    console.log("[notifykit]", notification.notificationId, "→", notification.recipientId)
  },
  "delivery.sent": ({ delivery }) => {
    console.log("[notifykit] ✓", delivery.channel, "sent to", delivery.recipientId)
  },
  "delivery.failed": ({ delivery, error }) => {
    console.error("[notifykit] ✗", delivery.channel, "failed:", error.message)
  },
}

export function buildHooks() {
  const env = process.env.NODE_ENV

  if (env === "test") return {}  // no hooks in test — use vi.fn() explicitly
  if (env === "development") return mergeHooks(devHooks)
  // production + staging:
  return mergeHooks(metricsHooks, errorHooks, auditHooks)
}

import { buildHooks } from "./hooks"

export const notify = createNotifyKit({
  // ...
  on: buildHooks(),
})

const SLACK_WEBHOOK = process.env.SLACK_ALERTS_WEBHOOK!
const DEBOUNCE_MS = 60_000 // batch failures over 1 minute

let buffer: Array<{ channel: string; error: string; notificationId: string }> = []
let flushTimer: ReturnType<typeof setTimeout> | null = null

function scheduleFlush() {
  if (flushTimer) return // already scheduled
  flushTimer = setTimeout(async () => {
    const batch = buffer.splice(0) // drain buffer
    flushTimer = null
    if (batch.length === 0) return

    const summary = batch.length === 1
      ? `Delivery failed: ${batch[0].notificationId} → ${batch[0].channel} (${batch[0].error})`
      : `${batch.length} deliveries failed in the last minute:\n` +
        Object.entries(Object.groupBy(batch, f => f.channel))
          .map(([ch, items]) => `• ${ch}: ${items!.length} failures`)
          .join("\n")

    await fetch(SLACK_WEBHOOK, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        text: `🚨 *NotifyKit alert*\n${summary}`,
      }),
    }).catch(err => console.error("Slack alert failed:", err))
  }, DEBOUNCE_MS)
}

export const slackAlertHooks = {
  "delivery.failed": ({ delivery, error }) => {
    buffer.push({
      channel: delivery.channel,
      error: error?.message ?? "unknown",
      notificationId: delivery.notificationId,
    })
    scheduleFlush()
  },

  "notification.rate_limited": ({ notificationId, recipientId }) => {
    // Rate limits are less noisy — alert immediately but only once per notification type
    void fetch(SLACK_WEBHOOK, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        text: `⚠️ Rate limit hit: ${notificationId} for ${recipientId}`,
      }),
    }).catch(() => {})
  },
}

import { slackAlertHooks } from "./hooks/slack-alerts"

export const notify = createNotifyKit({
  // ...
  on: mergeHooks(metricsHooks, errorHooks, slackAlertHooks),
})

import { describe, it, expect, vi } from "vitest"
import { createNotifyKit, memoryAdapter, fakeEmailProvider } from "@notifykitjs/core"
import { commentMentioned } from "./notifications"

describe("hooks", () => {
  it("fires delivery.sent on successful email", async () => {
    const onSent = vi.fn()

    const notify = createNotifyKit({
      notifications: [commentMentioned] as const,
      database: memoryAdapter(),
      providers: { email: fakeEmailProvider() },
      on: { "delivery.sent": onSent },
    })

    await notify.upsertRecipient({ id: "u1", email: "test@test.com" })
    await notify.send({
      recipientId: "u1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postUrl: "/p/1" },
    })

    expect(onSent).toHaveBeenCalledTimes(1)
    expect(onSent).toHaveBeenCalledWith(
      expect.objectContaining({
        delivery: expect.objectContaining({ channel: "email", status: "sent" }),
      })
    )
  })

  it("fires delivery.failed after retries exhaust", async () => {
    const onFailed = vi.fn()
    const failingProvider = { id: "broken", send: () => { throw new Error("down") } }

    const notify = createNotifyKit({
      notifications: [commentMentioned] as const,
      database: memoryAdapter(),
      providers: { email: failingProvider },
      retry: { maxAttempts: 2, delayMs: () => 0 },
      on: { "delivery.failed": onFailed },
    })

    await notify.upsertRecipient({ id: "u1", email: "test@test.com" })
    await notify.send({
      recipientId: "u1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postUrl: "/p/1" },
    })

    expect(onFailed).toHaveBeenCalledTimes(1)
    expect(onFailed).toHaveBeenCalledWith(
      expect.objectContaining({
        error: expect.any(Error),
        delivery: expect.objectContaining({ channel: "email" }),
      })
    )
  })
})