Defining notifications

import { channel, notification } from "@notifykitjs/core"

const inbox = channel.inbox()
const email = channel.email()

export const commentMentioned = notification({
  id: "comment_mentioned",
  payload: {
    actorName: "string",
    postTitle: "string",
    postUrl: "string",
  },
  channels: [
    inbox({
      title: "{{actorName}} mentioned you",
      body: "In {{postTitle}}",
      actionUrl: "{{postUrl}}",
    }),
    email({
      subject: "{{actorName}} mentioned you in {{postTitle}}",
      body: "Open {{postUrl}} to reply.",
    }),
  ],
})

notification({
  id: "order_shipped",
  payload: {
    orderNumber: "string",
    total:       "number",
    expedited:   "boolean",
  },
  channels: [...],
})

import { z } from "zod"
import { zodPayload } from "@notifykitjs/core/zod"

const invoicePayload = zodPayload(z.object({
  invoiceId: z.string().uuid(),
  amount: z.number().positive(),
}))

notification({
  id: "invoice_created",
  payload: invoicePayload.payload,
  validate: invoicePayload.validate,
  channels: [...],
})

notification({
  id: "team_invite",
  payload: { inviterName: "string", teamName: "string" },
  channels: [...],
  description: "Sent when a user is invited to a team",
  category: "social",
  required: true,
  redact: ["inviterName"],
  rateLimit: { max: 5, windowMs: 60_000 },
  fallback: inbox({ title: "You have a team invite" }),
})

// Actor + target: "Rey commented on Launch Plan"
notification({
  id: "comment_added",
  payload: {
    actorName: "string",
    targetName: "string",
    targetUrl: "string",
    preview: "string",
  },
  channels: [
    inbox({
      title: "{{actorName}} commented on {{targetName}}",
      body: "{{preview}}",
      actionUrl: "{{targetUrl}}",
    }),
  ],
})

// Status change: "Order #1234 shipped"
notification({
  id: "order_status_changed",
  payload: {
    orderNumber: "string",
    newStatus: "string",
    trackingUrl: "string",
  },
  channels: [
    inbox({
      title: "Order #{{orderNumber}} {{newStatus}}",
      actionUrl: "{{trackingUrl}}",
    }),
    email({
      subject: "Your order #{{orderNumber}} is now {{newStatus}}",
      body: "Track your order: {{trackingUrl}}\n\nUnsubscribe: {{_unsubscribeUrl}}",
    }),
  ],
})

// Threshold alert: "API latency hit 2400ms (limit: 2000ms)"
notification({
  id: "metric_threshold",
  payload: {
    metricName: "string",
    currentValue: "string",
    threshold: "string",
    dashboardUrl: "string",
  },
  channels: [
    inbox({
      title: "{{metricName}} exceeded threshold",
      body: "Current: {{currentValue}} (limit: {{threshold}})",
      actionUrl: "{{dashboardUrl}}",
    }),
  ],
})

export const commentMentioned = notification({
  id: "comment_mentioned",
  description: "Someone mentioned you in a comment",
  category: "activity",

  payload: {
    actorName: "string",
    actorEmail: "string",
    postTitle: "string",
    postUrl: "string",
    commentPreview: "string",
  },

  channels: [
    inbox({
      title: "{{actorName}} mentioned you",
      body: "{{commentPreview}}",
      actionUrl: "{{postUrl}}",
    }),
    email({
      subject: "{{actorName}} mentioned you in {{postTitle}}",
      body: "{{commentPreview}}\n\nOpen {{postUrl}} to reply.\n\nUnsubscribe: {{_unsubscribeUrl}}",
    }),
  ],

  // Don't spam — max 30 mentions per hour per recipient
  rateLimit: { max: 30, windowMs: 60 * 60_000 },

  // Batch rapid-fire mentions into one email
  digest: {
    windowMs: 5 * 60_000,
    key: ({ payload }) => payload.postUrl,
    render: ({ payloads, count }) => ({
      actorName: payloads[payloads.length - 1]!.actorName,
      actorEmail: payloads[payloads.length - 1]!.actorEmail,
      postTitle: payloads[0]!.postTitle,
      postUrl: payloads[0]!.postUrl,
      commentPreview: count > 1
        ? `${count} new mentions`
        : payloads[0]!.commentPreview,
    }),
  },

  // If email fails, at least show it in the inbox
  fallback: inbox({
    title: "{{actorName}} mentioned you (email delivery failed)",
    actionUrl: "{{postUrl}}",
  }),

  // Strip PII from logs and timeline
  redact: ["actorEmail"],
})

