db-model-router 1.0.8 → 1.0.10

package/src/cli/diff-engine.js

@@ -5,6 +5,7 @@ const path = require("path");
 const { generateModelFile } = require("./generate-model.js");
 const {
   generateRouteFile,
+  generateParentRouteFile,
   generateChildRouteFile,
   generateRoutesIndexFile,
   generateTestFile,
@@ -55,8 +56,11 @@ function buildExpectedFiles(meta, relationships) {
 
   // Collect child tables
   const nestedChildren = new Set();
+  const childrenByParent = {};
   for (const rel of relationships) {
     nestedChildren.add(rel.child);
+    if (!childrenByParent[rel.parent]) childrenByParent[rel.parent] = [];
+    childrenByParent[rel.parent].push(rel);
   }
 
   // Model files
@@ -67,16 +71,24 @@ function buildExpectedFiles(meta, relationships) {
   // 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),
-    );
+    const children = childrenByParent[m.table] || [];
+    if (children.length > 0) {
+      expected.set(
+        `routes/${m.table}/index.js`,
+        generateParentRouteFile(m.table, children),
+      );
+    } else {
+      expected.set(
+        `routes/${m.table}/index.js`,
+        generateRouteFile(m.table, modelsRelPath),
+      );
+    }
   }
 
-  // Child route files in subfolders: routes/<parent>/<child>.js
+  // Child route files inside parent folders: routes/<parent>/<child>/index.js
   for (const rel of relationships) {
     expected.set(
-      `routes/${rel.parent}/${rel.child}.js`,
+      `routes/${rel.parent}/${rel.child}/index.js`,
       generateChildRouteFile(
         rel.child,
         rel.parent,
@@ -100,7 +112,7 @@ function buildExpectedFiles(meta, relationships) {
     if (nestedChildren.has(m.table)) continue;
     expected.set(
       `test/${m.table}.test.js`,
-      generateTestFile(m.table, m.primary_key),
+      generateTestFile(m.table, m.primary_key, m.structure),
     );
   }
 

package/src/cli/generate-migration.js

@@ -11,17 +11,83 @@
 // Column type mapping per adapter
 // ---------------------------------------------------------------------------
 
+/**
+ * Known base types — anything not in this set is treated as a validator.
+ */
+const BASE_TYPES = new Set([
+  "auto_increment",
+  "string",
+  "integer",
+  "numeric",
+  "boolean",
+  "datetime",
+  "object",
+]);
+
+/**
+ * Parse a dbmr column rule string into its components.
+ *
+ * Format: [required|]<type>[:<subtype>][|<validator>...]
+ *
+ * @param {string} rule - e.g. "required|string:text|minLength:10|maxLength:5000"
+ * @returns {{ isRequired: boolean, baseType: string, subType: string|null, validators: string[] }}
+ */
+function parseColumnRule(rule) {
+  const parts = rule.split("|");
+  const isRequired = parts.includes("required");
+
+  let baseType = "string";
+  let subType = null;
+  const validators = [];
+
+  for (const part of parts) {
+    if (part === "required") continue;
+
+    // Check if this part is a base type (possibly with :subtype)
+    const colonIdx = part.indexOf(":");
+    const token = colonIdx > -1 ? part.slice(0, colonIdx) : part;
+
+    if (!baseType || baseType === "string") {
+      if (BASE_TYPES.has(token)) {
+        baseType = token;
+        subType = colonIdx > -1 ? part.slice(colonIdx + 1) : null;
+        continue;
+      }
+    }
+
+    // If we already found the base type, or this isn't a known type, it's a validator
+    if (BASE_TYPES.has(token) && baseType === "string" && token !== "string") {
+      baseType = token;
+      subType = colonIdx > -1 ? part.slice(colonIdx + 1) : null;
+    } else if (BASE_TYPES.has(part)) {
+      // Bare base type without colon, and we haven't set one yet
+      if (baseType === "string" && part !== "string") {
+        baseType = part;
+      } else if (baseType === "string" && part === "string") {
+        // already default, skip
+      } else {
+        validators.push(part);
+      }
+    } else if (BASE_TYPES.has(token)) {
+      baseType = token;
+      subType = colonIdx > -1 ? part.slice(colonIdx + 1) : null;
+    } else {
+      validators.push(part);
+    }
+  }
+
+  return { isRequired, baseType, subType, validators };
+}
+
 /**
  * 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} rule - e.g. "required|string:text|minLength:10", "auto_increment", "integer:bigint"
  * @param {string} adapter - e.g. "postgres", "mysql", "sqlite3"
- * @returns {{ sqlType: string, nullable: boolean, isAutoIncrement: boolean }}
+ * @returns {{ sqlType: string, nullable: boolean, isAutoIncrement: boolean, validators: string[] }}
  */
 function mapColumnType(rule, adapter) {
-  const parts = rule.split("|");
-  const isRequired = parts.includes("required");
-  const baseType = parts.filter((p) => p !== "required")[0] || "string";
+  const { isRequired, baseType, subType, validators } = parseColumnRule(rule);
 
   let sqlType;
   let isAutoIncrement = false;
@@ -32,13 +98,13 @@ function mapColumnType(rule, adapter) {
       sqlType = autoIncrementType(adapter);
       break;
     case "string":
-      sqlType = stringType(adapter);
+      sqlType = stringType(adapter, subType);
       break;
     case "integer":
-      sqlType = integerType(adapter);
+      sqlType = integerType(adapter, subType);
       break;
     case "numeric":
-      sqlType = numericType(adapter);
+      sqlType = numericType(adapter, subType);
       break;
     case "boolean":
       sqlType = booleanType(adapter);
@@ -50,13 +116,14 @@ function mapColumnType(rule, adapter) {
       sqlType = jsonType(adapter);
       break;
     default:
-      sqlType = stringType(adapter);
+      sqlType = stringType(adapter, subType);
   }
 
   return {
     sqlType,
     nullable: !isRequired && !isAutoIncrement,
     isAutoIncrement,
+    validators,
   };
 }
 
@@ -77,20 +144,140 @@ function autoIncrementType(adapter) {
   }
 }
 
-function stringType(adapter) {
-  if (adapter === "oracle") return "VARCHAR2(255)";
-  return "VARCHAR(255)";
+function stringType(adapter, subType) {
+  if (!subType) {
+    if (adapter === "oracle") return "VARCHAR2(255)";
+    if (adapter === "mssql") return "NVARCHAR(255)";
+    return "VARCHAR(255)";
+  }
+
+  // varchar(N) or char(N) with explicit length
+  const varcharMatch = subType.match(/^varchar\((\d+)\)$/i);
+  if (varcharMatch) {
+    const n = varcharMatch[1];
+    if (adapter === "oracle") return `VARCHAR2(${n})`;
+    if (adapter === "mssql") return `NVARCHAR(${n})`;
+    return `VARCHAR(${n})`;
+  }
+
+  const charMatch = subType.match(/^char\((\d+)\)$/i);
+  if (charMatch) {
+    const n = charMatch[1];
+    if (adapter === "oracle") return `CHAR(${n})`;
+    if (adapter === "mssql") return `NCHAR(${n})`;
+    if (adapter === "sqlite3") return "TEXT";
+    return `CHAR(${n})`;
+  }
+
+  switch (subType.toLowerCase()) {
+    case "text":
+      if (adapter === "oracle") return "CLOB";
+      if (adapter === "mssql") return "NVARCHAR(MAX)";
+      return "TEXT";
+    case "mediumtext":
+      if (adapter === "mysql" || adapter === "mariadb") return "MEDIUMTEXT";
+      if (adapter === "oracle") return "CLOB";
+      if (adapter === "mssql") return "NVARCHAR(MAX)";
+      return "TEXT";
+    case "longtext":
+      if (adapter === "mysql" || adapter === "mariadb") return "LONGTEXT";
+      if (adapter === "oracle") return "CLOB";
+      if (adapter === "mssql") return "NVARCHAR(MAX)";
+      return "TEXT";
+    case "char":
+      if (adapter === "oracle") return "CHAR(255)";
+      if (adapter === "mssql") return "NCHAR(255)";
+      if (adapter === "sqlite3") return "TEXT";
+      return "CHAR(255)";
+    case "uuid":
+      if (adapter === "postgres" || adapter === "cockroachdb") return "UUID";
+      if (adapter === "mssql") return "UNIQUEIDENTIFIER";
+      if (adapter === "oracle") return "CHAR(36)";
+      return "CHAR(36)";
+    default:
+      if (adapter === "oracle") return "VARCHAR2(255)";
+      if (adapter === "mssql") return "NVARCHAR(255)";
+      return "VARCHAR(255)";
+  }
 }
 
-function integerType(adapter) {
-  if (adapter === "oracle") return "NUMBER(10)";
-  return "INTEGER";
+function integerType(adapter, subType) {
+  if (!subType) {
+    if (adapter === "oracle") return "NUMBER(10)";
+    return "INTEGER";
+  }
+
+  switch (subType.toLowerCase()) {
+    case "tinyint":
+      if (adapter === "oracle") return "NUMBER(3)";
+      if (adapter === "mssql") return "TINYINT";
+      if (adapter === "postgres" || adapter === "cockroachdb")
+        return "SMALLINT";
+      if (adapter === "sqlite3") return "INTEGER";
+      return "TINYINT";
+    case "smallint":
+      if (adapter === "oracle") return "NUMBER(5)";
+      if (adapter === "sqlite3") return "INTEGER";
+      return "SMALLINT";
+    case "bigint":
+      if (adapter === "oracle") return "NUMBER(19)";
+      if (adapter === "sqlite3") return "INTEGER";
+      return "BIGINT";
+    case "unsigned":
+      if (adapter === "mysql" || adapter === "mariadb") return "INT UNSIGNED";
+      if (adapter === "oracle") return "NUMBER(10)";
+      // PostgreSQL, SQLite, MSSQL don't support UNSIGNED — use plain INT
+      return "INTEGER";
+    case "bigint_unsigned":
+      if (adapter === "mysql" || adapter === "mariadb")
+        return "BIGINT UNSIGNED";
+      if (adapter === "oracle") return "NUMBER(19)";
+      if (adapter === "sqlite3") return "INTEGER";
+      return "BIGINT";
+    default:
+      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 numericType(adapter, subType) {
+  if (!subType) {
+    if (adapter === "oracle") return "NUMBER(12,2)";
+    if (adapter === "mssql") return "DECIMAL(12,2)";
+    return "DECIMAL(12,2)";
+  }
+
+  // decimal(P,S) with explicit precision/scale
+  const decimalMatch = subType.match(/^decimal\((\d+),(\d+)\)$/i);
+  if (decimalMatch) {
+    const p = decimalMatch[1];
+    const s = decimalMatch[2];
+    if (adapter === "oracle") return `NUMBER(${p},${s})`;
+    return `DECIMAL(${p},${s})`;
+  }
+
+  switch (subType.toLowerCase()) {
+    case "float":
+      if (adapter === "oracle") return "FLOAT";
+      if (adapter === "postgres" || adapter === "cockroachdb") return "REAL";
+      if (adapter === "sqlite3") return "REAL";
+      return "FLOAT";
+    case "double":
+      if (adapter === "oracle") return "BINARY_DOUBLE";
+      if (adapter === "postgres" || adapter === "cockroachdb")
+        return "DOUBLE PRECISION";
+      if (adapter === "sqlite3") return "REAL";
+      if (adapter === "mssql") return "FLOAT";
+      return "DOUBLE";
+    case "money":
+      if (adapter === "postgres" || adapter === "cockroachdb") return "MONEY";
+      if (adapter === "mssql") return "MONEY";
+      if (adapter === "oracle") return "NUMBER(19,4)";
+      return "DECIMAL(19,4)";
+    default:
+      if (adapter === "oracle") return "NUMBER(12,2)";
+      return "DECIMAL(12,2)";
+  }
 }
 
 function booleanType(adapter) {
@@ -353,4 +540,5 @@ module.exports = {
   generateMigrationFiles,
   generateCreateTableSQL,
   mapColumnType,
+  parseColumnRule,
 };

package/src/cli/generate-route.js

@@ -166,15 +166,19 @@ function generateSimpleRoutesIndexFile(tableNames) {
  * Generate a test file for a route covering all CRUD methods.
  * Uses supertest + the app's express setup.
  */
-function generateTestFile(tableName, pk) {
+function generateTestFile(tableName, pk, structure) {
   const varName = safeVarName(tableName);
+  const fakerFields = generateFakerFields(structure || {});
+  const fakerImport = `import { faker } from "@faker-js/faker";`;
+
   return `import assert from "assert";
 import express from "express";
 import request from "supertest";
 import "dotenv/config";
-import "#commons/db.js";
+import "../commons/db.js";
 import dbModelRouter from "db-model-router";
-import { ${varName} } from "#models";
+import { ${varName} } from "../models/index.js";
+${fakerImport}
 
 const { route } = dbModelRouter;
 
@@ -185,92 +189,186 @@ function createApp() {
   return app;
 }
 
+${fakerFields.helperFn}
+
 describe("${tableName} routes", function () {
   let app;
+  let createdId;
 
   before(function () {
     app = createApp();
   });
 
-  describe("GET /${tableName}/", function () {
-    it("should list records", async function () {
+  describe("CRUD lifecycle", function () {
+    it("POST /${tableName}/add — should insert a record", async function () {
+      const data = generateFakeData();
+      const res = await request(app)
+        .post("/${tableName}/add")
+        .send(data);
+      assert.strictEqual(res.status, 200, \`Expected 200, got \${res.status}: \${JSON.stringify(res.body)}\`);
+      createdId = res.body.${pk} || res.body.id;
+      assert.ok(createdId, "Response should contain the created record ID");
+    });
+
+    it("GET /${tableName}/ — should list records including created one", async function () {
       const res = await request(app).get("/${tableName}/");
       assert.strictEqual(res.status, 200);
       assert.ok(Array.isArray(res.body.data));
+      assert.ok(res.body.data.length > 0, "Should have at least one record");
     });
-  });
 
-  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, 422, 500].includes(res.status));
+    it("GET /${tableName}/:${pk} — should get the created record", async function () {
+      const res = await request(app).get(\`/${tableName}/\${createdId}\`);
+      assert.strictEqual(res.status, 200, \`Expected 200, got \${res.status}\`);
+      assert.strictEqual(String(res.body.${pk} || res.body.id), String(createdId));
     });
-  });
 
-  describe("POST /${tableName}/", function () {
-    it("should bulk insert records", async function () {
+    it("PUT /${tableName}/:${pk} — should update the record", async function () {
+      const data = { ...generateFakeData(), ${pk}: createdId };
       const res = await request(app)
-        .post("/${tableName}/")
-        .send({ data: [] });
-      assert.ok([200, 201, 400, 422, 500].includes(res.status));
+        .put(\`/${tableName}/\${createdId}\`)
+        .send(data);
+      assert.strictEqual(res.status, 200, \`Expected 200, got \${res.status}: \${JSON.stringify(res.body)}\`);
     });
-  });
 
-  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 () {
+    it("PATCH /${tableName}/:${pk} — should partially update the record", async function () {
       const res = await request(app)
-        .put("/${tableName}/1")
-        .send({});
-      assert.ok([200, 400, 404].includes(res.status));
+        .patch(\`/${tableName}/\${createdId}\`)
+        .send(${fakerFields.patchPayload});
+      assert.strictEqual(res.status, 200, \`Expected 200, got \${res.status}: \${JSON.stringify(res.body)}\`);
     });
-  });
 
-  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));
+    it("DELETE /${tableName}/:${pk} — should delete the record", async function () {
+      const res = await request(app).delete(\`/${tableName}/\${createdId}\`);
+      assert.ok([200, 204].includes(res.status), \`Expected 200/204, got \${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));
+    it("GET /${tableName}/:${pk} — should return 404 after deletion", async function () {
+      const res = await request(app).get(\`/${tableName}/\${createdId}\`);
+      assert.strictEqual(res.status, 404);
     });
   });
 
-  describe("PUT /${tableName}/", function () {
-    it("should bulk update records", async function () {
+  describe("Bulk operations", function () {
+    it("POST /${tableName}/ — should bulk insert records", async function () {
+      const data = [generateFakeData(), generateFakeData()];
       const res = await request(app)
-        .put("/${tableName}/")
-        .send({ data: [] });
-      assert.ok([200, 400, 422, 500].includes(res.status));
+        .post("/${tableName}/")
+        .send({ data });
+      assert.strictEqual(res.status, 200, \`Expected 200, got \${res.status}: \${JSON.stringify(res.body)}\`);
     });
   });
 
-  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));
+  describe("Error handling", function () {
+    it("GET /${tableName}/:${pk} — should return 404 for non-existent ID", async function () {
+      const res = await request(app).get("/${tableName}/999999");
+      assert.strictEqual(res.status, 404);
     });
   });
 });
 `;
 }
 
+/**
+ * Generate a faker helper function string and patch payload based on model structure.
+ *
+ * @param {object} structure - Model structure { colName: "rule" }
+ * @returns {{ helperFn: string, patchPayload: string }}
+ */
+function generateFakerFields(structure) {
+  const lines = [];
+  let firstStringCol = null;
+
+  for (const [col, rule] of Object.entries(structure)) {
+    const fakerCall = columnToFaker(col, rule);
+    lines.push(`    ${col}: ${fakerCall},`);
+    if (!firstStringCol && rule.includes("string")) {
+      firstStringCol = col;
+    }
+  }
+
+  const helperFn = `function generateFakeData() {
+  return {
+${lines.join("\n")}
+  };
+}`;
+
+  const patchPayload = firstStringCol
+    ? `{ ${firstStringCol}: faker.lorem.word() }`
+    : `{ ${Object.keys(structure)[0] || "name"}: faker.lorem.word() }`;
+
+  return { helperFn, patchPayload };
+}
+
+/**
+ * Map a column name + rule to an appropriate faker call.
+ */
+function columnToFaker(col, rule) {
+  const lowerCol = col.toLowerCase();
+
+  // Name-based heuristics first
+  if (lowerCol === "email") return "faker.internet.email()";
+  if (lowerCol === "phone") return "faker.phone.number()";
+  if (lowerCol === "name" || lowerCol.endsWith("_name"))
+    return "faker.person.fullName()";
+  if (lowerCol === "url" || lowerCol.endsWith("_url"))
+    return "faker.internet.url()";
+  if (lowerCol === "slug") return "faker.helpers.slugify(faker.lorem.words(2))";
+  if (lowerCol === "password" || lowerCol === "password_hash")
+    return "faker.internet.password()";
+  if (lowerCol === "secret" || lowerCol === "key" || lowerCol === "token")
+    return "faker.string.alphanumeric(32)";
+  if (lowerCol === "title") return "faker.lorem.sentence()";
+  if (
+    lowerCol === "description" ||
+    lowerCol === "body" ||
+    lowerCol === "content"
+  )
+    return "faker.lorem.paragraph()";
+  if (lowerCol === "status")
+    return "faker.helpers.arrayElement(['active', 'inactive', 'pending'])";
+  if (lowerCol === "event_type")
+    return "faker.helpers.arrayElement(['user.created', 'order.placed', 'payment.received'])";
+  if (lowerCol === "currency") return "faker.finance.currencyCode()";
+  if (
+    lowerCol.includes("amount") ||
+    lowerCol.includes("price") ||
+    lowerCol.includes("total") ||
+    lowerCol.includes("subtotal")
+  )
+    return "parseFloat(faker.finance.amount())";
+  if (lowerCol.includes("quantity") || lowerCol.includes("count"))
+    return "faker.number.int({ min: 1, max: 100 })";
+  if (lowerCol === "unique_attribute") return "faker.string.uuid()";
+  if (lowerCol === "attributes") return "{ custom: faker.lorem.word() }";
+  if (lowerCol === "permission")
+    return "{ module: 'users', action: 'read', scope: 'tenant' }";
+  if (lowerCol === "response_body") return "faker.lorem.sentence()";
+  if (lowerCol === "response_status_code")
+    return "faker.helpers.arrayElement([200, 201, 400, 500])";
+
+  // Type-based fallback
+  const parts = rule.split("|");
+  const baseType = parts.filter((p) => p !== "required")[0] || "string";
+
+  switch (baseType) {
+    case "integer":
+      if (lowerCol.endsWith("_id"))
+        return "faker.number.int({ min: 1, max: 100 })";
+      return "faker.number.int({ min: 1, max: 1000 })";
+    case "numeric":
+      return "parseFloat(faker.finance.amount())";
+    case "boolean":
+      return "faker.datatype.boolean()";
+    case "object":
+      return "{ key: faker.lorem.word() }";
+    case "datetime":
+      return "faker.date.recent().toISOString()";
+    default:
+      return "faker.lorem.word()";
+  }
+}
+
 /**
  * Generate a child route test file that tests the nested parent/:fk/child endpoints.
  */

package/src/cli/init/dependencies.js

@@ -62,6 +62,10 @@ function collectDependencies(answers) {
 
   // Dev dependencies
   devDependencies["nodemon"] = "latest";
+  devDependencies["mocha"] = "latest";
+  devDependencies["supertest"] = "latest";
+  devDependencies["dotenv-cli"] = "latest";
+  devDependencies["@faker-js/faker"] = "latest";
 
   // Swagger UI for API documentation
   dependencies["swagger-ui-express"] = "latest";

package/src/cli/saas/generate-saas-routes.js

@@ -370,19 +370,16 @@ function generateRoutesIndex(tableNames, relationships, options) {
   code += `import saasPermissionsRoute from "#routes/roles/permissions/index.js";\n\n`;
 
   // --- dbmr schema-generated route imports (folder-based, skip SaaS-owned tables) ---
+  // Child routes are mounted inside their parent's index.js, not here
   const dbmrTables = tableNames.filter(
     (t) => !saasRouteModules.has(t) && !nestedChildren.has(t),
   );
-  if (dbmrTables.length > 0 || relationships.length > 0) {
+  if (dbmrTables.length > 0) {
     code += `// Schema-generated routes\n`;
   }
   for (const table of dbmrTables) {
     code += `import ${safeVarName(table)}Route from "#routes/${table}/index.js";\n`;
   }
-  for (const rel of relationships) {
-    if (saasRouteModules.has(rel.child)) continue;
-    code += `import ${safeVarName(rel.child)}ChildRoute from "#routes/${rel.parent}/${rel.child}/index.js";\n`;
-  }
 
   if (options.includeDocs) {
     code += `import docsRoute from "#routes/docs.js";\n`;
@@ -403,14 +400,7 @@ function generateRoutesIndex(tableNames, relationships, options) {
     code += `router.use("/docs", docsRoute);\n`;
   }
 
-  // --- Mount dbmr child routes before parent routes ---
-  for (const rel of relationships) {
-    if (saasRouteModules.has(rel.child)) continue;
-    const childVar = safeVarName(rel.child);
-    code += `router.use("/${rel.parent}/:${rel.foreignKey}/${rel.child}", ${childVar}ChildRoute);\n`;
-  }
-
-  // --- Mount dbmr top-level routes ---
+  // --- Mount dbmr top-level routes (children are inside parent's index.js) ---
   if (dbmrTables.length > 0) {
     code += `\n// Schema-generated routes\n`;
   }