create-nexwire 4.2.3 → 4.2.5

package/hono/src/framework/maker-cli/module/core.mjs

@@ -73,6 +73,8 @@ const STUBS = {
     },
     routeApi: "notification/route.api.ts.stub",
     routePlain: "notification/route.plain.ts.stub",
+    model: "notification/model.ts.stub",
+    provider: "notification/provider.ts.stub",
     job: "notification/job.ts.stub"
   },
   test: {
@@ -162,6 +164,28 @@ function parsePanelPath(flags) {
   return segments.join("/");
 }
 
+/**
+ * Parse `--notifiable=<type>` into the owner class written into the generated
+ * controller. Accepts both `--notifiable=user` and `--notifiable user`, and
+ * defaults to `user` so the common case needs no flag.
+ */
+function parseNotifiable(flags) {
+  const matches = flags
+    .map((flag, index) => ({ flag, index }))
+    .filter(({ flag }) => typeof flag === "string" && flag.startsWith("--notifiable"));
+  if (matches.length === 0) return "user";
+  if (matches.length > 1) throw new Error("--notifiable can only be given once.");
+
+  const [{ flag, index }] = matches;
+  let raw = flag.slice("--notifiable".length).replace(/^=/, "").trim();
+  if (!raw && typeof flags[index + 1] === "string" && !flags[index + 1].startsWith("--")) raw = flags[index + 1].trim();
+  if (!raw) throw new Error("--notifiable needs a value, e.g. --notifiable=user");
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(raw)) {
+    throw new Error(`Invalid --notifiable value "${raw}". Use lowercase letters, numbers, dashes and underscores.`);
+  }
+  return raw;
+}
+
 /** True when the path is a directory holding at least one entry. */
 async function dirHasFiles(target) {
   try {
@@ -172,6 +196,24 @@ async function dirHasFiles(target) {
   }
 }
 
+/**
+ * Path of the notification store already shipped by any module, or "".
+ *
+ * The table/model/provider is a singleton: two modules shipping it would
+ * generate the same `notifications` table twice and register two providers for
+ * one contract. `module:make-notification` therefore writes the store only when
+ * no module owns it yet, and otherwise adds just another HTTP surface over it.
+ */
+async function findNotificationStore() {
+  const backendSrc = path.resolve(process.cwd(), "src");
+  const files = await glob("modules/**/database/models/notification.{ts,js}", {
+    cwd: backendSrc,
+    nodir: true,
+    windowsPathsNoEscape: true
+  });
+  return files.sort()[0] ? path.join(backendSrc, files.sort()[0]) : "";
+}
+
 /**
  * Resolve the module a subcommand targets.
  *
@@ -519,7 +561,15 @@ export async function makeRoute(rawModule, rawControllerOrFlag, extraFlags = [])
   console.log(`Route ready: ${path.relative(process.cwd(), routePath)}`);
 }
 
-/** Generate a notification module with controller, routes, and job. */
+/**
+ * Generate the notification HTTP surface, plus the shared store the first time.
+ *
+ * The controller/schema/routes are always written: they are what lets a project
+ * expose `/api/notification/*` for a panel. The model, provider and mail job are
+ * written only when no module already ships the store, because the store is a
+ * singleton — a second copy would create a duplicate `notifications` table and
+ * register a second provider for the same contract.
+ */
 export async function makeNotificationModule(rawName = "notification", flags = []) {
   const { moduleName, leaf } = resolveModuleRef(rawName, flags);
   const root = moduleRoot(moduleName);
@@ -528,22 +578,39 @@ export async function makeNotificationModule(rawName = "notification", flags = [
     throw new Error(`Module already exists: src/modules/${moduleName}. Re-run with --force to overwrite its files.`);
   }
   const openApi = openApiEnabled();
+  const notifiable = parseNotifiable(flags);
+  const vars = { module: moduleName, leaf, notifiable };
 
-  await writeFiles(root, {
-    [`controllers/${leaf}.ts`]: await stub(STUBS.notification.controller, {
-      module: moduleName
-    }),
-    [`schemas/${leaf}.ts`]: await stub(openApi ? STUBS.notification.schema.openapi : STUBS.notification.schema.plain, {
-      module: moduleName
-    }),
-    "routes/index.ts": await stub(openApi ? STUBS.notification.routeApi : STUBS.notification.routePlain, { module: moduleName }),
-    [`jobs/${leaf}.ts`]: await stub(STUBS.notification.job, { module: moduleName })
-  });
+  const files = {
+    [`controllers/${leaf}.ts`]: await stub(STUBS.notification.controller, vars),
+    [`schemas/${leaf}.ts`]: await stub(openApi ? STUBS.notification.schema.openapi : STUBS.notification.schema.plain, vars),
+    "routes/index.ts": await stub(openApi ? STUBS.notification.routeApi : STUBS.notification.routePlain, vars)
+  };
+
+  const existingStore = await findNotificationStore();
+  const ownsStore = existingStore ? path.resolve(existingStore).startsWith(root + path.sep) : false;
+  const writesStore = !existingStore || (force && ownsStore);
+
+  if (writesStore) {
+    files["database/models/notification.ts"] = await stub(STUBS.notification.model, vars);
+    files["providers/notification.ts"] = await stub(STUBS.notification.provider, vars);
+    files["jobs/mail.ts"] = await stub(STUBS.notification.job, vars);
+  }
+
+  await writeFiles(root, files);
 
   console.log(`Notification module ready: ${moduleName}`);
+  if (writesStore) {
+    console.log("Notification store included: model, provider, mail job");
+    const panelFlag = panelOf(moduleName) ? ` --path=${panelOf(moduleName)}` : "";
+    console.log(`Next: bun maker module:migrate ${leaf}${panelFlag}`);
+  } else {
+    console.log(`Notification store reused: ${path.relative(process.cwd(), existingStore)}`);
+  }
   if (panelOf(moduleName)) console.log(`Panel: ${panelOf(moduleName)}  ->  /api/${moduleName}`);
+  console.log(`Notifiable type: ${notifiable}`);
   console.log(`Route style: ${openApi ? "openapi" : "plain"}`);
-  console.log("See docs (packages/docs/guide/notification.md) for Vue UI integration.");
+  console.log("See docs (packages/docs/guide/notification.md) for usage and UI integration.");
 }
 
 /** Soft-delete a module by moving it to storage trash. */
@@ -953,8 +1020,16 @@ export async function generateSchema(options = {}) {
   if (!options.silent) console.log(`Generated database schema with ${files.length} model file(s)`);
 }
 
-/** Generate a temporary schema file for a single module (used for module:generate/migrate). */
-async function generateModuleSchemaTemp(moduleName) {
+/**
+ * Generate and run migrations that include a module.
+ *
+ * Drizzle diffs the schema against the last snapshot, so generating from a
+ * module-only schema would emit `DROP TABLE` for every other module (auth
+ * included). The full schema is used instead: it adds the module's tables and
+ * keeps the rest of the database intact.
+ */
+export async function runModuleMigrate(rawModuleName, rawArgs = []) {
+  const { moduleName } = resolveModuleRef(rawModuleName, rawArgs);
   await assertModuleExists(moduleName);
   const backendSrc = path.resolve(process.cwd(), "src");
   const files = await glob(`modules/${moduleName}/database/models/*.{ts,js}`, {
@@ -963,47 +1038,13 @@ async function generateModuleSchemaTemp(moduleName) {
     windowsPathsNoEscape: true
   });
   if (!files.length) throw new Error(`No model files found for module '${moduleName}'.`);
-  const exports = [];
-  const tempDir = path.resolve(process.cwd(), "src/storage/tmp");
-  await fs.mkdir(tempDir, { recursive: true });
-  // Flatten the panel path: "admin/testme" must not become a nested
-  // storage/tmp/schema.admin/testme.<ts>.ts path.
-  const slug = moduleName.replaceAll("/", "-");
-  const tempSchemaPath = path.join(tempDir, `schema.${slug}.${Date.now()}.ts`);
-  const tempSchemaDir = path.dirname(tempSchemaPath);
-  for (const file of files.sort()) {
-    const absoluteFile = path.join(backendSrc, file);
-    const relativePath = path
-      .relative(tempSchemaDir, absoluteFile)
-      .replace(/\\/g, "/")
-      .replace(/\.(ts|js)$/, ".ts");
-    const importPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-    exports.push(`export * from "${importPath}";`);
-  }
-  await fs.writeFile(tempSchemaPath, `${exports.join("\n")}\n`);
-  return { tempSchemaPath, modelCount: files.length };
-}
-
-/** Generate and run migrations for a single module using a temporary schema. */
-export async function runModuleMigrate(rawModuleName, rawArgs = []) {
-  const { moduleName } = resolveModuleRef(rawModuleName, rawArgs);
   await syncMigrationDialect();
   await ensureMigrationMeta();
   await ensureDatabaseDirectory();
-  const keepTemp = rawArgs.includes("--keep-temp");
-  const { tempSchemaPath, modelCount } = await generateModuleSchemaTemp(moduleName);
-  const drizzleSchemaPath = `./${path.relative(process.cwd(), tempSchemaPath).replace(/\\/g, "/")}`;
-  const previousSchema = process.env.DRIZZLE_SCHEMA;
-  try {
-    process.env.DRIZZLE_SCHEMA = drizzleSchemaPath;
-    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), await drizzleGenerateArgs());
-    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["migrate"]);
-    console.log(`Module migration complete: ${moduleName} (${modelCount} model file(s))`);
-  } finally {
-    if (previousSchema == null) delete process.env.DRIZZLE_SCHEMA;
-    else process.env.DRIZZLE_SCHEMA = previousSchema;
-    if (!keepTemp) await fs.rm(tempSchemaPath, { force: true }).catch(() => { });
-  }
+  await generateSchema();
+  await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), await drizzleGenerateArgs());
+  await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["migrate"]);
+  console.log(`Module migration complete: ${moduleName} (${files.length} model file(s))`);
 }
 
 /** Generate a unit test file for a module. */