// BEFORE: original definition
notification({
  id: "comment_mentioned",
  payload: { actorName: "string", postUrl: "string" },
  channels: [
    inbox({ title: "{{actorName}} mentioned you" }),
  ],
})

// AFTER: added commentPreview (optional in template)
notification({
  id: "comment_mentioned",
  payload: { actorName: "string", postUrl: "string", commentPreview: "string" },
  channels: [
    inbox({
      title: "{{actorName}} mentioned you",
      body: "{{commentPreview}}",  // renders empty if old sends didn't have it
    }),
  ],
})

// Step 1: Create the new definition alongside the old one
export const commentReply = notification({
  id: "comment_reply",  // new name
  payload: { actorName: "string", postUrl: "string", commentPreview: "string" },
  channels: [...],
})

// Step 2: Migrate preferences from old ID to new ID
const allPrefs = await db
  .select()
  .from(notifyKitSchema.preferences)
  .where(eq(notifyKitSchema.preferences.notificationId, "comment_mentioned"))

for (const pref of allPrefs) {
  await notify.preferences.update({
    recipientId: pref.recipientId,
    notificationId: "comment_reply",
    channels: pref.channels,
  })
}

// Step 3: Update all send() call sites to use the new ID
// Step 4: Remove the old definition from the notifications array

import { createNotifyKit } from "@notifykitjs/core"
import { commentMentioned } from "./notifications/comment-mentioned"
import { orderShipped } from "./notifications/order-shipped"
import { teamInvite } from "./notifications/team-invite"

export const notify = createNotifyKit({
  notifications: [commentMentioned, orderShipped, teamInvite] as const,
  // ...
})

// Deploy 1: add as optional, handle absence in templates
notification({
  id: "order_shipped",
  payload: {
    orderNumber: "string",
    trackingUrl: "string",
    carrier: "string?",     // new optional field
  },
  channels: [
    inbox({
      render: (p) => ({
        title: `Order ${p.orderNumber} shipped`,
        body: p.carrier
          ? `Shipped via ${p.carrier}`
          : "Your order is on the way",
      }),
    }),
  ],
  digest: {
    windowMs: 60 * 60_000,
    render: ({ payloads, count }) => ({
      orderNumber: payloads[payloads.length - 1]!.orderNumber,
      trackingUrl: payloads[payloads.length - 1]!.trackingUrl,
      carrier: payloads[payloads.length - 1]?.carrier ?? undefined,
    }),
  },
})

// Deploy 2 (after all callers pass carrier): promote to required
// payload: { orderNumber: "string", trackingUrl: "string", carrier: "string" }

// lib/notifications/index.ts — barrel export for all definitions
export { commentMentioned } from "./activity/comment-mentioned"
export { taskAssigned } from "./activity/task-assigned"
export { newFollower } from "./social/new-follower"
export { invoicePaid } from "./billing/invoice-paid"
export { passwordReset } from "./billing/password-reset"

// lib/notifykit.ts — single import, wire up
import * as notifications from "./notifications"

export const notify = createNotifyKit({
  notifications: Object.values(notifications) as const,
  database: drizzlePostgresAdapter(db),
  providers: { email: resendProvider({ ... }) },
})

// lib/notifications/_shared.ts
import { channel } from "@notifykitjs/core"

const inbox = channel.inbox()
const email = channel.email()

export function actorInbox(template: { action: string; target: string }) {
  return inbox({
    title: `{{actorName}} ${template.action}`,
    body: `In ${template.target}`,
    actionUrl: "{{actionUrl}}",
  })
}

export function transactionalEmail(subject: string) {
  return email({
    subject,
    body: `${subject}\n\n{{body}}\n\n---\nUnsubscribe: {{_unsubscribeUrl}}`,
  })
}

