create-nexwire 4.2.3 → 4.2.5

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

@@ -1,6 +1,6 @@
 import { group } from "@/framework/facade.js";
 import { authMiddleware } from "@/middlewares/auth-middleware.js";
-import { list, unreadCount, markRead, markAllRead, remove } from "../controllers/{{module}}.js";
+import { list, unreadCount, markRead, markAllRead, remove } from "../controllers/{{leaf}}.js";
 
 export default group()
   .use(authMiddleware)

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

@@ -1,26 +1,26 @@
-import { z } from "@/framework/facade.js";
-
-export const NotificationSchema = z.object({
-  id: z.number(),
-  userId: z.number(),
-  type: z.string(),
-  title: z.string(),
-  body: z.string().nullable(),
-  data: z.any().nullable(),
-  link: z.string().nullable(),
-  readAt: z.string().nullable(),
-  createdAt: z.string(),
-});
-
-export const UnreadCountSchema = z.object({
-  count: z.number(),
-});
-
-export const PaginatedNotificationsSchema = z.object({
-  data: z.array(NotificationSchema),
-  total: z.number(),
-  unread: z.number(),
-  page: z.number(),
-  perPage: z.number(),
-});
+import { z } from "@/framework/facade.js";
 
+export const NotificationSchema = z.object({
+  id: z.string(),
+  notifiableType: z.string(),
+  notifiableId: z.string(),
+  type: z.string(),
+  title: z.string(),
+  body: z.string().nullable(),
+  data: z.any().nullable(),
+  link: z.string().nullable(),
+  readAt: z.string().nullable(),
+  createdAt: z.string()
+});
+
+export const UnreadCountSchema = z.object({
+  count: z.number()
+});
+
+export const PaginatedNotificationsSchema = z.object({
+  data: z.array(NotificationSchema),
+  total: z.number(),
+  unread: z.number(),
+  page: z.number(),
+  perPage: z.number()
+});

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

@@ -1,26 +1,26 @@
-import { z } from "@hono/zod-openapi";
-
-export const NotificationSchema = z.object({
-  id: z.number(),
-  userId: z.number(),
-  type: z.string(),
-  title: z.string(),
-  body: z.string().nullable(),
-  data: z.any().nullable(),
-  link: z.string().nullable(),
-  readAt: z.string().nullable(),
-  createdAt: z.string(),
-});
-
-export const UnreadCountSchema = z.object({
-  count: z.number(),
-});
-
-export const PaginatedNotificationsSchema = z.object({
-  data: z.array(NotificationSchema),
-  total: z.number(),
-  unread: z.number(),
-  page: z.number(),
-  perPage: z.number(),
-});
+import { z } from "@/framework/facade.js";
 
+export const NotificationSchema = z.object({
+  id: z.string(),
+  notifiableType: z.string(),
+  notifiableId: z.string(),
+  type: z.string(),
+  title: z.string(),
+  body: z.string().nullable(),
+  data: z.any().nullable(),
+  link: z.string().nullable(),
+  readAt: z.string().nullable(),
+  createdAt: z.string()
+});
+
+export const UnreadCountSchema = z.object({
+  count: z.number()
+});
+
+export const PaginatedNotificationsSchema = z.object({
+  data: z.array(NotificationSchema),
+  total: z.number(),
+  unread: z.number(),
+  page: z.number(),
+  perPage: z.number()
+});

package/hono/src/framework/notification/index.ts

@@ -1,27 +1,13 @@
-import { eq } from "drizzle-orm";
-import { db } from "@/framework/database/connection.js";
 import { dispatchEvent } from "@/framework/events/dispatcher.js";
-import { resolveAuthProvider } from "@/framework/providers/adapter.js";
+import { resolveAuthProvider, resolveNotificationProvider } from "@/framework/providers/adapter.js";
+import type { NotifiableTarget, NotificationRecord } from "@/framework/providers/contracts.js";
 import { redisClientIfReady } from "@/framework/redis/client.js";
 import { mail } from "@/framework/support/mail.js";
 
