db-model-router 1.0.3 → 1.0.5

package/src/cli/diff-engine.js

@@ -11,6 +11,7 @@ const {
   generateChildTestFile,
 } = require("./generate-route.js");
 const { generateOpenAPISpec } = require("./generate-openapi.js");
+const { generateDocsRoute } = require("./generate-docs-route.js");
 
 /**
  * Simple line-by-line diff between two strings.
@@ -52,54 +53,63 @@ function buildExpectedFiles(meta, relationships) {
   const modelsRelPath = "../models";
   const tableNames = meta.map((m) => m.table).sort();
 
+  // Collect child tables
+  const nestedChildren = new Set();
+  for (const rel of relationships) {
+    nestedChildren.add(rel.child);
+  }
+
   // Model files
   for (const m of meta) {
     expected.set(`models/${m.table}.js`, generateModelFile(m));
   }
 
-  // Route files (one per table)
+  // Route files (top-level only, skip children)
   for (const m of meta) {
+    if (nestedChildren.has(m.table)) continue;
     expected.set(
       `routes/${m.table}.js`,
       generateRouteFile(m.table, modelsRelPath),
     );
   }
 
-  // Child route files (one per relationship)
+  // Child route files in subfolders: routes/<parent>/<child>.js
   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`,
+      `routes/${rel.parent}/${rel.child}.js`,
       generateChildRouteFile(
         rel.child,
         rel.parent,
         rel.foreignKey,
-        modelsRelPath,
+        `../../models`,
       ),
     );
   }
 
-  // Routes index file
+  // Routes index file (with docs route)
   expected.set(
     "routes/index.js",
-    generateRoutesIndexFile(tableNames, relationships),
+    generateRoutesIndexFile(tableNames, relationships, { includeDocs: true }),
   );
 
-  // Test files (one per table)
+  // Docs route (Swagger UI)
+  expected.set("routes/docs.js", generateDocsRoute());
+
+  // Test files (top-level only, skip children)
   for (const m of meta) {
+    if (nestedChildren.has(m.table)) continue;
     expected.set(
       `test/${m.table}.test.js`,
       generateTestFile(m.table, m.primary_key),
     );
   }
 
-  // Child test files (one per relationship)
+  // Child test files in subfolders: test/<parent>/<child>.test.js
   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`,
+      `test/${rel.parent}/${rel.child}.test.js`,
       generateChildTestFile(rel.child, rel.parent, rel.foreignKey, pk),
     );
   }
@@ -115,7 +125,7 @@ function buildExpectedFiles(meta, relationships) {
 
 /**
  * Scan known artifact directories on disk and return a set of relative paths
- * that exist.
+ * that exist. Recursively scans subdirectories.
  *
  * @param {string} baseDir
  * @returns {Set<string>}
@@ -123,22 +133,42 @@ function buildExpectedFiles(meta, relationships) {
 function scanDiskFiles(baseDir) {
   const files = new Set();
 
-  const dirs = [
-    { dir: "models", ext: ".js" },
-    { dir: "routes", ext: ".js" },
-    { dir: "test", ext: ".test.js" },
-  ];
+  function scanDir(dir, prefix) {
+    const fullDir = path.join(baseDir, dir);
+    if (!fs.existsSync(fullDir)) return;
+    for (const entry of fs.readdirSync(fullDir, { withFileTypes: true })) {
+      const relPath = prefix
+        ? `${prefix}/${entry.name}`
+        : `${dir}/${entry.name}`;
+      if (entry.isDirectory()) {
+        scanDir(path.join(dir, entry.name), relPath);
+      } else if (entry.name.endsWith(".js")) {
+        files.add(relPath);
+      }
+    }
+  }
+
+  scanDir("models");
+  scanDir("routes");
 
-  for (const { dir, ext } of dirs) {
+  // For test dir, only include .test.js files
+  function scanTestDir(dir, prefix) {
     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}`);
+    if (!fs.existsSync(fullDir)) return;
+    for (const entry of fs.readdirSync(fullDir, { withFileTypes: true })) {
+      const relPath = prefix
+        ? `${prefix}/${entry.name}`
+        : `${dir}/${entry.name}`;
+      if (entry.isDirectory()) {
+        scanTestDir(path.join(dir, entry.name), relPath);
+      } else if (entry.name.endsWith(".test.js")) {
+        files.add(relPath);
       }
     }
   }
 
+  scanTestDir("test");
+
   // Check for openapi.json at root
   const openapiPath = path.join(baseDir, "openapi.json");
   if (fs.existsSync(openapiPath)) {

package/src/cli/generate-docs-route.js

@@ -0,0 +1,31 @@
+"use strict";
+
+/**
+ * Generate a routes/docs.js file that serves Swagger UI for the OpenAPI spec.
+ * Uses swagger-ui-express to mount at /docs.
+ *
+ * @returns {string}
+ */
+function generateDocsRoute() {
+  return `import express from "express";
+import swaggerUi from "swagger-ui-express";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const spec = JSON.parse(readFileSync(join(__dirname, "../openapi.json"), "utf8"));
+
+const router = express.Router();
+
+router.use("/", swaggerUi.serve);
+router.get("/", swaggerUi.setup(spec, {
+  customSiteTitle: "API Documentation",
+  customCss: ".swagger-ui .topbar { display: none }",
+}));
+
+export default router;
+`;
+}
+
+module.exports = { generateDocsRoute };

