db-model-router 1.0.2 → 1.0.4

package/src/cli/main.js

@@ -0,0 +1,175 @@
+#!/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");
+const helpCmd = require("./commands/help");
+
+/**
+ * Map of subcommand names to their handler functions.
+ */
+const COMMANDS = {
+  init: initCmd,
+  inspect: inspectCmd,
+  generate: generateCmd,
+  doctor: doctorCmd,
+  diff: diffCmd,
+  help: helpCmd,
+};
+
+/**
+ * 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",
+  help: "Show help for a command",
+};
+
+/**
+ * Per-command flag summaries shown in the general help overview.
+ */
+const COMMAND_FLAGS = {
+  init: [
+    ["--from <path>", "Read config from a schema file"],
+    ["--framework <name>", "express, ultimate-express"],
+    [
+      "--database <name>",
+      "mysql, mariadb, postgres, sqlite3, mongodb, mssql, cockroachdb, oracle, redis, dynamodb",
+    ],
+    ["--db <name>", "Alias for --database"],
+    ["--session <type>", "memory, redis, database"],
+    ["--output <dir>", "Directory for backend source files"],
+    ["--rateLimiting", "Enable rate limiting (default: yes)"],
+    ["--helmet", "Enable Helmet security headers (default: yes)"],
+    ["--logger", "Enable Winston + Loki logger (default: yes)"],
+  ],
+  inspect: [
+    ["--type <adapter>", "Database adapter (required)"],
+    ["--env <path>", "Path to .env file"],
+    ["--out <path>", "Output file (default: dbmr.schema.json)"],
+    ["--tables <list>", "Comma-separated table filter"],
+  ],
+  generate: [
+    ["--from <path>", "Schema file (default: dbmr.schema.json)"],
+    ["--models", "Generate only model files"],
+    ["--routes", "Generate only route files"],
+    ["--openapi", "Generate only OpenAPI spec"],
+    ["--tests", "Generate only test files"],
+    ["--llm-docs", "Generate only LLM documentation"],
+  ],
+  doctor: [["--from <path>", "Schema file (default: dbmr.schema.json)"]],
+  diff: [["--from <path>", "Schema file (default: dbmr.schema.json)"]],
+};
+
+/**
+ * Print help message listing all available subcommands with their flags.
+ */
+function printHelp() {
+  console.log("Usage: db-model-router <command> [options]\n");
+
+  console.log("Commands:\n");
+  for (const [name, desc] of Object.entries(COMMAND_DESCRIPTIONS)) {
+    if (name === "help") {
+      console.log(`  ${name.padEnd(12)} ${desc}`);
+      continue;
+    }
+    console.log(`  ${name.padEnd(12)} ${desc}`);
+    const flags = COMMAND_FLAGS[name];
+    if (flags) {
+      for (const [flag, info] of flags) {
+        console.log(`    ${flag.padEnd(22)} ${info}`);
+      }
+      console.log("");
+    }
+  }
+
+  console.log("Global flags (all commands):");
+  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");
+  console.log('\nRun "db-model-router help <command>" for detailed usage.');
+}
+
+/**
+ * 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) {
+    printHelp();
+    return;
+  }
+
+  // `help <command>` — extract the topic from the second positional arg
+  if (subcommand === "help") {
+    // Re-parse to grab the second positional word as the help topic.
+    // parseFlags puts the first positional into subcommand; the second
+    // positional ends up as a key in args (if it looks like a flag value)
+    // or is lost. So we grab it directly from argv.
+    const topic =
+      argv.find((a, i) => i > 0 && !a.startsWith("-") && argv[0] === "help") ||
+      argv.find(
+        (a, i) => i > 0 && !a.startsWith("-") && argv.indexOf("help") < i,
+      );
+    args._command = topic || null;
+    const ctx = new OutputContext(flags);
+    await helpCmd(args, flags, ctx, { printHelp });
+    ctx.flush();
+    return;
+  }
+
+  // `<command> --help` — show detailed help for that command
+  if (flags.help) {
+    args._command = subcommand;
+    const ctx = new OutputContext(flags);
+    await helpCmd(args, flags, ctx, { printHelp });
+    ctx.flush();
+    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/index.js

@@ -2,6 +2,7 @@ const model = require("./commons/model.js");
 const route = require("./commons/route.js");
 const routers = {
   mysql: "./mysql/db.js",
+  mariadb: "./mysql/db.js",
   postgresql: "./postgres/db.js",
   postgres: "./postgres/db.js",
   oracle: "./oracle/db.js",
@@ -29,6 +30,7 @@ function init(DB_TYPE) {
     if (err.code === "MODULE_NOT_FOUND") {
       const driverMap = {
         mysql: "mysql2",
+        mariadb: "mysql2",
         postgresql: "pg",
         postgres: "pg",
         oracle: "oracledb",

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 };

package/src/schema/schema-printer.js

@@ -0,0 +1,77 @@
+"use strict";
+
+/**
+ * Serialize a parsed schema (internal representation from parseSchema())
+ * back into a JSON string.
+ *
+ * - Tables are sorted alphabetically by name.
+ * - Relationships are sorted by [parent, child].
+ * - Output uses 2-space indentation with a trailing newline.
+ * - Optional fields (options, unique, softDelete, relationships) are preserved.
+ *
+ * @param {object} schema — internal representation from parseSchema()
+ * @returns {string} — JSON with 2-space indent + trailing newline
+ */
+function printSchema(schema) {
+  const output = {};
+
+  output.adapter = schema.adapter;
+  output.framework = schema.framework;
+
+  // Preserve options if present and non-empty
+  if (schema.options && Object.keys(schema.options).length > 0) {
+    output.options = schema.options;
+  }
+
+  // Sort tables alphabetically by name
+  const sortedTableNames = Object.keys(schema.tables).sort();
+  const tables = {};
+  for (const name of sortedTableNames) {
+    const table = schema.tables[name];
+    const tableDef = {
+      columns: table.columns,
+      pk: table.pk || "id",
+    };
+
+    // Preserve unique if not the default [pk]
+    const defaultUnique = [table.pk || "id"];
+    const hasCustomUnique =
+      table.unique &&
+      (table.unique.length !== defaultUnique.length ||
+        table.unique.some((v, i) => v !== defaultUnique[i]));
+    if (hasCustomUnique) {
+      tableDef.unique = table.unique;
+    }
+
+    // Preserve softDelete if set
+    if (table.softDelete !== null && table.softDelete !== undefined) {
+      tableDef.softDelete = table.softDelete;
+    }
+
+    // Preserve timestamps if not the default { created_at: null, modified_at: null }
+    if (table.timestamps) {
+      const hasCustomTimestamps =
+        table.timestamps.created_at !== null ||
+        table.timestamps.modified_at !== null;
+      if (hasCustomTimestamps) {
+        tableDef.timestamps = table.timestamps;
+      }
+    }
+
+    tables[name] = tableDef;
+  }
+  output.tables = tables;
+
+  // Sort relationships by [parent, child] and include if non-empty
+  if (schema.relationships && schema.relationships.length > 0) {
+    output.relationships = [...schema.relationships].sort((a, b) => {
+      const cmp = a.parent.localeCompare(b.parent);
+      if (cmp !== 0) return cmp;
+      return a.child.localeCompare(b.child);
+    });
+  }
+
+  return JSON.stringify(output, null, 2) + "\n";
+}
+
+module.exports = { printSchema };