-let notifications: any = null;
-let modelsLoaded = false;
-let modelsLoadAttempted = false;
-
-async function loadNotificationModel() {
-  if (modelsLoaded) return true;
-  if (modelsLoadAttempted) return false;
-  modelsLoadAttempted = true;
-  try {
-    const notificationMod = await import("@/modules/auth/database/models/notification.js").catch(() => null);
-    if (notificationMod?.notifications) notifications = notificationMod.notifications;
-    modelsLoaded = !!notifications;
-    return modelsLoaded;
-  } catch {
-    return false;
-  }
-}
+let missingProviderWarned = false;
+
+/** A numeric id (default auth), a string id (UUID/ULID), or an explicit target. */
+export type NotificationTarget = number | string | NotifiableTarget;
 
 /** Extra JSON metadata attached to the notification (e.g. entity IDs, links). */
 export type NotificationOptions = {
@@ -46,38 +32,55 @@ export type NotificationOptions = {
   };
 };
 
-/** Create a notification and persist it to the database. Optionally broadcast via Socket.IO and/or send by email. */
-export async function notify(userId: number, options: NotificationOptions) {
-  const ok = await loadNotificationModel();
-  if (!ok || !notifications) {
-    console.warn(
-      "[notification] skipped: notification model not available (@/modules/auth/database/models/notification.js). Delete or replace auth/notification without breaking framework."
-    );
+/** Turn the public target argument into the polymorphic owner pair. */
+function normalizeTarget(target: NotificationTarget): Required<Pick<NotifiableTarget, "id">> & { type: string } {
+  if (target !== null && typeof target === "object") {
+    return {
+      type: String(target.type || "user").trim() || "user",
+      id: target.id
+    };
+  }
+  return { type: "user", id: target as number | string };
+}
+
+/**
+ * Why: Persists a notification through the registered provider.
+ * When: A feature wants to record something for a user (or another notifiable).
+ * Where: Application code, through the framework facade.
+ * How: The provider owns storage; broadcasting and email stay here so a custom
+ *      store cannot silently disable them. A missing provider is reported once
+ *      and returns `null` instead of throwing, matching the framework's
+ *      "optional module" behaviour.
+ */
+export async function notify(target: NotificationTarget, options: NotificationOptions): Promise<NotificationRecord | null> {
+  const provider = await resolveNotificationProvider();
+  if (!provider) {
+    if (!missingProviderWarned) {
+      missingProviderWarned = true;
+      console.warn(
+        '[notification] skipped: no notification provider is registered. Run "bun maker module:make-notification notification" then "bun maker module:migrate notification", or register a provider in src/providers/.'
+      );
+    }
     return null;
   }
-  const insertResult = await db.insert(notifications).values({
-    userId,
-    type: options.type || "info",
+
+  const normalizedTarget = normalizeTarget(target);
+  const normalized = await provider.create(normalizedTarget, {
+    type: options.type,
     title: options.title,
-    body: options.body || null,
-    link: options.link || null,
-    data: options.data ? JSON.stringify(options.data) : null
+    body: options.body ?? null,
+    link: options.link ?? null,
+    data: options.data ?? null
   });
 
-  const insertedId = Number((insertResult as any)[0]?.insertId ?? (insertResult as any).insertId ?? (insertResult as any).lastInsertRowid);
-  if (!insertedId) throw new Error("Failed to create notification");
-
-  const [row] = await db.select().from(notifications).where(eq(notifications.id, insertedId));
-  const normalized = normalize(row);
-
   if (options.broadcast) {
     await dispatchEvent("notification.created", normalized, {
-      broadcast: { users: [userId] }
+      broadcast: { users: [normalizedTarget.id] }
     });
   }
 
   if (options.mail) {
-    await sendMailChannel(userId, normalized, options);
+    await sendMailChannel(normalizedTarget, normalized, options);
   }
 
   return normalized;
@@ -85,38 +88,18 @@ export async function notify(userId: number, options: NotificationOptions) {
 
 /** Deliver an email notification, either queued (if Redis is available) or direct. */
 async function sendMailChannel(
-  userId: number,
-  notification: { id: number; title: string; body: string | null },
+  target: { type: string; id: number | string },
+  notification: NotificationRecord,
   options: NotificationOptions
 ) {
-  let to: string | null = (options.mail as any)?.to || null;
-  let name: string | null = null;
+  let to: string | null = options.mail?.to || null;
 
   if (!to) {
     try {
       const provider = await resolveAuthProvider();
       if (provider?.getUserContact) {
-        const contact = await provider.getUserContact(userId);
-        if (contact?.email) {
-          to = contact.email as string;
-          name = (contact.name as string) || null;
-        }
-      }
-    } catch {}
-  }
-
-  if (!to) {
-    try {
-      const userMod = await import("@/modules/auth/database/models/user.js").catch(() => null);
-      if (userMod?.users) {
-        const [user] = await db
-          .select({ email: userMod.users.email, name: (userMod.users as any).name })
-          .from(userMod.users)
-          .where(eq(userMod.users.id, userId));
-        if (user?.email) {
-          to = user.email as string;
-          name = (user as any).name || null;
-        }
+        const contact = await provider.getUserContact(target.id);
+        if (contact?.email) to = contact.email as string;
       }
     } catch {}
   }
@@ -149,24 +132,3 @@ function defaultMailHtml(title: string, body: string | null) {
 function escapeHtml(str: string) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-
-/** Convert a DB row into the normalized response shape, parsing the `data` JSON column. */
-function normalize(row: any) {
-  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/providers/adapter.ts

@@ -1,8 +1,8 @@
 import { eq } from "drizzle-orm";
 import { db } from "@/framework/database/connection.js";
-import type { AuthProvider } from "./contracts.js";
+import type { AuthProvider, NotificationProvider } from "./contracts.js";
 import { loadProviders } from "./loader.js";
-import { getAuthProvider } from "./registry.js";
+import { getAuthProvider, getNotificationProvider } from "./registry.js";
 
 let defaultProvider: AuthProvider | null = null;
 let defaultLoadAttempted = false;
@@ -26,16 +26,16 @@ async function loadDefaultProvider(): Promise<AuthProvider | null> {
     const refreshTokens = userMod.refreshTokens;
 
     defaultProvider = {
-      async getUserById(id: number) {
+      async getUserById(id: number | string) {
         try {
           const user = await (db.query.users.findFirst as any)?.({
-            where: eq(users.id, id),
+            where: eq(users.id, id as any),
             with: { role: true }
           });
           if (user) return user;
         } catch {}
         try {
-          const rows = await db.select().from(users).where(eq(users.id, id));
+          const rows = await db.select().from(users).where(eq(users.id, id as any));
           return rows?.[0] ?? null;
         } catch {
           return null;
@@ -55,14 +55,14 @@ async function loadDefaultProvider(): Promise<AuthProvider | null> {
           return null;
         }
       },
-      async deleteRefreshToken(tokenId: number) {
+      async deleteRefreshToken(tokenId: number | string) {
         try {
-          await db.delete(refreshTokens).where(eq(refreshTokens.id, tokenId));
+          await db.delete(refreshTokens).where(eq(refreshTokens.id, tokenId as any));
         } catch {}
       },
-      async revokeRefreshToken(tokenId: number) {
+      async revokeRefreshToken(tokenId: number | string) {
         try {
-          await db.delete(refreshTokens).where(eq(refreshTokens.id, tokenId));
+          await db.delete(refreshTokens).where(eq(refreshTokens.id, tokenId as any));
         } catch {}
       },
       async getAuthContext(user: any, payload?: any) {
@@ -87,7 +87,7 @@ async function loadDefaultProvider(): Promise<AuthProvider | null> {
           ...user
         };
       },
-      async getUserContact(userId: number) {
+      async getUserContact(userId: number | string) {
         try {
           const user = await this.getUserById(userId);
           if (!user) return null;
@@ -123,3 +123,17 @@ export async function resolveAuthProvider(): Promise<AuthProvider | null> {
   if (def) return def;
   return null;
 }
+
+/**
+ * Why: Resolves the notification storage provider.
+ * When: `notify()` persists a notification; the HTTP handlers read it back.
+ * Where: Notification runtime and the generated notification controller.
+ * How: Provider files are loaded first, so a project can replace the store from
+ *      `src/providers/` or a module provider folder. The notification module is
+ *      opt-in, so an absent provider is a normal state: callers warn once
+ *      (runtime) or answer 503 (HTTP) instead of throwing.
+ */
+export async function resolveNotificationProvider(): Promise<NotificationProvider | null> {
+  await loadProviders();
+  return getNotificationProvider();
+}

package/hono/src/framework/providers/contracts.ts

@@ -1,6 +1,6 @@
 /**
  * Why: Defines the shapes a pluggable provider has to satisfy.
- * When: A developer replaces a framework default (auth today, payments later).
+ * When: A developer replaces a framework default (auth, notifications, payments later).
  * Where: Imported through the framework facade, never from framework internals.
  * How: Interfaces stay deliberately loose so custom user shapes pass through.
  */
@@ -8,6 +8,9 @@
 /** Registry key of the built-in auth provider contract. */
 export const AUTH_PROVIDER_KEY = "auth";
 
+/** Registry key of the built-in notification storage provider. */
+export const NOTIFICATION_PROVIDER_KEY = "notification";
+
 /**
  * Registry key for any provider implementation.
  *
@@ -15,25 +18,25 @@ export const AUTH_PROVIDER_KEY = "auth";
  * still accepting any custom key, so a project can register its own contracts
  * (payments, otp, storage, ...) without the framework having to know them.
  */
-export type ProviderKey = typeof AUTH_PROVIDER_KEY | (string & {});
+export type ProviderKey = typeof AUTH_PROVIDER_KEY | typeof NOTIFICATION_PROVIDER_KEY | (string & {});
 
 export interface AuthProviderUser {
-  id: number;
+  id: number | string;
   email?: string | null;
   [key: string]: any;
 }
 
 export interface AuthProviderRefreshToken {
-  id: number;
+  id: number | string;
   jti: string;
   revoked?: boolean | null;
   expiresAt?: Date | string | null;
-  userId?: number | null;
+  userId?: number | string | null;
   [key: string]: any;
 }
 
 export interface AuthUserContext {
-  id: number;
+  id: number | string;
   email?: string | null;
   roleId?: number | null;
   role?: string | null;
@@ -47,10 +50,77 @@ export interface AuthUserContact {
 }
 
 export interface AuthProvider {
-  getUserById(id: number): Promise<AuthProviderUser | null>;
+  getUserById(id: number | string): Promise<AuthProviderUser | null>;
   findRefreshToken(jti: string): Promise<AuthProviderRefreshToken | null>;
-  revokeRefreshToken?(tokenId: number): Promise<void>;
-  deleteRefreshToken?(tokenId: number): Promise<void>;
+  revokeRefreshToken?(tokenId: number | string): Promise<void>;
+  deleteRefreshToken?(tokenId: number | string): Promise<void>;
   getAuthContext?(user: AuthProviderUser, payload?: any): Promise<AuthUserContext | any>;
-  getUserContact?(userId: number): Promise<AuthUserContact | null>;
+  getUserContact?(userId: number | string): Promise<AuthUserContact | null>;
+}
+
+/**
+ * Who a notification belongs to. `id` accepts a numeric auth id and a string
+ * id (UUID, ULID, ...) so replacing auth does not force a notification change.
+ * The provider always stores the id as text.
+ */
+export interface NotifiableTarget {
+  /** Notifiable class. Defaults to "user". */
+  type?: string;
+  id: number | string;
+}
+
+/** Payload accepted by `NotificationProvider.create()`. */
+export interface NotificationCreateInput {
+  type?: string;
+  title: string;
+  body?: string | null;
+  link?: string | null;
+  data?: Record<string, unknown> | null;
+}
+
+/** Normalized notification returned by every provider operation. */
+export interface NotificationRecord {
+  id: string;
+  notifiableType: string;
+  notifiableId: string;
+  type: string;
+  title: string;
+  body: string | null;
+  data: Record<string, unknown> | null;
+  link: string | null;
+  readAt: string | null;
+  createdAt: string;
+}
+
+export interface NotificationListOptions {
+  page?: number;
+  perPage?: number;
+}
+
+export interface NotificationPage {
+  data: NotificationRecord[];
+  total: number;
+  unread: number;
+  page: number;
+  perPage: number;
+}
+
+/**
+ * Why: Keeps notification storage replaceable without touching `notify()` or
+ *      the generated HTTP routes.
+ * When: The default `src/modules/notification` store is replaced by a custom
+ *       implementation (a different table, another service, ...).
+ * Where: Registered through `registerNotificationProvider()`.
+ * How: The framework only reads through this contract; mail and realtime
+ *      delivery stay in the runtime so a storage swap cannot disable them.
+ */
+export interface NotificationProvider {
+  create(target: NotifiableTarget, input: NotificationCreateInput): Promise<NotificationRecord>;
+  list(target: NotifiableTarget, options?: NotificationListOptions): Promise<NotificationPage>;
+  unreadCount(target: NotifiableTarget): Promise<number>;
+  markRead(target: NotifiableTarget, id: number | string): Promise<boolean>;
+  markAllRead(target: NotifiableTarget): Promise<number>;
+  remove(target: NotifiableTarget, id: number | string): Promise<boolean>;
+  /** Optional bulk cleanup when a notifiable target is deleted. */
+  deleteForTarget?(target: NotifiableTarget): Promise<number>;
 }

package/hono/src/framework/providers/registry.ts

@@ -1,4 +1,10 @@
-import { AUTH_PROVIDER_KEY, type AuthProvider, type ProviderKey } from "./contracts.js";
+import {
+  AUTH_PROVIDER_KEY,
+  type AuthProvider,
+  NOTIFICATION_PROVIDER_KEY,
+  type NotificationProvider,
+  type ProviderKey
+} from "./contracts.js";
 
 /**
  * Why: Holds the app-wide provider implementations in one place.
@@ -60,3 +66,23 @@ export function hasAuthProvider(): boolean {
 export function clearAuthProvider(): void {
   clearProvider(AUTH_PROVIDER_KEY);
 }
+
+/** Registers the storage provider `notify()` and `/api/notification/*` use. */
+export function registerNotificationProvider(provider: NotificationProvider): NotificationProvider {
+  return registerProvider(NOTIFICATION_PROVIDER_KEY, provider);
+}
+
+/** Returns the registered notification provider, or null when none was registered. */
+export function getNotificationProvider(): NotificationProvider | null {
+  return getProvider<NotificationProvider>(NOTIFICATION_PROVIDER_KEY);
+}
+
+/** Reports whether a notification provider is registered. */
+export function hasNotificationProvider(): boolean {
+  return hasProvider(NOTIFICATION_PROVIDER_KEY);
+}
+
+/** Removes the registered notification provider. Mainly useful in tests. */
+export function clearNotificationProvider(): void {
+  clearProvider(NOTIFICATION_PROVIDER_KEY);
+}

package/hono/src/resources/src/components/Checkbox.vue

@@ -1,29 +1,32 @@
-<template>
-  <div class="form-check mb-0" :class="props.topclass">
-    <input
-      :id="String(props.id)"
-      v-model="model"
-      class="form-check-input shadow-none border-secondary"
-      type="checkbox"
-      v-bind="$attrs" />
-    <label v-if="props.label" class="form-check-label" :for="String(props.id)">{{ props.label }}</label>
-  </div>
-</template>
-
-<script setup lang="ts">
-defineOptions({ name: "Checkbox", inheritAttrs: false });
-
-interface CheckboxProps {
-  id?: string | number;
-  label?: string;
-  topclass?: string;
-}
-
-const props = defineProps<CheckboxProps>();
-
-type CheckboxModel = boolean | Array<string | number>;
-
-const model = defineModel<CheckboxModel>({ default: false });
-</script>
-
-<style lang="scss" scoped></style>
+<template>
+  <div class="form-check mb-0" :class="props.topclass">
+    <input
+      :id="String(props.id)"
+      v-model="model"
+      class="form-check-input shadow-none"
+      type="checkbox"
+      v-bind="$attrs"
+    />
+    <label v-if="props.label" class="form-check-label" :for="String(props.id)">{{
+      props.label
+    }}</label>
+  </div>
+</template>
+
+<script setup lang="ts">
+defineOptions({ name: "Checkbox", inheritAttrs: false });
+
+interface CheckboxProps {
+  id?: string | number;
+  label?: string;
+  topclass?: string;
+}
+
+const props = defineProps<CheckboxProps>();
+
+type CheckboxModel = boolean | Array<string | number>;
+
+const model = defineModel<CheckboxModel>({ default: false });
+</script>
+
+<style lang="scss" scoped></style>