create-nexwire 4.0.0

package/hono/src/framework/http/static.ts

@@ -0,0 +1,70 @@
+import fsSync from "node:fs";
+import { runtime } from "@/framework/runtime/runtime.js";
+
+export function hasUiBuild() {
+  return fsSync.existsSync("public/index.html");
+}
+
+/**
+ * Why: Loads the active runtime's Hono serveStatic implementation.
+ * When: A static middleware is first invoked at request time.
+ * Where: Framework HTTP static helpers.
+ * How: Dynamically imports hono/bun or @hono/node-server/serve-static
+ *      based on runtime(), so non-Node runtimes never load Node-only modules.
+ */
+export async function resolveServeStatic() {
+  const activeRuntime = runtime();
+  if (activeRuntime === "bun") {
+    return (await import("hono/bun")).serveStatic;
+  }
+  return (await import("@hono/node-server/serve-static")).serveStatic;
+}
+
+let _storageStaticMiddleware: ReturnType<Awaited<ReturnType<typeof resolveServeStatic>>> | null = null;
+
+/**
+ * Why: Serves public storage files under `/storage/*` URL space.
+ * When: Clients request uploaded public assets.
+ * Where: App middleware stack.
+ * How: Maps `/storage` path prefix to local storage public directory.
+ */
+export async function storageStaticMiddleware(c: any, next: any) {
+  if (!_storageStaticMiddleware) {
+    const serveStatic = await resolveServeStatic();
+    _storageStaticMiddleware = serveStatic({
+      root: "./src/storage/app/public",
+      rewriteRequestPath: (path) => path.replace(/^\/storage/, "")
+    });
+  }
+  return _storageStaticMiddleware(c, next);
+}
+
+let _uiStaticMiddleware: ReturnType<Awaited<ReturnType<typeof resolveServeStatic>>> | null = null;
+
+let _uiIndexMiddleware: ReturnType<Awaited<ReturnType<typeof resolveServeStatic>>> | null = null;
+
+function ensurePublicDir() {
+  if (!fsSync.existsSync("public")) {
+    fsSync.mkdirSync("public", { recursive: true });
+  }
+}
+
+async function uiStaticMiddleware(c: any, next: any) {
+  ensurePublicDir();
+  if (!_uiStaticMiddleware) {
+    const serveStatic = await resolveServeStatic();
+    _uiStaticMiddleware = serveStatic({ root: "./public" });
+  }
+  return _uiStaticMiddleware(c, next);
+}
+
+async function uiIndexMiddleware(c: any, next: any) {
+  ensurePublicDir();
+  if (!_uiIndexMiddleware) {
+    const serveStatic = await resolveServeStatic();
+    _uiIndexMiddleware = serveStatic({ path: "./public/index.html" });
+  }
+  return _uiIndexMiddleware(c, next);
+}
+
+export { ensurePublicDir, uiIndexMiddleware, uiStaticMiddleware };

package/hono/src/framework/http/validation.ts

@@ -0,0 +1,21 @@
+import type { z } from "zod";
+
+/**
+ * Why: Centralizes schema validation with consistent error shape.
+ * When: Non-route code needs explicit Zod validation.
+ * Where: Controllers/helpers/services.
+ * How: Runs safeParseAsync and throws 422 payload on failure.
+ */
+export async function validate<T extends z.ZodTypeAny>(schema: T, data: unknown): Promise<z.infer<T>> {
+  const result = await schema.safeParseAsync(data);
+
+  if (!result.success) {
+    throw {
+      status: 422,
+      message: "Validation failed",
+      errors: result.error.flatten()
+    };
+  }
+
+  return result.data;
+}

package/hono/src/framework/kernel.ts

