Digests & rate limits

notification({
  id: "new_comments",
  payload: {
    actorName: "string",
    postTitle: "string",
    count: "number",
  },
  channels: [
    inbox({ title: "{{count}} new comments on {{postTitle}}" }),
    email({
      subject: "{{count}} new comments on {{postTitle}}",
      body: "Latest from {{actorName}}. Open the post to read them all.",
    }),
  ],
  digest: {
    windowMs: 5 * 60_000,
    key: ({ payload }) => payload.postTitle,
    render: ({ payloads, count }) => ({
      actorName: payloads[payloads.length - 1]!.actorName,
      postTitle: payloads[0]!.postTitle,
      count,
    }),
  },
})

digest: {
  windowMs: 5 * 60_000,

  // Comments: group by post
  key: ({ payload }) => payload.postId,

  // Reactions: group by target
  // key: ({ payload }) => `${payload.targetType}:${payload.targetId}`,

  // Followers: constant key — all follows batch into one
  // key: () => "followers",

  render: ({ payloads, count }) => ({ /* ... */ }),
}

notification({
  id: "comment_mentioned",
  payload: { actorName: "string", postUrl: "string" },
  channels: [inbox({ title: "{{actorName}} mentioned you" })],
  rateLimit: {
    max: 20,
    windowMs: 60 * 60_000,
    scope: "recipient",
  },
})

notification({
  id: "activity_feed",
  payload: { summary: "string", count: "number" },
  channels: [inbox({ title: "{{count}} new activities" })],
  rateLimit: { max: 100, windowMs: 60 * 60_000 },
  digest: {
    windowMs: 10 * 60_000,
    render: ({ payloads, count }) => ({
      summary: `${count} things happened`,
      count,
    }),
  },
})

notification({
  id: "new_comments",
  // ...
  digest: {
    windowMs: process.env.NODE_ENV === "test" ? 0 : 5 * 60_000,
    key: ({ payload }) => payload.postUrl,
    render: ({ payloads, count }) => ({ /* ... */ }),
  },
})

import { describe, it, expect } from "vitest"

describe("comment digest", () => {
  it("batches 3 mentions into one delivery", async () => {
    for (const actor of ["Rey", "Sam", "Ava"]) {
      const result = await testNotify.send({
        recipientId: "user_1",
        notificationId: "new_comments",
        payload: { actorName: actor, postTitle: "Launch", postUrl: "/p/1", count: 1 },
      })
      expect(result.digested).toBe(true)
      expect(result.deliveries).toHaveLength(0)
    }

    const flushed = await testNotify.flushDigests()

    expect(flushed).toHaveLength(1)
    expect(flushed[0].deliveries.length).toBeGreaterThan(0)
  })
})

// BEFORE: direct delivery, noisy during active threads
notification({
  id: "comment_mentioned",
  payload: { actorName: "string", postTitle: "string", postUrl: "string" },
  channels: [
    inbox({ title: "{{actorName}} mentioned you in {{postTitle}}" }),
    email({ subject: "{{actorName}} mentioned you", body: "Open {{postUrl}}" }),
  ],
})

// AFTER: digested — one email per 5 minutes instead of one per comment
notification({
  id: "comment_mentioned",
  payload: {
    actorName: "string",
    postTitle: "string",
    postUrl: "string",
    count: "number",
  },
  channels: [
    inbox({ title: "{{actorName}} mentioned you in {{postTitle}}" }),
    email({
      subject: "{{count}} new mentions in {{postTitle}}",
      body: "Latest from {{actorName}}. Open {{postUrl}} to catch up.",
    }),
  ],
  digest: {
    windowMs: 5 * 60_000,
    key: ({ payload }) => payload.postUrl,
    render: ({ payloads, count }) => ({
      actorName: payloads[payloads.length - 1]!.actorName,
      postTitle: payloads[0]!.postTitle,
      postUrl: payloads[0]!.postUrl,
      count,
    }),
  },
})

// Latest actor + count
render: ({ payloads, count }) => ({
  actorName: payloads[payloads.length - 1]!.actorName,
  summary: count === 1
    ? `${payloads[0]!.actorName} commented`
    : `${payloads[payloads.length - 1]!.actorName} and ${count - 1} others commented`,
  postUrl: payloads[0]!.postUrl,
  count,
})

// Actor list (truncated to 2 names)
render: ({ payloads, count }) => {
  const unique = [...new Set(payloads.map(p => p.actorName))]
  const names = unique.slice(0, 2)
  const rest = unique.length - names.length

  return {
    actorList: rest > 0
      ? `${names.join(", ")}, and ${rest} others`
      : names.join(" and "),
    action: "liked your post",
    postUrl: payloads[0]!.postUrl,
    count,
  }
}

// Summary count only
render: ({ payloads, count }) => ({
  summary: `${count} new updates`,
  projectName: payloads[0]!.projectName,
  latestUrl: payloads[payloads.length - 1]!.url,
  count,
})

// Most recent event + tail count
render: ({ payloads, count }) => ({
  latest: payloads[payloads.length - 1]!.message,
  count,
  summary: count === 1
    ? payloads[0]!.message
    : `${payloads[payloads.length - 1]!.message} (+ ${count - 1} more)`,
})

createNotifyKit({
  // ...
  on: {
    "notification.created": ({ notification }) => {
      if (notification.digestedCount && notification.digestedCount > 0) {
        metrics.histogram("notifykit.digest.items_per_flush", notification.digestedCount, {
          notification: notification.notificationId,
        })
      }
    },
  },
})

const flushed = await notify.flushDigests()
metrics.gauge("notifykit.digest.last_flush_count", flushed.length)

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

async function diagnoseDigest() {
  const result = await notify.send({
    recipientId: "test_user",
    notificationId: "new_comments",
    payload: { actorName: "Debug", postTitle: "Test", postUrl: "/test", count: 1 },
  })
  console.log("Digested:", result.digested)

  const flushed = await notify.flushDigests()
  console.log("Flushed count:", flushed.length)
  if (flushed.length > 0) {
    console.log("Deliveries:", flushed[0].deliveries.length)
  } else {
    console.log("Nothing to flush — window hasn't expired yet")
  }
}

diagnoseDigest()