// lib/notifications/comment-mentioned.ts
import { notification } from "@notifykitjs/core"
import { actorInbox, transactionalEmail } from "./_shared"

export const commentMentioned = notification({
  id: "comment_mentioned",
  payload: { actorName: "string", postTitle: "string", actionUrl: "string", body: "string" },
  channels: [
    actorInbox({ action: "mentioned you", target: "{{postTitle}}" }),
    transactionalEmail("{{actorName}} mentioned you in {{postTitle}}"),
  ],
})

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

function setup() {
  return createNotifyKit({
    notifications: [commentMentioned, orderShipped] as const,
    database: memoryAdapter(),
    providers: { email: fakeEmailProvider() },
  })
}

describe("notification definitions", () => {
  it("comment_mentioned renders actor name in inbox title", async () => {
    const notify = setup()
    await notify.upsertRecipient({ id: "u1", email: "test@test.com" })

    const result = await notify.send({
      recipientId: "u1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postTitle: "Launch", postUrl: "/p/1" },
    })

    expect(result.inboxItems[0].title).toBe("Rey mentioned you")
    expect(result.inboxItems[0].body).toBe("In Launch")
    expect(result.inboxItems[0].actionUrl).toBe("/p/1")
  })

  it("comment_mentioned delivers to both inbox and email", async () => {
    const notify = setup()
    await notify.upsertRecipient({ id: "u1", email: "test@test.com" })

    const result = await notify.send({
      recipientId: "u1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postTitle: "Launch", postUrl: "/p/1" },
    })

    expect(result.inboxItems).toHaveLength(1)
    expect(result.deliveries.find(d => d.channel === "email")).toBeDefined()
  })

  it("rejects invalid payload (missing required field)", async () => {
    const notify = setup()
    await notify.upsertRecipient({ id: "u1", email: "test@test.com" })

    const result = await notify.send({
      recipientId: "u1",
      notificationId: "comment_mentioned",
      // @ts-expect-error — testing runtime validation
      payload: { actorName: "Rey" },
    })

    expect(result.skipped).toBe(true)
    expect(result.skipReason).toBe("invalid_payload")
  })
})

describe("comment_mentioned digest", () => {
  it("renders single event as normal message", async () => {
    const notify = setup()
    await notify.upsertRecipient({ id: "u1", email: "test@test.com" })

    await notify.send({
      recipientId: "u1",
      notificationId: "comment_mentioned",
      payload: { actorName: "Rey", postTitle: "Launch", postUrl: "/p/1", commentPreview: "looks good!" },
    })

    // Flush the digest window
    const flushed = await notify.flushDigests()
    expect(flushed[0].inboxItems[0].body).toBe("looks good!")
  })

  it("renders multiple events as count summary", async () => {
    const notify = setup()
    await notify.upsertRecipient({ id: "u1", email: "test@test.com" })

    // Send 3 events within the digest window
    for (const actor of ["Rey", "Sam", "Alex"]) {
      await notify.send({
        recipientId: "u1",
        notificationId: "comment_mentioned",
        payload: { actorName: actor, postTitle: "Launch", postUrl: "/p/1", commentPreview: "..." },
      })
    }

    const flushed = await notify.flushDigests()
    expect(flushed[0].inboxItems[0].body).toBe("3 new mentions")
  })
})

describe("comment_mentioned rate limit", () => {
  it("enforces max 30 sends per hour", async () => {
    const notify = setup()
    await notify.upsertRecipient({ id: "u1", email: "test@test.com" })

    // Send up to the limit
    for (let i = 0; i < 30; i++) {
      const result = await notify.send({
        recipientId: "u1",
        notificationId: "comment_mentioned",
        payload: { actorName: `User ${i}`, postTitle: "Post", postUrl: "/p/1" },
      })
      expect(result.skipped).toBeFalsy()
    }

    // 31st send should be rate-limited
    const blocked = await notify.send({
      recipientId: "u1",
      notificationId: "comment_mentioned",
      payload: { actorName: "One More", postTitle: "Post", postUrl: "/p/1" },
    })

    expect(blocked.skipped).toBe(true)
    expect(blocked.skipReason).toBe("rate_limited")
  })
})