create-nexwire 4.2.2 → 4.2.4

package/hono/src/framework/database/app-schema.ts

@@ -0,0 +1,37 @@
+import { discoverModuleFiles, importFile } from "@/framework/modules/discover.js";
+
+/**
+ * Why: Builds the Drizzle schema from the modules that actually exist.
+ * When: The database connection is initialised.
+ * Where: Framework database connection.
+ * How: Discovers `src/modules/**\/database/models/*` and merges their exports.
+ *      The generated barrel at `src/database/schema.ts` is only used by
+ *      drizzle-kit, so deleting or replacing a module never leaves the
+ *      framework importing a file that is no longer there.
+ */
+let cachedSchema: Record<string, unknown> | null = null;
+
+export async function loadAppSchema(): Promise<Record<string, unknown>> {
+  if (cachedSchema) return cachedSchema;
+
+  const schema: Record<string, unknown> = {};
+  const files = await discoverModuleFiles("**/database/models/*.{ts,js}");
+
+  for (const file of files) {
+    try {
+      const models = await importFile(file);
+      Object.assign(schema, models);
+    } catch {
+      // A model file that fails to load is skipped: the rest of the schema
+      // still works, and the framework keeps booting.
+    }
+  }
+
+  cachedSchema = schema;
+  return schema;
+}
+
+/** Clears the cached schema. Mainly useful in tests. */
+export function clearAppSchema(): void {
+  cachedSchema = null;
+}

package/hono/src/framework/database/connection.ts

