db-model-router 1.0.0 → 1.0.3

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

package/src/cli/generate-model.js

@@ -711,7 +711,7 @@ function parseArgs(argv) {
 
 function printUsage() {
   console.log(`
-Usage: rest-router-generate-model --type <db_type> [options]
+Usage: db-model-router-generate-model --type <db_type> [options]
 
 Options:
   --type        Database type (${SUPPORTED_TYPES.join(", ")})
@@ -728,9 +728,9 @@ Options:
   --help        Show this help message
 
 Examples:
-  rest-router-generate-model --type mysql --host localhost --database mydb --user root --password secret
-  rest-router-generate-model --type sqlite3 --database ./myapp.db --output ./src/models
-  rest-router-generate-model --type postgres --env .env --output ./models
+  db-model-router-generate-model --type mysql --host localhost --database mydb --user root --password secret
+  db-model-router-generate-model --type sqlite3 --database ./myapp.db --output ./src/models
+  db-model-router-generate-model --type postgres --env .env --output ./models
 `);
 }
 

package/src/cli/generate-openapi.js

@@ -8,7 +8,11 @@ function generateOpenAPISpec(models, options = {}) {
 
   const spec = {
     openapi: "3.0.3",
-    info: { title, version, description: "Auto-generated by rest-router CLI" },
+    info: {
+      title,
+      version,
+      description: "Auto-generated by db-model-router CLI",
+    },
     paths: {},
     components: { schemas: {} },
   };

package/src/cli/generate-route.js

@@ -108,6 +108,192 @@ function generateSimpleRoutesIndexFile(tableNames) {
   return generateRoutesIndexFile(tableNames, []);
 }
 
+/**
+ * Generate a test file for a route covering all CRUD methods.
+ * Uses supertest + the app's express setup.
+ */
+function generateTestFile(tableName, pk) {
+  const varName = safeVarName(tableName);
+  return `const assert = require("assert");
+const express = require("express");
+const request = require("supertest");
+const { route } = require("db-model-router");
+
+// Adjust the path to your model file as needed
+const ${varName} = require("../models/${tableName}");
+
+function createApp() {
+  const app = express();
+  app.use(express.json());
+  app.use("/${tableName}", route(${varName}));
+  return app;
+}
+
+describe("${tableName} routes", function () {
+  let app;
+
+  before(function () {
+    app = createApp();
+  });
+
+  describe("GET /${tableName}/", function () {
+    it("should list records", async function () {
+      const res = await request(app).get("/${tableName}/");
+      assert.strictEqual(res.status, 200);
+      assert.ok(Array.isArray(res.body.data));
+    });
+  });
+
+  describe("POST /${tableName}/add", function () {
+    it("should insert a single record", async function () {
+      const res = await request(app)
+        .post("/${tableName}/add")
+        .send({});
+      assert.ok([200, 201, 400].includes(res.status));
+    });
+  });
+
+  describe("POST /${tableName}/", function () {
+    it("should bulk insert records", async function () {
+      const res = await request(app)
+        .post("/${tableName}/")
+        .send({ data: [] });
+      assert.ok([200, 201, 400].includes(res.status));
+    });
+  });
+
+  describe("GET /${tableName}/:${pk}", function () {
+    it("should get a record by ID", async function () {
+      const res = await request(app).get("/${tableName}/1");
+      assert.ok([200, 404].includes(res.status));
+    });
+  });
+
+  describe("PUT /${tableName}/:${pk}", function () {
+    it("should update a record", async function () {
+      const res = await request(app)
+        .put("/${tableName}/1")
+        .send({});
+      assert.ok([200, 400, 404].includes(res.status));
+    });
+  });
+
+  describe("PATCH /${tableName}/:${pk}", function () {
+    it("should partially update a record", async function () {
+      const res = await request(app)
+        .patch("/${tableName}/1")
+        .send({});
+      assert.ok([200, 400, 404].includes(res.status));
+    });
+  });
+
+  describe("DELETE /${tableName}/:${pk}", function () {
+    it("should delete a record", async function () {
+      const res = await request(app).delete("/${tableName}/1");
+      assert.ok([200, 204, 404].includes(res.status));
+    });
+  });
+
+  describe("PUT /${tableName}/", function () {
+    it("should bulk update records", async function () {
+      const res = await request(app)
+        .put("/${tableName}/")
+        .send({ data: [] });
+      assert.ok([200, 400].includes(res.status));
+    });
+  });
+
+  describe("DELETE /${tableName}/", function () {
+    it("should bulk delete records", async function () {
+      const res = await request(app)
+        .delete("/${tableName}/")
+        .send({});
+      assert.ok([200, 204, 400].includes(res.status));
+    });
+  });
+});
+`;
+}
+
+/**
+ * Generate a child route test file that tests the nested parent/:fk/child endpoints.
+ */
+function generateChildTestFile(childTable, parentTable, fkColumn, pk) {
+  const childVar = safeVarName(childTable);
+  return `const assert = require("assert");
+const express = require("express");
+const request = require("supertest");
+const { route } = require("db-model-router");
+
+const ${childVar} = require("../models/${childTable}");
+
+function createApp() {
+  const app = express();
+  app.use(express.json());
+  app.use("/${parentTable}/:${fkColumn}/${childTable}", route(${childVar}, { ${fkColumn}: "params.${fkColumn}" }));
+  return app;
+}
+
+describe("${childTable} (child of ${parentTable}) routes", function () {
+  let app;
+  const parentId = 1;
+
+  before(function () {
+    app = createApp();
+  });
+
+  describe("GET /${parentTable}/:${fkColumn}/${childTable}/", function () {
+    it("should list child records scoped by parent", async function () {
+      const res = await request(app).get(\`/${parentTable}/\${parentId}/${childTable}/\`);
+      assert.strictEqual(res.status, 200);
+      assert.ok(Array.isArray(res.body.data));
+    });
+  });
+
+  describe("POST /${parentTable}/:${fkColumn}/${childTable}/add", function () {
+    it("should insert a child record", async function () {
+      const res = await request(app)
+        .post(\`/${parentTable}/\${parentId}/${childTable}/add\`)
+        .send({});
+      assert.ok([200, 201, 400].includes(res.status));
+    });
+  });
+
+  describe("GET /${parentTable}/:${fkColumn}/${childTable}/:${pk}", function () {
+    it("should get a child record by ID", async function () {
+      const res = await request(app).get(\`/${parentTable}/\${parentId}/${childTable}/1\`);
+      assert.ok([200, 404].includes(res.status));
+    });
+  });
+
+  describe("PUT /${parentTable}/:${fkColumn}/${childTable}/:${pk}", function () {
+    it("should update a child record", async function () {
+      const res = await request(app)
+        .put(\`/${parentTable}/\${parentId}/${childTable}/1\`)
+        .send({});
+      assert.ok([200, 400, 404].includes(res.status));
+    });
+  });
+
+  describe("PATCH /${parentTable}/:${fkColumn}/${childTable}/:${pk}", function () {
+    it("should partially update a child record", async function () {
+      const res = await request(app)
+        .patch(\`/${parentTable}/\${parentId}/${childTable}/1\`)
+        .send({});
+      assert.ok([200, 400, 404].includes(res.status));
+    });
+  });
+
+  describe("DELETE /${parentTable}/:${fkColumn}/${childTable}/:${pk}", function () {
+    it("should delete a child record", async function () {
+      const res = await request(app).delete(\`/${parentTable}/\${parentId}/${childTable}/1\`);
+      assert.ok([200, 204, 404].includes(res.status));
+    });
+  });
+});
+`;
+}
+
 /**
  * Read model directory to discover table names from generated model files.
  * Looks for .js files that are not index.js.
@@ -143,7 +329,7 @@ async function main() {
     if (!dbType) {
       console.error(
         `Error: No models found in "${modelsDir}" and no --type provided to generate them.\n` +
-          `Either generate models first with rest-router-generate-model, or provide --type to auto-generate.`,
+          `Either generate models first with db-model-router-generate-model, or provide --type to auto-generate.`,
       );
       process.exit(1);
     }
@@ -262,6 +448,51 @@ async function main() {
     // OpenAPI generation is optional, don't fail
   }
 
+  // Generate test files for all routes
+  const testsDir = path.resolve(path.dirname(routesDir), "tests");
+  if (!fs.existsSync(testsDir)) {
+    fs.mkdirSync(testsDir, { recursive: true });
+  }
+
+  for (const table of tableNames) {
+    // Try to extract PK from model file
+    let pk = "id";
+    const modelPath = path.join(modelsDir, table + ".js");
+    if (fs.existsSync(modelPath)) {
+      const meta = parseModelFile(fs.readFileSync(modelPath, "utf8"), table);
+      if (meta && meta.primary_key) pk = meta.primary_key;
+    }
+    const testPath = path.join(testsDir, table + ".test.js");
+    fs.writeFileSync(testPath, generateTestFile(table, pk));
+    console.log(`  Created ${testPath}`);
+  }
+
+  // Generate child route test files
+  for (const rel of relationships) {
+    let pk = "id";
+    const modelPath = path.join(modelsDir, rel.child + ".js");
+    if (fs.existsSync(modelPath)) {
+      const meta = parseModelFile(
+        fs.readFileSync(modelPath, "utf8"),
+        rel.child,
+      );
+      if (meta && meta.primary_key) pk = meta.primary_key;
+    }
+    const testPath = path.join(
+      testsDir,
+      `${rel.child}_child_of_${rel.parent}.test.js`,
+    );
+    fs.writeFileSync(
+      testPath,
+      generateChildTestFile(rel.child, rel.parent, rel.fkColumn, pk),
+    );
+    console.log(`  Created ${testPath}`);
+  }
+
+  console.log(
+    `Generated ${tableNames.length + relationships.length} test file(s) in ${testsDir}`,
+  );
+
   process.exit(0);
 }
 
@@ -271,7 +502,9 @@ async function main() {
 function parseModelFile(content, tableName) {
   try {
     // Extract structure JSON
-    const structMatch = content.match(/model\(\s*\n?\s*db,\s*\n?\s*"[^"]+",\s*\n?\s*(\{[\s\S]*?\}),/);
+    const structMatch = content.match(
+      /model\(\s*\n?\s*db,\s*\n?\s*"[^"]+",\s*\n?\s*(\{[\s\S]*?\}),/,
+    );
     if (!structMatch) return null;
     const structure = JSON.parse(structMatch[1]);
     // Extract primary key
@@ -281,7 +514,7 @@ function parseModelFile(content, tableName) {
   } catch (e) {
     return null;
   }
-
+}
 function parseArgs(argv) {
   const args = {};
   for (let i = 0; i < argv.length; i++) {
@@ -302,7 +535,7 @@ function parseArgs(argv) {
 
 function printUsage() {
   console.log(`
-Usage: rest-router-generate-route [options]
+Usage: db-model-router-generate-route [options]
 
 Options:
   --models      Path to models directory (default: ./models)
@@ -320,13 +553,13 @@ Options:
 
 Examples:
   # Generate routes from existing models
-  rest-router-generate-route --models ./models --output ./routes
+  db-model-router-generate-route --models ./models --output ./routes
 
   # Auto-generate models + routes in one step
-  rest-router-generate-route --type mysql --env .env --models ./models --output ./routes
+  db-model-router-generate-route --type mysql --env .env --models ./models --output ./routes
 
   # SQLite3 example
-  rest-router-generate-route --type sqlite3 --database ./myapp.db
+  db-model-router-generate-route --type sqlite3 --database ./myapp.db
 `);
 }
 
@@ -341,6 +574,8 @@ module.exports = {
   generateRouteFile,
   generateChildRouteFile,
   generateRoutesIndexFile,
+  generateTestFile,
+  generateChildTestFile,
   discoverModels,
   safeVarName,
 };