create-nexgen 1.0.4

package/template/src/framework/maker-cli/src/levels/level-2/db/core.mjs

@@ -0,0 +1,299 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { glob } from "glob";
+import { databaseNameFromUrl, databaseUrl, detectDialect, parsedDatabaseUrl, sqlitePathFromUrl } from "../../level-1/env-db.mjs";
+import { packageScript, runCommand, runNodeScript } from "../../level-1/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 sqliteHints = ["autoincrement", "integer primary key", "pragma"];
+  const mysqlHints = ["auto_increment", "engine=", "datetime", "varchar("];
+  const postgresHints = ["serial", "bigserial", "timestamp with time zone", "public."];
+
+  if (mysqlHints.some((hint) => source.includes(hint))) return "mysql";
+  if (postgresHints.some((hint) => source.includes(hint))) return "postgresql";
+  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 pg = await import("pg");
+  const admin = new pg.Client({
+    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" ? { rejectUnauthorized: false } : undefined
+  });
+  await admin.connect();
+  try {
+    const { rows } = await admin.query("SELECT 1 FROM pg_database WHERE datname = $1", [database]);
+    if (!rows.length) {
+      const safe = database.replace(/"/g, '""');
+      await admin.query(`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 pg = await import("pg");
+  const admin = new pg.Client({
+    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" ? { rejectUnauthorized: false } : undefined
+  });
+  await admin.connect();
+  try {
+    const safe = database.replace(/"/g, '""');
+    await admin.query(
+      "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid <> pg_backend_pid()",
+      [database]
+    );
+    await admin.query(`DROP DATABASE IF EXISTS "${safe}"`);
+    await admin.query(`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 sqlite = await import("better-sqlite3");
+    const file = sqliteDatabasePath();
+    const db = sqlite.default(file);
+    try {
+      const rows = db
+        .prepare(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name != '__drizzle_migrations'"
+        )
+        .all();
+      return rows.length > 0;
+    } finally {
+      db.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 pg = await import("pg");
+  const client = new pg.Client({ connectionString: databaseUrl() });
+  await client.connect();
+  try {
+    const result = await client.query("SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename != '__drizzle_migrations'");
+    return result.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/template/src/framework/maker-cli/src/levels/level-2/db/index.mjs

@@ -0,0 +1,177 @@
+import { syncMigrationDialect, ensureMigrationMeta, drizzleGenerateArgs, migrationFiles, ensureDatabaseDirectory, ensureDatabaseExists, hasExistingAppTables, runSeed, resetDatabase } from "./core.mjs";
+import { generateSchema } from "../module/core.mjs";
+import { assertName as assertNameLeaf } from "../../level-1/naming.mjs";
+import { showHelp } from "../../level-1/help.mjs";
+import { packageScript, runNodeScript } from "../../level-1/process.mjs";
+
+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 "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"]);
+  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 'bun maker db:fresh --seed' to rebuild locally, or restore migration files before running db:migrate."
+      );
+    }
+    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["migrate"]);
+    if (args.includes("--seed")) await runSeed();
+  },
+
+  "migrate:run": async () => {
+    await generateSchema();
+    await ensureDatabaseExists();
+    await runNodeScript(packageScript("drizzle-kit", "bin.cjs"), ["migrate"]);
+  },
+
+  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, "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" }]);
+  cmd("migrate:run", "Run existing Drizzle migrations only");
+  cmd("fresh", "Reset database then generate, migrate, optionally seed", [{ flag: "--seed", description: "Run seeders after fresh" }]);
+  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");
+}