Multi-tenancy

await notify.send({
  recipientId: user.id,
  tenantId: org.id,          // or organizationId: org.id
  workspaceId: workspace.id, // optional
  notificationId: "comment_mentioned",
  payload: { actorName: "Rey", postUrl: "/posts/42" },
})

createRouteHandler({
  notifykit: notify,
  identify: async (request) => {
    const session = await auth(request)
    if (!session) return null

    return {
      recipientId: session.user.id,
      tenantId: session.organizationId,
      workspaceId: session.workspaceId,
    }
  },
})

const notify = createNotifyKit({
  // ...
  defaults: {
    channels: { inbox: true, email: true },
  },
  tenantDefaults: async (tenantId) => {
    const org = await db.query.organizations.findFirst({
      where: eq(organizations.id, tenantId),
    })
    if (org?.plan === "free") {
      return { email: false } // free plans don't get email by default
    }
    return null // use app defaults
  },
})

// Same user, two orgs — separate inboxes and preferences
await notify.upsertRecipient({ id: user.id, tenantId: "org_acme", email: user.email })
await notify.upsertRecipient({ id: user.id, tenantId: "org_globex", email: user.email })

// Project management app: user gets task notifications per-project
await notify.send({
  recipientId: user.id,
  tenantId: org.id,              // "Acme Inc"
  workspaceId: project.id,       // "Backend Refactor"
  notificationId: "task_assigned",
  payload: { taskTitle: "Fix auth bug", assignerName: "Rey" },
})

// Same user, same org, different project:
await notify.send({
  recipientId: user.id,
  tenantId: org.id,              // "Acme Inc"
  workspaceId: anotherProject.id, // "Mobile App"
  notificationId: "task_assigned",
  payload: { taskTitle: "Add dark mode", assignerName: "Sam" },
})

// User mutes email for "Backend Refactor" but keeps it on elsewhere
await notify.preferences.update({
  recipientId: user.id,
  tenantId: org.id,
  workspaceId: "proj_backend_refactor",
  notificationId: "task_assigned",
  channels: { email: false },
})

// "Mobile App" still sends email — workspace preferences are independent
const explanation = await notify.explain({
  recipientId: user.id,
  tenantId: org.id,
  workspaceId: "proj_mobile_app",
  notificationId: "task_assigned",
  payload: { taskTitle: "Test", assignerName: "Test" },
})
// explanation.channels.email.outcome → "deliver"

import { usePreferences } from "@notifykitjs/react"

function MuteProjectButton({ workspaceId, workspaceName }: {
  workspaceId: string
  workspaceName: string
}) {
  const { isEnabled, update } = usePreferences()
  const isMuted = !isEnabled("*", "inbox", { workspaceId })

  return (
    <button onClick={() => update({
      notificationId: "*",
      workspaceId,
      channels: { inbox: !isMuted, email: !isMuted },
    })}>
      {isMuted ? `Unmute ${workspaceName}` : `Mute ${workspaceName}`}
    </button>
  )
}

const notify = createNotifyKit({
  // ...
  tenantDefaults: async (tenantId) => {
    // Look up this org's admin-configured defaults
    const settings = await db.query.tenantNotificationSettings.findMany({
      where: eq(tenantNotificationSettings.tenantId, tenantId),
    })

    if (settings.length === 0) return null // fall through to app defaults

    // Merge global ("*") and notification-specific settings
    const global = settings.find(s => s.notificationId === "*")
    return global?.channels ?? null
  },
})

import { auth } from "@/lib/auth"
import { db } from "@/lib/db"
import { tenantNotificationSettings } from "@/lib/schema"
import { eq, and } from "drizzle-orm"

export async function POST(request: Request) {
  const session = await auth(request)
  if (!session?.isOrgAdmin) return Response.json({ error: "Forbidden" }, { status: 403 })

  const { notificationId, channels } = await request.json()

  await db
    .insert(tenantNotificationSettings)
    .values({
      tenantId: session.organizationId,
      notificationId, // "*" for org-wide, or specific ID
      channels,
    })
    .onConflictDoUpdate({
      target: [tenantNotificationSettings.tenantId, tenantNotificationSettings.notificationId],
      set: { channels },
    })

  return Response.json({ ok: true })
}

function OrgNotificationSettings({ notifications }) {
  const orgId = useCurrentOrg().id

  async function toggleChannel(notificationId: string, channel: string, enabled: boolean) {
    await fetch("/api/admin/notification-settings", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        notificationId,
        channels: { [channel]: enabled },
      }),
    })
  }

  return (
    <div>
      <h2>Organization notification defaults</h2>
      <p>These apply to all members unless they override in their own settings.</p>
      <table>
        <thead>
          <tr><th>Notification</th><th>Inbox</th><th>Email</th></tr>
        </thead>
        <tbody>
          {notifications.map(n => (
            <tr key={n.id}>
              <td>{n.description}</td>
              <td><input type="checkbox" onChange={e => toggleChannel(n.id, "inbox", e.target.checked)} /></td>
              <td><input type="checkbox" onChange={e => toggleChannel(n.id, "email", e.target.checked)} /></td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  )
}

import { createNotifyKit, memoryAdapter, fakeEmailProvider } from "@notifykitjs/core"
import { createHandler } from "@notifykitjs/core"

const notify = createNotifyKit({
  notifications: [commentMentioned] as const,
  database: memoryAdapter(),
  providers: { email: fakeEmailProvider() },
})

// Send to same user in two different orgs
await notify.upsertRecipient({ id: "alice", tenantId: "org_acme", email: "a@test.com" })
await notify.upsertRecipient({ id: "alice", tenantId: "org_globex", email: "a@test.com" })

await notify.send({
  recipientId: "alice", tenantId: "org_acme",
  notificationId: "comment_mentioned",
  payload: { actorName: "Bob", postUrl: "/posts/1" },
})

// Handler scoped to org_globex should see nothing
const globexHandler = createHandler(notify, {
  identify: async () => ({ recipientId: "alice", tenantId: "org_globex" }),
})
const res = await globexHandler(new Request("http://localhost/api/notifykit/inbox"))
const { data: items } = await res.json()
expect(items).toHaveLength(0) // ✓ Acme notification not visible

// Handler scoped to org_acme sees the item
const acmeHandler = createHandler(notify, {
  identify: async () => ({ recipientId: "alice", tenantId: "org_acme" }),
})
const acmeRes = await acmeHandler(new Request("http://localhost/api/notifykit/inbox"))
const { data: acmeItems } = await acmeRes.json()
expect(acmeItems).toHaveLength(1) // ✓ correct isolation

import { notifyKitSchema } from "@notifykitjs/drizzle"
import { isNull, eq } from "drizzle-orm"

const { recipients, inboxItems, preferences } = notifyKitSchema

// Map each user to their org (your app's logic)
const userOrgs = await db.select({ userId: users.id, orgId: users.organizationId }).from(users)

for (const { userId, orgId } of userOrgs) {
  // Backfill recipients
  await db.update(recipients)
    .set({ tenantId: orgId })
    .where(and(eq(recipients.id, userId), isNull(recipients.tenantId)))

  // Backfill inbox items
  await db.update(inboxItems)
    .set({ tenantId: orgId })
    .where(and(eq(inboxItems.recipientId, userId), isNull(inboxItems.tenantId)))

  // Backfill preferences
  await db.update(preferences)
    .set({ tenantId: orgId })
    .where(and(eq(preferences.recipientId, userId), isNull(preferences.tenantId)))
}