db-model-router 1.0.2 → 1.0.3

package/src/cli/commands/init.js

@@ -0,0 +1,153 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { parseSchema } = require("../../schema/schema-parser");
+const {
+  generateFiles,
+  updatePackageJson,
+  runInstall,
+  printSummary,
+  ensurePackageJson,
+} = require("../init");
+const { promptUser } = require("../init/prompt");
+
+/**
+ * Default answers used when --yes is provided and no schema is available.
+ */
+const DEFAULT_ANSWERS = {
+  framework: "express",
+  database: "postgres",
+  session: "memory",
+  rateLimiting: false,
+  helmet: false,
+  logger: false,
+};
+
+/**
+ * Init command handler for the unified CLI.
+ *
+ * Scaffolds a new project from a schema file or interactively.
+ *
+ * @param {object} args - Parsed positional/key-value args (e.g. { from, framework, database })
+ * @param {object} flags - Universal flags: { yes, json, dryRun, noInstall, help }
+ * @param {import('../flags').OutputContext} ctx - Output context for --json support
+ */
+async function init(args, flags, ctx) {
+  let answers;
+
+  if (args.from) {
+    // --from points to a schema file: read adapter/framework from it
+    const schemaPath = path.resolve(args.from);
+    if (!fs.existsSync(schemaPath)) {
+      throw new Error(`Schema file not found: ${args.from}`);
+    }
+    const raw = fs.readFileSync(schemaPath, "utf8");
+    const schema = parseSchema(raw);
+
+    answers = {
+      framework: schema.framework,
+      database: schema.adapter,
+      session: (schema.options && schema.options.session) || "memory",
+      rateLimiting: !!(schema.options && schema.options.rateLimiting),
+      helmet: !!(schema.options && schema.options.helmet),
+      logger: !!(schema.options && schema.options.logger),
+    };
+  } else if (flags.yes) {
+    // --yes with no schema: use defaults, but allow CLI overrides
+    answers = Object.assign({}, DEFAULT_ANSWERS);
+    if (args.framework) answers.framework = args.framework;
+    if (args.database) answers.database = args.database;
+  } else {
+    // Interactive: build prefilled from CLI args, prompt for the rest
+    const prefilled = {};
+    if (args.framework) prefilled.framework = args.framework;
+    if (args.database) prefilled.database = args.database;
+    answers = await promptUser(prefilled);
+  }
+
+  // --dry-run: report planned files without writing
+  if (flags.dryRun) {
+    const planned = planFiles(answers);
+    if (flags.json) {
+      ctx.result({
+        files: planned,
+        dependencies: { installed: false },
+        actions: ["dry-run"],
+      });
+    } else {
+      ctx.log("Dry run — the following files would be created:");
+      for (const f of planned) {
+        ctx.log(`  ${f}`);
+      }
+      ctx.log("\nNo files were written.");
+    }
+    return;
+  }
+
+  // Ensure package.json exists
+  ensurePackageJson();
+
+  // Generate project files
+  const generated = generateFiles(answers);
+
+  // Update package.json with deps and scripts
+  updatePackageJson(answers);
+
+  // npm install (unless --no-install)
+  const installed = !flags.noInstall;
+  if (installed) {
+    runInstall();
+  }
+
+  // Output
+  const allFiles = [
+    ...generated.files,
+    ...generated.migrationFiles.map((m) => `migrations/${m}`),
+  ];
+
+  if (flags.json) {
+    ctx.result({
+      files: allFiles,
+      dependencies: { installed },
+      actions: installed ? ["scaffolded", "installed"] : ["scaffolded"],
+    });
+  } else {
+    printSummary(generated);
+    if (!installed) {
+      ctx.log(
+        "\nSkipped npm install (--no-install). Run `npm install` manually.",
+      );
+    }
+  }
+}
+
+/**
+ * Compute the list of files that would be created (for --dry-run).
+ * This mirrors the file list from generateFiles() without writing anything.
+ *
+ * @param {object} answers
+ * @returns {string[]}
+ */
+function planFiles(answers) {
+  const { isSql } = require("../init/generators");
+  const files = [
+    "app.js",
+    ".env",
+    ".env.example",
+    "middleware/logger.js",
+    "migrate.js",
+    "add_migration.js",
+    ".gitignore",
+    "migrations/<timestamp>_create_migrations_table" +
+      (isSql(answers.database) ? ".sql" : ".js"),
+  ];
+
+  if (answers.session === "database" && isSql(answers.database)) {
+    files.push("migrations/<timestamp>_create_sessions_table.sql");
+  }
+
+  return files;
+}
+
+module.exports = init;