@@ -1,196 +1,198 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { databaseConfig } from "@/config/index.js";
-import * as schema from "@/database/schema.js";
-
-export type Dialect = "sqlite" | "mysql" | "postgresql";
-
-let databaseInstance: any;
-let pool: any;
-let dialect: Dialect;
-
-async function optionalImport<T = any>(name: string): Promise<T> {
-  return import(name) as Promise<T>;
-}
-
-/**
- * Why: Resolves the active DB driver from DATABASE_URL.
- * When: Called during bootstrap and dialect-specific branching.
- * Where: Used by init/close and schema generation helpers.
- * How: Checks DATABASE_URL prefix and maps to sqlite/mysql/postgresql.
- */
-export function detectDialect(): Dialect {
-  const url = databaseConfig.url.toLowerCase();
-  if (url.startsWith("mysql")) return "mysql";
-  if (url.startsWith("postgres")) return "postgresql";
-  return "sqlite";
-}
-
-/**
- * Why: Creates a singleton Drizzle connection for the current dialect.
- * When: Called once at app/worker/scheduler startup.
- * Where: Framework bootstrap entry points.
- * How: Builds dialect-specific pool/client and stores it in module state.
- */
-export async function initDatabase() {
-  if (databaseInstance) return databaseInstance;
-
-  dialect = detectDialect();
-
-  if (dialect === "sqlite") {
-    let drizzleSqlite: any;
-    let createClient: any;
-    try {
-      [{ drizzle: drizzleSqlite }, { createClient }] = await Promise.all([
-        optionalImport("drizzle-orm/libsql"),
-        optionalImport("@libsql/client")
-      ]);
-    } catch {
-      throw new Error("Missing sqlite dependencies. Install with: bun add drizzle-orm @libsql/client");
-    }
-
-    const file = path.resolve(process.cwd(), databaseConfig.url.replace(/^sqlite:/, ""));
-    await fs.mkdir(path.dirname(file), { recursive: true });
-    pool = createClient({ url: `file:${file.replace(/\\/g, "/")}` });
-    databaseInstance = drizzleSqlite(pool, { schema });
-    return databaseInstance;
-  }
-
-  if (dialect === "mysql") {
-    let drizzleMysql: any;
-    let mysql: any;
-    try {
-      [{ drizzle: drizzleMysql }, mysql] = await Promise.all([optionalImport("drizzle-orm/mysql2"), optionalImport("mysql2/promise")]);
-    } catch {
-      throw new Error("Missing mysql dependencies. Install with: bun add drizzle-orm mysql2");
-    }
-
-    pool = mysql.createPool({ uri: databaseConfig.url, connectionLimit: 10, enableKeepAlive: true });
-    databaseInstance = drizzleMysql(pool, { schema, mode: "default" });
-    return databaseInstance;
-  }
-
-  let drizzlePg: any;
-  let postgres: any;
-  try {
-    [{ drizzle: drizzlePg }, { default: postgres }] = await Promise.all([
-      optionalImport("drizzle-orm/postgres-js"),
-      optionalImport("postgres")
-    ]);
-  } catch {
-    throw new Error("Missing postgres dependencies. Install with: bun add drizzle-orm postgres");
-  }
-
-  pool = postgres(databaseConfig.url);
-  databaseInstance = drizzlePg(pool, { schema });
-  return databaseInstance;
-}
-
-/**
- * Why: Returns initialized Drizzle instance for queries.
- * When: Used by app code after bootstrap.
- * Where: Facade `db` proxy and direct internal consumers.
- * How: Throws if initDatabase has not completed.
- */
-export function database() {
-  if (!databaseInstance) throw new Error("Database is not initialized");
-  return databaseInstance;
-}
-
-/**
- * Why: Exposes low-level pool/client for advanced operations.
- * When: Needed by internals that require native pool behavior.
- * Where: Scheduler lock and infrastructure helpers.
- * How: Returns shared pool and guards against uninitialized access.
- */
-export function databasePool() {
-  if (!pool) throw new Error("Database pool is not initialized");
-  return pool;
-}
-
-/**
- * Why: Gracefully closes DB resources during shutdown/reset flows.
- * When: Server stop, worker stop, migration/reset commands.
- * Where: Runtime lifecycle scripts.
- * How: Detects dialect, closes pool, and clears singleton state.
- */
-export async function closeDatabase() {
-  if (!pool) return;
-
-  const activeDialect = databaseDialect();
-
-  if (activeDialect === "sqlite") {
-    pool.close?.();
-    pool = undefined;
-    databaseInstance = undefined;
-    return;
-  }
-
-  if (activeDialect === "mysql") {
-    await pool.end();
-    pool = undefined;
-    databaseInstance = undefined;
-    return;
-  }
-
-  await pool.end();
-  pool = undefined;
-  databaseInstance = undefined;
-}
-
-/**
- * Why: Returns active dialect for conditional SQL/runtime behavior.
- * When: Dialect-specific features are required.
- * Where: Locking, schema, and shutdown helpers.
- * How: Uses initialized dialect or falls back to detection.
- */
-export function databaseDialect() {
-  return dialect || detectDialect();
-}
-
-/**
- * Why: Normalizes raw query results into a consistent { rows } shape.
- * When: Drivers differ in what db.execute() returns:
- *   - postgres-js / libsql return a plain array of rows
- *   - mysql2 returns a [rows, fields] tuple
- *   - pg node clients already wrap rows in { rows }
- * Consumers across modules read `result.rows`.
- * Where: Applied to every db.execute() call.
- * How: Wraps arrays of row objects (and the mysql2 tuple) into { rows },
- * leaves object shapes untouched.
- */
-function normalizeExecuteResult(result: unknown): unknown {
-  if (Array.isArray(result)) {
-    if (result.length === 2 && Array.isArray(result[1])) {
-      return { rows: result[0], fields: result[1] };
-    }
-    const isRowList = result.length === 0 || result.every((row) => row != null && typeof row === "object" && !Array.isArray(row));
-    if (isRowList) {
-      return { rows: result };
-    }
-  }
-  return result;
-}
-
-/**
- * Why: Provides ergonomic global query surface without calling database().
- * When: Used by modules, seeders, and facade consumers.
- * Where: Exposed via framework facade as `db`.
- * How: Proxy forwards property access to the initialized Drizzle instance.
- */
-export const db = new Proxy(
-  {},
-  {
-    get(_target, property) {
-      const instance = database();
-      if (property === "execute") {
-        return async (query: unknown, params?: unknown) => {
-          const raw = instance.execute ? await instance.execute(query, params) : await instance.all(query);
-          return normalizeExecuteResult(raw);
-        };
-      }
-      const value = instance[property as keyof typeof instance];
-      return typeof value === "function" ? value.bind(instance) : value;
-    }
-  }
-) as any;
+import fs from "node:fs/promises";
+import path from "node:path";
+import { databaseConfig } from "@/config/index.js";
+import { loadAppSchema } from "@/framework/database/app-schema.js";
+
+export type Dialect = "sqlite" | "mysql" | "postgresql";
+
+let databaseInstance: any;
+let pool: any;
+let dialect: Dialect;
+
+async function optionalImport<T = any>(name: string): Promise<T> {
+  return import(name) as Promise<T>;
+}
+
+/**
+ * Why: Resolves the active DB driver from DATABASE_URL.
+ * When: Called during bootstrap and dialect-specific branching.
+ * Where: Used by init/close and schema generation helpers.
+ * How: Checks DATABASE_URL prefix and maps to sqlite/mysql/postgresql.
+ */
+export function detectDialect(): Dialect {
+  const url = databaseConfig.url.toLowerCase();
+  if (url.startsWith("mysql")) return "mysql";
+  if (url.startsWith("postgres")) return "postgresql";
+  return "sqlite";
+}
+
+/**
+ * Why: Creates a singleton Drizzle connection for the current dialect.
+ * When: Called once at app/worker/scheduler startup.
+ * Where: Framework bootstrap entry points.
+ * How: Builds dialect-specific pool/client and stores it in module state.
+ */
+export async function initDatabase() {
+  if (databaseInstance) return databaseInstance;
+
+  dialect = detectDialect();
+
+  const schema = await loadAppSchema();
+
+  if (dialect === "sqlite") {
+    let drizzleSqlite: any;
+    let createClient: any;
+    try {
+      [{ drizzle: drizzleSqlite }, { createClient }] = await Promise.all([
+        optionalImport("drizzle-orm/libsql"),
+        optionalImport("@libsql/client")
+      ]);
+    } catch {
+      throw new Error("Missing sqlite dependencies. Install with: bun add drizzle-orm @libsql/client");
+    }
+
+    const file = path.resolve(process.cwd(), databaseConfig.url.replace(/^sqlite:/, ""));
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    pool = createClient({ url: `file:${file.replace(/\\/g, "/")}` });
+    databaseInstance = drizzleSqlite(pool, { schema });
+    return databaseInstance;
+  }
+
+  if (dialect === "mysql") {
+    let drizzleMysql: any;
+    let mysql: any;
+    try {
+      [{ drizzle: drizzleMysql }, mysql] = await Promise.all([optionalImport("drizzle-orm/mysql2"), optionalImport("mysql2/promise")]);
+    } catch {
+      throw new Error("Missing mysql dependencies. Install with: bun add drizzle-orm mysql2");
+    }
+
+    pool = mysql.createPool({ uri: databaseConfig.url, connectionLimit: 10, enableKeepAlive: true });
+    databaseInstance = drizzleMysql(pool, { schema, mode: "default" });
+    return databaseInstance;
+  }
+
+  let drizzlePg: any;
+  let postgres: any;
+  try {
+    [{ drizzle: drizzlePg }, { default: postgres }] = await Promise.all([
+      optionalImport("drizzle-orm/postgres-js"),
+      optionalImport("postgres")
+    ]);
+  } catch {
+    throw new Error("Missing postgres dependencies. Install with: bun add drizzle-orm postgres");
+  }
+
+  pool = postgres(databaseConfig.url);
+  databaseInstance = drizzlePg(pool, { schema });
+  return databaseInstance;
+}
+
+/**
+ * Why: Returns initialized Drizzle instance for queries.
+ * When: Used by app code after bootstrap.
+ * Where: Facade `db` proxy and direct internal consumers.
+ * How: Throws if initDatabase has not completed.
+ */
+export function database() {
+  if (!databaseInstance) throw new Error("Database is not initialized");
+  return databaseInstance;
+}
+
+/**
+ * Why: Exposes low-level pool/client for advanced operations.
+ * When: Needed by internals that require native pool behavior.
+ * Where: Scheduler lock and infrastructure helpers.
+ * How: Returns shared pool and guards against uninitialized access.
+ */
+export function databasePool() {
+  if (!pool) throw new Error("Database pool is not initialized");
+  return pool;
+}
+
+/**
+ * Why: Gracefully closes DB resources during shutdown/reset flows.
+ * When: Server stop, worker stop, migration/reset commands.
+ * Where: Runtime lifecycle scripts.
+ * How: Detects dialect, closes pool, and clears singleton state.
+ */
+export async function closeDatabase() {
+  if (!pool) return;
+
+  const activeDialect = databaseDialect();
+
+  if (activeDialect === "sqlite") {
+    pool.close?.();
+    pool = undefined;
+    databaseInstance = undefined;
+    return;
+  }
+
+  if (activeDialect === "mysql") {
+    await pool.end();
+    pool = undefined;
+    databaseInstance = undefined;
+    return;
+  }
+
+  await pool.end();
+  pool = undefined;
+  databaseInstance = undefined;
+}
+
+/**
+ * Why: Returns active dialect for conditional SQL/runtime behavior.
+ * When: Dialect-specific features are required.
+ * Where: Locking, schema, and shutdown helpers.
+ * How: Uses initialized dialect or falls back to detection.
+ */
+export function databaseDialect() {
+  return dialect || detectDialect();
+}
+
+/**
+ * Why: Normalizes raw query results into a consistent { rows } shape.
+ * When: Drivers differ in what db.execute() returns:
+ *   - postgres-js / libsql return a plain array of rows
+ *   - mysql2 returns a [rows, fields] tuple
+ *   - pg node clients already wrap rows in { rows }
+ * Consumers across modules read `result.rows`.
+ * Where: Applied to every db.execute() call.
+ * How: Wraps arrays of row objects (and the mysql2 tuple) into { rows },
+ * leaves object shapes untouched.
+ */
+function normalizeExecuteResult(result: unknown): unknown {
+  if (Array.isArray(result)) {
+    if (result.length === 2 && Array.isArray(result[1])) {
+      return { rows: result[0], fields: result[1] };
+    }
+    const isRowList = result.length === 0 || result.every((row) => row != null && typeof row === "object" && !Array.isArray(row));
+    if (isRowList) {
+      return { rows: result };
+    }
+  }
+  return result;
+}
+
+/**
+ * Why: Provides ergonomic global query surface without calling database().
+ * When: Used by modules, seeders, and facade consumers.
+ * Where: Exposed via framework facade as `db`.
+ * How: Proxy forwards property access to the initialized Drizzle instance.
+ */
+export const db = new Proxy(
+  {},
+  {
+    get(_target, property) {
+      const instance = database();
+      if (property === "execute") {
+        return async (query: unknown, params?: unknown) => {
+          const raw = instance.execute ? await instance.execute(query, params) : await instance.all(query);
+          return normalizeExecuteResult(raw);
+        };
+      }
+      const value = instance[property as keyof typeof instance];
+      return typeof value === "function" ? value.bind(instance) : value;
+    }
+  }
+) as any;

