@beignet/cli 0.0.26 → 0.0.28

package/dist/make/inbox.js

@@ -0,0 +1,1747 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { loadBeignetConfig, resolveConfig, } from "../config.js";
+import { addNamedValueImport, appendToNamedArray } from "../registry-edits.js";
+import { aliasModule, appendSharedErrorEntries, assertStandardApp, detectResourceDatabase, detectResourcePersistence, detectUiShell, drizzleDialects, drizzleRepositoriesPath, drizzleSchemaIndexPath, fileExists, infrastructureDir, missingCapabilityBuilderFiles, notificationPortWirings, planGeneratedFiles, readOptionalFile, resourceNames, resourceSharedErrorsPath, seedEntrypointPath, seedNames, uniqueStrings, updateDatabaseProviderPick, updateDatabaseResetTables, updateDrizzleRepositories, updateDrizzleSchemaIndexExports, updateInfrastructureDeferredPorts, updateOpenApiRouteContracts, updatePackageJson, updatePackageScripts, updatePortsIndex, updateSeedEntrypoint, updateServerRoutes, updateTransactionPortsPick, wirePortProviders, writePlannedGeneratedFile, } from "./shared.js";
+const sidebarFile = "components/app-sidebar.tsx";
+const sidebarNavEntry = '{ href: "/inbox", label: "Inbox", icon: InboxIcon }';
+/**
+ * Contract export names registered with array-literal
+ * `createOpenAPIHandler([...])` routes. The starter documents
+ * `contractsFromRoutes(routes)` instead, which needs no edit.
+ */
+const inboxContractNames = [
+    "listInbox",
+    "unreadCount",
+    "markRead",
+    "markAllRead",
+];
+/**
+ * The inbox channel writes rows through `ctx.ports.inbox`, so only the
+ * notifications half of the notification wiring is required — no mailer.
+ */
+function inboxPortWirings() {
+    return notificationPortWirings("make inbox").filter((wiring) => wiring.portKey === "notifications");
+}
+/**
+ * Generate an actor-scoped in-app inbox slice: notification schemas, an
+ * `InboxRepository` port with a Drizzle adapter, cursor-paginated contracts
+ * and use cases, an in-app notification channel, seeds, tests, and — when the
+ * React Query shell is present — inbox UI plus a sidebar link.
+ *
+ * The inbox is personal (scoped by the signed-in user id), so it requires no
+ * tenancy setup.
+ */
+export async function makeInbox(options) {
+    const targetDir = path.resolve(options.cwd ?? process.cwd());
+    const config = options.config
+        ? resolveConfig(options.config)
+        : await loadBeignetConfig(targetDir);
+    await assertStandardApp(targetDir, config);
+    const persistence = await detectResourcePersistence(targetDir, config);
+    if (persistence !== "drizzle") {
+        throw new Error("beignet make inbox expects a Drizzle-backed Beignet app because inbox notifications must be durable. Add a database provider first, then run make inbox again.");
+    }
+    const sharedErrorsFile = resourceSharedErrorsPath(config);
+    if (!(await fileExists(path.join(targetDir, sharedErrorsFile)))) {
+        throw new Error(`beignet make inbox expects the shared error catalog at ${sharedErrorsFile}. Restore the generated error catalog, then run make inbox again.`);
+    }
+    const database = await detectResourceDatabase(targetDir, config);
+    const ui = await detectUiShell(targetDir, config);
+    const generatedFiles = [
+        ...(await missingCapabilityBuilderFiles(targetDir, "notifications", config)),
+        ...inboxFiles(config, database, { ui }),
+    ];
+    const plannedFiles = await planGeneratedFiles(targetDir, generatedFiles, {
+        force: Boolean(options.force),
+    });
+    const inboxNames = resourceNames("inbox");
+    // Plan every edit with dryRun: true before writing anything so an anchor
+    // miss aborts with manual instructions instead of leaving partial wiring.
+    const plannedInboxUpdates = await updateInboxWiring(targetDir, inboxNames, config, { dryRun: true, ui });
+    const plannedProviderUpdates = (await wirePortProviders(targetDir, config, inboxPortWirings(), {
+        dryRun: true,
+    })).updatedFiles;
+    const createdFiles = plannedFiles
+        .filter((file) => file.result === "created")
+        .map((file) => file.path);
+    const updatedFiles = plannedFiles
+        .filter((file) => file.result === "updated")
+        .map((file) => file.path);
+    const skippedFiles = plannedFiles
+        .filter((file) => file.result === "skipped")
+        .map((file) => file.path);
+    const files = generatedFiles.map((file) => file.path);
+    const dryRun = Boolean(options.dryRun);
+    const inboxSeedNames = seedNames("inbox/demo-inbox");
+    const seedScript = { "db:seed": `bun ${seedEntrypointPath(config)}` };
+    const recordSeedEntrypoint = (result) => {
+        const entrypoint = seedEntrypointPath(config);
+        if (result === "created")
+            createdFiles.push(entrypoint);
+        if (result === "updated")
+            updatedFiles.push(entrypoint);
+        if (result === "skipped")
+            skippedFiles.push(entrypoint);
+        if (!files.includes(entrypoint))
+            files.push(entrypoint);
+    };
+    if (dryRun) {
+        updatedFiles.push(...plannedInboxUpdates, ...plannedProviderUpdates);
+        recordSeedEntrypoint(await updateSeedEntrypoint(targetDir, inboxSeedNames, config, {
+            dryRun: true,
+        }));
+        if (await updatePackageScripts(targetDir, seedScript, { dryRun: true })) {
+            updatedFiles.push("package.json");
+        }
+    }
+    else {
+        for (const file of plannedFiles) {
+            await writePlannedGeneratedFile(targetDir, file);
+        }
+        updatedFiles.push(...(await updateInboxWiring(targetDir, inboxNames, config, {
+            dryRun: false,
+            ui,
+        })));
+        updatedFiles.push(...(await wirePortProviders(targetDir, config, inboxPortWirings(), {
+            dryRun: false,
+        })).updatedFiles);
+        recordSeedEntrypoint(await updateSeedEntrypoint(targetDir, inboxSeedNames, config, {
+            dryRun: false,
+        }));
+        if (await updatePackageScripts(targetDir, seedScript, { dryRun: false })) {
+            updatedFiles.push("package.json");
+        }
+    }
+    return {
+        schemaVersion: 1,
+        name: "inbox",
+        targetDir,
+        dryRun,
+        files,
+        createdFiles,
+        updatedFiles: uniqueStrings(updatedFiles),
+        skippedFiles,
+    };
+}
+/**
+ * Post-generate guidance for `beignet make inbox`, one step per entry.
+ */
+export function makeInboxNextStepLines() {
+    return [
+        "Run beignet db generate and beignet db migrate so inbox_notifications exists.",
+        'Add an in-app channel to any feature notification: import { defineInboxNotificationChannel } from "@/features/inbox/channel" and add inApp: defineInboxNotificationChannel(({ payload }) => ({ userId: payload.userId, type: "your-type", title: "Something happened" })) to its channels.',
+        "Render the unread badge from features/inbox/components/unread-badge.tsx next to your Inbox nav link for a live unread count.",
+        "Run your app's test, lint, and typecheck commands, then beignet lint and beignet doctor.",
+    ];
+}
+export async function updateInboxWiring(targetDir, inboxNames, config, options) {
+    const updated = new Set();
+    if (await updatePackageJson(targetDir, options)) {
+        updated.add("package.json");
+    }
+    if (await updatePortsIndex(targetDir, inboxNames, config, {
+        ...options,
+        generationOptions: {
+            auth: false,
+            tenant: false,
+            events: false,
+            softDelete: false,
+        },
+    })) {
+        updated.add(config.paths.ports);
+    }
+    if (await updateInfrastructureDeferredPorts(targetDir, inboxNames, config, options)) {
+        updated.add(config.paths.infrastructurePorts);
+    }
+    if (await updateDrizzleSchemaIndexExports(targetDir, config, { exports: ["inboxNotifications"], module: "./inbox" }, options)) {
+        updated.add(drizzleSchemaIndexPath(config));
+    }
+    if (await updateDrizzleRepositories(targetDir, inboxNames, config, options)) {
+        updated.add(drizzleRepositoriesPath(config));
+    }
+    if (await updateDatabaseProviderPick(targetDir, config, ["inbox"], options)) {
+        updated.add(path.join(infrastructureDir(config), "db/provider.ts"));
+    }
+    if (await updateTransactionPortsPick(targetDir, config, ["inbox"], "make inbox", options)) {
+        updated.add(path.join(infrastructureDir(config), "db/transaction-ports.ts"));
+    }
+    if (await updateDatabaseResetTables(targetDir, config, ["inbox_notifications"], options)) {
+        updated.add(path.join(infrastructureDir(config), "db/reset.ts"));
+    }
+    if (await updateInboxSharedErrors(targetDir, config, options)) {
+        updated.add(resourceSharedErrorsPath(config));
+    }
+    const routesFile = await updateServerRoutes(targetDir, inboxNames, config, options);
+    if (routesFile)
+        updated.add(routesFile);
+    if (await updateOpenApiRouteContracts(targetDir, config, {
+        contractNames: inboxContractNames,
+        contractsModule: aliasModule(path.join(config.paths.features, "inbox/contracts.ts")),
+    }, options)) {
+        updated.add(config.paths.openapiRoute);
+    }
+    if (options.ui && (await updateSidebarNavLinks(targetDir, options))) {
+        updated.add(sidebarFile);
+    }
+    return [...updated];
+}
+export async function updateInboxSharedErrors(targetDir, config, options) {
+    return appendSharedErrorEntries(targetDir, config, [
+        {
+            name: "NotificationNotFound",
+            entry: `NotificationNotFound: {
+\t\tcode: "NOTIFICATION_NOT_FOUND",
+\t\tstatus: 404,
+\t\tmessage: "Notification not found",
+\t},`,
+        },
+    ], "make inbox", options);
+}
+export async function updateSidebarNavLinks(targetDir, options) {
+    const filePath = path.join(targetDir, sidebarFile);
+    const original = await readOptionalFile(filePath);
+    const manual = `Add ${sidebarNavEntry} to your navigation manually with import { InboxIcon } from "lucide-react", or restore the generated sidebar before running make inbox.`;
+    if (original === undefined) {
+        throw new Error(`Could not find ${sidebarFile}. ${manual}`);
+    }
+    if (original.includes('href: "/inbox"'))
+        return false;
+    let next = addNamedValueImport(original, "InboxIcon", "lucide-react");
+    const appended = appendToNamedArray(next, "navLinks", sidebarNavEntry);
+    if (appended.kind === "missing") {
+        throw new Error(`Could not find the navLinks array in ${sidebarFile}. ${manual}`);
+    }
+    if (appended.kind === "updated")
+        next = appended.source;
+    if (next === original)
+        return false;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
+export function inboxFiles(config, database, options) {
+    const featureDir = (file) => path.join(config.paths.features, "inbox", file);
+    const files = [
+        { path: featureDir("schemas.ts"), content: inboxSchemasFile() },
+        { path: featureDir("ports.ts"), content: inboxPortsFile() },
+        { path: featureDir("channel.ts"), content: inboxChannelFile(config) },
+        { path: featureDir("contracts.ts"), content: inboxContractsFile(config) },
+        {
+            path: featureDir("use-cases/list-inbox.ts"),
+            content: inboxListUseCaseFile(config),
+        },
+        {
+            path: featureDir("use-cases/get-unread-count.ts"),
+            content: inboxUnreadCountUseCaseFile(config),
+        },
+        {
+            path: featureDir("use-cases/mark-read.ts"),
+            content: inboxMarkReadUseCaseFile(config),
+        },
+        {
+            path: featureDir("use-cases/mark-all-read.ts"),
+            content: inboxMarkAllReadUseCaseFile(config),
+        },
+        {
+            path: featureDir("use-cases/index.ts"),
+            content: inboxUseCasesIndexFile(),
+        },
+        { path: featureDir("routes.ts"), content: inboxRoutesFile(config) },
+        {
+            path: featureDir("notifications/index.ts"),
+            content: inboxNotificationsFile(config),
+        },
+        { path: featureDir("seeds/index.ts"), content: inboxSeedsFile(config) },
+        {
+            path: featureDir("tests/factories/inbox-notification.ts"),
+            content: inboxFactoryFile(config),
+        },
+        { path: featureDir("tests/inbox.test.ts"), content: inboxTestFile(config) },
+        {
+            path: featureDir("tests/channel.test.ts"),
+            content: inboxChannelTestFile(config),
+        },
+        {
+            path: path.join(infrastructureDir(config), "inbox/drizzle-inbox-repository.ts"),
+            content: inboxDrizzleRepositoryFile(config, database),
+        },
+        {
+            path: path.join(infrastructureDir(config), "db/schema/inbox.ts"),
+            content: inboxDrizzleSchemaFile(database),
+        },
+    ];
+    if (options.ui) {
+        files.push({
+            path: featureDir("client/queries.ts"),
+            content: inboxClientQueriesFile(config),
+        }, {
+            path: featureDir("components/unread-badge.tsx"),
+            content: inboxUnreadBadgeFile(config),
+        }, {
+            path: featureDir("components/inbox-item.tsx"),
+            content: inboxItemComponentFile(config),
+        }, {
+            path: featureDir("components/inbox-list.tsx"),
+            content: inboxListComponentFile(config),
+        }, {
+            path: featureDir("components/index.ts"),
+            content: inboxComponentsIndexFile(),
+        }, { path: "app/(app)/inbox/page.tsx", content: inboxPageFile(config) });
+    }
+    return files;
+}
+export function inboxSchemasFile() {
+    return `import { z } from "zod";
+
+/**
+ * Response metadata for cursor-paginated lists. Matches \`CursorPageInfo\`
+ * from \`@beignet/core/pagination\`.
+ */
+export const cursorPageSchema = z.object({
+\tkind: z.literal("cursor"),
+\tlimit: z.number().int().min(1),
+\tcursor: z.string().nullable(),
+\tnextCursor: z.string().nullable(),
+\thasMore: z.boolean(),
+});
+
+/**
+ * Notification type is an open string so any feature can deliver its own
+ * kinds without editing this schema. Example values: "welcome", "mention",
+ * "assignment", "status_change".
+ */
+export const inboxNotificationTypeSchema = z.string().min(1);
+
+export const inboxNotificationSchema = z.object({
+\tid: z.string().min(1),
+\tuserId: z.string().min(1),
+\ttype: inboxNotificationTypeSchema,
+\ttitle: z.string().min(1),
+\tbody: z.string().nullable(),
+\tresourceKey: z.string().min(1).nullable(),
+\tactorUserId: z.string().min(1).nullable(),
+\tactorName: z.string().nullable(),
+\treadAt: z.string().nullable(),
+\tcreatedAt: z.string(),
+});
+
+export const listInboxQuerySchema = z.object({
+\tlimit: z.coerce.number().int().min(1).max(50).default(20),
+\tcursor: z.string().min(1).optional(),
+\tunread: z.coerce.boolean().default(false),
+});
+
+export const listInboxOutputSchema = z.object({
+\titems: z.array(inboxNotificationSchema),
+\tpage: cursorPageSchema,
+});
+
+export const unreadCountOutputSchema = z.object({
+\tcount: z.number().int().min(0),
+});
+
+export const markReadPathSchema = z.object({
+\tnotificationId: z.string().min(1),
+});
+
+export const markAllReadOutputSchema = z.object({
+\tupdated: z.number().int().min(0),
+});
+
+export type InboxNotificationType = z.infer<typeof inboxNotificationTypeSchema>;
+export type InboxNotification = z.infer<typeof inboxNotificationSchema>;
+`;
+}
+export function inboxPortsFile() {
+    return `import type {
+\tCursorPage,
+\tCursorPageInfo,
+\tPageResult,
+} from "@beignet/core/pagination";
+import type { InboxNotification, InboxNotificationType } from "./schemas";
+
+export type { InboxNotification, InboxNotificationType };
+
+/**
+ * A user's inbox is personal: rows are scoped by the recipient's user id, so
+ * no tenant is required.
+ */
+export type InboxUserScope = {
+\tuserId: string;
+};
+
+/**
+ * Input written by the in-app notification channel
+ * (\`features/inbox/channel.ts\`) and by seeds.
+ */
+export type InboxNotificationInput = {
+\tuserId: string;
+\ttype: InboxNotificationType;
+\ttitle: string;
+\tbody?: string;
+\t/** Optional key linking the notification to an app resource. */
+\tresourceKey?: string;
+\tactorUserId?: string;
+\tactorName?: string;
+};
+
+export interface InboxRepository {
+\tfindMany(
+\t\tparams: InboxUserScope & {
+\t\t\tunreadOnly?: boolean;
+\t\t\tpage: CursorPage;
+\t\t},
+\t): Promise<PageResult<InboxNotification, CursorPageInfo>>;
+\tunreadCount(scope: InboxUserScope): Promise<number>;
+\tcreate(input: InboxNotificationInput): Promise<InboxNotification>;
+\tmarkRead(
+\t\tlookup: InboxUserScope & { id: string },
+\t): Promise<InboxNotification | null>;
+\t/** Returns the number of notifications marked read. */
+\tmarkAllRead(scope: InboxUserScope): Promise<number>;
+}
+`;
+}
+export function inboxChannelFile(config) {
+    const portsModule = aliasModule(path.join(config.paths.features, "inbox/ports.ts"));
+    return `import type {
+\tInferSchemaOutput,
+\tNotificationChannelHandler,
+\tStandardSchema,
+} from "@beignet/core/notifications";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import type { InboxNotificationInput } from "${portsModule}";
+
+export type { InboxNotificationInput };
+
+/**
+ * In-app notification channel that writes rows through the inbox repository
+ * port. Return \`null\` (or an empty array) from \`render\` to skip delivery.
+ *
+ * Used as a \`channels\` entry in \`defineNotification(...)\`, alongside
+ * \`defineMailNotificationChannel(...)\`.
+ */
+export function defineInboxNotificationChannel<Payload extends StandardSchema>(
+\trender: (args: {
+\t\tpayload: InferSchemaOutput<Payload>;
+\t\tctx: AppContext;
+\t}) => InboxNotificationInput | InboxNotificationInput[] | null,
+): NotificationChannelHandler<Payload, AppContext> {
+\treturn async ({ payload, ctx, channel }) => {
+\t\tconst rendered = render({ payload, ctx });
+\t\tconst entries =
+\t\t\trendered == null ? [] : Array.isArray(rendered) ? rendered : [rendered];
+
+\t\tif (entries.length === 0) {
+\t\t\treturn {
+\t\t\t\tchannel,
+\t\t\t\tstatus: "skipped",
+\t\t\t\treason: "No inbox entries to write.",
+\t\t\t};
+\t\t}
+
+\t\tconst created = await Promise.all(
+\t\t\tentries.map((entry) => ctx.ports.inbox.create(entry)),
+\t\t);
+
+\t\treturn {
+\t\t\tchannel,
+\t\t\tstatus: "sent",
+\t\t\tdetails: {
+\t\t\t\tnotificationIds: created.map((notification) => notification.id),
+\t\t\t},
+\t\t};
+\t};
+}
+`;
+}
+export function inboxContractsFile(config) {
+    const schemasModule = aliasModule(path.join(config.paths.features, "inbox/schemas.ts"));
+    const errorsModule = aliasModule(resourceSharedErrorsPath(config));
+    return `import { defineContractGroup } from "@beignet/core/contracts";
+import {
+\tinboxNotificationSchema,
+\tlistInboxOutputSchema,
+\tlistInboxQuerySchema,
+\tmarkAllReadOutputSchema,
+\tmarkReadPathSchema,
+\tunreadCountOutputSchema,
+} from "${schemasModule}";
+import { errors } from "${errorsModule}";
+
+const inbox = defineContractGroup().namespace("inbox").prefix("/api/inbox");
+
+export const listInbox = inbox
+\t.get("/")
+\t.query(listInboxQuerySchema)
+\t.meta({ auth: "required" })
+\t.errors({ Unauthorized: errors.Unauthorized })
+\t.responses({
+\t\t200: listInboxOutputSchema,
+\t})
+\t.openapi({ summary: "List inbox notifications", tags: ["inbox"] });
+
+export const unreadCount = inbox
+\t.get("/unread-count")
+\t.meta({ auth: "required" })
+\t.errors({ Unauthorized: errors.Unauthorized })
+\t.responses({
+\t\t200: unreadCountOutputSchema,
+\t})
+\t.openapi({ summary: "Count unread inbox notifications", tags: ["inbox"] });
+
+export const markRead = inbox
+\t.post("/:notificationId/read")
+\t.pathParams(markReadPathSchema)
+\t.meta({ auth: "required" })
+\t.errors({
+\t\tNotificationNotFound: errors.NotificationNotFound,
+\t\tUnauthorized: errors.Unauthorized,
+\t})
+\t.responses({
+\t\t200: inboxNotificationSchema,
+\t})
+\t.openapi({ summary: "Mark an inbox notification read", tags: ["inbox"] });
+
+export const markAllRead = inbox
+\t.post("/read-all")
+\t.meta({ auth: "required" })
+\t.errors({ Unauthorized: errors.Unauthorized })
+\t.responses({
+\t\t200: markAllReadOutputSchema,
+\t})
+\t.openapi({ summary: "Mark all inbox notifications read", tags: ["inbox"] });
+
+export const inboxContracts = [listInbox, unreadCount, markRead, markAllRead];
+`;
+}
+export function inboxListUseCaseFile(config) {
+    return `import { normalizeCursorPage } from "@beignet/core/pagination";
+import { requireUserId } from "@beignet/core/ports";
+import { useCase } from "${aliasModule(config.paths.useCaseBuilder)}";
+import { listInboxOutputSchema, listInboxQuerySchema } from "../schemas";
+
+/**
+ * Cursor-paginated inbox for the signed-in user, newest first. Rows are
+ * scoped to the caller's user id — a user can only ever see their own inbox,
+ * so no policy is involved.
+ */
+export const listInboxUseCase = useCase
+\t.query("inbox.list")
+\t.input(listInboxQuerySchema)
+\t.output(listInboxOutputSchema)
+\t.run(async ({ ctx, input }) => {
+\t\tconst userId = requireUserId(ctx);
+\t\tconst page = normalizeCursorPage(
+\t\t\t{ limit: input.limit, cursor: input.cursor ?? null },
+\t\t\t{ defaultLimit: 20, maxLimit: 50 },
+\t\t);
+
+\t\tconst result = await ctx.ports.inbox.findMany({
+\t\t\tuserId,
+\t\t\tunreadOnly: input.unread,
+\t\t\tpage,
+\t\t});
+
+\t\treturn { items: [...result.items], page: result.page };
+\t});
+`;
+}
+export function inboxUnreadCountUseCaseFile(config) {
+    return `import { requireUserId } from "@beignet/core/ports";
+import { z } from "zod";
+import { useCase } from "${aliasModule(config.paths.useCaseBuilder)}";
+import { unreadCountOutputSchema } from "../schemas";
+
+/**
+ * Unread inbox count for the signed-in user; polled by the unread badge.
+ */
+export const getUnreadCountUseCase = useCase
+\t.query("inbox.unread-count")
+\t.input(z.object({}))
+\t.output(unreadCountOutputSchema)
+\t.run(async ({ ctx }) => {
+\t\tconst userId = requireUserId(ctx);
+\t\tconst count = await ctx.ports.inbox.unreadCount({ userId });
+
+\t\treturn { count };
+\t});
+`;
+}
+export function inboxMarkReadUseCaseFile(config) {
+    const errorsModule = aliasModule(resourceSharedErrorsPath(config));
+    return `import { requireUserId } from "@beignet/core/ports";
+import { appError } from "${errorsModule}";
+import { useCase } from "${aliasModule(config.paths.useCaseBuilder)}";
+import { inboxNotificationSchema, markReadPathSchema } from "../schemas";
+
+/**
+ * Marks one of the caller's notifications read. The repository lookup is
+ * scoped by (user, id), so another user's notification reads as not found
+ * rather than forbidden.
+ */
+export const markReadUseCase = useCase
+\t.command("inbox.mark-read")
+\t.input(markReadPathSchema)
+\t.output(inboxNotificationSchema)
+\t.run(async ({ ctx, input }) => {
+\t\tconst userId = requireUserId(ctx);
+
+\t\treturn ctx.ports.uow.transaction(async (tx) => {
+\t\t\tconst notification = await tx.inbox.markRead({
+\t\t\t\tuserId,
+\t\t\t\tid: input.notificationId,
+\t\t\t});
+\t\t\tif (!notification) {
+\t\t\t\tthrow appError("NotificationNotFound", {
+\t\t\t\t\tdetails: { notificationId: input.notificationId },
+\t\t\t\t});
+\t\t\t}
+
+\t\t\treturn notification;
+\t\t});
+\t});
+`;
+}
+export function inboxMarkAllReadUseCaseFile(config) {
+    return `import { requireUserId } from "@beignet/core/ports";
+import { z } from "zod";
+import { useCase } from "${aliasModule(config.paths.useCaseBuilder)}";
+import { markAllReadOutputSchema } from "../schemas";
+
+/**
+ * Marks every unread notification in the caller's inbox as read.
+ */
+export const markAllReadUseCase = useCase
+\t.command("inbox.mark-all-read")
+\t.input(z.object({}))
+\t.output(markAllReadOutputSchema)
+\t.run(async ({ ctx }) => {
+\t\tconst userId = requireUserId(ctx);
+
+\t\treturn ctx.ports.uow.transaction(async (tx) => {
+\t\t\tconst updated = await tx.inbox.markAllRead({ userId });
+
+\t\t\treturn { updated };
+\t\t});
+\t});
+`;
+}
+export function inboxUseCasesIndexFile() {
+    return `export { getUnreadCountUseCase } from "./get-unread-count";
+export { listInboxUseCase } from "./list-inbox";
+export { markAllReadUseCase } from "./mark-all-read";
+export { markReadUseCase } from "./mark-read";
+`;
+}
+export function inboxRoutesFile(config) {
+    const contractsModule = aliasModule(path.join(config.paths.features, "inbox/contracts.ts"));
+    const useCasesModule = aliasModule(path.join(config.paths.features, "inbox/use-cases/index.ts"));
+    return `import { defineRouteGroup } from "@beignet/next";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import {
+\tlistInbox,
+\tmarkAllRead,
+\tmarkRead,
+\tunreadCount,
+} from "${contractsModule}";
+import {
+\tgetUnreadCountUseCase,
+\tlistInboxUseCase,
+\tmarkAllReadUseCase,
+\tmarkReadUseCase,
+} from "${useCasesModule}";
+
+export const inboxRoutes = defineRouteGroup<AppContext>()({
+\tname: "inbox",
+\troutes: [
+\t\t{ contract: listInbox, useCase: listInboxUseCase },
+\t\t{ contract: unreadCount, useCase: getUnreadCountUseCase },
+\t\t{ contract: markRead, useCase: markReadUseCase },
+\t\t{ contract: markAllRead, useCase: markAllReadUseCase },
+\t],
+});
+`;
+}
+export function inboxNotificationsFile(config) {
+    const channelModule = aliasModule(path.join(config.paths.features, "inbox/channel.ts"));
+    return `import { z } from "zod";
+import { defineInboxNotificationChannel } from "${channelModule}";
+import { defineNotification } from "${aliasModule(config.paths.notificationsBuilder)}";
+
+const welcomePayloadSchema = z.object({
+\tuserId: z.string().min(1),
+\tname: z.string().optional(),
+});
+
+/**
+ * Sample in-app notification demonstrating the inbox channel. Send it with
+ * \`ctx.ports.notifications.send(InboxWelcomeNotification, { userId })\`, and
+ * add an \`inApp\` channel like this one to any feature's notification to
+ * deliver it to the inbox.
+ */
+export const InboxWelcomeNotification = defineNotification("inbox.welcome", {
+\tpayload: welcomePayloadSchema,
+\tdescription: "Welcomes a new user in their in-app inbox.",
+\tchannels: {
+\t\tinApp: defineInboxNotificationChannel(({ payload }) => ({
+\t\t\tuserId: payload.userId,
+\t\t\ttype: "welcome",
+\t\t\ttitle: payload.name ? \`Welcome, \${payload.name}!\` : "Welcome!",
+\t\t\tbody: "This notification was delivered to your in-app inbox.",
+\t\t})),
+\t},
+});
+
+export const inboxNotifications = [InboxWelcomeNotification] as const;
+`;
+}
+export function inboxSeedsFile(config) {
+    const portsModule = aliasModule(path.join(config.paths.features, "inbox/ports.ts"));
+    return `import { normalizeCursorPage } from "@beignet/core/pagination";
+import { defineSeed } from "@beignet/core/testing";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import type { InboxNotificationInput } from "${portsModule}";
+
+/**
+ * Demo inbox rows for local development. The starter has no seeded users, so
+ * rows target a placeholder user id; change DEMO_USER_ID to a real user id
+ * (for example your first sign-up) to see them in the app.
+ */
+const DEMO_USER_ID = "demo-user";
+
+const rows: readonly (InboxNotificationInput & { read?: boolean })[] = [
+\t{
+\t\tuserId: DEMO_USER_ID,
+\t\ttype: "welcome",
+\t\ttitle: "Welcome to your inbox",
+\t\tbody: "In-app notifications from your features land here.",
+\t},
+\t{
+\t\tuserId: DEMO_USER_ID,
+\t\ttype: "mention",
+\t\ttitle: "You were mentioned",
+\t\tbody: "Demo data seeded by beignet make inbox.",
+\t\tresourceKey: "demo-resource",
+\t},
+\t{
+\t\tuserId: DEMO_USER_ID,
+\t\ttype: "status_change",
+\t\ttitle: "A resource you follow changed",
+\t\tread: true,
+\t},
+];
+
+export const inboxDemoSeed = defineSeed<"inbox.demo", AppContext>(
+\t"inbox.demo",
+\t{
+\t\tdescription: "Demo inbox notifications for local development.",
+\t\tasync run(ctx) {
+\t\t\tconst existing = await ctx.ports.inbox.findMany({
+\t\t\t\tuserId: DEMO_USER_ID,
+\t\t\t\tpage: normalizeCursorPage(
+\t\t\t\t\t{ limit: 50 },
+\t\t\t\t\t{ defaultLimit: 50, maxLimit: 50 },
+\t\t\t\t),
+\t\t\t});
+
+\t\t\tfor (const { read, ...input } of rows) {
+\t\t\t\t// Idempotent: skip rows that were already seeded.
+\t\t\t\tif (existing.items.some((item) => item.title === input.title)) {
+\t\t\t\t\tcontinue;
+\t\t\t\t}
+
+\t\t\t\tconst created = await ctx.ports.inbox.create(input);
+\t\t\t\tif (read) {
+\t\t\t\t\tawait ctx.ports.inbox.markRead({
+\t\t\t\t\t\tuserId: input.userId,
+\t\t\t\t\t\tid: created.id,
+\t\t\t\t\t});
+\t\t\t\t}
+\t\t\t}
+\t\t},
+\t},
+);
+
+export const inboxSeeds = [inboxDemoSeed] as const;
+`;
+}
+export function inboxFactoryFile(config) {
+    const portsModule = aliasModule(path.join(config.paths.features, "inbox/ports.ts"));
+    return `import { cursorPageResult } from "@beignet/core/pagination";
+import { createFactory } from "@beignet/core/testing";
+import type { InboxNotification, InboxRepository } from "${portsModule}";
+
+export const inboxNotificationFactory = createFactory("inbox.notification", {
+\tdefaults: ({ sequence, clock }): InboxNotification => ({
+\t\tid: \`00000000-0000-4000-a000-\${String(sequence).padStart(12, "0")}\`,
+\t\tuserId: "user_test",
+\t\ttype: "mention",
+\t\ttitle: \`Notification \${sequence}\`,
+\t\tbody: null,
+\t\tresourceKey: null,
+\t\tactorUserId: null,
+\t\tactorName: null,
+\t\treadAt: null,
+\t\t// Spread timestamps out so cursor ordering (created_at desc, id desc)
+\t\t// is deterministic per sequence.
+\t\tcreatedAt: new Date(clock.now().getTime() + sequence * 1_000).toISOString(),
+\t}),
+});
+
+export type MemoryInboxRepository = InboxRepository & {
+\trows: InboxNotification[];
+};
+
+/**
+ * In-memory InboxRepository mirroring the Drizzle adapter: newest first,
+ * cursor is the last row's id, lookups scoped by user id.
+ */
+export function createMemoryInboxRepository(
+\tseed: readonly InboxNotification[] = [],
+): MemoryInboxRepository {
+\tconst rows: InboxNotification[] = [...seed];
+\tlet sequence = rows.length;
+
+\tconst scoped = (userId: string) =>
+\t\trows
+\t\t\t.filter((row) => row.userId === userId)
+\t\t\t.sort((a, b) =>
+\t\t\t\ta.createdAt === b.createdAt
+\t\t\t\t\t? b.id.localeCompare(a.id)
+\t\t\t\t\t: b.createdAt.localeCompare(a.createdAt),
+\t\t\t);
+
+\treturn {
+\t\trows,
+
+\t\tasync findMany(params) {
+\t\t\tlet matches = scoped(params.userId);
+\t\t\tif (params.unreadOnly) {
+\t\t\t\tmatches = matches.filter((row) => row.readAt === null);
+\t\t\t}
+\t\t\tif (params.page.cursor) {
+\t\t\t\tconst index = matches.findIndex(
+\t\t\t\t\t(row) => row.id === params.page.cursor,
+\t\t\t\t);
+\t\t\t\tmatches = index === -1 ? [] : matches.slice(index + 1);
+\t\t\t}
+
+\t\t\tconst items = matches.slice(0, params.page.limit);
+\t\t\tconst hasMore = matches.length > params.page.limit;
+\t\t\tconst lastItem = items[items.length - 1];
+\t\t\treturn cursorPageResult(
+\t\t\t\titems,
+\t\t\t\tparams.page,
+\t\t\t\thasMore && lastItem ? lastItem.id : null,
+\t\t\t);
+\t\t},
+
+\t\tasync unreadCount({ userId }) {
+\t\t\treturn scoped(userId).filter((row) => row.readAt === null).length;
+\t\t},
+
+\t\tasync create(input) {
+\t\t\tsequence += 1;
+\t\t\tconst row: InboxNotification = {
+\t\t\t\tid: \`inbox-\${sequence}\`,
+\t\t\t\tuserId: input.userId,
+\t\t\t\ttype: input.type,
+\t\t\t\ttitle: input.title,
+\t\t\t\tbody: input.body ?? null,
+\t\t\t\tresourceKey: input.resourceKey ?? null,
+\t\t\t\tactorUserId: input.actorUserId ?? null,
+\t\t\t\tactorName: input.actorName ?? null,
+\t\t\t\treadAt: null,
+\t\t\t\tcreatedAt: new Date().toISOString(),
+\t\t\t};
+\t\t\trows.push(row);
+\t\t\treturn row;
+\t\t},
+
+\t\tasync markRead({ userId, id }) {
+\t\t\tconst row = rows.find(
+\t\t\t\t(candidate) => candidate.userId === userId && candidate.id === id,
+\t\t\t);
+\t\t\tif (!row) return null;
+\t\t\tif (row.readAt === null) row.readAt = new Date().toISOString();
+\t\t\treturn row;
+\t\t},
+
+\t\tasync markAllRead({ userId }) {
+\t\t\tconst unread = scoped(userId).filter((row) => row.readAt === null);
+\t\t\tconst readAt = new Date().toISOString();
+\t\t\tfor (const row of unread) row.readAt = readAt;
+\t\t\treturn unread.length;
+\t\t},
+\t};
+}
+`;
+}
+export function inboxTestFile(config) {
+    return `import { describe, expect, it } from "bun:test";
+import { createUseCaseTester } from "@beignet/core/application";
+import { createAnonymousActor } from "@beignet/core/ports";
+import { createTestUserActor } from "@beignet/core/ports/testing";
+import {
+\tcreateTestContextFactory,
+\tcreateTestPorts,
+} from "@beignet/core/testing";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import { appPorts } from "${aliasModule(config.paths.infrastructurePorts)}";
+import type { AppTransactionPorts } from "${aliasModule(config.paths.ports)}";
+import { getUnreadCountUseCase } from "../use-cases/get-unread-count";
+import { listInboxUseCase } from "../use-cases/list-inbox";
+import { markAllReadUseCase } from "../use-cases/mark-all-read";
+import { markReadUseCase } from "../use-cases/mark-read";
+import {
+\tcreateMemoryInboxRepository,
+\tinboxNotificationFactory,
+\ttype MemoryInboxRepository,
+} from "./factories/inbox-notification";
+
+function createHarness(
+\toptions: {
+\t\tactor?: AppContext["actor"];
+\t\tinbox?: MemoryInboxRepository;
+\t} = {},
+) {
+\tconst inbox = options.inbox ?? createMemoryInboxRepository();
+\tconst actor = options.actor ?? createTestUserActor("user_test");
+\tconst fixture = createTestPorts<AppContext["ports"], AppTransactionPorts>({
+\t\tbase: appPorts,
+\t\toverrides: {
+\t\t\tgate: appPorts.gate,
+\t\t\tinbox,
+\t\t},
+\t});
+\tconst createContext = createTestContextFactory<
+\t\tAppContext,
+\t\tAppContext["ports"]
+\t>({
+\t\tports: fixture.ports,
+\t\tactor,
+\t\tauth:
+\t\t\tactor.type === "user" && actor.id
+\t\t\t\t? { user: { id: actor.id }, session: { id: "session_test" } }
+\t\t\t\t: null,
+\t});
+
+\treturn { inbox, tester: createUseCaseTester<AppContext>(createContext) };
+}
+
+function seededInbox() {
+\treturn createMemoryInboxRepository([
+\t\t// Rows for the caller: three unread, one read.
+\t\t...inboxNotificationFactory.buildList(3, { userId: "user_test" }),
+\t\tinboxNotificationFactory.build({
+\t\t\tuserId: "user_test",
+\t\t\treadAt: "2026-01-01T00:00:00.000Z",
+\t\t}),
+\t\t// A row belonging to someone else; it must never leak into results.
+\t\tinboxNotificationFactory.build({
+\t\t\tid: "inbox-other-1",
+\t\t\tuserId: "user_other",
+\t\t}),
+\t]);
+}
+
+describe("listInboxUseCase", () => {
+\tit("requires an authenticated user", async () => {
+\t\tconst harness = createHarness({ actor: createAnonymousActor() });
+
+\t\tawait expect(
+\t\t\tharness.tester.run(listInboxUseCase, { limit: 20, unread: false }),
+\t\t).rejects.toMatchObject({ code: "UNAUTHORIZED" });
+\t});
+
+\tit("returns only the caller's rows, newest first, with cursor paging", async () => {
+\t\tconst harness = createHarness({ inbox: seededInbox() });
+
+\t\tconst firstPage = await harness.tester.run(listInboxUseCase, {
+\t\t\tlimit: 3,
+\t\t\tunread: false,
+\t\t});
+\t\texpect(firstPage.items).toHaveLength(3);
+\t\texpect(firstPage.items.every((item) => item.userId === "user_test")).toBe(
+\t\t\ttrue,
+\t\t);
+\t\texpect(firstPage.page.hasMore).toBe(true);
+\t\texpect(firstPage.page.nextCursor).not.toBeNull();
+
+\t\tconst secondPage = await harness.tester.run(listInboxUseCase, {
+\t\t\tlimit: 3,
+\t\t\tcursor: firstPage.page.nextCursor ?? undefined,
+\t\t\tunread: false,
+\t\t});
+\t\texpect(secondPage.items).toHaveLength(1);
+\t\texpect(secondPage.page.hasMore).toBe(false);
+\t\texpect(
+\t\t\tsecondPage.items.every(
+\t\t\t\t(item) => !firstPage.items.some((seen) => seen.id === item.id),
+\t\t\t),
+\t\t).toBe(true);
+\t});
+
+\tit("filters to unread rows when asked", async () => {
+\t\tconst harness = createHarness({ inbox: seededInbox() });
+
+\t\tconst result = await harness.tester.run(listInboxUseCase, {
+\t\t\tlimit: 20,
+\t\t\tunread: true,
+\t\t});
+
+\t\texpect(result.items).toHaveLength(3);
+\t\texpect(result.items.every((item) => item.readAt === null)).toBe(true);
+\t});
+});
+
+describe("getUnreadCountUseCase", () => {
+\tit("counts the caller's unread rows only", async () => {
+\t\tconst harness = createHarness({ inbox: seededInbox() });
+
+\t\tawait expect(
+\t\t\tharness.tester.run(getUnreadCountUseCase, {}),
+\t\t).resolves.toEqual({ count: 3 });
+\t});
+});
+
+describe("markReadUseCase", () => {
+\tit("marks one of the caller's notifications read", async () => {
+\t\tconst inbox = seededInbox();
+\t\tconst harness = createHarness({ inbox });
+
+\t\tconst target = inbox.rows.find(
+\t\t\t(row) => row.userId === "user_test" && row.readAt === null,
+\t\t);
+\t\tif (!target) throw new Error("Expected an unread row.");
+
+\t\tconst updated = await harness.tester.run(markReadUseCase, {
+\t\t\tnotificationId: target.id,
+\t\t});
+
+\t\texpect(updated.readAt).not.toBeNull();
+\t\tawait expect(
+\t\t\tharness.tester.run(getUnreadCountUseCase, {}),
+\t\t).resolves.toEqual({ count: 2 });
+\t});
+
+\tit("treats other users' notifications as not found", async () => {
+\t\tconst harness = createHarness({ inbox: seededInbox() });
+
+\t\tawait expect(
+\t\t\tharness.tester.run(markReadUseCase, {
+\t\t\t\tnotificationId: "inbox-other-1",
+\t\t\t}),
+\t\t).rejects.toMatchObject({ code: "NOTIFICATION_NOT_FOUND" });
+\t});
+});
+
+describe("markAllReadUseCase", () => {
+\tit("marks every unread row read and reports the count", async () => {
+\t\tconst inbox = seededInbox();
+\t\tconst harness = createHarness({ inbox });
+
+\t\tawait expect(
+\t\t\tharness.tester.run(markAllReadUseCase, {}),
+\t\t).resolves.toEqual({ updated: 3 });
+\t\tawait expect(
+\t\t\tharness.tester.run(getUnreadCountUseCase, {}),
+\t\t).resolves.toEqual({ count: 0 });
+
+\t\t// The other user's row is untouched.
+\t\tconst otherRow = inbox.rows.find((row) => row.userId === "user_other");
+\t\texpect(otherRow?.readAt).toBeNull();
+\t});
+});
+`;
+}
+export function inboxChannelTestFile(config) {
+    const channelModule = aliasModule(path.join(config.paths.features, "inbox/channel.ts"));
+    return `import { describe, expect, it } from "bun:test";
+import { createTestSystemActor } from "@beignet/core/ports/testing";
+import {
+\tcreateTestContextFactory,
+\tcreateTestPorts,
+} from "@beignet/core/testing";
+import { z } from "zod";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+import {
+\tdefineInboxNotificationChannel,
+\ttype InboxNotificationInput,
+} from "${channelModule}";
+import { appPorts } from "${aliasModule(config.paths.infrastructurePorts)}";
+import { defineNotification } from "${aliasModule(config.paths.notificationsBuilder)}";
+import type { AppTransactionPorts } from "${aliasModule(config.paths.ports)}";
+import { createMemoryInboxRepository } from "./factories/inbox-notification";
+
+const payloadSchema = z.object({
+\tuserIds: z.array(z.string()),
+\ttitle: z.string(),
+});
+
+const testNotification = defineNotification("inbox.channel-test", {
+\tpayload: payloadSchema,
+\tchannels: {
+\t\tinApp: defineInboxNotificationChannel(({ payload }) =>
+\t\t\tpayload.userIds.map(
+\t\t\t\t(userId): InboxNotificationInput => ({
+\t\t\t\t\tuserId,
+\t\t\t\t\ttype: "test",
+\t\t\t\t\ttitle: payload.title,
+\t\t\t\t}),
+\t\t\t),
+\t\t),
+\t},
+});
+
+const skippingNotification = defineNotification("inbox.channel-skip-test", {
+\tpayload: payloadSchema,
+\tchannels: {
+\t\tinApp: defineInboxNotificationChannel(() => null),
+\t},
+});
+
+function createHarness() {
+\tconst inbox = createMemoryInboxRepository();
+\tconst fixture = createTestPorts<AppContext["ports"], AppTransactionPorts>({
+\t\tbase: appPorts,
+\t\toverrides: {
+\t\t\tgate: appPorts.gate,
+\t\t\tinbox,
+\t\t},
+\t});
+\tconst createContext = createTestContextFactory<
+\t\tAppContext,
+\t\tAppContext["ports"]
+\t>({
+\t\tports: fixture.ports,
+\t\tactor: createTestSystemActor("test-channel"),
+\t\tauth: null,
+\t});
+
+\treturn { ctx: createContext(), inbox };
+}
+
+describe("defineInboxNotificationChannel", () => {
+\tit("writes one inbox row per rendered entry through the repository port", async () => {
+\t\tconst { ctx, inbox } = createHarness();
+
+\t\tconst handler = testNotification.channels.inApp;
+\t\tconst result = await handler({
+\t\t\tnotification: testNotification,
+\t\t\tpayload: {
+\t\t\t\tuserIds: ["user_a", "user_b"],
+\t\t\t\ttitle: "Hello from the inbox channel",
+\t\t\t},
+\t\t\tctx,
+\t\t\tchannel: "inApp",
+\t\t});
+
+\t\texpect(result).toMatchObject({ channel: "inApp", status: "sent" });
+\t\texpect(inbox.rows).toHaveLength(2);
+\t\texpect(inbox.rows.map((row) => row.userId)).toEqual([
+\t\t\t"user_a",
+\t\t\t"user_b",
+\t\t]);
+\t\texpect(inbox.rows[0]).toMatchObject({
+\t\t\ttype: "test",
+\t\t\ttitle: "Hello from the inbox channel",
+\t\t\treadAt: null,
+\t\t});
+\t\texpect(result?.details).toMatchObject({
+\t\t\tnotificationIds: inbox.rows.map((row) => row.id),
+\t\t});
+\t});
+
+\tit("skips delivery when the renderer returns null", async () => {
+\t\tconst { ctx, inbox } = createHarness();
+
+\t\tconst handler = skippingNotification.channels.inApp;
+\t\tconst result = await handler({
+\t\t\tnotification: skippingNotification,
+\t\t\tpayload: { userIds: [], title: "Nothing" },
+\t\t\tctx,
+\t\t\tchannel: "inApp",
+\t\t});
+
+\t\texpect(result).toMatchObject({ channel: "inApp", status: "skipped" });
+\t\texpect(inbox.rows).toHaveLength(0);
+\t});
+});
+`;
+}
+export function inboxDrizzleSchemaFile(database) {
+    const dialect = drizzleDialects[database];
+    const column = database === "mysql"
+        ? (columnName) => `varchar("${columnName}", { length: 255 })`
+        : (columnName) => `text("${columnName}")`;
+    // Notification bodies can exceed 255 characters, so MySQL stores them as
+    // text while shorter identifying columns stay varchar.
+    const bodyColumn = database === "mysql" ? 'text("body")' : column("body");
+    const imports = database === "mysql"
+        ? "index, mysqlTable, text, varchar"
+        : `index, ${dialect.tableFunction}, text`;
+    return `import { ${imports} } from "${dialect.columnModule}";
+
+export const inboxNotifications = ${dialect.tableFunction}(
+\t"inbox_notifications",
+\t{
+\t\tid: ${column("id")}.primaryKey(),
+\t\tuserId: ${column("user_id")}.notNull(),
+\t\ttype: ${column("type")}.notNull(),
+\t\ttitle: ${column("title")}.notNull(),
+\t\tbody: ${bodyColumn},
+\t\tresourceKey: ${column("resource_key")},
+\t\tactorUserId: ${column("actor_user_id")},
+\t\tactorName: ${column("actor_name")},
+\t\treadAt: ${column("read_at")},
+\t\tcreatedAt: ${column("created_at")}.notNull(),
+\t},
+\t(table) => ({
+\t\tunreadIdx: index("inbox_notifications_unread_idx").on(
+\t\t\ttable.userId,
+\t\t\ttable.readAt,
+\t\t),
+\t\tcursorIdx: index("inbox_notifications_cursor_idx").on(
+\t\t\ttable.userId,
+\t\t\ttable.createdAt,
+\t\t\ttable.id,
+\t\t),
+\t}),
+);
+`;
+}
+export function inboxDrizzleRepositoryFile(config, database) {
+    const dialect = drizzleDialects[database];
+    const portsModule = aliasModule(path.join(config.paths.features, "inbox/ports.ts"));
+    const schemaModule = aliasModule(path.join(infrastructureDir(config), "db/schema/index.ts"));
+    return `import { cursorPageResult } from "@beignet/core/pagination";
+import type { ${dialect.dbTypeName} } from "@beignet/provider-db-drizzle/${dialect.subpath}";
+import { and, count, desc, eq, isNull, lt, or, type SQL } from "drizzle-orm";
+import type { InboxNotification, InboxRepository } from "${portsModule}";
+import * as schema from "${schemaModule}";
+
+type InboxRow = typeof schema.inboxNotifications.$inferSelect;
+
+function toNotification(row: InboxRow): InboxNotification {
+\treturn {
+\t\tid: row.id,
+\t\tuserId: row.userId,
+\t\ttype: row.type,
+\t\ttitle: row.title,
+\t\tbody: row.body,
+\t\tresourceKey: row.resourceKey,
+\t\tactorUserId: row.actorUserId,
+\t\tactorName: row.actorName,
+\t\treadAt: row.readAt,
+\t\tcreatedAt: row.createdAt,
+\t};
+}
+
+type CursorPayload = {
+\tcreatedAt: string;
+\tid: string;
+};
+
+function encodeCursor(payload: CursorPayload): string {
+\treturn Buffer.from(JSON.stringify(payload)).toString("base64url");
+}
+
+function decodeCursor(cursor: string): CursorPayload | null {
+\ttry {
+\t\tconst parsed: unknown = JSON.parse(
+\t\t\tBuffer.from(cursor, "base64url").toString("utf8"),
+\t\t);
+\t\tif (typeof parsed !== "object" || parsed === null) return null;
+\t\tconst candidate = parsed as Record<string, unknown>;
+\t\tif (
+\t\t\ttypeof candidate.createdAt !== "string" ||
+\t\t\ttypeof candidate.id !== "string"
+\t\t) {
+\t\t\treturn null;
+\t\t}
+\t\treturn { createdAt: candidate.createdAt, id: candidate.id };
+\t} catch {
+\t\treturn null;
+\t}
+}
+
+export function createDrizzleInboxRepository(
+\tdb: ${dialect.dbTypeName}<typeof schema>,
+): InboxRepository {
+\treturn {
+\t\tasync findMany(params) {
+\t\t\tconst filters: SQL<unknown>[] = [
+\t\t\t\teq(schema.inboxNotifications.userId, params.userId),
+\t\t\t];
+\t\t\tif (params.unreadOnly) {
+\t\t\t\tfilters.push(isNull(schema.inboxNotifications.readAt));
+\t\t\t}
+
+\t\t\tconst cursor = params.page.cursor
+\t\t\t\t? decodeCursor(params.page.cursor)
+\t\t\t\t: null;
+\t\t\tif (cursor) {
+\t\t\t\tfilters.push(
+\t\t\t\t\tor(
+\t\t\t\t\t\tlt(schema.inboxNotifications.createdAt, cursor.createdAt),
+\t\t\t\t\t\tand(
+\t\t\t\t\t\t\teq(schema.inboxNotifications.createdAt, cursor.createdAt),
+\t\t\t\t\t\t\tlt(schema.inboxNotifications.id, cursor.id),
+\t\t\t\t\t\t),
+\t\t\t\t\t) as SQL<unknown>,
+\t\t\t\t);
+\t\t\t}
+
+\t\t\tconst rows = await db
+\t\t\t\t.select()
+\t\t\t\t.from(schema.inboxNotifications)
+\t\t\t\t.where(and(...filters))
+\t\t\t\t.orderBy(
+\t\t\t\t\tdesc(schema.inboxNotifications.createdAt),
+\t\t\t\t\tdesc(schema.inboxNotifications.id),
+\t\t\t\t)
+\t\t\t\t.limit(params.page.limit + 1);
+
+\t\t\tconst pageRows = rows.slice(0, params.page.limit);
+\t\t\tconst hasMore = rows.length > params.page.limit;
+\t\t\tconst items = pageRows.map(toNotification);
+\t\t\tconst lastItem = items[items.length - 1];
+\t\t\tconst nextCursor =
+\t\t\t\thasMore && lastItem
+\t\t\t\t\t? encodeCursor({ createdAt: lastItem.createdAt, id: lastItem.id })
+\t\t\t\t\t: null;
+
+\t\t\treturn cursorPageResult(items, params.page, nextCursor);
+\t\t},
+
+\t\tasync unreadCount({ userId }) {
+\t\t\tconst [row] = await db
+\t\t\t\t.select({ total: count() })
+\t\t\t\t.from(schema.inboxNotifications)
+\t\t\t\t.where(
+\t\t\t\t\tand(
+\t\t\t\t\t\teq(schema.inboxNotifications.userId, userId),
+\t\t\t\t\t\tisNull(schema.inboxNotifications.readAt),
+\t\t\t\t\t),
+\t\t\t\t);
+
+\t\t\treturn row?.total ?? 0;
+\t\t},
+
+\t\tasync create(input) {
+\t\t\t// The row is built locally so every dialect (including MySQL, which
+\t\t\t// has no INSERT ... RETURNING) returns the same shape.
+\t\t\tconst row: InboxRow = {
+\t\t\t\tid: crypto.randomUUID(),
+\t\t\t\tuserId: input.userId,
+\t\t\t\ttype: input.type,
+\t\t\t\ttitle: input.title,
+\t\t\t\tbody: input.body ?? null,
+\t\t\t\tresourceKey: input.resourceKey ?? null,
+\t\t\t\tactorUserId: input.actorUserId ?? null,
+\t\t\t\tactorName: input.actorName ?? null,
+\t\t\t\treadAt: null,
+\t\t\t\tcreatedAt: new Date().toISOString(),
+\t\t\t};
+
+\t\t\tawait db.insert(schema.inboxNotifications).values(row);
+
+\t\t\treturn toNotification(row);
+\t\t},
+
+\t\tasync markRead({ userId, id }) {
+\t\t\tconst [existing] = await db
+\t\t\t\t.select()
+\t\t\t\t.from(schema.inboxNotifications)
+\t\t\t\t.where(
+\t\t\t\t\tand(
+\t\t\t\t\t\teq(schema.inboxNotifications.userId, userId),
+\t\t\t\t\t\teq(schema.inboxNotifications.id, id),
+\t\t\t\t\t),
+\t\t\t\t)
+\t\t\t\t.limit(1);
+
+\t\t\tif (!existing) return null;
+\t\t\tif (existing.readAt) return toNotification(existing);
+
+\t\t\tconst readAt = new Date().toISOString();
+\t\t\tawait db
+\t\t\t\t.update(schema.inboxNotifications)
+\t\t\t\t.set({ readAt })
+\t\t\t\t.where(
+\t\t\t\t\tand(
+\t\t\t\t\t\teq(schema.inboxNotifications.userId, userId),
+\t\t\t\t\t\teq(schema.inboxNotifications.id, id),
+\t\t\t\t\t),
+\t\t\t\t);
+
+\t\t\treturn toNotification({ ...existing, readAt });
+\t\t},
+
+\t\tasync markAllRead({ userId }) {
+\t\t\tconst unread = await db
+\t\t\t\t.select({ id: schema.inboxNotifications.id })
+\t\t\t\t.from(schema.inboxNotifications)
+\t\t\t\t.where(
+\t\t\t\t\tand(
+\t\t\t\t\t\teq(schema.inboxNotifications.userId, userId),
+\t\t\t\t\t\tisNull(schema.inboxNotifications.readAt),
+\t\t\t\t\t),
+\t\t\t\t);
+\t\t\tif (unread.length === 0) return 0;
+
+\t\t\tawait db
+\t\t\t\t.update(schema.inboxNotifications)
+\t\t\t\t.set({ readAt: new Date().toISOString() })
+\t\t\t\t.where(
+\t\t\t\t\tand(
+\t\t\t\t\t\teq(schema.inboxNotifications.userId, userId),
+\t\t\t\t\t\tisNull(schema.inboxNotifications.readAt),
+\t\t\t\t\t),
+\t\t\t\t);
+
+\t\t\treturn unread.length;
+\t\t},
+\t};
+}
+`;
+}
+export function inboxClientQueriesFile(config) {
+    const contractsModule = aliasModule(path.join(config.paths.features, "inbox/contracts.ts"));
+    return `import { cursorPagination } from "@beignet/react-query";
+import { keepPreviousData, type QueryClient } from "@tanstack/react-query";
+import { rq } from "@/client";
+import {
+\tlistInbox,
+\tmarkAllRead,
+\tmarkRead,
+\tunreadCount,
+} from "${contractsModule}";
+
+const PAGE_SIZE = 20;
+
+export function listInboxInfiniteQueryOptions(
+\toptions: { unread?: boolean } = {},
+) {
+\treturn rq(listInbox).infiniteQueryOptions({
+\t\tquery: { limit: PAGE_SIZE, unread: options.unread ?? false },
+\t\t...cursorPagination(),
+\t\tplaceholderData: keepPreviousData,
+\t});
+}
+
+export function unreadCountQueryOptions() {
+\treturn rq(unreadCount).queryOptions();
+}
+
+export function markReadMutationOptions() {
+\treturn rq(markRead).mutationOptions();
+}
+
+export function markAllReadMutationOptions() {
+\treturn rq(markAllRead).mutationOptions();
+}
+
+export function invalidateInbox(queryClient: QueryClient) {
+\treturn Promise.all([
+\t\trq(listInbox).invalidate(queryClient),
+\t\trq(unreadCount).invalidate(queryClient),
+\t]);
+}
+`;
+}
+export function inboxUnreadBadgeFile(config) {
+    const queriesModule = aliasModule(path.join(config.paths.features, "inbox/client/queries.ts"));
+    return `"use client";
+
+import { useQuery } from "@tanstack/react-query";
+import { unreadCountQueryOptions } from "${queriesModule}";
+
+const POLL_INTERVAL_MS = 30_000;
+
+/**
+ * Unread inbox count badge. Polls GET /api/inbox/unread-count while mounted;
+ * render it next to your Inbox nav link.
+ */
+export function UnreadBadge() {
+\tconst countQuery = useQuery({
+\t\t...unreadCountQueryOptions(),
+\t\tstaleTime: POLL_INTERVAL_MS,
+\t\trefetchInterval: POLL_INTERVAL_MS,
+\t\tretry: false,
+\t});
+
+\tconst count = countQuery.data?.count ?? 0;
+\tif (countQuery.isError || count === 0) return null;
+
+\treturn (
+\t\t<span
+\t\t\trole="status"
+\t\t\tclassName="inline-flex min-w-5 items-center justify-center rounded-full bg-primary px-1.5 py-0.5 text-xs font-medium leading-none text-primary-foreground"
+\t\t\taria-label={\`\${count} unread notifications\`}
+\t\t>
+\t\t\t{count > 99 ? "99+" : count}
+\t\t</span>
+\t);
+}
+`;
+}
+export function inboxItemComponentFile(config) {
+    const queriesModule = aliasModule(path.join(config.paths.features, "inbox/client/queries.ts"));
+    const schemasModule = aliasModule(path.join(config.paths.features, "inbox/schemas.ts"));
+    return `"use client";
+
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { BellIcon } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import {
+\tinvalidateInbox,
+\tmarkReadMutationOptions,
+} from "${queriesModule}";
+import type { InboxNotification } from "${schemasModule}";
+import { cn } from "@/lib/utils";
+
+function formatDate(value: string) {
+\treturn new Date(value).toLocaleDateString(undefined, {
+\t\tmonth: "short",
+\t\tday: "numeric",
+\t});
+}
+
+export function InboxItem({
+\tnotification,
+}: {
+\tnotification: InboxNotification;
+}) {
+\tconst queryClient = useQueryClient();
+\tconst unread = notification.readAt === null;
+
+\tconst markReadMutation = useMutation({
+\t\t...markReadMutationOptions(),
+\t\tonSuccess: () => invalidateInbox(queryClient),
+\t});
+
+\treturn (
+\t\t<div
+\t\t\tclassName={cn(
+\t\t\t\t"flex items-start gap-3 rounded-lg border bg-card p-3",
+\t\t\t\tunread && "border-primary/40",
+\t\t\t)}
+\t\t>
+\t\t\t<BellIcon className="mt-0.5 size-4 shrink-0 text-muted-foreground" />
+\t\t\t<div className="min-w-0 flex-1">
+\t\t\t\t<div className="flex items-center gap-2">
+\t\t\t\t\t{unread ? (
+\t\t\t\t\t\t<span className="size-1.5 shrink-0 rounded-full bg-primary">
+\t\t\t\t\t\t\t<span className="sr-only">Unread</span>
+\t\t\t\t\t\t</span>
+\t\t\t\t\t) : null}
+\t\t\t\t\t<span className="truncate text-sm font-medium">
+\t\t\t\t\t\t{notification.title}
+\t\t\t\t\t</span>
+\t\t\t\t\t<span className="ml-auto shrink-0 text-xs text-muted-foreground">
+\t\t\t\t\t\t{formatDate(notification.createdAt)}
+\t\t\t\t\t</span>
+\t\t\t\t</div>
+\t\t\t\t{notification.body ? (
+\t\t\t\t\t<p className="mt-0.5 truncate text-sm text-muted-foreground">
+\t\t\t\t\t\t{notification.body}
+\t\t\t\t\t</p>
+\t\t\t\t) : null}
+\t\t\t</div>
+\t\t\t{unread ? (
+\t\t\t\t<Button
+\t\t\t\t\ttype="button"
+\t\t\t\t\tvariant="ghost"
+\t\t\t\t\tsize="sm"
+\t\t\t\t\tdisabled={markReadMutation.isPending}
+\t\t\t\t\tonClick={() =>
+\t\t\t\t\t\tmarkReadMutation.mutate({
+\t\t\t\t\t\t\tpath: { notificationId: notification.id },
+\t\t\t\t\t\t})
+\t\t\t\t\t}
+\t\t\t\t>
+\t\t\t\t\tMark read
+\t\t\t\t</Button>
+\t\t\t) : null}
+\t\t</div>
+\t);
+}
+`;
+}
+export function inboxListComponentFile(config) {
+    const queriesModule = aliasModule(path.join(config.paths.features, "inbox/client/queries.ts"));
+    return `"use client";
+
+import {
+\tuseInfiniteQuery,
+\tuseMutation,
+\tuseQueryClient,
+} from "@tanstack/react-query";
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import {
+\tinvalidateInbox,
+\tlistInboxInfiniteQueryOptions,
+\tmarkAllReadMutationOptions,
+} from "${queriesModule}";
+import { cn } from "@/lib/utils";
+import { InboxItem } from "./inbox-item";
+
+export function InboxList() {
+\tconst queryClient = useQueryClient();
+\tconst [unreadOnly, setUnreadOnly] = useState(false);
+\t// The infinite query accumulates cursor pages; pageIndex picks which
+\t// fetched page is on screen, so Previous/Next stays a paged UX. Refetches
+\t// (mark read, poll) refresh every fetched page under the same key.
+\tconst [pageIndex, setPageIndex] = useState(0);
+
+\tconst inboxQuery = useInfiniteQuery(
+\t\tlistInboxInfiniteQueryOptions({ unread: unreadOnly }),
+\t);
+
+\tconst markAllReadMutation = useMutation({
+\t\t...markAllReadMutationOptions(),
+\t\tonSuccess: async () => {
+\t\t\tsetPageIndex(0);
+\t\t\tawait invalidateInbox(queryClient);
+\t\t},
+\t});
+
+\tconst pages = inboxQuery.data?.pages ?? [];
+\tconst currentPage = pages[pageIndex] ?? pages[pages.length - 1];
+\tconst items = currentPage?.items ?? [];
+
+\tconst setFilter = (unread: boolean) => {
+\t\tsetUnreadOnly(unread);
+\t\tsetPageIndex(0);
+\t};
+
+\tconst goToNextPage = () => {
+\t\tif (pageIndex < pages.length - 1) {
+\t\t\tsetPageIndex(pageIndex + 1);
+\t\t\treturn;
+\t\t}
+\t\tvoid inboxQuery.fetchNextPage().then(() => setPageIndex(pageIndex + 1));
+\t};
+
+\treturn (
+\t\t<div className="flex flex-col gap-3">
+\t\t\t<div className="flex items-center gap-2">
+\t\t\t\t<div className="flex rounded-lg border p-0.5">
+\t\t\t\t\t<button
+\t\t\t\t\t\ttype="button"
+\t\t\t\t\t\tclassName={cn(
+\t\t\t\t\t\t\t"rounded-md px-2.5 py-1 text-sm",
+\t\t\t\t\t\t\t!unreadOnly
+\t\t\t\t\t\t\t\t? "bg-secondary text-secondary-foreground"
+\t\t\t\t\t\t\t\t: "text-muted-foreground hover:text-foreground",
+\t\t\t\t\t\t)}
+\t\t\t\t\t\tonClick={() => setFilter(false)}
+\t\t\t\t\t>
+\t\t\t\t\t\tAll
+\t\t\t\t\t</button>
+\t\t\t\t\t<button
+\t\t\t\t\t\ttype="button"
+\t\t\t\t\t\tclassName={cn(
+\t\t\t\t\t\t\t"rounded-md px-2.5 py-1 text-sm",
+\t\t\t\t\t\t\tunreadOnly
+\t\t\t\t\t\t\t\t? "bg-secondary text-secondary-foreground"
+\t\t\t\t\t\t\t\t: "text-muted-foreground hover:text-foreground",
+\t\t\t\t\t\t)}
+\t\t\t\t\t\tonClick={() => setFilter(true)}
+\t\t\t\t\t>
+\t\t\t\t\t\tUnread
+\t\t\t\t\t</button>
+\t\t\t\t</div>
+\t\t\t\t<Button
+\t\t\t\t\ttype="button"
+\t\t\t\t\tvariant="outline"
+\t\t\t\t\tsize="sm"
+\t\t\t\t\tclassName="ml-auto"
+\t\t\t\t\tdisabled={markAllReadMutation.isPending}
+\t\t\t\t\tonClick={() => markAllReadMutation.mutate({})}
+\t\t\t\t>
+\t\t\t\t\tMark all read
+\t\t\t\t</Button>
+\t\t\t</div>
+
+\t\t\t{inboxQuery.isPending ? (
+\t\t\t\t<p className="text-sm text-muted-foreground">Loading inbox...</p>
+\t\t\t) : inboxQuery.isError ? (
+\t\t\t\t<p className="text-sm text-destructive">Could not load your inbox.</p>
+\t\t\t) : items.length === 0 ? (
+\t\t\t\t<p className="text-sm text-muted-foreground">
+\t\t\t\t\t{unreadOnly ? "No unread notifications." : "Your inbox is empty."}
+\t\t\t\t</p>
+\t\t\t) : (
+\t\t\t\t<div className="flex flex-col gap-2">
+\t\t\t\t\t{items.map((notification) => (
+\t\t\t\t\t\t<InboxItem key={notification.id} notification={notification} />
+\t\t\t\t\t))}
+\t\t\t\t</div>
+\t\t\t)}
+
+\t\t\t{pageIndex > 0 || pages.length > 1 || inboxQuery.hasNextPage ? (
+\t\t\t\t<div className="flex items-center gap-2">
+\t\t\t\t\t<Button
+\t\t\t\t\t\ttype="button"
+\t\t\t\t\t\tvariant="outline"
+\t\t\t\t\t\tsize="sm"
+\t\t\t\t\t\tdisabled={pageIndex <= 0 || inboxQuery.isFetching}
+\t\t\t\t\t\tonClick={() => setPageIndex(pageIndex - 1)}
+\t\t\t\t\t>
+\t\t\t\t\t\tPrevious
+\t\t\t\t\t</Button>
+\t\t\t\t\t<Button
+\t\t\t\t\t\ttype="button"
+\t\t\t\t\t\tvariant="outline"
+\t\t\t\t\t\tsize="sm"
+\t\t\t\t\t\tdisabled={
+\t\t\t\t\t\t\t(pageIndex >= pages.length - 1 && !inboxQuery.hasNextPage) ||
+\t\t\t\t\t\t\tinboxQuery.isFetching
+\t\t\t\t\t\t}
+\t\t\t\t\t\tonClick={goToNextPage}
+\t\t\t\t\t>
+\t\t\t\t\t\tNext
+\t\t\t\t\t</Button>
+\t\t\t\t</div>
+\t\t\t) : null}
+\t\t</div>
+\t);
+}
+`;
+}
+export function inboxComponentsIndexFile() {
+    return `export { InboxItem } from "./inbox-item";
+export { InboxList } from "./inbox-list";
+export { UnreadBadge } from "./unread-badge";
+`;
+}
+export function inboxPageFile(config) {
+    const componentsModule = aliasModule(path.join(config.paths.features, "inbox/components/inbox-list.tsx"));
+    return `import { InboxList } from "${componentsModule}";
+
+export const metadata = {
+\ttitle: "Inbox",
+};
+
+export default function InboxPage() {
+\treturn (
+\t\t<div className="flex flex-col gap-6">
+\t\t\t<div className="flex flex-col gap-1">
+\t\t\t\t<h1 className="font-heading text-xl font-semibold">Inbox</h1>
+\t\t\t\t<p className="text-sm text-muted-foreground">
+\t\t\t\t\tIn-app notifications delivered through the inbox channel.
+\t\t\t\t</p>
+\t\t\t</div>
+\t\t\t<InboxList />
+\t\t</div>
+\t);
+}
+`;
+}
+//# sourceMappingURL=inbox.js.map