package/hono/src/framework/maker-cli/module/index.mjs

@@ -39,8 +39,9 @@ export function registerModuleCommands(program, rawArgs) {
     });
   program
     .command("module:make-notification [name]")
-    .description("Generate notification backend module (controller, routes, job)")
+    .description("Generate the notification HTTP module, and the shared store the first time")
     .option("--path <panel>", "Nest the module under a panel folder (e.g. --path=admin)")
+    .option("--notifiable <type>", "Owner type recorded with each notification (default: user)")
     .option("--force", "Overwrite the files of a module that already exists")
     .allowUnknownOption(true)
     .action(async (name) => {
@@ -195,8 +196,7 @@ export function registerModuleCommands(program, rawArgs) {
     });
   program
     .command("module:migrate <module>")
-    .description("Generate module-only schema, generate migration, then run migrate")
-    .option("--keep-temp", "Keep temporary schema file after migration")
+    .description("Generate and run a migration that includes the module")
     .option("--path <panel>", "Address a module inside a panel folder (e.g. --path=admin)")
     .allowUnknownOption(true)
     .action(async (moduleName) => runModuleMigrate(moduleName, rawArgs));

package/hono/src/framework/maker-cli/stubs/notification/controller.ts.stub

@@ -1,86 +1,91 @@
 import type { Handler } from "hono";
-import { and, count, desc, eq, sql } from "drizzle-orm";
-import { db } from "@/framework/facade.js";
-import { notifications } from "@/modules/auth/database/models/notification.js";
+import { HttpStatusCodes, resolveNotificationProvider } from "@/framework/facade.js";
+import type { NotifiableTarget } from "@/framework/providers/contracts.js";
+
+/** Read the authenticated owner. A missing auth context means the request is anonymous. */
+function targetFrom(c: any): NotifiableTarget | null {
+  const auth = c.get("auth");
+  if (!auth || auth.id === undefined || auth.id === null) return null;
+  return { type: "{{notifiable}}", id: auth.id };
+}
 
 export const list: Handler = async (c: any) => {
-  const userId = c.get("auth").id;
-  const page = Math.max(1, Number(c.req.query("page")) || 1);
-  const perPage = Math.min(50, Math.max(1, Number(c.req.query("perPage")) || 20));
-
-  const unread = await db.select({ count: count() }).from(notifications)
-    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
+  const provider = await resolveNotificationProvider();
+  if (!provider) {
+    return c.json(
+      { message: "Notification provider not available. Restore src/modules/notification or register one in src/providers/." },
+      HttpStatusCodes.SERVICE_UNAVAILABLE
+    );
+  }
 
-  const total = await db.select({ count: count() }).from(notifications)
-    .where(eq(notifications.userId, userId));
+  const target = targetFrom(c);
+  if (!target) return c.json({ message: "Unauthorized" }, HttpStatusCodes.UNAUTHORIZED);
 
-  const rows = await db.select().from(notifications)
-    .where(eq(notifications.userId, userId))
-    .orderBy(desc(notifications.createdAt))
-    .limit(perPage).offset((page - 1) * perPage);
+  const page = Math.max(1, Number(c.req.query("page")) || 1);
+  const perPage = Math.min(50, Math.max(1, Number(c.req.query("perPage")) || 20));
 
-  return c.json({
-    data: rows.map(normalize),
-    total: total[0].count,
-    unread: unread[0].count,
-    page,
-    perPage,
-  });
+  return c.json(await provider.list(target, { page, perPage }));
 };
 
 export const unreadCount: Handler = async (c: any) => {
-  const userId = c.get("auth").id;
-  const rows = await db.select({ count: count() }).from(notifications)
-    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
-  return c.json({ count: rows[0].count });
+  const provider = await resolveNotificationProvider();
+  if (!provider) {
+    return c.json(
+      { message: "Notification provider not available. Restore src/modules/notification or register one in src/providers/." },
+      HttpStatusCodes.SERVICE_UNAVAILABLE
+    );
+  }
+
+  const target = targetFrom(c);
+  if (!target) return c.json({ message: "Unauthorized" }, HttpStatusCodes.UNAUTHORIZED);
+
+  return c.json({ count: await provider.unreadCount(target) });
 };
 
 export const markRead: Handler = async (c: any) => {
-  const userId = c.get("auth").id;
-  const id = Number(c.req.param("id"));
+  const provider = await resolveNotificationProvider();
+  if (!provider) {
+    return c.json(
+      { message: "Notification provider not available. Restore src/modules/notification or register one in src/providers/." },
+      HttpStatusCodes.SERVICE_UNAVAILABLE
+    );
+  }
 
-  await db.update(notifications)
-    .set({ readAt: sql`now()` })
-    .where(and(eq(notifications.id, id), eq(notifications.userId, userId)));
+  const target = targetFrom(c);
+  if (!target) return c.json({ message: "Unauthorized" }, HttpStatusCodes.UNAUTHORIZED);
 
+  await provider.markRead(target, c.req.param("id"));
   return c.json({ ok: true });
 };
 
 export const markAllRead: Handler = async (c: any) => {
-  const userId = c.get("auth").id;
+  const provider = await resolveNotificationProvider();
+  if (!provider) {
+    return c.json(
+      { message: "Notification provider not available. Restore src/modules/notification or register one in src/providers/." },
+      HttpStatusCodes.SERVICE_UNAVAILABLE
+    );
+  }
 
-  await db.update(notifications)
-    .set({ readAt: sql`now()` })
-    .where(and(eq(notifications.userId, userId), sql`${notifications.readAt} IS NULL`));
+  const target = targetFrom(c);
+  if (!target) return c.json({ message: "Unauthorized" }, HttpStatusCodes.UNAUTHORIZED);
 
+  await provider.markAllRead(target);
   return c.json({ ok: true });
 };
 
 export const remove: Handler = async (c: any) => {
-  const userId = c.get("auth").id;
-  const id = Number(c.req.param("id"));
+  const provider = await resolveNotificationProvider();
+  if (!provider) {
+    return c.json(
+      { message: "Notification provider not available. Restore src/modules/notification or register one in src/providers/." },
+      HttpStatusCodes.SERVICE_UNAVAILABLE
+    );
+  }
 
-  await db.delete(notifications)
-    .where(and(eq(notifications.id, id), eq(notifications.userId, userId)));
+  const target = targetFrom(c);
+  if (!target) return c.json({ message: "Unauthorized" }, HttpStatusCodes.UNAUTHORIZED);
 
+  await provider.remove(target, c.req.param("id"));
   return c.json({ ok: true });
 };
-
-function normalize(row: typeof notifications.$inferSelect) {
-  let parsed: unknown = null;
-  if (row.data) {
-    try { parsed = JSON.parse(row.data); } catch {}
-  }
-  return {
-    id: row.id,
-    userId: row.userId,
-    type: row.type,
-    title: row.title,
-    body: row.body,
-    data: parsed,
-    link: row.link,
-    readAt: row.readAt?.toISOString() || null,
-    createdAt: row.createdAt.toISOString(),
-  };
-}
-

package/hono/src/framework/maker-cli/stubs/notification/job.ts.stub

@@ -1,13 +1,11 @@
-import { mail } from "@/framework/support/mail.js";
-import { logger } from "@/framework/support/logger.js";
-import { shouldQueue } from "@/framework/queue/queue.js";
-
-shouldQueue("{{module}}:mail", "mail", async (job) => {
-  const { to, subject, html } = job.data;
-
-  await mail.sendMail({ to, subject, html });
-  logger.info("Notification mail sent", { to, subject });
-
-  return { ok: true };
-});
+import { mail, shouldQueue } from "@/framework/facade.js";
+import { logger } from "@/framework/support/logger.js";
 
+shouldQueue("notification:mail", "mail", async (job) => {
+  const { to, subject, html } = job.data;
+
+  await mail.sendMail({ to, subject, html });
+  logger.info("Notification mail sent", { to, subject });
+
+  return { ok: true };
+});

package/hono/src/framework/maker-cli/stubs/notification/model.ts.stub

@@ -0,0 +1,29 @@
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+/**
+ * Why: Notifications are stored by a standalone module, not by auth.
+ * When: `notify()` writes a row and `/api/notification/*` reads it back.
+ * Where: `src/modules/notification/database/models/notification.ts`.
+ * How: A polymorphic owner (`notifiable_type` + `notifiable_id`) with no
+ *      foreign key, so deleting or replacing auth cannot cascade-delete
+ *      notifications and a UUID or numeric owner id stores the same way.
+ */
+export const notifications = sqliteTable(
+  "notifications",
+  {
+    id: text("id").primaryKey(),
+    notifiableType: text("notifiable_type").notNull().default("user"),
+    notifiableId: text("notifiable_id").notNull(),
+    type: text("type").notNull(),
+    title: text("title").notNull(),
+    body: text("body"),
+    data: text("data"),
+    link: text("link"),
+    readAt: integer("read_at", { mode: "timestamp" }),
+    createdAt: integer("created_at", { mode: "timestamp" }).defaultNow().notNull()
+  },
+  (table) => [
+    index("notifications_notifiable_read_idx").on(table.notifiableType, table.notifiableId, table.readAt),
+    index("notifications_notifiable_created_idx").on(table.notifiableType, table.notifiableId, table.createdAt)
+  ]
+);

package/hono/src/framework/maker-cli/stubs/notification/provider.ts.stub

@@ -0,0 +1,174 @@
+import { randomUUID } from "node:crypto";
+import { and, count, desc, eq, isNull } from "drizzle-orm";
+import { db } from "@/framework/database/connection.js";
+import type {
+  NotifiableTarget,
+  NotificationCreateInput,
+  NotificationListOptions,
+  NotificationPage,
+  NotificationProvider,
+  NotificationRecord
+} from "@/framework/providers/contracts.js";
+import { registerNotificationProvider } from "@/framework/providers/registry.js";
+import { notifications } from "@/modules/{{module}}/database/models/notification.js";
+
+/** Normalize a target into the polymorphic pair stored in the table. */
+function normalizeTarget(target: NotifiableTarget) {
+  const type = String(target?.type || "user").trim() || "user";
+  if (target?.id === undefined || target?.id === null || target?.id === "") {
+    throw new Error("A notification target needs an id.");
+  }
+  return { type, id: String(target.id) };
+}
+
+/** Build the owner scope shared by every read and write. */
+function scope(target: NotifiableTarget) {
+  const normalized = normalizeTarget(target);
+  return {
+    target: normalized,
+    where: and(eq(notifications.notifiableType, normalized.type), eq(notifications.notifiableId, normalized.id))
+  };
+}
+
+function toIso(value: Date | string | number | null | undefined): string | null {
+  if (value === null || value === undefined) return null;
+  const date = value instanceof Date ? value : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+function parseData(value: unknown): Record<string, unknown> | null {
+  if (!value) return null;
+  if (typeof value === "object") return value as Record<string, unknown>;
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Convert a DB row into the stable shape every consumer receives. */
+function normalizeRow(row: typeof notifications.$inferSelect): NotificationRecord {
+  return {
+    id: String(row.id),
+    notifiableType: row.notifiableType,
+    notifiableId: row.notifiableId,
+    type: row.type,
+    title: row.title,
+    body: row.body ?? null,
+    data: parseData(row.data),
+    link: row.link ?? null,
+    readAt: toIso(row.readAt),
+    createdAt: toIso(row.createdAt) ?? new Date(0).toISOString()
+  };
+}
+
+/**
+ * Why: Ships a working notification store so `notify()` needs no setup.
+ * When: Imported at boot by the provider loader (and lazily by the resolver).
+ * Where: `src/modules/notification/providers/notification.ts`.
+ * How: Drizzle-backed implementation of `NotificationProvider`. The primary
+ *      key is a UUID string, so ids never depend on the auth table; numeric
+ *      targets are accepted and stored as text by the contract.
+ */
+export const notificationProvider: NotificationProvider = {
+  async create(target: NotifiableTarget, input: NotificationCreateInput): Promise<NotificationRecord> {
+    const { target: normalized } = scope(target);
+    const id = randomUUID();
+
+    await db.insert(notifications).values({
+      id,
+      notifiableType: normalized.type,
+      notifiableId: normalized.id,
+      type: input.type || "info",
+      title: input.title,
+      body: input.body ?? null,
+      link: input.link ?? null,
+      data: input.data ? JSON.stringify(input.data) : null
+    });
+
+    const [row] = await db.select().from(notifications).where(eq(notifications.id, id));
+    if (!row) throw new Error("Failed to create notification");
+    return normalizeRow(row);
+  },
+
+  async list(target: NotifiableTarget, options: NotificationListOptions = {}): Promise<NotificationPage> {
+    const { where } = scope(target);
+    const page = Math.max(1, Math.floor(Number(options.page) || 1));
+    const perPage = Math.min(100, Math.max(1, Math.floor(Number(options.perPage) || 20)));
+
+    const [totalRows, unreadRows, rows] = await Promise.all([
+      db.select({ count: count() }).from(notifications).where(where),
+      db.select({ count: count() }).from(notifications).where(and(where, isNull(notifications.readAt))),
+      db
+        .select()
+        .from(notifications)
+        .where(where)
+        .orderBy(desc(notifications.createdAt))
+        .limit(perPage)
+        .offset((page - 1) * perPage)
+    ]);
+
+    return {
+      data: rows.map(normalizeRow),
+      total: Number(totalRows[0]?.count ?? 0),
+      unread: Number(unreadRows[0]?.count ?? 0),
+      page,
+      perPage
+    };
+  },
+
+  async unreadCount(target: NotifiableTarget): Promise<number> {
+    const { where } = scope(target);
+    const rows = await db
+      .select({ count: count() })
+      .from(notifications)
+      .where(and(where, isNull(notifications.readAt)));
+    return Number(rows[0]?.count ?? 0);
+  },
+
+  async markRead(target: NotifiableTarget, id: number | string): Promise<boolean> {
+    const { where } = scope(target);
+    const notificationWhere = and(where, eq(notifications.id, String(id)));
+    const [existing] = await db.select({ id: notifications.id }).from(notifications).where(notificationWhere);
+    if (!existing) return false;
+
+    await db.update(notifications).set({ readAt: new Date() }).where(notificationWhere);
+    return true;
+  },
+
+  async markAllRead(target: NotifiableTarget): Promise<number> {
+    const { where } = scope(target);
+    const unreadWhere = and(where, isNull(notifications.readAt));
+    const rows = await db.select({ count: count() }).from(notifications).where(unreadWhere);
+    const unread = Number(rows[0]?.count ?? 0);
+    if (unread === 0) return 0;
+
+    await db.update(notifications).set({ readAt: new Date() }).where(unreadWhere);
+    return unread;
+  },
+
+  async remove(target: NotifiableTarget, id: number | string): Promise<boolean> {
+    const { where } = scope(target);
+    const notificationWhere = and(where, eq(notifications.id, String(id)));
+    const [existing] = await db.select({ id: notifications.id }).from(notifications).where(notificationWhere);
+    if (!existing) return false;
+
+    await db.delete(notifications).where(notificationWhere);
+    return true;
+  },
+
+  async deleteForTarget(target: NotifiableTarget): Promise<number> {
+    const { where } = scope(target);
+    const rows = await db.select({ count: count() }).from(notifications).where(where);
+    const total = Number(rows[0]?.count ?? 0);
+    if (total === 0) return 0;
+
+    await db.delete(notifications).where(where);
+    return total;
+  }
+};
+
+registerNotificationProvider(notificationProvider);
+
+export default notificationProvider;

package/hono/src/framework/maker-cli/stubs/notification/route.api.ts.stub

@@ -1,43 +1,45 @@
 import { createRoute, createRouter, HttpStatusCodes, jsonContent, z } from "@/framework/facade.js";
 import { authMiddleware } from "@/middlewares/auth-middleware.js";
-import { list, markAllRead, markRead, remove, unreadCount } from "../controllers/{{module}}.js";
-import { PaginatedNotificationsSchema, UnreadCountSchema } from "../schemas/{{module}}.js";
+import { list, markAllRead, markRead, remove, unreadCount } from "../controllers/{{leaf}}.js";
+import { PaginatedNotificationsSchema, UnreadCountSchema } from "../schemas/{{leaf}}.js";
+
+const notificationId = z.object({ id: z.string().min(1) });
 
 const listRoute = createRoute({
   path: "/",
   method: "get",
   tags: ["Notifications"],
-  responses: { [HttpStatusCodes.OK]: jsonContent(PaginatedNotificationsSchema, "Paginated notifications") },
+  responses: { [HttpStatusCodes.OK]: jsonContent(PaginatedNotificationsSchema, "Paginated notifications") }
 });
 
 const unreadCountRoute = createRoute({
   path: "/unread-count",
   method: "get",
   tags: ["Notifications"],
-  responses: { [HttpStatusCodes.OK]: jsonContent(UnreadCountSchema, "Unread count") },
+  responses: { [HttpStatusCodes.OK]: jsonContent(UnreadCountSchema, "Unread count") }
 });
 
 const markReadRoute = createRoute({
   path: "/{id}/read",
   method: "patch",
   tags: ["Notifications"],
-  request: { params: z.object({ id: z.coerce.number() }) },
-  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "Marked as read") },
+  request: { params: notificationId },
+  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "Marked as read") }
 });
 
 const markAllReadRoute = createRoute({
   path: "/read-all",
   method: "patch",
   tags: ["Notifications"],
-  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "All marked as read") },
+  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "All marked as read") }
 });
 
 const deleteRoute = createRoute({
   path: "/{id}",
   method: "delete",
   tags: ["Notifications"],
-  request: { params: z.object({ id: z.coerce.number() }) },
-  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "Deleted") },
+  request: { params: notificationId },
+  responses: { [HttpStatusCodes.OK]: jsonContent(z.object({ ok: z.boolean() }), "Deleted") }
 });
 
 export default createRouter()
@@ -47,4 +49,3 @@ export default createRouter()
   .api(markReadRoute, markRead)
   .api(markAllReadRoute, markAllRead)
   .api(deleteRoute, remove);
-