db-model-router 1.0.17 → 1.0.19

package/src/cli/commands/help.js

@@ -5,25 +5,33 @@
  * Each key matches a subcommand name from main.js.
  */
 const COMMAND_HELP = {
-  init: `Usage: db-model-router init [options]
+  init: `Usage: db-model-router init [schemaPath] [options]
 
-Scaffold a new project from a schema file or interactively.
-Creates app.js, .env, commons/, routes/, middleware/, and migrations/.
+First-buildout ONLY. Scaffolds a complete project (app.js, commons/, routes/,
+middleware/, migrations/, models/, tests, OpenAPI spec, and optional SaaS
+structure) from a single dbmr.schema.json file.
+
+ALL project configuration lives in the schema's "options" block. There are no
+config flags on this command — set everything in dbmr.schema.json:
+
+  options:
+    output          Relative/absolute dir for source files (null = cwd root)
+    saasStructure   boolean (default: true) — generate multi-tenant SaaS scaffold
+    apiBasePath     string starting with "/" (default: "/api")
+    port            positive integer (default: 3000)
+    session         "memory" | "redis" | "database" (default: "memory")
+    rateLimiting    boolean (default: true)
+    helmet          boolean (default: true)
+    logger          boolean (default: true)
+    loki            boolean (default: false)
+
+refuses to run if a project already exists in cwd (app.js or package.json
+present). init is NOT for adding new tables, models, or routes — see below.
+
+Arguments:
+  schemaPath             Path to schema file (default: ./dbmr.schema.json)
 
 Options:
-  --from <path>          Read adapter, framework, and options from a schema file
-  --framework <name>     Express framework: express, ultimate-express
-  --database <name>      Database adapter: mysql, mariadb, postgres, sqlite3, mongodb,
-                         mssql, cockroachdb, oracle, redis, dynamodb
-  --db <name>            Alias for --database
-  --session <type>       Session store: memory, redis, database
-  --output <dir>         Directory for backend source files (relative to cwd).
-                         package.json and app.js stay in root; commons/, routes/,
-                         middleware/, and migrations/ go inside this folder.
-  --rateLimiting         Enable rate limiting (default: yes)
-  --helmet               Enable Helmet security headers (default: yes)
-  --logger               Enable Winston + Loki logger for Grafana (default: yes)
-  --yes                  Accept all defaults without prompting
   --json                 Output machine-readable JSON
   --dry-run              Preview planned files without writing
   --no-install           Skip npm install after scaffolding
@@ -31,23 +39,45 @@ Options:
 
 Generated files:
   app.js                              Express app entry point
-  .env / .env.example                 Environment configuration
+  .env / .env.example                 Environment configuration (PORT, API_BASE_PATH)
   .gitignore                          Git ignore rules
   <output>/commons/db.js              Database init, connect, and global.db
   <output>/commons/session.js         Session configuration
   <output>/commons/migrate.js         Migration runner (also runs as script)
   <output>/commons/add_migration.js   Migration creation helper (also runs as script)
   <output>/commons/security.js        Helmet, rate limiting, custom headers
-  <output>/middleware/logger.js        Winston + Loki request logger
-  <output>/routes/index.js             Central route mounting
-  <output>/routes/health.js            GET /health endpoint
-  <output>/migrations/                Initial migration files
+  <output>/middleware/logger.js       Winston + Loki request logger
+  <output>/routes/index.js            Central route mounting
+  <output>/routes/health.js           GET /health endpoint
+  <output>/routes/docs.js             Swagger UI at /docs
+  <output>/routes/<table>/index.js    CRUD route per table (nested by parent)
+  <output>/models/<table>.js          Model with CRUD operations per table
+  <output>/migrations/                CREATE TABLE migrations (SQL) or per-table (NoSQL)
+  <output>/test/<table>.test.js       CRUD endpoint tests per table
+  <output>/openapi.json               OpenAPI 3.0 spec
+  SaaS files (when saasStructure=true): tenants/users/roles middleware + routes + seeds
 
 Examples:
-  db-model-router init --from dbmr.schema.json --yes --no-install
-  db-model-router init --framework express --database postgres --output backend --yes
-  db-model-router init --database mysql --session redis --helmet --rateLimiting
-  db-model-router init --dry-run`,
+  db-model-router init                          # uses ./dbmr.schema.json
+  db-model-router init ./my.schema.json
+  db-model-router init --dry-run
+  db-model-router init --no-install --json
+
+ADDING NEW TABLES / MODELS / ROUTES AFTER BUILDOUT (manual — do NOT re-run init):
+  1. Migration: create a new timestamped migration under migrations/ with the
+     CREATE TABLE (SQL) or create_<table>.js (NoSQL). Use the scaffold helper:
+       node commons/add_migration.js <name>
+     then write your CREATE TABLE SQL / collection setup inside it.
+  2. Model: add models/<table>.js mirroring an existing model:
+       const model = require('#commons/model');
+       const db = require('#commons/db');
+       module.exports = model(db, '<table>', structure, '<pk>', uniqueKeys, option);
+  3. Route: add routes/<table>/index.js via route(model):
+       const route = require('#commons/route');
+       module.exports = route(require('#models/<table>'));
+     then mount it in routes/index.js at the desired endpoint:
+       router.use('/<endpoint>', require('./<table>/index.js'));
+  4. Run the new migration, then restart the server.`,
 
   inspect: `Usage: db-model-router inspect [options]
 
@@ -70,43 +100,6 @@ Examples:
   db-model-router inspect --type sqlite3 --out schema.json --tables users,posts
   db-model-router inspect --type mysql --json`,
 
-  generate: `Usage: db-model-router generate [options]
-
-Generate models, routes, tests, OpenAPI spec, and LLM docs from a schema file.
-When no artifact flags are provided, all artifact types are generated.
-
-Options:
-  --from <path>          Path to schema file (default: dbmr.schema.json)
-  --models               Generate only model files
-  --routes               Generate only route files (including child routes and index)
-  --openapi              Generate only OpenAPI spec + Swagger UI docs route
-  --tests                Generate only test files
-  --migrations           Generate only database migration files
-  --yes                  Accept all defaults without prompting
-  --json                 Output machine-readable JSON
-  --dry-run              Report planned files without writing
-  --help                 Show this help message
-
-Generated files:
-  models/<table>.js                        Model with CRUD operations
-  routes/<table>.js                        Express route handlers
-  routes/<parent>/<child>.js               Child route (scoped by FK)
-  routes/docs.js                           Swagger UI at /docs
-  routes/index.js                          Route mounting index
-  migrations/<timestamp>_create_tables.sql Database migration (SQL adapters)
-  migrations/<timestamp>_create_<t>.js     Database migration (NoSQL adapters)
-  test/<table>.test.js                     CRUD endpoint tests
-  openapi.json                             OpenAPI 3.0 spec
-  llms.txt                                 LLM quick reference
-  docs/llm.md                              Full LLM reference
-
-Examples:
-  db-model-router generate --from dbmr.schema.json
-  db-model-router generate --models --dry-run
-  db-model-router generate --routes --tests
-  db-model-router generate --migrations
-  db-model-router generate --from dbmr.schema.json --json`,
-
   doctor: `Usage: db-model-router doctor [options]
 
 Validate schema, check adapter driver dependencies, and verify generated

package/src/cli/commands/init.js

@@ -10,70 +10,99 @@ const {
   printSummary,
   ensurePackageJson,
 } = require("../init");
-const { promptUser } = require("../init/prompt");
-const generateCmd = require("./generate");
-
-/**
- * Default answers used when --yes is provided and no schema is available.
- */
-const DEFAULT_ANSWERS = {
-  framework: "express",
-  database: "postgres",
-  session: "memory",
-  rateLimiting: true,
-  helmet: true,
-  logger: true,
-  loki: false,
-};
+const { buildSchemaArtifacts } = require("./generate");
 
 /**
  * Init command handler for the unified CLI.
  *
- * Scaffolds a new project from a schema file or interactively.
+ * First-buildout ONLY. Scaffolds a full project (app.js, commons/, routes/,
+ * migrations/, models/, tests, OpenAPI spec, optional SaaS structure) from a
+ * single `dbmr.schema.json` file. All project config lives in the schema's
+ * `options` block — no config flags here. Refuses to run if a project already
+ * exists (app.js or package.json present in cwd).
+ *
+ * To add new tables/models/routes after buildout, do it manually — see
+ * `db-model-router help init` for the procedure.
  *
- * @param {object} args - Parsed positional/key-value args (e.g. { from, framework, database })
+ * @param {object} args - Parsed args; args._[0] or args.from may hold schema path
  * @param {object} flags - Universal flags: { yes, json, dryRun, noInstall, help }
  * @param {import('../flags').OutputContext} ctx - Output context for --json support
  */
 async function init(args, flags, ctx) {
-  let answers;
+  // Resolve schema path: positional arg, --from, or default ./dbmr.schema.json
+  const schemaPathArg =
+    (args._ && args._[0]) || args.from || "./dbmr.schema.json";
+  const schemaPath = path.resolve(schemaPathArg);
 
-  if (args.from) {
-    // --from points to a schema file: read adapter/framework from it
-    const schemaPath = path.resolve(args.from);
-    if (!fs.existsSync(schemaPath)) {
-      throw new Error(`Schema file not found: ${args.from}`);
+  if (!fs.existsSync(schemaPath)) {
+    const msg = `Schema file not found: ${schemaPathArg}`;
+    if (flags.json) {
+      ctx.result({ error: true, code: "SCHEMA_NOT_FOUND", message: msg });
+    } else {
+      ctx.log(`Error: ${msg}`);
     }
+    process.exitCode = 1;
+    return;
+  }
+
+  let schema;
+  try {
     const raw = fs.readFileSync(schemaPath, "utf8");
-    const schema = parseSchema(raw);
-
-    answers = {
-      framework: schema.framework,
-      database: schema.adapter,
-      session: (schema.options && schema.options.session) || "memory",
-      rateLimiting: !!(schema.options && schema.options.rateLimiting),
-      helmet: !!(schema.options && schema.options.helmet),
-      logger: !!(schema.options && schema.options.logger),
-      loki: !!(schema.options && schema.options.loki),
-    };
-  } else if (flags.yes) {
-    // --yes with no schema: use defaults, but allow CLI overrides
-    answers = Object.assign({}, DEFAULT_ANSWERS);
-    if (args.framework) answers.framework = args.framework;
-    if (args.database) answers.database = args.database;
-  } else {
-    // Interactive: build prefilled from CLI args, prompt for the rest
-    const prefilled = {};
-    if (args.framework) prefilled.framework = args.framework;
-    if (args.database) prefilled.database = args.database;
-    answers = await promptUser(prefilled);
+    schema = parseSchema(raw);
+  } catch (err) {
+    const msg = `Schema parse error: ${err.message}`;
+    if (flags.json) {
+      ctx.result({
+        error: true,
+        code: "SCHEMA_VALIDATION",
+        message: msg,
+        errors: err.errors || [],
+      });
+    } else {
+      ctx.log(`Error: ${msg}`);
+    }
+    process.exitCode = 1;
+    return;
   }
 
-  // Resolve --output directory (relative to cwd)
-  // CLI --output flag takes precedence, then interactive prompt answer
-  const outputDir = args.output || answers.output || "";
+  // All config comes from schema.options.
+  const outputDir = (schema.options && schema.options.output) || "";
+  const baseDir = path.resolve(outputDir || process.cwd());
+
+  const answers = {
+    framework: schema.framework,
+    database: schema.adapter,
+    session: (schema.options && schema.options.session) || "memory",
+    rateLimiting: !!(schema.options && schema.options.rateLimiting),
+    helmet: !!(schema.options && schema.options.helmet),
+    logger: !!(schema.options && schema.options.logger),
+    loki: !!(schema.options && schema.options.loki),
+    port: schema.options && schema.options.port,
+    apiBasePath: schema.options && schema.options.apiBasePath,
+    output: outputDir,
+  };
+
+  // First-buildout-only guard: refuse if a project already exists in cwd.
+  // app.js is the db-model-router project marker (package.json may pre-exist
+  // as a legit npm project, so it alone does not block a first buildout).
+  if (!flags.dryRun) {
+    const cwd = process.cwd();
+    if (fs.existsSync(path.join(cwd, "app.js"))) {
+      const msg =
+        `init is first-buildout only; a project already exists in ${cwd} ` +
+        `(app.js present). To add new tables, models, or routes, do it ` +
+        `manually — see: db-model-router help init`;
+      if (flags.json) {
+        ctx.result({ error: true, code: "PROJECT_EXISTS", message: msg });
+      } else {
+        ctx.log(`Error: ${msg}`);
+      }
+      process.exitCode = 1;
+      return;
+    }
+  }
 
-  // --dry-run: report planned files without writing
+  // --- dry-run: report planned files without writing ---
   if (flags.dryRun) {
     const planned = planFiles(answers, outputDir);
     if (flags.json) {
@@ -83,43 +112,32 @@ async function init(args, flags, ctx) {
         actions: ["dry-run"],
       });
     } else {
-      ctx.log("Dry run — the following files would be created:");
+      ctx.log("Dry run — the following scaffold files would be created:");
       for (const f of planned) {
         ctx.log(`  ${f}`);
       }
     }
-    // Also preview schema-generated artifacts when --from is used
-    if (args.from) {
-      await generateCmd(args, flags, ctx);
-    }
+    // Preview schema-driven artifacts too (non-writing)
+    await buildSchemaArtifacts({ schema, baseDir, ctx, flags });
     if (!flags.json) {
       ctx.log("\nNo files were written.");
     }
     return;
   }
 
-  // Ensure package.json exists
+  // --- real run ---
   ensurePackageJson();
 
-  // Generate project files
   const generated = generateFiles(answers, outputDir);
-
-  // Update package.json with deps and scripts
   updatePackageJson(answers, outputDir);
 
-  // npm install (unless --no-install)
   const installed = !flags.noInstall;
   if (installed) {
     runInstall();
   }
 
-  // When --from points to a schema, also generate models, routes, tests, etc.
-  if (args.from) {
-    await generateCmd(args, flags, ctx);
-    if (process.exitCode) return; // bail if generate reported an error
-  }
-
-  // Output
+  // Build init's JSON result first so it lands at ctx._results[0] (buildSchemaArtifacts
+  // pushes its own result afterward).
   const allFiles = [
     ...generated.files,
     ...generated.migrationFiles.map((m) => {
@@ -127,14 +145,20 @@ async function init(args, flags, ctx) {
       return base === "." ? `migrations/${m}` : `${base}/migrations/${m}`;
     }),
   ];
-
   if (flags.json) {
     ctx.result({
       files: allFiles,
       dependencies: { installed },
       actions: installed ? ["scaffolded", "installed"] : ["scaffolded"],
     });
-  } else {
+  }
+
+  // Schema-driven artifacts: models, routes, migrations, openapi, tests, SaaS
+  await buildSchemaArtifacts({ schema, baseDir, ctx, flags });
+  if (process.exitCode) return; // bail if build reported an error
+
+  // Human-readable summary (non-json only)
+  if (!flags.json) {
     printSummary(generated);
     if (!installed) {
       ctx.log(
@@ -145,8 +169,8 @@ async function init(args, flags, ctx) {
 }
 
 /**
- * Compute the list of files that would be created (for --dry-run).
- * This mirrors the file list from generateFiles() without writing anything.
+ * Compute the list of scaffold files that would be created (for --dry-run).
+ * Mirrors generateFiles() without writing anything.
  *
  * @param {object} answers
  * @param {string} [outputDir] - relative output directory for source files
@@ -166,7 +190,6 @@ function planFiles(answers, outputDir) {
     ".dockerignore",
   ];
 
-  // docker-compose.yml for databases that need Docker
   if (answers.database !== "sqlite3") {
     files.push("docker-compose.yml");
   }
@@ -191,4 +214,4 @@ function planFiles(answers, outputDir) {
   return files;
 }
 
-module.exports = init;
+module.exports = init;

package/src/cli/flags.js

@@ -25,7 +25,7 @@ function parseFlags(argv) {
     help: false,
   };
 
-  const args = {};
+  const args = { _: [] };
   let subcommand = null;
 
   for (let i = 0; i < argv.length; i++) {
@@ -53,6 +53,9 @@ function parseFlags(argv) {
       }
     } else if (subcommand === null) {
       subcommand = arg;
+    } else {
+      // Extra positional args after the subcommand
+      args._.push(arg);
     }
   }
 

package/src/cli/init/generators.js

@@ -168,8 +168,8 @@ function buildEnvContent(answers, mode, secrets) {
   const pick = mode === "placeholder" ? "placeholder" : "defaultValue";
   const lines = [];
   lines.push("# Server");
-  lines.push("PORT=3000");
-  lines.push("API_BASE_PATH=/api");
+  lines.push(`PORT=${answers.port != null ? answers.port : 3000}`);
+  lines.push(`API_BASE_PATH=${answers.apiBasePath || "/api"}`);
   lines.push("");
   lines.push("# Database");
   lines.push(`DB_TYPE=${answers.database}`);

package/src/cli/init.js

@@ -28,7 +28,6 @@ const {
 } = require("./init/generators");
 
 const { collectDependencies, getScripts } = require("./init/dependencies");
-const { promptUser, parseInitArgs } = require("./init/prompt");
 
 /**
  * Ensure a package.json exists in the current directory.
@@ -304,84 +303,21 @@ function printSummary(generated) {
 }
 
 /**
- * Main orchestrator.
+ * Legacy direct-entry orchestrator.
+ *
+ * This module is no longer a user-facing entry point. The unified CLI
+ * (`src/cli/main.js` → `db-model-router init`) drives project buildout via
+ * `dbmr.schema.json` and calls `generateFiles` / `updatePackageJson` /
+ * `runInstall` / `printSummary` directly. This stub kept only so that running
+ * `node src/cli/init.js` points users at the unified CLI instead of silently
+ * doing nothing.
  */
 async function main() {
-  const cliArgs = parseInitArgs(process.argv.slice(2));
-
-  // If --help flag, print usage and exit
-  if (process.argv.includes("--help")) {
-    printUsage();
-    process.exit(0);
-  }
-
-  ensurePackageJson();
-
-  let answers;
-  try {
-    answers = await promptUser(cliArgs);
-  } catch (err) {
-    // Handle Ctrl+C (inquirer throws on user cancel)
-    console.log("\nAborted.");
-    process.exit(1);
-  }
-
-  let generated;
-  try {
-    generated = generateFiles(answers);
-  } catch (err) {
-    if (err.code === "EACCES" || err.code === "EPERM") {
-      console.error(
-        `Error: Permission denied writing files. Check directory permissions.\n  ${err.message}`,
-      );
-    } else {
-      console.error(`Error: Failed to generate files.\n  ${err.message}`);
-    }
-    process.exit(1);
-  }
-
-  updatePackageJson(answers);
-  runInstall();
-  printSummary(generated);
-}
-
-/**
- * Print CLI usage information.
- */
-function printUsage() {
-  console.log(`
-Usage: db-model-router-init [options]
-
-Scaffolds a complete Express-based REST API project. When all options are
-provided, runs non-interactively (no prompts). Missing options are prompted.
-
-Options:
-  --framework <name>    Express framework: ultimate-express, express
-  --database <name>     Database: mysql, postgres, sqlite3, mongodb, mssql,
-                        cockroachdb, oracle, redis, dynamodb
-  --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/, routes/,
-                        middleware/, and migrations/ go inside the output folder.
-  --rateLimiting        Enable rate limiting (express-rate-limit)
-  --helmet              Enable Helmet security headers
-  --logger              Enable request/response logger (express-mung)
-  --help                Show this help message
-
-Examples:
-  # Fully non-interactive (LLM-friendly)
-  db-model-router-init --framework express --database postgres --session redis --rateLimiting --helmet --logger
-
-  # With output directory
-  db-model-router-init --framework express --database postgres --output backend --yes
-
-  # Partial — only prompts for missing values
-  db-model-router-init --database mysql --session memory
-
-  # Interactive (no flags)
-  db-model-router-init
-`);
+  console.error(
+    "db-model-router init is now the unified entry point.\n" +
+      "Run: db-model-router init [schemaPath]   (default: ./dbmr.schema.json)",
+  );
+  process.exit(1);
 }
 
 if (require.main === module) {

package/src/cli/main.js

@@ -5,7 +5,6 @@ const { parseFlags, OutputContext } = require("./flags");
 
 const initCmd = require("./commands/init");
 const inspectCmd = require("./commands/inspect");
-const generateCmd = require("./commands/generate");
 const doctorCmd = require("./commands/doctor");
 const diffCmd = require("./commands/diff");
 const helpCmd = require("./commands/help");
@@ -17,7 +16,6 @@ const dbManagerCmd = require("./commands/db-manager");
 const COMMANDS = {
   init: initCmd,
   inspect: inspectCmd,
-  generate: generateCmd,
   doctor: doctorCmd,
   diff: diffCmd,
   "db-manager": dbManagerCmd,
@@ -28,9 +26,8 @@ const COMMANDS = {
  * Descriptions for each subcommand, used in help output.
  */
 const COMMAND_DESCRIPTIONS = {
-  init: "Scaffold a new project from a schema file or interactively",
+  init: "First-buildout only: scaffold a full project from dbmr.schema.json",
   inspect: "Introspect a live database and produce a schema file",
-  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",
@@ -42,18 +39,9 @@ const COMMAND_DESCRIPTIONS = {
  */
 const COMMAND_FLAGS = {
   init: [
-    ["--from <path>", "Read config from a schema file"],
-    ["--framework <name>", "express, ultimate-express"],
-    [
-      "--database <name>",
-      "mysql, mariadb, postgres, sqlite3, mongodb, mssql, cockroachdb, oracle, redis, dynamodb",
-    ],
-    ["--db <name>", "Alias for --database"],
-    ["--session <type>", "memory, redis, database"],
-    ["--output <dir>", "Directory for backend source files"],
-    ["--rateLimiting", "Enable rate limiting (default: yes)"],
-    ["--helmet", "Enable Helmet security headers (default: yes)"],
-    ["--logger", "Enable Winston + Loki logger (default: yes)"],
+    ["[schemaPath]", "Path to schema file (default: ./dbmr.schema.json)"],
+    ["--dry-run", "Preview planned files without writing"],
+    ["--no-install", "Skip npm install after scaffolding"],
   ],
   inspect: [
     ["--type <adapter>", "Database adapter (required)"],
@@ -61,15 +49,6 @@ const COMMAND_FLAGS = {
     ["--out <path>", "Output file (default: dbmr.schema.json)"],
     ["--tables <list>", "Comma-separated table filter"],
   ],
-  generate: [
-    ["--from <path>", "Schema file (default: dbmr.schema.json)"],
-    ["--output <dir>", "Directory for generated files (default: cwd)"],
-    ["--models", "Generate only model files"],
-    ["--routes", "Generate only route files"],
-    ["--openapi", "Generate only OpenAPI spec"],
-    ["--tests", "Generate only test files"],
-    ["--db-manager", "Generate DB Manager UI (SQL adapters only)"],
-  ],
   doctor: [["--from <path>", "Schema file (default: dbmr.schema.json)"]],
   diff: [["--from <path>", "Schema file (default: dbmr.schema.json)"]],
   "db-manager": [

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

@@ -5,7 +5,7 @@
  *
  * Generates CREATE TABLE migration files for all SaaS tables with proper
  * column types, foreign key constraints, and unique constraints per adapter.
- * Supports SQL adapters (postgres, mysql, sqlite3, mssql, oracle, cockroachdb)
+ * Supports SQL adapters (postgres, mysql, mariadb, sqlite3, mssql, oracle, cockroachdb)
  * and NoSQL adapters (mongodb, dynamodb, redis).
  */
 
@@ -17,6 +17,7 @@ const { mapColumnType } = require("../generate-migration");
 
 const SQL_ADAPTERS = [
   "mysql",
+  "mariadb",
   "postgres",
   "sqlite3",
   "mssql",

package/src/schema/schema-parser.js

@@ -113,12 +113,29 @@ function parseSchema(input) {
     }
   }
 
+  // Normalize options with defaults for buildout config.
+  // output defaults to null (caller resolves to cwd); saasStructure defaults on;
+  // apiBasePath defaults to "/api"; port defaults to 3000.
+  const rawOptions = raw.options ? { ...raw.options } : {};
+  const options = {
+    ...rawOptions,
+    session: rawOptions.session || "memory",
+    rateLimiting: rawOptions.rateLimiting !== undefined ? !!rawOptions.rateLimiting : true,
+    helmet: rawOptions.helmet !== undefined ? !!rawOptions.helmet : true,
+    logger: rawOptions.logger !== undefined ? !!rawOptions.logger : true,
+    loki: rawOptions.loki !== undefined ? !!rawOptions.loki : false,
+    output: rawOptions.output !== undefined ? rawOptions.output : null,
+    saasStructure: rawOptions.saasStructure !== undefined ? !!rawOptions.saasStructure : true,
+    apiBasePath: rawOptions.apiBasePath || "/api",
+    port: rawOptions.port !== undefined ? rawOptions.port : 3000,
+  };
+
   return {
     adapter: raw.adapter,
     framework: raw.framework,
     tables,
     relationships: derivedRelationships,
-    options: raw.options ? { ...raw.options } : {},
+    options,
   };
 }