package/hono/src/framework/database/seed.ts

@@ -45,30 +45,39 @@ try {
   const seeders: SeederEntry[] = [];
 
   for (const file of files) {
-    const source = await readFile(file, "utf8");
-    const isUnfilledStub = !/^\s*export\s/m.test(source);
-    const mod = await importFile(file);
-    if (typeof mod.default !== "function") {
-      if (isUnfilledStub) {
-        console.log(`Skipped unfilled seeder ${file} (no exports yet)`);
+    try {
+      const source = await readFile(file, "utf8");
+      const isUnfilledStub = !/^\s*export\s/m.test(source);
+      const mod = await importFile(file).catch((err: any) => {
+        console.warn(`[seed:skip] ${file}: ${err?.message || err}`);
+        return null as any;
+      });
+      if (!mod) continue;
+      if (typeof mod.default !== "function") {
+        if (isUnfilledStub) {
+          console.log(`Skipped unfilled seeder ${file} (no exports yet)`);
+          continue;
+        }
+        console.warn(`[seed:skip] ${file}: has no default export function`);
         continue;
       }
-      throw new Error(`Seeder file ${file} has no default export function`);
-    }
-    const table: any = mod.table;
-    const entry: SeederEntry = {
-      file,
-      name: file
-        .split(/[\\/]/)
-        .pop()!
-        .replace(/\.(ts|js)$/, ""),
-      execute: () => mod.default(),
-      dependsOn: table ? getTableDeps(table) : []
-    };
-    if (table) {
-      entry.tableName = table[NAME_SYMBOL] as string;
+      const table: any = mod.table;
+      const entry: SeederEntry = {
+        file,
+        name: file
+          .split(/[\\/]/)
+          .pop()!
+          .replace(/\.(ts|js)$/, ""),
+        execute: () => mod.default(),
+        dependsOn: table ? getTableDeps(table) : []
+      };
+      if (table) {
+        entry.tableName = table[NAME_SYMBOL] as string;
+      }
+      seeders.push(entry);
+    } catch (err: any) {
+      console.warn(`[seed:skip] ${file}: ${err?.message || err}`);
     }
-    seeders.push(entry);
   }
 
   const tableToSeeder = new Map<string, SeederEntry>();
@@ -130,7 +139,11 @@ try {
   }
 
   for (const s of sorted) {
-    await s.execute();
+    try {
+      await s.execute();
+    } catch (err: any) {
+      console.warn(`[seed:skip] ${s.name} failed: ${err?.message || err}`);
+    }
   }
 
   console.log(`Executed ${sorted.length} seeder file(s)${moduleName ? ` for module ${moduleName}` : ""}`);

package/hono/src/framework/facade.ts

@@ -1,29 +1,59 @@
-/**
- * Why: Central public API surface for framework consumers.
- * When: Modules/middlewares need framework utilities.
- * Where: App-layer imports should target this file.
- * How: Re-exports stable, reusable helpers while hiding setup internals.
- */
-
-export { createRoute, z } from "@hono/zod-openapi";
-export * as lodash from "lodash-es";
-export * as HttpStatusCodes from "stoker/http-status-codes";
-export { jsonContent } from "stoker/openapi/helpers";
-export { cache } from "@/framework/cache/cache.js";
-export { database, db } from "@/framework/database/connection.js";
-export { type PaginatedResult, paginate, paginateModel, paginateQuery, paginateTable } from "@/framework/database/paginate.js";
-export { command, dispatchCommand, dispatchEvent } from "@/framework/events/dispatcher.js";
-export { createRouter, group } from "@/framework/http/router.js";
-export { validate } from "@/framework/http/validation.js";
-export { notify } from "@/framework/notification/index.js";
-export { queue, queueJob, shouldQueue } from "@/framework/queue/queue.js";
-export { broadcast } from "@/framework/realtime/index.js";
-export { defineSchedule } from "@/framework/scheduler/scheduler.js";
-export { session } from "@/framework/session/session.js";
-export { storage } from "@/framework/storage/storage.js";
-export { cookie } from "@/framework/support/cookie.js";
-export { jwt } from "@/framework/support/jwt.js";
-export { logger } from "@/framework/support/logger.js";
-export { mail } from "@/framework/support/mail.js";
-export { password } from "@/framework/support/password.js";
-export { urls } from "@/framework/support/url.js";
+/**
+ * Why: Central public API surface for framework consumers.
+ * When: Modules/middlewares need framework utilities.
+ * Where: App-layer imports should target this file.
+ * How: Re-exports stable, reusable helpers while hiding setup internals.
+ */
+
+export { createRoute, z } from "@hono/zod-openapi";
+export * as lodash from "lodash-es";
+export * as HttpStatusCodes from "stoker/http-status-codes";
+export { jsonContent } from "stoker/openapi/helpers";
+export { cache } from "@/framework/cache/cache.js";
+export { database, db } from "@/framework/database/connection.js";
+export { type PaginatedResult, paginate, paginateModel, paginateQuery, paginateTable } from "@/framework/database/paginate.js";
+export { command, dispatchCommand, dispatchEvent } from "@/framework/events/dispatcher.js";
+export { createRouter, group } from "@/framework/http/router.js";
+export { validate } from "@/framework/http/validation.js";
+export { notify } from "@/framework/notification/index.js";
+export type {
+  AuthProvider,
+  AuthProviderRefreshToken,
+  AuthProviderUser,
+  AuthUserContact,
+  AuthUserContext,
+  NotifiableTarget,
+  NotificationCreateInput,
+  NotificationListOptions,
+  NotificationPage,
+  NotificationProvider,
+  NotificationRecord
+} from "@/framework/providers/contracts.js";
+export { resolveAuthProvider, resolveNotificationProvider } from "@/framework/providers/adapter.js";
+export { loadProviders } from "@/framework/providers/loader.js";
+export {
+  clearAuthProvider,
+  clearNotificationProvider,
+  clearProvider,
+  getAuthProvider,
+  getNotificationProvider,
+  getProvider,
+  hasAuthProvider,
+  hasNotificationProvider,
+  hasProvider,
+  listProviders,
+  registerAuthProvider,
+  registerNotificationProvider,
+  registerProvider
+} from "@/framework/providers/registry.js";
+export { queue, queueJob, shouldQueue } from "@/framework/queue/queue.js";
+export { broadcast } from "@/framework/realtime/index.js";
+export { defineSchedule } from "@/framework/scheduler/scheduler.js";
+export { session } from "@/framework/session/session.js";
+export { storage } from "@/framework/storage/storage.js";
+export { cookie } from "@/framework/support/cookie.js";
+export { jwt } from "@/framework/support/jwt.js";
+export { logger } from "@/framework/support/logger.js";
+export { mail } from "@/framework/support/mail.js";
+export { password } from "@/framework/support/password.js";
+export { urls } from "@/framework/support/url.js";