db-model-router 1.0.6 → 1.0.7

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

@@ -0,0 +1,122 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const { generateSaasMigrations } = require("./saas/generate-saas-migrations");
+const { generateSaasModels } = require("./saas/generate-saas-models");
+const {
+  generateAuthenticateMiddleware,
+  generateTenantIsolationMiddleware,
+  generateHasPermissionMiddleware,
+} = require("./saas/generate-saas-middleware");
+const {
+  generateCrudRoutes,
+  generateAuthRoutes,
+  generateRoutesIndex,
+} = require("./saas/generate-saas-routes");
+const { generateSaasSeeds } = require("./saas/generate-saas-seeds");
+const {
+  generatePasswordUtil,
+  generateModulesUtil,
+  generateWebhookUtil,
+} = require("./saas/generate-saas-utils");
+
+/**
+ * Read the existing .gitignore file and append `credentials.md` if not already present.
+ * Returns the full .gitignore content to be written.
+ *
+ * @returns {string} Updated .gitignore content
+ */
+function getGitignoreContent() {
+  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  let content = "";
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, "utf8");
+  }
+  if (!content.includes("credentials.md")) {
+    content = content.trimEnd() + "\ncredentials.md\n";
+  }
+  return content;
+}
+
+/**
+ * Main SaaS structure generator orchestrator.
+ *
+ * Calls all sub-generators and aggregates their output into a single
+ * planned[] array of { relPath, content } objects compatible with the
+ * existing generate command's file write loop.
+ *
+ * @param {string} adapter - Database adapter name (e.g. "postgres", "mysql", "sqlite3")
+ * @param {object} [options] - Generation options
+ * @param {boolean} [options.dryRun] - If true, files will not be written (handled by caller)
+ * @param {boolean} [options.json] - If true, output JSON format (handled by caller)
+ * @param {Date|number} [options.timestamp] - Base timestamp for migration files
+ * @param {string[]} [options.tableNames] - Schema-generated table names for routes index
+ * @param {Array<{parent, child, foreignKey}>} [options.relationships] - Schema relationships for routes index
+ * @param {{ includeDocs?: boolean }} [options.routeOptions] - Options for routes index generation
+ * @returns {Array<{ relPath: string, content: string }>} Combined planned file array
+ */
+function generateSaasStructure(adapter, options) {
+  const opts = options || {};
+  const planned = [];
+
+  // 1. Migrations
+  const timestamp = opts.timestamp || new Date();
+  const migrations = generateSaasMigrations(adapter, timestamp);
+  for (const entry of migrations) {
+    planned.push(entry);
+  }
+
+  // 2. Models (includes models/index.js barrel with both SaaS + dbmr tables)
+  const models = generateSaasModels(adapter, opts.tableNames || []);
+  for (const entry of models) {
+    planned.push(entry);
+  }
+
+  // 3. Middleware
+  planned.push(generateAuthenticateMiddleware());
+  planned.push(generateTenantIsolationMiddleware());
+  planned.push(generateHasPermissionMiddleware());
+
+  // 4. Routes (CRUD + auth + combined index with dbmr routes)
+  const crudRoutes = generateCrudRoutes();
+  for (const entry of crudRoutes) {
+    planned.push(entry);
+  }
+  planned.push(generateAuthRoutes());
+  planned.push(
+    generateRoutesIndex(
+      opts.tableNames || [],
+      opts.relationships || [],
+      opts.routeOptions || {},
+    ),
+  );
+
+  // 5. Seeds
+  const seeds = generateSaasSeeds(adapter);
+  for (const entry of seeds) {
+    planned.push(entry);
+  }
+
+  // 6. Utilities
+  planned.push({
+    relPath: "commons/password.js",
+    content: generatePasswordUtil(),
+  });
+  planned.push({
+    relPath: "commons/modules.js",
+    content: generateModulesUtil(),
+  });
+  planned.push({
+    relPath: "commons/webhook.js",
+    content: generateWebhookUtil(),
+  });
+
+  // 7. .gitignore update (add credentials.md)
+  planned.push({ relPath: ".gitignore", content: getGitignoreContent() });
+
+  return planned;
+}
+
+module.exports = { generateSaasStructure, getGitignoreContent };

package/src/cli/init/generators.js

