db-model-router 1.0.0 → 1.0.3

package/src/cli/init/prompt.js

@@ -0,0 +1,159 @@
+"use strict";
+
+const inquirer = require("inquirer");
+
+const VALID_FRAMEWORKS = ["ultimate-express", "express"];
+const VALID_DATABASES = [
+  "mysql",
+  "postgres",
+  "sqlite3",
+  "mongodb",
+  "mssql",
+  "cockroachdb",
+  "oracle",
+  "redis",
+  "dynamodb",
+];
+const VALID_SESSIONS = ["memory", "redis", "database"];
+
+/**
+ * Parse CLI arguments into a partial answers object.
+ * Supports: --framework, --database, --session, --rateLimiting, --helmet, --logger
+ * Boolean flags accept: true/false, yes/no, 1/0, or just --flag (implies true)
+ * @param {string[]} argv
+ * @returns {Partial<import('./types').InitAnswers>}
+ */
+function parseInitArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("--")) {
+        args[key] = next;
+        i++;
+      } else {
+        args[key] = "true";
+      }
+    }
+  }
+
+  const partial = {};
+
+  if (args.framework && VALID_FRAMEWORKS.includes(args.framework)) {
+    partial.framework = args.framework;
+  }
+  if (args.database && VALID_DATABASES.includes(args.database)) {
+    partial.database = args.database;
+  }
+  // Accept --db as alias for --database
+  if (!partial.database && args.db && VALID_DATABASES.includes(args.db)) {
+    partial.database = args.db;
+  }
+  if (args.session && VALID_SESSIONS.includes(args.session)) {
+    partial.session = args.session;
+  }
+
+  // Boolean flags
+  for (const flag of ["rateLimiting", "helmet", "logger"]) {
+    if (args[flag] !== undefined) {
+      partial[flag] = parseBool(args[flag]);
+    }
+  }
+
+  return partial;
+}
+
+/**
+ * Parse a string as a boolean.
+ * @param {string} val
+ * @returns {boolean}
+ */
+function parseBool(val) {
+  return ["true", "yes", "1"].includes(String(val).toLowerCase());
+}
+
+/**
+ * Run the interactive prompt flow to collect user preferences.
+ * Any values already present in `prefilledAnswers` are skipped (not prompted).
+ * When all 6 values are provided, no prompts are shown at all.
+ * @param {Partial<import('./types').InitAnswers>} [prefilledAnswers={}]
+ * @returns {Promise<import('./types').InitAnswers>}
+ */
+async function promptUser(prefilledAnswers) {
+  const prefilled = prefilledAnswers || {};
+
+  const questions = [];
+
+  if (prefilled.framework === undefined) {
+    questions.push({
+      type: "list",
+      name: "framework",
+      message: "Select your Express framework:",
+      choices: VALID_FRAMEWORKS,
+      default: "ultimate-express",
+    });
+  }
+
+  if (prefilled.database === undefined) {
+    questions.push({
+      type: "list",
+      name: "database",
+      message: "Select your database:",
+      choices: VALID_DATABASES,
+    });
+  }
+
+  if (prefilled.session === undefined) {
+    questions.push({
+      type: "list",
+      name: "session",
+      message: "Select your session store:",
+      choices: VALID_SESSIONS,
+    });
+  }
+
+  if (prefilled.rateLimiting === undefined) {
+    questions.push({
+      type: "confirm",
+      name: "rateLimiting",
+      message: "Enable rate limiting?",
+      default: false,
+    });
+  }
+
+  if (prefilled.helmet === undefined) {
+    questions.push({
+      type: "confirm",
+      name: "helmet",
+      message: "Enable Helmet security headers?",
+      default: false,
+    });
+  }
+
+  if (prefilled.logger === undefined) {
+    questions.push({
+      type: "confirm",
+      name: "logger",
+      message: "Enable request/response logger?",
+      default: false,
+    });
+  }
+
+  // If all values are prefilled, skip prompts entirely
+  if (questions.length === 0) {
+    return /** @type {import('./types').InitAnswers} */ (prefilled);
+  }
+
+  const prompted = await inquirer.prompt(questions);
+  return Object.assign({}, prefilled, prompted);
+}
+
+module.exports = {
+  promptUser,
+  parseInitArgs,
+  VALID_FRAMEWORKS,
+  VALID_DATABASES,
+  VALID_SESSIONS,
+};

