db-model-router 1.0.4 → 1.0.5

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-route.js

@@ -58,8 +58,15 @@ export default route(${varName}, { ${fkColumn}: "params.${fkColumn}" });
 /**
  * Generate the routes index file that mounts all routes on an express Router.
  * Supports parent-child nesting: parent/:pk/child
+ *
+ * Child routes are placed in subfolders: routes/<parent>/<child>.js
+ * Children are only mounted under their parent path (no duplicate top-level route).
+ *
+ * @param {string[]} tableNames
+ * @param {Array<{parent, child, foreignKey}>} relationships
+ * @param {{ includeDocs?: boolean }} [options]
  */
-function generateRoutesIndexFile(tableNames, relationships = []) {
+function generateRoutesIndexFile(tableNames, relationships = [], options = {}) {
   let imports = `import express from "express";\n\nconst router = express.Router();\n\n`;
 
   // Collect child tables that are nested under parents
@@ -68,35 +75,42 @@ function generateRoutesIndexFile(tableNames, relationships = []) {
     nestedChildren.add(rel.child);
   }
 
+  // Import top-level routes only (not children)
   for (const table of tableNames) {
+    if (nestedChildren.has(table)) continue;
     const varName = safeVarName(table);
     imports += `import ${varName}Route from "./${table}.js";\n`;
   }
-  // Import child routes with _child suffix for nested ones
+
+  // Import child routes from subfolders
   for (const rel of relationships) {
     const varName = safeVarName(rel.child);
-    imports += `import ${varName}ChildRoute from "./${rel.child}_child_of_${rel.parent}.js";\n`;
+    imports += `import ${varName}ChildRoute from "./${rel.parent}/${rel.child}.js";\n`;
+  }
+
+  // Import docs route if openapi is generated
+  if (options.includeDocs) {
+    imports += `import docsRoute from "./docs.js";\n`;
   }
 
   imports += "\n";
 
-  // Mount top-level routes (skip tables that are ONLY children)
+  // Mount docs route first
+  if (options.includeDocs) {
+    imports += `router.use("/docs", docsRoute);\n`;
+  }
+
+  // Mount top-level routes
   for (const table of tableNames) {
     if (nestedChildren.has(table)) continue;
     const varName = safeVarName(table);
     imports += `router.use("/${table}", ${varName}Route);\n`;
   }
 
-  // Mount nested child routes under parent
+  // Mount child routes under parent path
   for (const rel of relationships) {
     const childVar = safeVarName(rel.child);
-    imports += `router.use("/${rel.parent}/:${rel.fkColumn}/${rel.child}", ${childVar}ChildRoute);\n`;
-  }
-
-  // Also mount children as top-level for direct access
-  for (const rel of relationships) {
-    const varName = safeVarName(rel.child);
-    imports += `router.use("/${rel.child}", ${varName}Route);\n`;
+    imports += `router.use("/${rel.parent}/:${rel.foreignKey}/${rel.child}", ${childVar}ChildRoute);\n`;
   }
 
   imports += "\nexport default router;\n";
@@ -387,7 +401,7 @@ async function main() {
         const fkColumn = parent.replace(/s$/, "") + "_id";
         // Only add if both tables exist in our model set
         if (tableNames.includes(parent) && tableNames.includes(child)) {
-          relationships.push({ parent, child, fkColumn });
+          relationships.push({ parent, child, foreignKey: fkColumn });
         }
       }
     }
@@ -398,23 +412,36 @@ async function main() {
     fs.mkdirSync(routesDir, { recursive: true });
   }
 
+  // Collect child tables to skip top-level route files
+  const nestedChildren = new Set();
+  for (const rel of relationships) {
+    nestedChildren.add(rel.child);
+  }
+
   for (const table of tableNames) {
+    if (nestedChildren.has(table)) continue;
     const filePath = path.join(routesDir, table + ".js");
     fs.writeFileSync(filePath, generateRouteFile(table, modelsRelPath));
     console.log(`  Created ${filePath}`);
   }
 
-  // Write child route files for parent-child relationships
+  // Write child route files in subfolders: routes/<parent>/<child>.js
   for (const rel of relationships) {
-    const fileName = `${rel.child}_child_of_${rel.parent}.js`;
-    const filePath = path.join(routesDir, fileName);
+    const parentDir = path.join(routesDir, rel.parent);
+    if (!fs.existsSync(parentDir)) {
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+    const filePath = path.join(parentDir, `${rel.child}.js`);
+    const childModelsRelPath = path
+      .relative(parentDir, path.resolve(modelsDir))
+      .replace(/\\/g, "/");
     fs.writeFileSync(
       filePath,
       generateChildRouteFile(
         rel.child,
         rel.parent,
-        rel.fkColumn,
-        modelsRelPath,
+        rel.foreignKey,
+        childModelsRelPath,
       ),
     );
     console.log(`  Created ${filePath}`);
@@ -473,7 +500,7 @@ async function main() {
     console.log(`  Created ${testPath}`);
   }
 
-  // Generate child route test files
+  // Generate child route test files in subfolders
   for (const rel of relationships) {
     let pk = "id";
     const modelPath = path.join(modelsDir, rel.child + ".js");
@@ -484,13 +511,14 @@ async function main() {
       );
       if (meta && meta.primary_key) pk = meta.primary_key;
     }
-    const testPath = path.join(
-      testsDir,
-      `${rel.child}_child_of_${rel.parent}.test.js`,
-    );
+    const parentTestDir = path.join(testsDir, rel.parent);
+    if (!fs.existsSync(parentTestDir)) {
+      fs.mkdirSync(parentTestDir, { recursive: true });
+    }
+    const testPath = path.join(parentTestDir, `${rel.child}.test.js`);
     fs.writeFileSync(
       testPath,
-      generateChildTestFile(rel.child, rel.parent, rel.fkColumn, pk),
+      generateChildTestFile(rel.child, rel.parent, rel.foreignKey, pk),
     );
     console.log(`  Created ${testPath}`);
   }

package/src/cli/init/dependencies.js

@@ -63,6 +63,9 @@ function collectDependencies(answers) {
   // Dev dependencies
   devDependencies["nodemon"] = "latest";
 
+  // Swagger UI for API documentation
+  dependencies["swagger-ui-express"] = "latest";
+
   return { dependencies, devDependencies };
 }
 

package/src/cli/init/generators.js

@@ -1715,7 +1715,7 @@ function generateAppJsV2(answers, outputDir) {
     answers.framework === "ultimate-express" ? "ultimate-express" : "express";
 
   const commonsPrefix = outputDir ? `./${outputDir}/commons` : "./commons";
-  const routePrefix = outputDir ? `./${outputDir}/route` : "./route";
+  const routePrefix = outputDir ? `./${outputDir}/routes` : "./routes";
   const middlewarePrefix = outputDir
     ? `./${outputDir}/middleware`
     : "./middleware";

package/src/cli/init.js

@@ -95,7 +95,7 @@ function generateFiles(answers, outputDir) {
     path.join(srcBase, "middleware"),
     path.join(srcBase, "migrations"),
     path.join(srcBase, "commons"),
-    path.join(srcBase, "route"),
+    path.join(srcBase, "routes"),
   ];
   // SQLite3 needs a data/ folder for the database file
   if (answers.database === "sqlite3") {
@@ -189,15 +189,15 @@ function generateFiles(answers, outputDir) {
   if (safeWriteFile(dbPath, generateDbModule(answers)))
     files.push(path.join(srcBase, "commons/db.js"));
 
-  // route/health.js
-  const healthPath = path.join(srcBase, "route", "health.js");
+  // routes/health.js
+  const healthPath = path.join(srcBase, "routes", "health.js");
   if (safeWriteFile(healthPath, generateHealthRoute()))
-    files.push(path.join(srcBase, "route/health.js"));
+    files.push(path.join(srcBase, "routes/health.js"));
 
-  // route/index.js
-  const routeIndexPath = path.join(srcBase, "route", "index.js");
+  // routes/index.js
+  const routeIndexPath = path.join(srcBase, "routes", "index.js");
   if (safeWriteFile(routeIndexPath, generateRouteIndexFile()))
-    files.push(path.join(srcBase, "route/index.js"));
+    files.push(path.join(srcBase, "routes/index.js"));
 
   // Initial migration (inside outputDir/migrations)
   const initialMigration = generateInitialMigration(answers);
@@ -365,7 +365,7 @@ Options:
   --db <name>           Alias for --database
   --session <type>      Session store: memory, redis, database
   --output <dir>        Directory for backend source files (e.g. --output backend).
-                        package.json stays in root; index.js, commons/, route/,
+                        package.json stays in root; index.js, commons/, routes/,
                         middleware/, and migrations/ go inside the output folder.
   --rateLimiting        Enable rate limiting (express-rate-limit)
   --helmet              Enable Helmet security headers