@@ -169,6 +169,7 @@ function buildEnvContent(answers, mode, secrets) {
   const lines = [];
   lines.push("# Server");
   lines.push("PORT=3000");
+  lines.push("API_BASE_PATH=/api");
   lines.push("");
   lines.push("# Database");
 
@@ -411,6 +412,10 @@ app.use(express.urlencoded({ extended: true }));
 ${helmetBlock ? helmetBlock + "\n" : ""}${rateLimitBlock ? rateLimitBlock + "\n" : ""}${sessionBlock(answers)}
 app.use(logger);
 
+// Routes
+import routes from "#routes/index.js";
+app.use(process.env.API_BASE_PATH || "/api", routes);
+
 // Health check
 app.get("/health", (req, res) => {
   res.json({ status: "ok", timestamp: new Date().toISOString() });
@@ -1732,6 +1737,7 @@ import applySecurity from "${commonsPrefix}/security.js";
 import logger from "${middlewarePrefix}/logger.js";
 import route from "${routePrefix}/index.js";
 import { fileURLToPath } from 'node:url';
+import path from "path";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const app = express();
 const PORT = process.env.PORT || 3000;

package/src/cli/init.js

@@ -254,6 +254,14 @@ function updatePackageJson(answers, outputDir) {
   const scripts = getScripts(outputDir);
 
   pkg.type = "module";
+  pkg.imports = {
+    "#root/*.js": "./*.js",
+    "#models": "./models/index.js",
+    "#models/*.js": "./models/*.js",
+    "#routes/*.js": "./routes/*.js",
+    "#commons/*.js": "./commons/*.js",
+    "#middleware/*.js": "./middleware/*.js",
+  };
   pkg.scripts = Object.assign({}, pkg.scripts || {}, scripts);
   pkg.dependencies = Object.assign({}, pkg.dependencies || {}, dependencies);
   pkg.devDependencies = Object.assign(

package/src/cli/main.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 "use strict";
 
 const { parseFlags, OutputContext } = require("./flags");
@@ -9,6 +9,7 @@ const generateCmd = require("./commands/generate");
 const doctorCmd = require("./commands/doctor");
 const diffCmd = require("./commands/diff");
 const helpCmd = require("./commands/help");
+const dbManagerCmd = require("./commands/db-manager");
 
 /**
  * Map of subcommand names to their handler functions.
@@ -19,6 +20,7 @@ const COMMANDS = {
   generate: generateCmd,
   doctor: doctorCmd,
   diff: diffCmd,
+  "db-manager": dbManagerCmd,
   help: helpCmd,
 };
 
@@ -31,6 +33,7 @@ const COMMAND_DESCRIPTIONS = {
   generate: "Generate models, routes, tests, and OpenAPI spec from a schema",
   doctor: "Validate schema, check dependencies, and verify file sync",
   diff: "Preview changes between current files and what the schema would produce",
+  "db-manager": "Start a live database management UI",
   help: "Show help for a command",
 };
 
@@ -68,6 +71,10 @@ const COMMAND_FLAGS = {
   ],
   doctor: [["--from <path>", "Schema file (default: dbmr.schema.json)"]],
   diff: [["--from <path>", "Schema file (default: dbmr.schema.json)"]],
+  "db-manager": [
+    ["--env <path>", "Path to .env file (default: .env)"],
+    ["--port <number>", "Server port (default: 4000)"],
+  ],
 };
 
 /**

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

@@ -0,0 +1,108 @@
+"use strict";
+
+/**
+ * SaaS middleware generators.
+ *
+ * Each function returns a { relPath, content } object for a middleware file.
+ * Generated code uses ES6 module syntax (import/export).
+ */
+
+/**
+ * Generate the authenticate middleware file.
+ *
+ * @returns {{ relPath: string, content: string }}
+ */
+function generateAuthenticateMiddleware() {
+  const relPath = "middleware/authenticate.js";
+  const content = `/**
+ * Authentication middleware.
+ *
+ * Validates that the request has an active session with a user object.
+ * Responds with 401 Unauthorized if no valid session exists.
+ */
+function authenticate(req, res, next) {
+  if (!req.session || !req.session.user) {
+    return res.status(401).json({ message: "Unauthorized" });
+  }
+  next();
+}
+
+export default authenticate;
+`;
+  return { relPath, content };
+}
+
+/**
+ * Generate the tenant isolation middleware file.
+ *
+ * @returns {{ relPath: string, content: string }}
+ */
+function generateTenantIsolationMiddleware() {
+  const relPath = "middleware/tenantIsolation.js";
+  const content = `/**
+ * Tenant isolation middleware.
+ *
+ * Restricts data access to the user's own tenant unless the user
+ * has a global-scoped permission. Injects tenant_id into query
+ * and body parameters for non-global users.
+ */
+function tenantIsolation(req, res, next) {
+  const hasGlobal = req.session.permission.some((p) => p.scope === "global");
+  if (!hasGlobal) {
+    req.query.tenant_id = req.session.user.tenant_id;
+    req.body.tenant_id = req.session.user.tenant_id;
+  }
+  next();
+}
+
+export default tenantIsolation;
+`;
+  return { relPath, content };
+}
+
+/**
+ * Generate the hasPermission middleware file.
+ *
+ * @returns {{ relPath: string, content: string }}
+ */
+function generateHasPermissionMiddleware() {
+  const relPath = "middleware/hasPermission.js";
+  const content = `import { isValidModule } from "#commons/modules.js";
+
+/**
+ * Permission validation middleware factory.
+ *
+ * Returns a middleware function that checks whether the authenticated user
+ * has the required permission for the specified module and action.
+ * A permission entry with action "global" grants access to any action
+ * on that module.
+ *
+ * @param {string} module - The module name to check permission for
+ * @param {string} action - The required action
+ * @returns {function} Express middleware function
+ */
+function hasPermission(module, action) {
+  return (req, res, next) => {
+    if (!isValidModule(module)) {
+      return res.status(403).json({ message: "Invalid module" });
+    }
+    const match = req.session.permission.find(
+      (p) => p.module === module && (p.action === action || p.action === "global")
+    );
+    if (!match) {
+      return res.status(403).json({ message: "Forbidden" });
+    }
+    next();
+  };
+}
+
+export default hasPermission;
+`;
+  return { relPath, content };
+}
+
+module.exports = {
+  generateAuthenticateMiddleware,
+  generateTenantIsolationMiddleware,
+  generateHasPermissionMiddleware,
+};