package/src/cli/init.js

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const {
+  generateAppJs,
+  generateEnvFile,
+  generateEnvExample,
+  generateLoggerMiddleware,
+  generateMigrateScript,
+  generateAddMigrationScript,
+  generateInitialMigration,
+  generateSessionMigration,
+  generateGitignore,
+} = require("./init/generators");
+
+const { collectDependencies, getScripts } = require("./init/dependencies");
+const { promptUser, parseInitArgs } = require("./init/prompt");
+
+/**
+ * Ensure a package.json exists in the current directory.
+ * Uses `npm init -y` for non-interactive creation. Exits with code 1 on failure.
+ */
+function ensurePackageJson() {
+  if (fs.existsSync("package.json")) {
+    return;
+  }
+  try {
+    execSync("npm init -y", { stdio: "inherit" });
+  } catch (err) {
+    console.error("Error: npm init failed or was aborted.");
+    process.exit(1);
+  }
+  if (!fs.existsSync("package.json")) {
+    console.error("Error: package.json was not created. Aborting.");
+    process.exit(1);
+  }
+}
+
+/**
+ * Write a file, but warn (and skip) if it already exists.
+ * @param {string} filePath
+ * @param {string} content
+ * @returns {boolean} true if written, false if skipped
+ */
+function safeWriteFile(filePath, content) {
+  if (fs.existsSync(filePath)) {
+    console.log(`  Skipped ${filePath} (already exists)`);
+    return false;
+  }
+  fs.writeFileSync(filePath, content);
+  console.log(`  Created ${filePath}`);
+  return true;
+}
+
+/**
+ * Generate all project files based on user answers.
+ * Creates directories and writes files. Skips files that already exist.
+ * Returns the list of generated filenames for the summary.
+ * @param {import('./init/types').InitAnswers} answers
+ * @returns {{ files: string[], migrationFiles: string[] }}
+ */
+function generateFiles(answers) {
+  const files = [];
+  const migrationFiles = [];
+
+  // Create directories
+  if (!fs.existsSync("middleware")) {
+    fs.mkdirSync("middleware", { recursive: true });
+  }
+  if (!fs.existsSync("migrations")) {
+    fs.mkdirSync("migrations", { recursive: true });
+  }
+
+  // Write files (skip if they already exist)
+  if (safeWriteFile("app.js", generateAppJs(answers))) files.push("app.js");
+  if (safeWriteFile(".env", generateEnvFile(answers))) files.push(".env");
+  if (safeWriteFile(".env.example", generateEnvExample(answers)))
+    files.push(".env.example");
+
+  const loggerPath = path.join("middleware", "logger.js");
+  if (safeWriteFile(loggerPath, generateLoggerMiddleware(answers)))
+    files.push("middleware/logger.js");
+
+  if (safeWriteFile("migrate.js", generateMigrateScript(answers)))
+    files.push("migrate.js");
+  if (safeWriteFile("add_migration.js", generateAddMigrationScript(answers)))
+    files.push("add_migration.js");
+  if (safeWriteFile(".gitignore", generateGitignore()))
+    files.push(".gitignore");
+
+  // Initial migration
+  const initialMigration = generateInitialMigration(answers);
+  const initialPath = path.join("migrations", initialMigration.filename);
+  if (safeWriteFile(initialPath, initialMigration.content)) {
+    migrationFiles.push(initialMigration.filename);
+  }
+
+  // Conditional session migration
+  const sessionMigration = generateSessionMigration(answers);
+  if (sessionMigration !== null) {
+    const sessionPath = path.join("migrations", sessionMigration.filename);
+    if (safeWriteFile(sessionPath, sessionMigration.content)) {
+      migrationFiles.push(sessionMigration.filename);
+    }
+  }
+
+  return { files, migrationFiles };
+}
+
+/**
+ * Update package.json with scripts and dependencies from the answers.
+ * @param {import('./init/types').InitAnswers} answers
+ */
+function updatePackageJson(answers) {
+  let raw;
+  try {
+    raw = fs.readFileSync("package.json", "utf8");
+  } catch (err) {
+    console.error("Error: Could not read package.json.");
+    process.exit(1);
+  }
+
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch (err) {
+    console.error(
+      "Error: package.json contains invalid JSON. Please fix it manually and re-run.",
+    );
+    process.exit(1);
+  }
+
+  const { dependencies, devDependencies } = collectDependencies(answers);
+  const scripts = getScripts();
+
+  pkg.scripts = Object.assign({}, pkg.scripts || {}, scripts);
+  pkg.dependencies = Object.assign({}, pkg.dependencies || {}, dependencies);
+  pkg.devDependencies = Object.assign(
+    {},
+    pkg.devDependencies || {},
+    devDependencies,
+  );
+
+  fs.writeFileSync("package.json", JSON.stringify(pkg, null, 2) + "\n");
+  console.log("  Updated package.json");
+}
+
+/**
+ * Run npm install. On failure, print manual install instructions and exit with code 1.
+ */
+function runInstall() {
+  console.log("\nInstalling dependencies...\n");
+  try {
+    execSync("npm install", { stdio: "inherit" });
+  } catch (err) {
+    console.error(
+      "\nError: npm install failed. Please run the following command manually:",
+    );
+    console.error("  npm install");
+    process.exit(1);
+  }
+}
+
+/**
+ * Print a summary of generated files and next-step instructions.
+ * Uses the file lists captured during generation (no re-calling generators).
+ * @param {{ files: string[], migrationFiles: string[] }} generated
+ */
+function printSummary(generated) {
+  console.log("\n✔ Project scaffolded successfully!\n");
+  console.log("Generated files:");
+
+  for (const f of generated.files) {
+    console.log(`  ${f}`);
+  }
+  if (generated.migrationFiles.length > 0) {
+    console.log("  migrations/");
+    for (const m of generated.migrationFiles) {
+      console.log(`    └── ${m}`);
+    }
+  }
+
+  console.log("\nNext steps:");
+  console.log("  1. Edit .env with your database credentials");
+  console.log("  2. Run: npm run dev");
+}
+
+/**
+ * Main orchestrator.
+ */
+async function main() {
+  const cliArgs = parseInitArgs(process.argv.slice(2));
+
+  // If --help flag, print usage and exit
+  if (process.argv.includes("--help")) {
+    printUsage();
+    process.exit(0);
+  }
+
+  ensurePackageJson();
+
+  let answers;
+  try {
+    answers = await promptUser(cliArgs);
+  } catch (err) {
+    // Handle Ctrl+C (inquirer throws on user cancel)
+    console.log("\nAborted.");
+    process.exit(1);
+  }
+
+  let generated;
+  try {
+    generated = generateFiles(answers);
+  } catch (err) {
+    if (err.code === "EACCES" || err.code === "EPERM") {
+      console.error(
+        `Error: Permission denied writing files. Check directory permissions.\n  ${err.message}`,
+      );
+    } else {
+      console.error(`Error: Failed to generate files.\n  ${err.message}`);
+    }
+    process.exit(1);
+  }
+
+  updatePackageJson(answers);
+  runInstall();
+  printSummary(generated);
+}
+
+/**
+ * Print CLI usage information.
+ */
+function printUsage() {
+  console.log(`
+Usage: db-model-router-init [options]
+
+Scaffolds a complete Express-based REST API project. When all options are
+provided, runs non-interactively (no prompts). Missing options are prompted.
+
+Options:
+  --framework <name>    Express framework: ultimate-express, express
+  --database <name>     Database: mysql, postgres, sqlite3, mongodb, mssql,
+                        cockroachdb, oracle, redis, dynamodb
+  --db <name>           Alias for --database
+  --session <type>      Session store: memory, redis, database
+  --rateLimiting        Enable rate limiting (express-rate-limit)
+  --helmet              Enable Helmet security headers
+  --logger              Enable request/response logger (express-mung)
+  --help                Show this help message
+
+Examples:
+  # Fully non-interactive (LLM-friendly)
+  db-model-router-init --framework express --database postgres --session redis --rateLimiting --helmet --logger
+
+  # Partial — only prompts for missing values
+  db-model-router-init --database mysql --session memory
+
+  # Interactive (no flags)
+  db-model-router-init
+`);
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error("Error:", err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  ensurePackageJson,
+  generateFiles,
+  updatePackageJson,
+  runInstall,
+  printSummary,
+  main,
+};

package/src/cli/main.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+"use strict";
+
+const { parseFlags, OutputContext } = require("./flags");
+
+const initCmd = require("./commands/init");
+const inspectCmd = require("./commands/inspect");
+const generateCmd = require("./commands/generate");
+const doctorCmd = require("./commands/doctor");
+const diffCmd = require("./commands/diff");
+
+/**
+ * Map of subcommand names to their handler functions.
+ */
+const COMMANDS = {
+  init: initCmd,
+  inspect: inspectCmd,
+  generate: generateCmd,
+  doctor: doctorCmd,
+  diff: diffCmd,
+};
+
+/**
+ * Descriptions for each subcommand, used in help output.
+ */
+const COMMAND_DESCRIPTIONS = {
+  init: "Scaffold a new project from a schema file or interactively",
+  inspect: "Introspect a live database and produce a schema file",
+  generate: "Generate models, routes, tests, and OpenAPI spec from a schema",
+  doctor: "Validate schema, check dependencies, and verify file sync",
+  diff: "Preview changes between current files and what the schema would produce",
+};
+
+/**
+ * Print help message listing all available subcommands.
+ */
+function printHelp() {
+  console.log("Usage: db-model-router <command> [options]\n");
+  console.log("Commands:");
+  for (const [name, desc] of Object.entries(COMMAND_DESCRIPTIONS)) {
+    console.log(`  ${name.padEnd(12)} ${desc}`);
+  }
+  console.log("\nGlobal flags:");
+  console.log("  --yes          Accept all defaults without prompting");
+  console.log("  --json         Output machine-readable JSON");
+  console.log("  --dry-run      Preview actions without side effects");
+  console.log("  --no-install   Skip npm install step");
+  console.log("  --help         Show help for a command");
+}
+
+/**
+ * Print error for unknown subcommand and list valid subcommands.
+ * @param {string} cmd - The unknown subcommand
+ */
+function printUnknown(cmd) {
+  const valid = Object.keys(COMMANDS).join(", ");
+  console.error(`Unknown command: ${cmd}`);
+  console.error(`Valid commands: ${valid}`);
+}
+
+/**
+ * Main CLI entry point.
+ * @param {string[]} argv - process.argv.slice(2) style array
+ */
+async function main(argv) {
+  const { subcommand, flags, args } = parseFlags(argv);
+
+  if (!subcommand || flags.help) {
+    printHelp();
+    return;
+  }
+
+  if (!COMMANDS[subcommand]) {
+    printUnknown(subcommand);
+    process.exitCode = 1;
+    return;
+  }
+
+  const ctx = new OutputContext(flags);
+  await COMMANDS[subcommand](args, flags, ctx);
+  ctx.flush();
+}
+
+// When run directly as a script
+if (require.main === module) {
+  main(process.argv.slice(2)).catch((err) => {
+    console.error(err.message || err);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = main;
+module.exports.COMMANDS = COMMANDS;
+module.exports.printHelp = printHelp;
+module.exports.printUnknown = printUnknown;

package/src/commons/model.js

@@ -280,6 +280,7 @@ module.exports = function model(
           data,
           getPayloadValidator("CREATE", modelStructure, primary_key, false),
         );
+        const originalData = { ...data };
         data = RemoveUnknownData(modelStructure, [data]);
         data = jsonStringify(data);
         updateResult = await db.upsert(table, data, unique);
@@ -288,12 +289,10 @@ module.exports = function model(
             [[primary_key, "=", updateResult.id]],
           ]);
           return getResult.count > 0 ? getResult["data"][0] : null;
-        } else if (data.hasOwnProperty(primary_key)) {
-          const result = await db.get(
-            table,
-            [[[primary_key, "=", data[primary_key]]]],
-            option.safeDelete,
-          );
+        } else if (originalData.hasOwnProperty(primary_key)) {
+          const result = await db.get(table, [
+            [[primary_key, "=", originalData[primary_key]]],
+          ]);
           if (result.count > 0) return result["data"][0];
           else return null;
         }

package/src/commons/route.js

@@ -156,6 +156,14 @@ module.exports = function route(model, override = {}) {
         });
     })
     .post("/", (req, res) => {
+      if (!req.body || !Array.isArray(req.body.data)) {
+        return res
+          .status(400)
+          .send({
+            type: "danger",
+            message: "Request body must contain a 'data' array",
+          });
+      }
       let payload = payloadOverride(req.body.data, req, override);
       model
         .insert({ data: payload })
@@ -167,6 +175,14 @@ module.exports = function route(model, override = {}) {
         });
     })
     .put("/", (req, res) => {
+      if (!req.body || !Array.isArray(req.body.data)) {
+        return res
+          .status(400)
+          .send({
+            type: "danger",
+            message: "Request body must contain a 'data' array",
+          });
+      }
       let payload = payloadOverride(req.body.data, req, override);
       model
         .update({ data: payload })
@@ -178,6 +194,14 @@ module.exports = function route(model, override = {}) {
         });
     })
     .delete("/", (req, res) => {
+      if (!req.body || !Array.isArray(req.body.data)) {
+        return res
+          .status(400)
+          .send({
+            type: "danger",
+            message: "Request body must contain a 'data' array",
+          });
+      }
       let payload = payloadOverride(req.body.data, req, override);
       model
         .remove(payload)

package/src/schema/schema-parser.js

@@ -0,0 +1,78 @@
+"use strict";
+
+const { validateSchema, SchemaValidationError } = require("./schema-validator");
+
+/**
+ * Parse a schema from a JSON string or plain object.
+ *
+ * - If `input` is a string, JSON.parse it (wrapping parse errors).
+ * - Validate via validateSchema(); throw SchemaValidationError if invalid.
+ * - Normalize each table with defaults for pk, unique, timestamps, softDelete.
+ * - Return the internal { adapter, framework, tables, relationships, options } representation.
+ *
+ * @param {string|object} input — raw JSON string or parsed object
+ * @returns {{ adapter: string, framework: string, tables: object, relationships: Array, options: object }}
+ * @throws {SchemaValidationError}
+ */
+function parseSchema(input) {
+  let raw = input;
+
+  // If string, attempt JSON.parse; wrap errors
+  if (typeof raw === "string") {
+    try {
+      raw = JSON.parse(raw);
+    } catch (err) {
+      throw new SchemaValidationError([
+        {
+          path: "",
+          message: `Invalid JSON: ${err.message}`,
+        },
+      ]);
+    }
+  }
+
+  // Validate
+  const result = validateSchema(raw);
+  if (!result.valid) {
+    throw new SchemaValidationError(result.errors);
+  }
+
+  // Normalize tables
+  const tables = {};
+  for (const [tableName, tableDef] of Object.entries(raw.tables)) {
+    const pk = tableDef.pk || "id";
+    const unique = tableDef.unique !== undefined ? [...tableDef.unique] : [pk];
+    const timestamps =
+      tableDef.timestamps !== undefined
+        ? { ...tableDef.timestamps }
+        : { created_at: null, modified_at: null };
+    // Ensure timestamps always has both keys
+    if (!("created_at" in timestamps)) {
+      timestamps.created_at = null;
+    }
+    if (!("modified_at" in timestamps)) {
+      timestamps.modified_at = null;
+    }
+    const softDelete =
+      tableDef.softDelete !== undefined ? tableDef.softDelete : null;
+
+    tables[tableName] = {
+      name: tableName,
+      columns: { ...tableDef.columns },
+      pk,
+      unique,
+      softDelete,
+      timestamps,
+    };
+  }
+
+  return {
+    adapter: raw.adapter,
+    framework: raw.framework,
+    tables,
+    relationships: raw.relationships ? [...raw.relationships] : [],
+    options: raw.options ? { ...raw.options } : {},
+  };
+}
+
+module.exports = { parseSchema };