package/src/cli/commands/inspect.js

@@ -0,0 +1,205 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { printSchema } = require("../../schema/schema-printer");
+const {
+  introspectMySQL,
+  introspectPostgres,
+  introspectSQLite3,
+  introspectMSSQL,
+  introspectOracle,
+  introspectCockroachDB,
+} = require("../generate-model");
+
+/**
+ * Map of adapter names to their introspection functions.
+ * Each value is an async function(db) => ModelMeta[].
+ */
+const INTROSPECT_MAP = {
+  mysql: introspectMySQL,
+  postgres: introspectPostgres,
+  sqlite3: introspectSQLite3,
+  mssql: introspectMSSQL,
+  oracle: introspectOracle,
+  cockroachdb: introspectCockroachDB,
+};
+
+/**
+ * Convert a ModelMeta array (from introspection) into a ParsedSchema object.
+ * This is the reverse of schemaToModelMeta.
+ *
+ * @param {string} adapter - The database adapter name
+ * @param {string} framework - The framework name (default: "express")
+ * @param {Array<{table, structure, primary_key, unique, option}>} models
+ * @returns {object} ParsedSchema
+ */
+function modelMetaToSchema(adapter, framework, models) {
+  const tables = {};
+
+  for (const m of models) {
+    const columns = {};
+
+    // Re-add columns from structure
+    for (const [col, rule] of Object.entries(m.structure)) {
+      columns[col] = rule;
+    }
+
+    const pk = m.primary_key || "id";
+    const unique = m.unique && m.unique.length > 0 ? [...m.unique] : [pk];
+
+    const opt = m.option || {};
+    const softDelete = opt.safeDelete || null;
+    const timestamps = {
+      created_at: opt.created_at || null,
+      modified_at: opt.modified_at || null,
+    };
+
+    tables[m.table] = {
+      name: m.table,
+      columns,
+      pk,
+      unique,
+      softDelete,
+      timestamps,
+    };
+  }
+
+  return {
+    adapter,
+    framework: framework || "express",
+    tables,
+    relationships: [],
+    options: {},
+  };
+}
+
+/**
+ * Inspect command handler for the unified CLI.
+ *
+ * Connects to a live database, introspects its structure, converts to
+ * ParsedSchema, prints via schema-printer, and writes to file.
+ *
+ * Supported flags:
+ *   --type     Database adapter type (required)
+ *   --env      Path to .env file for connection params
+ *   --out      Output file path (default: dbmr.schema.json)
+ *   --tables   Comma-separated list of tables to include
+ *   --json     Output schema to stdout as JSON (no file write)
+ *   --dry-run  Output schema to stdout without writing file
+ *
+ * @param {object} args - Parsed key-value args
+ * @param {object} flags - Universal flags: { yes, json, dryRun, noInstall, help }
+ * @param {import('../flags').OutputContext} ctx - Output context
+ */
+async function inspect(args, flags, ctx) {
+  const adapterType = args.type;
+  if (!adapterType || !INTROSPECT_MAP[adapterType]) {
+    const supported = Object.keys(INTROSPECT_MAP).join(", ");
+    const msg = adapterType
+      ? `Unsupported --type "${adapterType}". Supported: ${supported}`
+      : `Missing required --type flag. Supported: ${supported}`;
+    if (flags.json) {
+      ctx.result({ error: true, code: "INVALID_TYPE", message: msg });
+    } else {
+      ctx.log(`Error: ${msg}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  // Load .env file if --env provided
+  if (args.env) {
+    require("dotenv").config({ path: path.resolve(args.env) });
+  }
+
+  // Connect to database
+  let db;
+  try {
+    const restRouter = require("../../index.js");
+    restRouter.init(adapterType);
+    db = restRouter.db;
+
+    const config = {
+      host: process.env.DB_HOST || "localhost",
+      port: process.env.DB_PORT,
+      database: process.env.DB_NAME,
+      user: process.env.DB_USER,
+      password: process.env.DB_PASS,
+      filename: process.env.DB_NAME,
+      server: process.env.DB_HOST || "localhost",
+      options: { encrypt: false, trustServerCertificate: true },
+    };
+
+    db.connect(config);
+  } catch (err) {
+    const msg = `Database connection failed: ${err.message}`;
+    if (flags.json) {
+      ctx.result({ error: true, code: "CONNECTION_FAILED", message: msg });
+    } else {
+      ctx.log(`Error: ${msg}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  // Introspect
+  let models;
+  try {
+    const introspectFn = INTROSPECT_MAP[adapterType];
+    models = await introspectFn(db);
+  } catch (err) {
+    const msg = `Introspection failed: ${err.message}`;
+    if (flags.json) {
+      ctx.result({ error: true, code: "INTROSPECTION_FAILED", message: msg });
+    } else {
+      ctx.log(`Error: ${msg}`);
+    }
+    process.exitCode = 1;
+    // Disconnect
+    if (db.disconnect) await db.disconnect();
+    else if (db.close) db.close();
+    return;
+  }
+
+  // Disconnect
+  try {
+    if (db.disconnect) await db.disconnect();
+    else if (db.close) db.close();
+  } catch (_) {
+    // ignore disconnect errors
+  }
+
+  // Filter by --tables if provided
+  if (args.tables) {
+    const allowed = new Set(args.tables.split(",").map((s) => s.trim()));
+    models = models.filter((m) => allowed.has(m.table));
+  }
+
+  // Convert ModelMeta[] → ParsedSchema
+  const schema = modelMetaToSchema(adapterType, "express", models);
+
+  // Print via schema-printer
+  const output = printSchema(schema);
+
+  // Determine output path
+  const outPath = args.out || "dbmr.schema.json";
+
+  if (flags.json) {
+    // --json: output schema to stdout, no file write
+    ctx.result({ schema: JSON.parse(output), writtenTo: null });
+  } else if (flags.dryRun) {
+    // --dry-run: output schema to stdout, no file write
+    ctx.log(output);
+    ctx.log(`Would write to: ${outPath}`);
+  } else {
+    // Write to file
+    const resolvedPath = path.resolve(outPath);
+    fs.writeFileSync(resolvedPath, output, "utf8");
+    ctx.log(`Schema written to ${outPath}`);
+    ctx.log(output);
+  }
+}
+
+module.exports = inspect;
+module.exports.modelMetaToSchema = modelMetaToSchema;

package/src/cli/diff-engine.js

@@ -0,0 +1,198 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { generateModelFile } = require("./generate-model.js");
+const {
+  generateRouteFile,
+  generateChildRouteFile,
+  generateRoutesIndexFile,
+  generateTestFile,
+  generateChildTestFile,
+} = require("./generate-route.js");
+const { generateOpenAPISpec } = require("./generate-openapi.js");
+
+/**
+ * Simple line-by-line diff between two strings.
+ * Returns a human-readable unified-style diff string.
+ */
+function lineDiff(expected, actual) {
+  const expectedLines = expected.split("\n");
+  const actualLines = actual.split("\n");
+  const lines = [];
+  const maxLen = Math.max(expectedLines.length, actualLines.length);
+
+  for (let i = 0; i < maxLen; i++) {
+    const exp = i < expectedLines.length ? expectedLines[i] : undefined;
+    const act = i < actualLines.length ? actualLines[i] : undefined;
+
+    if (exp === act) continue;
+    if (act !== undefined && exp === undefined) {
+      lines.push(`+${i + 1}: ${act}`);
+    } else if (exp !== undefined && act === undefined) {
+      lines.push(`-${i + 1}: ${exp}`);
+    } else {
+      lines.push(`-${i + 1}: ${act}`);
+      lines.push(`+${i + 1}: ${exp}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+/**
+ * Build a map of relative file path → expected content for all artifacts
+ * that the schema would generate.
+ *
+ * @param {Array<{table, structure, primary_key, unique, option}>} meta
+ * @param {Array<{parent, child, foreignKey}>} relationships
+ * @returns {Map<string, string>}
+ */
+function buildExpectedFiles(meta, relationships) {
+  const expected = new Map();
+  const modelsRelPath = "../models";
+  const tableNames = meta.map((m) => m.table).sort();
+
+  // Model files
+  for (const m of meta) {
+    expected.set(`models/${m.table}.js`, generateModelFile(m));
+  }
+
+  // Route files (one per table)
+  for (const m of meta) {
+    expected.set(
+      `routes/${m.table}.js`,
+      generateRouteFile(m.table, modelsRelPath),
+    );
+  }
+
+  // Child route files (one per relationship)
+  for (const rel of relationships) {
+    const childMeta = meta.find((m) => m.table === rel.child);
+    const pk = childMeta ? childMeta.primary_key : "id";
+    expected.set(
+      `routes/${rel.child}_child_of_${rel.parent}.js`,
+      generateChildRouteFile(
+        rel.child,
+        rel.parent,
+        rel.foreignKey,
+        modelsRelPath,
+      ),
+    );
+  }
+
+  // Routes index file
+  expected.set(
+    "routes/index.js",
+    generateRoutesIndexFile(tableNames, relationships),
+  );
+
+  // Test files (one per table)
+  for (const m of meta) {
+    expected.set(
+      `test/${m.table}.test.js`,
+      generateTestFile(m.table, m.primary_key),
+    );
+  }
+
+  // Child test files (one per relationship)
+  for (const rel of relationships) {
+    const childMeta = meta.find((m) => m.table === rel.child);
+    const pk = childMeta ? childMeta.primary_key : "id";
+    expected.set(
+      `test/${rel.child}_child_of_${rel.parent}.test.js`,
+      generateChildTestFile(rel.child, rel.parent, rel.foreignKey, pk),
+    );
+  }
+
+  // OpenAPI spec
+  expected.set(
+    "openapi.json",
+    JSON.stringify(generateOpenAPISpec(meta), null, 2) + "\n",
+  );
+
+  return expected;
+}
+
+/**
+ * Scan known artifact directories on disk and return a set of relative paths
+ * that exist.
+ *
+ * @param {string} baseDir
+ * @returns {Set<string>}
+ */
+function scanDiskFiles(baseDir) {
+  const files = new Set();
+
+  const dirs = [
+    { dir: "models", ext: ".js" },
+    { dir: "routes", ext: ".js" },
+    { dir: "test", ext: ".test.js" },
+  ];
+
+  for (const { dir, ext } of dirs) {
+    const fullDir = path.join(baseDir, dir);
+    if (!fs.existsSync(fullDir)) continue;
+    for (const file of fs.readdirSync(fullDir)) {
+      if (file.endsWith(ext)) {
+        files.add(`${dir}/${file}`);
+      }
+    }
+  }
+
+  // Check for openapi.json at root
+  const openapiPath = path.join(baseDir, "openapi.json");
+  if (fs.existsSync(openapiPath)) {
+    files.add("openapi.json");
+  }
+
+  return files;
+}
+
+/**
+ * Compare expected generated content against actual files on disk.
+ *
+ * @param {string} baseDir — project root
+ * @param {Array<{table, structure, primary_key, unique, option}>} meta — from schema
+ * @param {Array<{parent, child, foreignKey}>} relationships
+ * @returns {{ added: string[], modified: Array<{file: string, diff: string}>, deleted: string[] }}
+ */
+function computeDiff(baseDir, meta, relationships) {
+  const expected = buildExpectedFiles(meta, relationships);
+  const diskFiles = scanDiskFiles(baseDir);
+
+  const added = [];
+  const modified = [];
+  const deleted = [];
+
+  // Check expected files against disk
+  for (const [relPath, expectedContent] of expected) {
+    const fullPath = path.join(baseDir, relPath);
+    if (!fs.existsSync(fullPath)) {
+      added.push(relPath);
+    } else {
+      const actualContent = fs.readFileSync(fullPath, "utf8");
+      if (actualContent !== expectedContent) {
+        modified.push({
+          file: relPath,
+          diff: lineDiff(expectedContent, actualContent),
+        });
+      }
+      // unchanged — not reported
+    }
+  }
+
+  // Check disk files not in expected set → deleted
+  for (const diskFile of diskFiles) {
+    if (!expected.has(diskFile)) {
+      deleted.push(diskFile);
+    }
+  }
+
+  return {
+    added: added.sort(),
+    modified: modified.sort((a, b) => a.file.localeCompare(b.file)),
+    deleted: deleted.sort(),
+  };
+}
+
+module.exports = { computeDiff, buildExpectedFiles, lineDiff };

package/src/cli/flags.js

@@ -0,0 +1,112 @@
+"use strict";
+
+/**
+ * Universal flag parser and OutputContext for the db-model-router CLI.
+ *
+ * Parses --yes, --json, --dry-run, --no-install, --help from argv.
+ * Extracts the subcommand (first non-flag argument).
+ * Collects remaining key-value flags into an args object.
+ *
+ * @module cli/flags
+ */
+
+/**
+ * Parse CLI argv into subcommand, flags, and args.
+ *
+ * @param {string[]} argv - process.argv.slice(2) style array
+ * @returns {{ subcommand: string|null, flags: Flags, args: object }}
+ */
+function parseFlags(argv) {
+  const flags = {
+    yes: false,
+    json: false,
+    dryRun: false,
+    noInstall: false,
+    help: false,
+  };
+
+  const args = {};
+  let subcommand = null;
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === "--yes") {
+      flags.yes = true;
+    } else if (arg === "--json") {
+      flags.json = true;
+    } else if (arg === "--dry-run") {
+      flags.dryRun = true;
+    } else if (arg === "--no-install") {
+      flags.noInstall = true;
+    } else if (arg === "--help") {
+      flags.help = true;
+    } else if (arg.startsWith("--")) {
+      // Key-value flag: --from schema.json → { from: "schema.json" }
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("--")) {
+        args[key] = next;
+        i++; // skip the value
+      } else {
+        args[key] = true;
+      }
+    } else if (subcommand === null) {
+      subcommand = arg;
+    }
+  }
+
+  return { subcommand, flags, args };
+}
+
+/**
+ * OutputContext controls CLI output behavior based on flags.
+ *
+ * When --json is active:
+ *   - log() is a no-op (suppresses human-readable output)
+ *   - result() accumulates data
+ *   - flush() prints the accumulated JSON to stdout
+ *
+ * When --json is NOT active:
+ *   - log() prints to stdout
+ *   - result() is a no-op
+ *   - flush() is a no-op
+ */
+class OutputContext {
+  constructor(flags) {
+    this._json = !!(flags && flags.json);
+    this._results = [];
+  }
+
+  /**
+   * Log a human-readable message. No-op when --json is active.
+   * @param {string} msg
+   */
+  log(msg) {
+    if (!this._json) {
+      console.log(msg);
+    }
+  }
+
+  /**
+   * Accumulate a result object for JSON output.
+   * @param {*} data
+   */
+  result(data) {
+    this._results.push(data);
+  }
+
+  /**
+   * Flush accumulated JSON results to stdout if --json is active.
+   * Prints a single JSON object (or the last result if only one was accumulated).
+   */
+  flush() {
+    if (this._json && this._results.length > 0) {
+      const output =
+        this._results.length === 1 ? this._results[0] : this._results;
+      console.log(JSON.stringify(output));
+    }
+  }
+}
+
+module.exports = { parseFlags, OutputContext };