package/src/cli/generate-migration.js

@@ -0,0 +1,356 @@
+"use strict";
+
+/**
+ * Generate database migration SQL/JS from parsed schema tables.
+ *
+ * Produces CREATE TABLE statements (or equivalent) for each table,
+ * with proper column types, constraints, and indexes per adapter.
+ */
+
+// ---------------------------------------------------------------------------
+// Column type mapping per adapter
+// ---------------------------------------------------------------------------
+
+/**
+ * Map a dbmr column rule to a SQL column type for the given adapter.
+ *
+ * @param {string} rule - e.g. "required|string", "auto_increment", "integer"
+ * @param {string} adapter - e.g. "postgres", "mysql", "sqlite3"
+ * @returns {{ sqlType: string, nullable: boolean, isAutoIncrement: boolean }}
+ */
+function mapColumnType(rule, adapter) {
+  const parts = rule.split("|");
+  const isRequired = parts.includes("required");
+  const baseType = parts.filter((p) => p !== "required")[0] || "string";
+
+  let sqlType;
+  let isAutoIncrement = false;
+
+  switch (baseType) {
+    case "auto_increment":
+      isAutoIncrement = true;
+      sqlType = autoIncrementType(adapter);
+      break;
+    case "string":
+      sqlType = stringType(adapter);
+      break;
+    case "integer":
+      sqlType = integerType(adapter);
+      break;
+    case "numeric":
+      sqlType = numericType(adapter);
+      break;
+    case "boolean":
+      sqlType = booleanType(adapter);
+      break;
+    case "datetime":
+      sqlType = datetimeType(adapter);
+      break;
+    case "object":
+      sqlType = jsonType(adapter);
+      break;
+    default:
+      sqlType = stringType(adapter);
+  }
+
+  return {
+    sqlType,
+    nullable: !isRequired && !isAutoIncrement,
+    isAutoIncrement,
+  };
+}
+
+function autoIncrementType(adapter) {
+  switch (adapter) {
+    case "postgres":
+    case "cockroachdb":
+      return "SERIAL";
+    case "mssql":
+      return "INT IDENTITY(1,1)";
+    case "oracle":
+      return "NUMBER GENERATED BY DEFAULT AS IDENTITY";
+    case "sqlite3":
+      return "INTEGER";
+    default:
+      // mysql, mariadb
+      return "INT AUTO_INCREMENT";
+  }
+}
+
+function stringType(adapter) {
+  if (adapter === "oracle") return "VARCHAR2(255)";
+  return "VARCHAR(255)";
+}
+
+function integerType(adapter) {
+  if (adapter === "oracle") return "NUMBER(10)";
+  return "INTEGER";
+}
+
+function numericType(adapter) {
+  if (adapter === "oracle") return "NUMBER(12,2)";
+  if (adapter === "mssql") return "DECIMAL(12,2)";
+  return "DECIMAL(12,2)";
+}
+
+function booleanType(adapter) {
+  if (adapter === "oracle") return "NUMBER(1)";
+  if (adapter === "mssql") return "BIT";
+  if (adapter === "mysql" || adapter === "mariadb") return "TINYINT(1)";
+  return "BOOLEAN";
+}
+
+function datetimeType(adapter) {
+  if (adapter === "mssql") return "DATETIME";
+  return "TIMESTAMP";
+}
+
+function jsonType(adapter) {
+  if (adapter === "postgres" || adapter === "cockroachdb") return "JSONB";
+  if (adapter === "oracle") return "CLOB";
+  if (adapter === "mssql") return "NVARCHAR(MAX)";
+  if (adapter === "sqlite3") return "TEXT";
+  return "JSON";
+}
+
+// ---------------------------------------------------------------------------
+// SQL migration generators
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a CREATE TABLE SQL statement for a single table.
+ *
+ * @param {string} tableName
+ * @param {object} tableDef - parsed table definition from schema
+ * @param {string} adapter
+ * @returns {string}
+ */
+function generateCreateTableSQL(tableName, tableDef, adapter) {
+  const lines = [];
+  const pk = tableDef.pk;
+
+  for (const [colName, rule] of Object.entries(tableDef.columns)) {
+    const { sqlType, nullable, isAutoIncrement } = mapColumnType(rule, adapter);
+    let line = `  ${quoteIdent(colName, adapter)} ${sqlType}`;
+
+    if (colName === pk) {
+      line += " PRIMARY KEY";
+      if (isAutoIncrement && adapter === "sqlite3") {
+        // SQLite needs AUTOINCREMENT after PRIMARY KEY for INTEGER type
+        line = `  ${quoteIdent(colName, adapter)} INTEGER PRIMARY KEY AUTOINCREMENT`;
+      }
+    } else {
+      if (!nullable) line += " NOT NULL";
+    }
+
+    // Default values for timestamps
+    if (tableDef.timestamps) {
+      if (
+        colName === tableDef.timestamps.created_at ||
+        colName === tableDef.timestamps.modified_at
+      ) {
+        line += defaultTimestamp(adapter);
+      }
+    }
+
+    // Default for boolean softDelete column
+    if (tableDef.softDelete && colName === tableDef.softDelete) {
+      line += defaultBoolean(adapter);
+    }
+
+    lines.push(line);
+  }
+
+  // Unique constraints (excluding PK which is already PRIMARY KEY)
+  if (tableDef.unique && tableDef.unique.length > 0) {
+    const uniqueCols = tableDef.unique.filter((c) => c !== pk);
+    for (const col of uniqueCols) {
+      lines.push(`  UNIQUE (${quoteIdent(col, adapter)})`);
+    }
+  }
+
+  const createPrefix =
+    adapter === "oracle" || adapter === "mssql"
+      ? `CREATE TABLE ${quoteIdent(tableName, adapter)}`
+      : `CREATE TABLE IF NOT EXISTS ${quoteIdent(tableName, adapter)}`;
+
+  return `${createPrefix} (\n${lines.join(",\n")}\n);\n`;
+}
+
+/**
+ * Quote an identifier based on adapter.
+ */
+function quoteIdent(name, adapter) {
+  // Most adapters are fine without quoting for simple names
+  // but we keep it safe for reserved words
+  if (adapter === "mssql") return `[${name}]`;
+  if (adapter === "oracle") return `"${name.toUpperCase()}"`;
+  return name;
+}
+
+/**
+ * Default timestamp expression per adapter.
+ */
+function defaultTimestamp(adapter) {
+  switch (adapter) {
+    case "mssql":
+      return " DEFAULT GETDATE()";
+    case "oracle":
+      return " DEFAULT CURRENT_TIMESTAMP";
+    case "sqlite3":
+      return " DEFAULT CURRENT_TIMESTAMP";
+    default:
+      return " DEFAULT CURRENT_TIMESTAMP";
+  }
+}
+
+/**
+ * Default boolean false expression per adapter.
+ */
+function defaultBoolean(adapter) {
+  if (adapter === "oracle" || adapter === "mssql") return " DEFAULT 0";
+  if (adapter === "mysql" || adapter === "mariadb") return " DEFAULT 0";
+  return " DEFAULT FALSE";
+}
+
+// ---------------------------------------------------------------------------
+// NoSQL migration generators
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a MongoDB migration JS file for a single table (collection).
+ */
+function generateMongoDBMigration(tableName, tableDef) {
+  const uniqueCols = (tableDef.unique || []).filter((c) => c !== tableDef.pk);
+  const indexLines = uniqueCols
+    .map(
+      (col) =>
+        `  await db.collection("${tableName}").createIndex({ ${col}: 1 }, { unique: true });`,
+    )
+    .join("\n");
+
+  return `"use strict";
+
+module.exports = {
+  async up(db) {
+    await db.createCollection("${tableName}");
+${indexLines ? indexLines + "\n" : ""}  },
+
+  async down(db) {
+    await db.collection("${tableName}").drop();
+  },
+};
+`;
+}
+
+/**
+ * Generate a DynamoDB migration JS file for a single table.
+ */
+function generateDynamoDBMigration(tableName, tableDef) {
+  const pk = tableDef.pk;
+  return `import { CreateTableCommand, DeleteTableCommand } from "@aws-sdk/client-dynamodb";
+
+export async function up(db) {
+  await db.send(new CreateTableCommand({
+    TableName: "${tableName}",
+    KeySchema: [{ AttributeName: "${pk}", KeyType: "HASH" }],
+    AttributeDefinitions: [{ AttributeName: "${pk}", AttributeType: "N" }],
+    BillingMode: "PAY_PER_REQUEST",
+  }));
+}
+
+export async function down(db) {
+  await db.send(new DeleteTableCommand({ TableName: "${tableName}" }));
+}
+`;
+}
+
+/**
+ * Generate a Redis migration JS file (Redis doesn't need table creation,
+ * but we create a placeholder for consistency).
+ */
+function generateRedisMigration(tableName) {
+  return `"use strict";
+
+module.exports = {
+  async up(db) {
+    // Redis is schema-less. This migration is a placeholder.
+    // Data for "${tableName}" will be stored as hash keys: ${tableName}:<id>
+    console.log("Redis: ${tableName} collection ready (schema-less).");
+  },
+
+  async down(db) {
+    // Warning: this deletes ALL keys matching the pattern
+    // In production, use SCAN instead of KEYS
+    const keys = await db.keys("${tableName}:*");
+    if (keys.length > 0) {
+      await db.del(...keys);
+    }
+  },
+};
+`;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+const SQL_ADAPTERS = [
+  "mysql",
+  "mariadb",
+  "postgres",
+  "sqlite3",
+  "mssql",
+  "cockroachdb",
+  "oracle",
+];
+
+/**
+ * Generate migration file content for all tables in the schema.
+ *
+ * For SQL adapters: produces a single .sql file with all CREATE TABLE statements.
+ * For NoSQL adapters: produces one .js file per table.
+ *
+ * @param {object} schema - parsed schema from parseSchema()
+ * @returns {Array<{ filename: string, content: string }>}
+ */
+function generateMigrationFiles(schema) {
+  const adapter = schema.adapter;
+  const tables = schema.tables;
+  const tableNames = Object.keys(tables).sort();
+
+  if (SQL_ADAPTERS.includes(adapter)) {
+    // Single SQL file with all CREATE TABLE statements
+    const statements = [];
+    for (const name of tableNames) {
+      statements.push(generateCreateTableSQL(name, tables[name], adapter));
+    }
+    const content = statements.join("\n");
+    return [{ filename: `create_tables.sql`, content }];
+  }
+
+  // NoSQL: one file per table
+  const files = [];
+  for (const name of tableNames) {
+    let content;
+    if (adapter === "mongodb") {
+      content = generateMongoDBMigration(name, tables[name]);
+    } else if (adapter === "dynamodb") {
+      content = generateDynamoDBMigration(name, tables[name]);
+    } else if (adapter === "redis") {
+      content = generateRedisMigration(name);
+    } else {
+      // Fallback
+      content = `// Migration for ${name}\n`;
+    }
+    files.push({ filename: `create_${name}.js`, content });
+  }
+
+  return files;
+}
+
+module.exports = {
+  generateMigrationFiles,
+  generateCreateTableSQL,
+  mapColumnType,
+};

package/src/cli/generate-model.js

@@ -475,7 +475,7 @@ function mysqlTypeToValidator(t) {
   if (/json/.test(t)) return "object";
   if (/text|char|varchar|enum|set/.test(t)) return "string";
   if (/blob|binary/.test(t)) return "string";
-  if (/date|time|year/.test(t)) return "string";
+  if (/date|time|year/.test(t)) return "datetime";
   if (/bool/.test(t)) return "integer";
   return "string";
 }
@@ -487,7 +487,7 @@ function pgTypeToValidator(t) {
   if (/json/.test(t)) return "object";
   if (/bool/.test(t)) return "integer";
   if (/char|text|varchar|uuid/.test(t)) return "string";
-  if (/date|time|interval/.test(t)) return "string";
+  if (/date|time|interval/.test(t)) return "datetime";
   return "string";
 }
 
@@ -496,6 +496,7 @@ function sqliteTypeToValidator(t) {
   if (/int/.test(t)) return "integer";
   if (/real|float|double|numeric|decimal/.test(t)) return "numeric";
   if (/json/.test(t)) return "object";
+  if (/date|time/.test(t)) return "datetime";
   if (/blob/.test(t)) return "string";
   return "string";
 }
@@ -506,7 +507,7 @@ function mssqlTypeToValidator(t) {
   if (/decimal|numeric|float|real|money/.test(t)) return "numeric";
   if (/bit/.test(t)) return "integer";
   if (/char|text|varchar|nchar|nvarchar|ntext/.test(t)) return "string";
-  if (/date|time|datetime/.test(t)) return "string";
+  if (/date|time|datetime/.test(t)) return "datetime";
   if (/uniqueidentifier/.test(t)) return "string";
   return "string";
 }
@@ -515,7 +516,7 @@ function oracleTypeToValidator(t) {
   if (/NUMBER|INTEGER|FLOAT|BINARY_FLOAT|BINARY_DOUBLE/.test(t))
     return "numeric";
   if (/CLOB|BLOB|RAW|LONG/.test(t)) return "string";
-  if (/DATE|TIMESTAMP/.test(t)) return "string";
+  if (/DATE|TIMESTAMP/.test(t)) return "datetime";
   if (/CHAR|VARCHAR|NCHAR|NVARCHAR/.test(t)) return "string";
   return "string";
 }