package/src/schema/schema-to-meta.js

@@ -0,0 +1,78 @@
+"use strict";
+
+/**
+ * Convert a parsed schema into the model metadata array used by
+ * generateModelFile(), generateRouteFile(), generateOpenAPISpec().
+ *
+ * Each ModelMeta matches the shape returned by the existing introspection
+ * functions:
+ *   { table, structure, primary_key, unique, option }
+ *
+ * - The primary key column is excluded from `structure`.
+ * - Timestamp columns (created_at, modified_at values) are excluded from `structure`.
+ * - The softDelete column is excluded from `structure`.
+ * - Output is sorted alphabetically by table name.
+ *
+ * @param {{ adapter: string, framework: string, tables: object, relationships: Array, options: object }} schema
+ * @returns {Array<{ table: string, structure: object, primary_key: string, unique: string[], option: { safeDelete: string|null, created_at: string|null, modified_at: string|null } }>}
+ */
+function schemaToModelMeta(schema) {
+  const tableNames = Object.keys(schema.tables).sort();
+  return tableNames.map((tableName) => {
+    const tableDef = schema.tables[tableName];
+
+    // Build the set of columns to exclude from structure
+    const excludeSet = new Set();
+
+    // Exclude primary key
+    excludeSet.add(tableDef.pk);
+
+    // Exclude timestamp columns
+    if (tableDef.timestamps) {
+      if (tableDef.timestamps.created_at) {
+        excludeSet.add(tableDef.timestamps.created_at);
+      }
+      if (tableDef.timestamps.modified_at) {
+        excludeSet.add(tableDef.timestamps.modified_at);
+      }
+    }
+
+    // Exclude softDelete column
+    if (tableDef.softDelete) {
+      excludeSet.add(tableDef.softDelete);
+    }
+
+    // Build structure, excluding the above columns
+    const structure = {};
+    for (const [colName, rule] of Object.entries(tableDef.columns)) {
+      if (!excludeSet.has(colName)) {
+        // Strip auto_increment and datetime columns from model structure
+        // (DB handles these automatically)
+        const baseType = rule.replace(/^required\|/, "");
+        if (baseType === "auto_increment") continue;
+        structure[colName] = rule;
+      }
+    }
+
+    // Map option fields
+    const option = {
+      safeDelete: tableDef.softDelete || null,
+      created_at: tableDef.timestamps
+        ? tableDef.timestamps.created_at || null
+        : null,
+      modified_at: tableDef.timestamps
+        ? tableDef.timestamps.modified_at || null
+        : null,
+    };
+
+    return {
+      table: tableName,
+      structure,
+      primary_key: tableDef.pk,
+      unique: [...tableDef.unique],
+      option,
+    };
+  });
+}
+
+module.exports = { schemaToModelMeta };