@@ -0,0 +1,48 @@
+import { appConfig } from "@/config/index.js";
+import { validateConfig } from "@/config/validate.js";
+import { initDatabase } from "@/framework/database/connection.js";
+import { createHttpApp } from "@/framework/http/app.js";
+import { ensurePublicDir, hasUiBuild, uiIndexMiddleware, uiStaticMiddleware } from "@/framework/http/static.js";
+import { registerModuleRoutes } from "@/framework/modules/routes.js";
+import { bootQueueJobs } from "@/framework/queue/queue.js";
+import { setupQueueDashboard } from "@/framework/queue/ui.js";
+import { initRedis } from "@/framework/redis/client.js";
+import { storage } from "@/framework/storage/storage.js";
+
+/**
+ * Why: Assembles app kernel and boots all framework dependencies.
+ * When: HTTP server startup.
+ * Where: Called by server runtime entrypoint.
+ * How: Initializes storage/db/redis/queues/events/routes and optional UI.
+ */
+export async function createKernel() {
+  validateConfig();
+
+  await storage.init();
+
+  await initRedis();
+
+  const app = createHttpApp();
+
+  await initDatabase();
+  await bootQueueJobs();
+  await registerModuleRoutes(app);
+
+  const queueDashboard = await setupQueueDashboard();
+  if (typeof queueDashboard.route === "function") {
+    queueDashboard.route(app);
+  } else {
+    app.route(queueDashboard.basePath, queueDashboard.route);
+  }
+
+  if (appConfig.uiEnabled) {
+    ensurePublicDir();
+  }
+
+  if (appConfig.uiEnabled && hasUiBuild()) {
+    app.use("/*", uiStaticMiddleware);
+    app.get("/*", uiIndexMiddleware);
+  }
+
+  return { app, bullBoard: queueDashboard };
+}

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

