db-model-router 1.0.7 → 1.0.9

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

@@ -40,7 +40,7 @@ export default router;
 
 /**
  * Generate a parent route file that includes its own CRUD and mounts child routes.
- * e.g., routes/orders/index.js mounts order_items under /:order_id/items
+ * e.g., routes/users.js mounts posts under /:user_id/posts
  *
  * @param {string} tableName - Parent table name
  * @param {Array<{child, foreignKey}>} children - Child relationships for this parent
@@ -56,7 +56,7 @@ import { ${varName} } from "#models";
   // Import child routes
   for (const child of children) {
     const childVar = safeVarName(child.child);
-    code += `import ${childVar}Route from "./${child.child}/index.js";\n`;
+    code += `import ${childVar}Route from "./${tableName}/${child.child}.js";\n`;
   }
 
   code += `
@@ -129,7 +129,7 @@ function generateRoutesIndexFile(tableNames, relationships = [], options = {}) {
   for (const table of tableNames) {
     if (nestedChildren.has(table)) continue;
     const varName = safeVarName(table);
-    imports += `import ${varName}Route from "./${table}/index.js";\n`;
+    imports += `import ${varName}Route from "./${table}.js";\n`;
   }
 
   // Import docs route if openapi is generated
@@ -166,18 +166,22 @@ 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 dbModelRouter from "db-model-router";
+import { ${varName} } from "../models/index.js";
+${fakerImport}
 
 const { route } = dbModelRouter;
 
-// Adjust the path to your model file as needed
-import ${varName} from "../models/${tableName}.js";
-
 function createApp() {
   const app = express();
   app.use(express.json());
@@ -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].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].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].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/generate-saas-structure.js

@@ -21,6 +21,7 @@ const {
   generateModulesUtil,
   generateWebhookUtil,
 } = require("./saas/generate-saas-utils");
+const { generateSaasTests } = require("./saas/generate-saas-tests");
 
 /**
  * Read the existing .gitignore file and append `credentials.md` if not already present.
@@ -113,7 +114,13 @@ function generateSaasStructure(adapter, options) {
     content: generateWebhookUtil(),
   });
 
-  // 7. .gitignore update (add credentials.md)
+  // 7. Tests
+  const tests = generateSaasTests();
+  for (const entry of tests) {
+    planned.push(entry);
+  }
+
+  // 8. .gitignore update (add credentials.md)
   planned.push({ relPath: ".gitignore", content: getGitignoreContent() });
 
   return planned;

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";
@@ -79,7 +83,7 @@ function getScripts(outputDir) {
   return {
     start: "node app.js",
     dev: "nodemon app.js",
-    test: 'echo "Error: no test specified" && exit 1',
+    test: "dotenv -- mocha --exit",
     migrate: `node ${prefix}commons/migrate.js`,
     add_migration: `node ${prefix}commons/add_migration.js`,
     "docker:build": "docker build -t app .",