db-model-router 1.0.4 → 1.0.6

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

@@ -544,7 +544,9 @@ function generateModelFile(m) {
     if (opt.modified_at) parts.push(`modified_at: "${opt.modified_at}"`);
     optionStr = `\n  { ${parts.join(", ")} },`;
   }
-  return `const { db, model } = require("db-model-router");
+  return `import dbModelRouter from "db-model-router";
+
+const { db, model } = dbModelRouter;
 
 const ${varName} = model(
   db,
@@ -554,7 +556,7 @@ const ${varName} = model(
   ${uniqueStr},${optionStr}
 );
 
-module.exports = ${varName};
+export default ${varName};
 `;
 }
 
@@ -563,11 +565,14 @@ function generateIndexFile(models) {
   let exports = "";
   for (const m of models) {
     const varName = safeVarName(m.table);
-    imports += `const ${varName} = require("./${m.table}");\n`;
+    imports += `import ${varName} from "./${m.table}.js";\n`;
     exports += `  ${varName},\n`;
   }
   return `${imports}
-module.exports = {
+export {
+${exports}};
+
+export default {
 ${exports}};
 `;
 }

package/src/cli/generate-openapi.js

@@ -5,6 +5,13 @@ function generateOpenAPISpec(models, options = {}) {
   const basePath = options.basePath || "/api";
   const title = options.title || "REST Router API";
   const version = options.version || "1.0.0";
+  const relationships = options.relationships || [];
+
+  // Build a lookup: child table -> { parent, foreignKey }
+  const childMap = {};
+  for (const rel of relationships) {
+    childMap[rel.child] = { parent: rel.parent, foreignKey: rel.foreignKey };
+  }
 
   const spec = {
     openapi: "3.0.3",
@@ -39,14 +46,34 @@ function generateOpenAPISpec(models, options = {}) {
     };
 
     const ref = { $ref: `#/components/schemas/${schemaName}` };
-    const prefix = `${basePath}/${m.table}`;
+
+    // Determine path prefix: nested under parent if this is a child table
+    let prefix;
+    const isChild = !!childMap[m.table];
+    let fkParam = null;
+    if (isChild) {
+      const { parent, foreignKey } = childMap[m.table];
+      prefix = `${basePath}/${parent}/{${foreignKey}}/${m.table}`;
+      fkParam = {
+        name: foreignKey,
+        in: "path",
+        required: true,
+        schema: { type: "string" },
+        description: `${capitalize(parent)} foreign key`,
+      };
+    } else {
+      prefix = `${basePath}/${m.table}`;
+    }
+
+    // Helper: prepend FK path param for child routes
+    const withFk = (params) => (fkParam ? [fkParam, ...params] : params);
 
     // GET / — list
     spec.paths[`${prefix}/`] = {
       get: {
         tags: [tag],
         summary: `List ${m.table}`,
-        parameters: [
+        parameters: withFk([
           {
             name: "page",
             in: "query",
@@ -69,7 +96,7 @@ function generateOpenAPISpec(models, options = {}) {
             in: "query",
             schema: { type: "string", enum: ["json", "csv", "xml"] },
           },
-        ],
+        ]),
         responses: {
           200: {
             description: "Success",
@@ -141,7 +168,7 @@ function generateOpenAPISpec(models, options = {}) {
       get: {
         tags: [tag],
         summary: `Get ${m.table} by ${pk}`,
-        parameters: [
+        parameters: withFk([
           { name: pk, in: "path", required: true, schema: { type: "string" } },
           { name: "select_columns", in: "query", schema: { type: "string" } },
           {
@@ -149,7 +176,7 @@ function generateOpenAPISpec(models, options = {}) {
             in: "query",
             schema: { type: "string", enum: ["json", "csv", "xml"] },
           },
-        ],
+        ]),
         responses: {
           200: {
             description: "Success",
@@ -161,9 +188,9 @@ function generateOpenAPISpec(models, options = {}) {
       post: {
         tags: [tag],
         summary: `Insert a ${m.table}`,
-        parameters: [
+        parameters: withFk([
           { name: pk, in: "path", required: true, schema: { type: "string" } },
-        ],
+        ]),
         requestBody: { content: { "application/json": { schema: ref } } },
         responses: {
           200: {
@@ -175,9 +202,9 @@ function generateOpenAPISpec(models, options = {}) {
       put: {
         tags: [tag],
         summary: `Update a ${m.table}`,
-        parameters: [
+        parameters: withFk([
           { name: pk, in: "path", required: true, schema: { type: "string" } },
-        ],
+        ]),
         requestBody: { content: { "application/json": { schema: ref } } },
         responses: {
           200: {
@@ -190,9 +217,9 @@ function generateOpenAPISpec(models, options = {}) {
       patch: {
         tags: [tag],
         summary: `Partial update a ${m.table}`,
-        parameters: [
+        parameters: withFk([
           { name: pk, in: "path", required: true, schema: { type: "string" } },
-        ],
+        ]),
         requestBody: {
           content: { "application/json": { schema: { type: "object" } } },
         },
@@ -207,9 +234,9 @@ function generateOpenAPISpec(models, options = {}) {
       delete: {
         tags: [tag],
         summary: `Delete a ${m.table}`,
-        parameters: [
+        parameters: withFk([
           { name: pk, in: "path", required: true, schema: { type: "string" } },
-        ],
+        ]),
         responses: {
           200: { description: "Deleted" },
           404: { description: "Not Found" },