@@ -0,0 +1,288 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { glob } from "glob";
+import { databaseNameFromUrl, databaseUrl, detectDialect, parsedDatabaseUrl, sqlitePathFromUrl } from "../utils/env-db.mjs";
+import { packageScript, runCommand, runNodeScript } from "../utils/process.mjs";
+
+/** Detect SQL dialect from raw SQL content by matching against known syntax hints. */
+function detectMigrationDialectFromSql(sql = "") {
+  const source = sql.toLowerCase();
+  if (!source.trim()) return "unknown";
+
+  const postgresHints = ["generated always as identity", "bigserial", "serial", "timestamp with time zone", "public."];
+  const mysqlHints = ["auto_increment", "engine=", "`"];
+  const sqliteHints = ["autoincrement", "pragma"];
+
+  if (postgresHints.some((hint) => source.includes(hint))) return "postgresql";
+  if (mysqlHints.some((hint) => source.includes(hint))) return "mysql";
+  if (sqliteHints.some((hint) => source.includes(hint))) return "sqlite";
+  return "unknown";
+}
+
+/** List existing migration .sql files for the current dialect, sorted. */
+export async function migrationFiles() {
+  const files = await glob(`src/database/migrations/${detectDialect()}/*.sql`, {
+    cwd: process.cwd(),
+    nodir: true,
+    windowsPathsNoEscape: true
+  });
+  return files.sort();
+}
+
+/** Generate drizzle-kit CLI args for migration generation. Uses --name init for the first migration. */
+export async function drizzleGenerateArgs() {
+  const files = await migrationFiles();
+  if (!files.length) return ["generate", "--name", "init"];
+  return ["generate"];
+}
+
+/** Create MySQL database if it does not exist. Uses DATABASE_URL credentials. */
+async function ensureMysqlDatabaseExists() {
+  const targetUrl = parsedDatabaseUrl();
+  const database = databaseNameFromUrl(targetUrl);
+  if (!targetUrl || !database) return;
+  const mysql = await import("mysql2/promise");
+  const connection = await mysql.createConnection({
+    host: targetUrl.hostname,
+    port: targetUrl.port ? Number(targetUrl.port) : 3306,
+    user: decodeURIComponent(targetUrl.username || "root"),
+    password: decodeURIComponent(targetUrl.password || ""),
+    database: "mysql",
+    ssl: targetUrl.searchParams.get("ssl") === "true" ? {} : undefined
+  });
+  try {
+    const [rows] = await connection.query("SELECT SCHEMA_NAME as name FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?", [database]);
+    const exists = Array.isArray(rows) && rows.length > 0;
+    if (!exists) {
+      const safe = database.replace(/`/g, "``");
+      await connection.query(`CREATE DATABASE \`${safe}\``);
+      console.log(`Created MySQL database: ${database}`);
+    }
+  } finally {
+    await connection.end();
+  }
+}
+
+/** Create Postgres database if it does not exist. Uses DATABASE_URL credentials. */
+async function ensurePostgresDatabaseExists() {
+  const targetUrl = parsedDatabaseUrl();
+  const database = databaseNameFromUrl(targetUrl);
+  if (!targetUrl || !database) return;
+  const postgres = (await import("postgres")).default;
+  const admin = postgres({
+    host: targetUrl.hostname,
+    port: targetUrl.port ? Number(targetUrl.port) : 5432,
+    user: decodeURIComponent(targetUrl.username || "postgres"),
+    password: decodeURIComponent(targetUrl.password || ""),
+    database: "postgres",
+    ssl: targetUrl.searchParams.get("ssl") === "true" ? "require" : false
+  });
+  try {
+    const rows = await admin.unsafe("SELECT 1 FROM pg_database WHERE datname = $1", [database]);
+    if (!rows.length) {
+      const safe = database.replace(/"/g, '""');
+      await admin.unsafe(`CREATE DATABASE "${safe}"`);
+      console.log(`Created Postgres database: ${database}`);
+    }
+  } finally {
+    await admin.end();
+  }
+}
+
+/** Ensure the database exists for the current DATABASE_URL dialect. Creates it if missing (MySQL/Postgres). */
+export async function ensureDatabaseExists() {
+  const dialect = detectDialect();
+  if (dialect === "sqlite") {
+    await ensureDatabaseDirectory();
+    return;
+  }
+  if (dialect === "mysql") {
+    await ensureMysqlDatabaseExists();
+    return;
+  }
+  if (dialect === "postgresql") {
+    await ensurePostgresDatabaseExists();
+  }
+}
+
+/** Resolve the filesystem path for the SQLite database file. */
+function sqliteDatabasePath() {
+  return path.resolve(process.cwd(), sqlitePathFromUrl(databaseUrl()));
+}
+
+/** Delete and recreate the SQLite database file. */
+async function resetSqliteDatabase() {
+  const file = sqliteDatabasePath();
+  await fs.rm(file, { force: true });
+  await fs.mkdir(path.dirname(file), { recursive: true });
+}
+
+/** Drop and recreate the MySQL database. */
+async function resetMysqlDatabase() {
+  const targetUrl = parsedDatabaseUrl();
+  const database = databaseNameFromUrl(targetUrl);
+  if (!targetUrl || !database) return;
+  const mysql = await import("mysql2/promise");
+  const connection = await mysql.createConnection({
+    host: targetUrl.hostname,
+    port: targetUrl.port ? Number(targetUrl.port) : 3306,
+    user: decodeURIComponent(targetUrl.username || "root"),
+    password: decodeURIComponent(targetUrl.password || ""),
+    database: "mysql",
+    ssl: targetUrl.searchParams.get("ssl") === "true" ? {} : undefined
+  });
+  try {
+    const safe = database.replace(/`/g, "``");
+    await connection.query(`DROP DATABASE IF EXISTS \`${safe}\``);
+    await connection.query(`CREATE DATABASE \`${safe}\``);
+  } finally {
+    await connection.end();
+  }
+}
+
+/** Drop and recreate the Postgres database. Terminates active connections first. */
+async function resetPostgresDatabase() {
+  const targetUrl = parsedDatabaseUrl();
+  const database = databaseNameFromUrl(targetUrl);
+  if (!targetUrl || !database) return;
+  const postgres = (await import("postgres")).default;
+  const admin = postgres({
+    host: targetUrl.hostname,
+    port: targetUrl.port ? Number(targetUrl.port) : 5432,
+    user: decodeURIComponent(targetUrl.username || "postgres"),
+    password: decodeURIComponent(targetUrl.password || ""),
+    database: "postgres",
+    ssl: targetUrl.searchParams.get("ssl") === "true" ? "require" : false
+  });
+  try {
+    const safe = database.replace(/"/g, '""');
+    await admin.unsafe("SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid <> pg_backend_pid()", [database]);
+    await admin.unsafe(`DROP DATABASE IF EXISTS "${safe}"`);
+    await admin.unsafe(`CREATE DATABASE "${safe}"`);
+  } finally {
+    await admin.end();
+  }
+}
+
+/** Drop and recreate the database for the current dialect. */
+export async function resetDatabase() {
+  const dialect = detectDialect();
+  if (dialect === "sqlite") return await resetSqliteDatabase();
+  if (dialect === "mysql") return await resetMysqlDatabase();
+  if (dialect === "postgresql") return await resetPostgresDatabase();
+}
+
+/** Check if the database has existing app tables (excluding drizzle meta tables). */
+export async function hasExistingAppTables() {
+  const dialect = detectDialect();
+  if (dialect === "sqlite") {
+    const libsql = await import("@libsql/client");
+    const file = sqliteDatabasePath();
+    const client = libsql.createClient({ url: `file:${file.replace(/\\/g, "/")}` });
+    try {
+      const result = await client.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name != '__drizzle_migrations'"
+      );
+      return result.rows.length > 0;
+    } finally {
+      client.close();
+    }
+  }
+
+  if (dialect === "mysql") {
+    const mysql = await import("mysql2/promise");
+    const connection = await mysql.createConnection(databaseUrl());
+    try {
+      const [rows] = await connection.query(
+        "SELECT table_name as name FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name != '__drizzle_migrations'"
+      );
+      return Array.isArray(rows) && rows.length > 0;
+    } finally {
+      await connection.end();
+    }
+  }
+
+  const postgres = (await import("postgres")).default;
+  const client = postgres(databaseUrl());
+  try {
+    const rows = await client.unsafe("SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename != '__drizzle_migrations'");
+    return rows.length > 0;
+  } finally {
+    await client.end();
+  }
+}
+
+/** Run the application seed script via tsx or Bun. */
+export async function runSeed(moduleName = "") {
+  const seedArgs = ["src/framework/database/seed.ts"];
+  if (moduleName) seedArgs.push(`--module=${moduleName}`);
+  if (process.versions?.bun) {
+    await runCommand("bun", seedArgs);
+    return;
+  }
+  await runNodeScript(packageScript("tsx", "dist/cli.mjs"), seedArgs);
+}
+
+/** Ensure the SQLite database directory exists. No-op for MySQL/Postgres. */
+export async function ensureDatabaseDirectory() {
+  if (detectDialect() !== "sqlite") return;
+  const file = path.resolve(process.cwd(), sqlitePathFromUrl(databaseUrl()));
+  await fs.mkdir(path.dirname(file), { recursive: true });
+}
+
+/** Ensure the drizzle migration meta directory and _journal.json exist. */
+export async function ensureMigrationMeta() {
+  const migrationRoot = path.resolve(process.cwd(), "src/database/migrations", detectDialect());
+  const metaRoot = path.join(migrationRoot, "meta");
+  const journalPath = path.join(metaRoot, "_journal.json");
+  await fs.mkdir(metaRoot, { recursive: true });
+  try {
+    await fs.access(journalPath);
+  } catch {
+    const dialect = detectDialect();
+    const journalDialect = dialect === "postgresql" ? "postgresql" : dialect;
+    await fs.writeFile(
+      journalPath,
+      `{
+  "version": "7",
+  "dialect": "${journalDialect}",
+  "entries": []
+}
+`
+    );
+  }
+}
+
+/** Sync the migration dialect to match the current DATABASE_URL. Resets migrations if dialect changed. */
+export async function syncMigrationDialect() {
+  async function existingMigrationDialect() {
+    const files = await migrationFiles();
+    if (!files.length) return null;
+    const first = await fs.readFile(path.resolve(process.cwd(), files[0]), "utf8");
+    return detectMigrationDialectFromSql(first);
+  }
+
+  async function resetMigrationFiles() {
+    const migrationRoot = path.resolve(process.cwd(), "src/database/migrations", detectDialect());
+    const dialect = detectDialect();
+    const journalDialect = dialect === "postgresql" ? "postgresql" : dialect;
+    await fs.rm(migrationRoot, { recursive: true, force: true });
+    await fs.mkdir(path.join(migrationRoot, "meta"), { recursive: true });
+    await fs.writeFile(
+      path.join(migrationRoot, "meta", "_journal.json"),
+      `{
+  "version": "7",
+  "dialect": "${journalDialect}",
+  "entries": []
+}
+`
+    );
+    console.log("Reset existing migration files due to dialect change.");
+  }
+
+  const target = detectDialect();
+  const current = await existingMigrationDialect();
+  if (!current || current === "unknown" || current === target) return;
+  console.log(`Migration dialect changed (${current} -> ${target}). Regenerating migration files for current DATABASE_URL.`);
+  await resetMigrationFiles();
+}

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

@@ -0,0 +1,204 @@
+import { generateSchema } from "../module/core.mjs";
+import { showHelp } from "../utils/help.mjs";
+import { assertName as assertNameLeaf } from "../utils/naming.mjs";
+import { packageScript, runCommand, runNodeScript } from "../utils/process.mjs";
+import {
+  drizzleGenerateArgs,
+  ensureDatabaseDirectory,
+  ensureDatabaseExists,
+  ensureMigrationMeta,
+  hasExistingAppTables,
+  migrationFiles,
+  resetDatabase,
+  runSeed,
+  syncMigrationDialect
+} from "./core.mjs";
+
+async function runMigrationHooks() {
+  const args = ["src/framework/database/migrate-hooks.ts"];
+  if (process.versions?.bun) {
+    await runCommand("bun", args);
+    return;
+  }
+  await runNodeScript(packageScript("tsx", "dist/cli.mjs"), args);
+}
+
+let args = [];
+let command = "",
+  firstArg = "",
+  secondArg = "";
+let dbProgram = null;
+
+/** Wrapper around assertName that exits with help on failure. */
+function assertName(value, label) {
+  try {
+    return assertNameLeaf(value, label);
+  } catch {
+    console.error(`${label} is required.`);
+    showHelp(dbProgram);
+    process.exit(1);
+  }
+}
+
+function unsupported() {
+  console.error(
+    'Drizzle Kit does not support Laravel-style rollback/refresh migrations. Use "npm run maker db:fresh -- --seed" (or "bun maker db:fresh --seed") for a SQLite development reset, or manage rollback SQL manually for production databases.'
+  );
+  process.exit(1);
+}
+
+async function handleFresh() {
+  await ensureDatabaseExists();
+  await resetDatabase();
+  await generateSchema();
+  await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), await drizzleGenerateArgs());
+  await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["migrate"]);
+  await runMigrationHooks();
+  if (args.includes("--seed")) await runSeed();
+}
+
+async function handleReset() {
+  await ensureDatabaseExists();
+  await resetDatabase();
+}
+
+async function handleStatus() {
+  await generateSchema();
+  const files = await migrationFiles();
+  if (!files.length) {
+    console.log("No generated migration files found.");
+    return;
+  }
+  console.log("Generated migrations:");
+  for (const file of files) console.log(`  - ${file}`);
+}
+
+const handlers = {
+  schema: () => generateSchema(),
+
+  generate: async () => {
+    await syncMigrationDialect();
+    await ensureMigrationMeta();
+    await generateSchema();
+    await ensureDatabaseDirectory();
+    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), await drizzleGenerateArgs());
+  },
+
+  migrate: async () => {
+    await syncMigrationDialect();
+    await ensureMigrationMeta();
+    const hadMigrationsBeforeGenerate = (await migrationFiles()).length > 0;
+    await ensureDatabaseExists();
+    const hadExistingTablesBeforeGenerate = await hasExistingAppTables();
+    await generateSchema();
+    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), await drizzleGenerateArgs());
+    if (!hadMigrationsBeforeGenerate && hadExistingTablesBeforeGenerate) {
+      throw new Error(
+        "Initial migration was generated, but the database already contains tables. " +
+          "This usually means migration files were deleted while DB data still exists. " +
+          "Use 'npm run maker db:fresh -- --seed' (or 'bun maker db:fresh --seed') to rebuild locally, or restore migration files before running db:migrate."
+      );
+    }
+    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["migrate"]);
+    await runMigrationHooks();
+    if (args.includes("--seed")) await runSeed();
+  },
+
+  "migrate:run": async () => {
+    await generateSchema();
+    await ensureDatabaseExists();
+    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["migrate"]);
+    await runMigrationHooks();
+  },
+
+  fresh: handleFresh,
+  "migrate:fresh": handleFresh,
+
+  reset: handleReset,
+  wipe: handleReset,
+  "migrate:reset": handleReset,
+
+  status: handleStatus,
+  "migrate:status": handleStatus,
+
+  push: async () => {
+    await generateSchema();
+    await ensureDatabaseExists();
+    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["push"]);
+  },
+
+  check: async () => {
+    await generateSchema();
+    await ensureDatabaseExists();
+    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["check"]);
+  },
+
+  studio: async () => {
+    const quiet = args.includes("--quiet");
+    await generateSchema({ silent: quiet });
+    await ensureDatabaseExists();
+    try {
+      await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["studio"], { silent: quiet });
+    } catch (error) {
+      if (quiet) throw new Error("db:studio unavailable");
+      throw error;
+    }
+  },
+
+  seed: async () => {
+    const possibleModule = command?.startsWith("db:") ? firstArg : secondArg;
+    const moduleName = possibleModule && !possibleModule.startsWith("--") ? possibleModule : null;
+    await runSeed(moduleName || "");
+  },
+
+  "module:seed": async () => {
+    const moduleName = assertName(secondArg || firstArg, "Module name");
+    await runSeed(moduleName);
+  },
+
+  rollback: unsupported,
+  "migrate:rollback": unsupported,
+  refresh: unsupported,
+  "migrate:refresh": unsupported
+};
+
+/** Register db:* subcommands on the CLI program. */
+export function registerDbCommands(program, rawArgs) {
+  dbProgram = program;
+  args = rawArgs;
+  command = rawArgs[0] || "";
+  firstArg = rawArgs[1] || "";
+  secondArg = rawArgs[2] || "";
+  program
+    .command("db [subcommand]")
+    .description("Run database operations (schema, generate, migrate, fresh, seed, etc.)")
+    .allowUnknownOption(true)
+    .action(async (subcommand) => {
+      const handler = handlers[subcommand];
+      if (handler) return await handler();
+      console.error(`Unknown db command: ${subcommand || ""}`);
+      showHelp(dbProgram);
+      process.exit(1);
+    });
+
+  const cmd = (name, desc, opts = []) => {
+    const c = program.command(`db:${name}`).description(desc).allowUnknownOption(true);
+    for (const o of opts) c.option(o.flag, o.description);
+    c.action(handlers[name]);
+  };
+
+  cmd("schema", "Generate src/database/schema.ts from module models");
+  cmd("generate", "Generate Drizzle migrations after schema discovery");
+  cmd("migrate", "Generate then run Drizzle migrations", [{ flag: "--seed", description: "Run seeders after migration (npm: use `npm run maker db:migrate -- --seed`)" }]);
+  cmd("migrate:run", "Run existing Drizzle migrations only");
+  cmd("fresh", "Reset database then generate, migrate, optionally seed", [{ flag: "--seed", description: "Run seeders after fresh (npm: use `npm run maker db:fresh -- --seed`)" }]);
+  cmd("seed", "Run all seeders or one module seeder set", [{ flag: "--module", description: "Optional module name" }]);
+  cmd("status", "Show generated migration files");
+  cmd("push", "Run drizzle-kit push after schema discovery");
+  cmd("check", "Run drizzle-kit check after schema discovery");
+  cmd("studio", "Open Drizzle Studio after schema discovery", [{ flag: "--quiet", description: "Suppress output" }]);
+  cmd("module:seed", "Run seeders for a specific module");
+  cmd("reset", "Drop all tables (wipe database)");
+  cmd("wipe", "Drop all tables (wipe database)");
+  cmd("migrate:reset", "Drop all tables (wipe database)");
+}