db-model-router 1.0.12 → 1.0.14

package/docs/dbmr-schema-spec.md

@@ -17,18 +17,16 @@ This document is the single source of truth for writing a `dbmr.schema.json` fil
     "logger": true,
     "loki": false
   },
-  "tables": { ... },
-  "relationships": [ ... ]
+  "tables": { ... }
 }
 ```
 
-| Field           | Required | Description                                                                    |
-| --------------- | -------- | ------------------------------------------------------------------------------ |
-| `adapter`       | Yes      | Database adapter. One of: `mysql`, `mariadb`, `postgres`, `sqlite3`, `mongodb`, `mssql`, `cockroachdb`, `oracle`, `redis`, `dynamodb` |
-| `framework`     | Yes      | Express variant. One of: `express`, `ultimate-express`                           |
-| `options`       | No       | Project scaffolding options (session store, rate limiting, helmet, logger, loki) |
-| `tables`        | Yes      | Object where each key is a table name and the value is a **Table Definition**    |
-| `relationships` | No       | Array of parent-child route nesting descriptors                                |
+| Field       | Required | Description                                                                    |
+| ----------- | -------- | ------------------------------------------------------------------------------ |
+| `adapter`   | Yes      | Database adapter. One of: `mysql`, `mariadb`, `postgres`, `sqlite3`, `mongodb`, `mssql`, `cockroachdb`, `oracle`, `redis`, `dynamodb` |
+| `framework` | Yes      | Express variant. One of: `express`, `ultimate-express`                           |
+| `options`   | No       | Project scaffolding options (session store, rate limiting, helmet, logger, loki) |
+| `tables`    | Yes      | Object where each key is a table name and the value is a **Table Definition**    |
 
 ---
 
@@ -54,7 +52,7 @@ Each entry in `tables` is a Table Definition object:
 | ------------ | -------- | --------------------------------------------------------------------------------------------- |
 | `columns`    | Yes      | **All** columns in the table, including PK, timestamps, and soft-delete. Each key is a column name; the value is a **Column Rule** string. |
 | `pk`         | Yes      | Primary key column name. Convention: `<table>_id` (e.g. `user_id`, `order_id`).                 |
-| `unique`     | No       | Array of column names with unique constraints. Defaults to `[pk]` if omitted.                   |
+| `unique`     | No       | Unique constraint columns. A flat array creates one composite unique group; an array-of-arrays creates multiple independent constraints. Defaults to `[[pk]]`. |
 | `softDelete` | No       | Column name used for soft-delete. When set, `remove()` updates this column to `1`/`true` instead of hard-deleting. |
 | `timestamps` | No       | Object mapping `{ created_at: "col_name", modified_at: "col_name" }`. These columns are auto-excluded from insert/update payloads. |
 | `parent`     | No       | Parent table name for route nesting, or `null` for a top-level route.                           |
@@ -367,31 +365,28 @@ Tables that must **never** appear in your schema (because SaaS generates them):
 
 ---
 
-## Relationships and Route Nesting
+## Route Nesting via the `parent` Field
 
-The `relationships` array defines parent-child route nesting independent of foreign key columns.
-
-```json
-"relationships": [
-  {
-    "parent": "posts",
-    "child": "comments",
-    "foreignKey": "post_id"
-  }
-]
-```
-
-| Field        | Description                                                    |
-| ------------ | -------------------------------------------------------------- |
-| `parent`     | Parent table name. Must exist in `tables`.                   |
-| `child`      | Child table name. Must exist in `tables`.                    |
-| `foreignKey` | Column in the child table that references the parent's PK.     |
+Route nesting is driven **exclusively** by the `parent` field on each table. Set `parent` to the name of the table this module belongs under. Use `null` (or omit) for top-level routes.
 
 ### Routing Behavior
 
 - `parent: null` → Top-level routes: `GET /products/`, `GET /products/:product_id`
 - `parent: "posts"` → Nested routes: `GET /posts/:post_id/comments/`, `GET /posts/:post_id/comments/:comment_id`
-- Child routes are **also** mounted at top-level for direct access: `GET /comments/:comment_id`
+- Child routes are **only** available under their parent path. There is no duplicate top-level route for child tables.
+
+### Multi-Level Nesting (Deep Hierarchies)
+
+You can nest more than two levels. Intermediate tables that are both a child and a parent (e.g. `tasks` under `projects`, with `subtasks` under `tasks`) get a **hybrid route file** that:
+
+1. Scopes their own CRUD by the ancestor parameter (e.g. `project_id`).
+2. Mounts their own children under their path.
+
+Example: `projects → tasks → subtasks` produces:
+
+- `GET /projects/` — top-level project CRUD
+- `GET /projects/:project_id/tasks/` — task CRUD scoped by project
+- `GET /projects/:project_id/tasks/:task_id/subtasks/` — subtask CRUD scoped by task
 
 ### Best Practice: Don't Nest System Tables
 
@@ -399,7 +394,7 @@ Tables like `users`, `tenants`, `roles`, `permissions`, `sessions`, `accounts`,
 
 - `posts → comments`
 - `orders → order_items`
-- `projects → tasks`
+- `projects → tasks → subtasks`
 - `invoices → invoice_items`
 
 ---
@@ -559,14 +554,7 @@ Validators map to OpenAPI schema properties:
       },
       "parent": "orders"
     }
-  },
-  "relationships": [
-    {
-      "parent": "orders",
-      "child": "order_items",
-      "foreignKey": "order_id"
-    }
-  ]
+  }
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "db-model-router",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Generative API Creation using mysql2 and express libraries in node js",
   "main": "src/index.js",
   "bin": {
@@ -23,7 +23,8 @@
     "test:all": "mocha test/adapters/*.test.js test/properties/*.property.test.js test/function.test.js test/commands/*.test.js --timeout 300000 --exit",
     "test:command": "mocha test/commands/*.test.js --timeout 30000 --exit",
     "demo:clear": "node -e \"var fs=require('fs'),p=require('path'),d=p.join(__dirname,'demo');fs.existsSync(d)&&fs.rmSync(d,{recursive:true,force:true});fs.mkdirSync(d,{recursive:true})\"",
-    "demo:create": "node scripts/demo-create.js"
+    "demo:create": "node scripts/demo-create.js",
+    "demo:create-postgres": "node scripts/demo-create.js postgres"
   },
   "repository": {
     "type": "git",

package/scripts/demo-create.js

@@ -8,6 +8,15 @@ const { execSync } = require("child_process");
 const ROOT = path.resolve(__dirname, "..");
 const DEMO = path.join(ROOT, "demo");
 
+const ADAPTER = process.argv[2] || "sqlite3";
+const SUPPORTED_ADAPTERS = ["sqlite3", "postgres", "mysql", "mariadb"];
+
+if (!SUPPORTED_ADAPTERS.includes(ADAPTER)) {
+  console.error(`Error: Unsupported adapter "${ADAPTER}".`);
+  console.error(`Supported: ${SUPPORTED_ADAPTERS.join(", ")}`);
+  process.exit(1);
+}
+
 // 1. Clear demo folder
 if (fs.existsSync(DEMO)) {
   fs.rmSync(DEMO, { recursive: true, force: true });
@@ -19,29 +28,60 @@ const run = (cmd, cwd) => {
   execSync(cmd, { cwd, stdio: "inherit" });
 };
 
-// 2. Scaffold project with sqlite3
-run("node ../src/cli/main.js init --database sqlite3 --yes --no-install", DEMO);
-
-// 3. Copy schema and patch adapter to sqlite3
-const schema = JSON.parse(
-  fs.readFileSync(path.join(ROOT, "dbmr.schema.json"), "utf8"),
-);
-schema.adapter = "sqlite3";
-if (schema.options) {
-  delete schema.options.session;
-  delete schema.options.loki;
-}
-fs.writeFileSync(
-  path.join(DEMO, "dbmr.schema.json"),
-  JSON.stringify(schema, null, 2) + "\n",
-);
-console.log("\n> Copied and patched dbmr.schema.json (adapter → sqlite3)");
+if (ADAPTER === "postgres") {
+  // --- Postgres demo flow ---
+  const schemaPath = path.join(ROOT, "dbmr.postgres.test.schema.json");
+
+  // 2. Copy Postgres schema into the demo folder
+  const schema = JSON.parse(fs.readFileSync(schemaPath, "utf8"));
+  const schemaDest = path.join(DEMO, "dbmr.schema.json");
+  fs.writeFileSync(schemaDest, JSON.stringify(schema, null, 2) + "\n");
+  console.log(`\n> Copied ${schemaPath} → ${schemaDest}`);
+
+  // 3. Scaffold project with postgres
+  run(
+    "node ../src/cli/main.js init --database postgres --yes --no-install",
+    DEMO,
+  );
 
-// 4. Generate models, routes, tests, openapi from schema
-run("node ../src/cli/main.js generate --from dbmr.schema.json", DEMO);
+  // 4. Generate from schema (already copied)
+  run("node ../src/cli/main.js generate --from dbmr.schema.json", DEMO);
 
-// 5. Install dependencies
-run("npm install", DEMO);
+  // 5. Install dependencies
+  run("npm install", DEMO);
 
-console.log("\n✔ Demo project ready in ./demo");
-console.log("cd demo && npm run migrate && npm run dev\n");
+  console.log("\n✔ Postgres demo project ready in ./demo");
+  console.log("cd demo && npm run migrate && npm run dev\n");
+} else {
+  // --- SQLite3 demo flow (default) ---
+
+  // 2. Scaffold project with sqlite3
+  run(
+    "node ../src/cli/main.js init --database sqlite3 --yes --no-install",
+    DEMO,
+  );
+
+  // 3. Copy schema and patch adapter to sqlite3
+  const schema = JSON.parse(
+    fs.readFileSync(path.join(ROOT, "dbmr.schema.json"), "utf8"),
+  );
+  schema.adapter = "sqlite3";
+  if (schema.options) {
+    delete schema.options.session;
+    delete schema.options.loki;
+  }
+  fs.writeFileSync(
+    path.join(DEMO, "dbmr.schema.json"),
+    JSON.stringify(schema, null, 2) + "\n",
+  );
+  console.log("\n> Copied and patched dbmr.schema.json (adapter → sqlite3)");
+
+  // 4. Generate models, routes, tests, openapi from schema
+  run("node ../src/cli/main.js generate --from dbmr.schema.json", DEMO);
+
+  // 5. Install dependencies
+  run("npm install", DEMO);
+
+  console.log("\n✔ Demo project ready in ./demo");
+  console.log("cd demo && npm run migrate && npm run dev\n");
+}

package/skill/SKILL.md

@@ -117,7 +117,7 @@ For adapter-specific connect options (ports, env vars, upsert behavior), read th
 | ----------- | --------------- | --------------------------------------------------------------------------------------------------------------- |
 | `structure` | `{col: "rule"}` | Types: `string\|integer\|numeric\|boolean\|object\|datetime\|auto_increment`. Prefix `required\|` for NOT NULL. |
 | `pk`        | string          | Primary key column. Convention: `<table>_id`                                                                    |
-| `unique`    | string[]        | Columns for upsert conflict resolution                                                                          |
+| `unique`    | string[] \| string[][] | Flat array = one composite unique group; array-of-arrays = multiple independent constraints               |
 | `option`    | object          | `{ safeDelete, created_at, modified_at }` — column names or null                                                |
 
 > PK, timestamp, soft-delete, and `auto_increment` cols are auto-excluded from insert/update payloads.
@@ -249,7 +249,7 @@ Generated structure (ESM, `"type":"module"`):
 ```
 app.js                             Express entry point
 .env / .env.example                Env config (random passwords)
-docker-compose.yml                 DB + CloudBeaver + optional Loki/Grafana
+docker-compose.yml                 DB + optional Loki/Grafana
 <output>/commons/db.js             Database init + global.db
 <output>/commons/migrate.js        Migration runner
 <output>/route/index.js            Central route mounting
@@ -257,7 +257,7 @@ docker-compose.yml                 DB + CloudBeaver + optional Loki/Grafana
 <output>/migrations/               Initial migration files
 ```
 
-Docker services auto-generated: database, Redis (if session=redis), CloudBeaver (SQL/MongoDB, port 8978), Loki + Grafana (if --loki).
+Docker services auto-generated: database, Redis (if session=redis), Loki + Grafana (if --loki).
 
 Scripts: `start`, `dev`, `test`, `migrate`, `add_migration`, `docker:build`, `docker:up`, `docker:down`.
 
@@ -270,7 +270,7 @@ db-model-router inspect --type postgres --env .env [--out schema.json] [--tables
 ### `generate` — Generate code from schema
 
 ```bash
-db-model-router generate --from dbmr.schema.json [--models=false] [--routes=false] [--openapi=false] [--tests=false] [--migrations=false] [--saas-structure=false]
+db-model-router generate --from dbmr.schema.json [--output <dir>] [--models=false] [--routes=false] [--openapi=false] [--tests=false] [--migrations=false] [--saas-structure=false]
 ```
 
 All artifact types are **enabled by default**. Use `--flag=false` to disable specific ones.
@@ -383,7 +383,7 @@ Requires a `.env` file with `DB_TYPE` and connection variables.
 ### `parent` field rules
 
 - `"parent": null` → top-level route: `/comments/`
-- `"parent": "posts"` → nested route: `/posts/:post_id/comments/` (also mounted at top-level for direct access)
+- `"parent": "posts"` → nested route: `/posts/:post_id/comments/` (only available under parent path)
 - **Do NOT use system tables as parents** (`users`, `tenants`, `roles`, `permissions`, `sessions`, `accounts`, `auth_tokens`). They are cross-cutting and referenced via FK columns — not route hierarchies. Only use `parent` for true domain hierarchies: `posts → comments`, `orders → order_items`, `projects → tasks`.
 
 ### Column Rules

package/src/cli/commands/diff.js

@@ -61,8 +61,23 @@ async function diff(args, flags, ctx) {
 
   // --- 2. Compute diff ---
   const meta = schemaToModelMeta(schema);
-  const relationships = schema.relationships || [];
-  const result = computeDiff(baseDir, meta, relationships);
+
+  // For diff, match generate by using only parent-derived relationships
+  const routeRelationships = [];
+  for (const [tableName, tableDef] of Object.entries(schema.tables)) {
+    if (tableDef.parent) {
+      const parentTable = schema.tables[tableDef.parent];
+      if (parentTable) {
+        routeRelationships.push({
+          parent: tableDef.parent,
+          child: tableName,
+          foreignKey: parentTable.pk,
+        });
+      }
+    }
+  }
+
+  const result = computeDiff(baseDir, meta, routeRelationships);
 
   // --- 3. Output results ---
   if (flags.json) {

package/src/cli/commands/doctor.js

@@ -6,6 +6,7 @@ const { parseSchema } = require("../../schema/schema-parser");
 const { SchemaValidationError } = require("../../schema/schema-validator");
 const { schemaToModelMeta } = require("../../schema/schema-to-meta");
 const { computeDiff } = require("../diff-engine");
+const { generateSaasStructure } = require("../generate-saas-structure");
 
 /**
  * Adapter-to-driver mapping.
@@ -111,13 +112,53 @@ async function doctor(args, flags, ctx) {
 
   if (schema) {
     const meta = schemaToModelMeta(schema);
-    const relationships = schema.relationships || [];
-    const diff = computeDiff(baseDir, meta, relationships);
+
+    // Derive route relationships from parent fields (same logic as generate)
+    const routeRelationships = [];
+    for (const [tableName, tableDef] of Object.entries(schema.tables || {})) {
+      if (tableDef.parent) {
+        const parentTable = schema.tables[tableDef.parent];
+        if (parentTable) {
+          routeRelationships.push({
+            parent: tableDef.parent,
+            child: tableName,
+            foreignKey: parentTable.pk,
+          });
+        }
+      }
+    }
+
+    const tableNames = meta.map((m) => m.table).sort();
+
+    // Detect whether OpenAPI docs were generated
+    const includeDocs = fs.existsSync(path.join(baseDir, "openapi.json"));
+
+    // Detect whether SaaS structure was generated
+    const saasFiles = [];
+    if (fs.existsSync(path.join(baseDir, "routes", "auth", "index.js"))) {
+      const adapter = schema.adapter;
+      saasFiles.push(
+        ...generateSaasStructure(adapter, {
+          tableNames,
+          relationships: routeRelationships,
+          routeOptions: { includeDocs },
+        }),
+      );
+    }
+
+    const diffOptions = { includeDocs, saasFiles };
+    const diff = computeDiff(baseDir, meta, routeRelationships, diffOptions);
+
+    // Filter out known init-scaffold files that doctor should ignore
+    const initWhitelist = new Set(["routes/health.js"]);
+    const filteredDeleted = diff.deleted.filter(
+      (f) => !initWhitelist.has(f),
+    );
 
     if (
       diff.added.length > 0 ||
       diff.modified.length > 0 ||
-      diff.deleted.length > 0
+      filteredDeleted.length > 0
     ) {
       sync.ok = false;
       for (const f of diff.added) {
@@ -126,7 +167,7 @@ async function doctor(args, flags, ctx) {
       for (const m of diff.modified) {
         sync.outOfSync.push({ file: m.file, status: "modified" });
       }
-      for (const f of diff.deleted) {
+      for (const f of filteredDeleted) {
         sync.outOfSync.push({ file: f, status: "extra" });
       }
     }

package/src/cli/commands/generate.js

@@ -97,6 +97,35 @@ async function generate(args, flags, ctx) {
   const relationships = schema.relationships || [];
   const tableNames = meta.map((m) => m.table).sort();
 
+  // For route generation, only use parent-derived relationships.
+  // Explicit relationships may define multiple foreign keys per table,
+  // but nested routes should follow the canonical parent declared on each table.
+  const routeRelationships = [];
+  for (const [tableName, tableDef] of Object.entries(schema.tables)) {
+    if (tableDef.parent) {
+      const parentTable = schema.tables[tableDef.parent];
+      if (parentTable) {
+        routeRelationships.push({
+          parent: tableDef.parent,
+          child: tableName,
+          foreignKey: parentTable.pk,
+        });
+      }
+    }
+  }
+
+  // Build ancestry chains for correct multi-level nested file placement.
+  const ancestors = {};
+  for (const m of meta) {
+    const chain = [];
+    let current = m.table;
+    while (schema.tables[current]?.parent) {
+      chain.unshift(schema.tables[current].parent);
+      current = schema.tables[current].parent;
+    }
+    ancestors[m.table] = chain;
+  }
+
   // Determine which artifact types to generate.
   // If any specific artifact flag is explicitly set to true, only generate those.
   // Otherwise, all artifact types are generated (unless explicitly set to false).
@@ -127,7 +156,7 @@ async function generate(args, flags, ctx) {
     genSaas = args["saas-structure"] !== false;
   }
 
-  const baseDir = process.cwd();
+  const baseDir = path.resolve(args.output || process.cwd());
 
   // Collect all planned files: { relPath, content }
   const planned = [];
@@ -144,47 +173,62 @@ async function generate(args, flags, ctx) {
 
   // --- Route files ---
   if (genRoutes) {
-    // Collect child tables and group by parent
-    const nestedChildren = new Set();
     const childrenByParent = {};
-    for (const rel of relationships) {
-      nestedChildren.add(rel.child);
+    for (const rel of routeRelationships) {
       if (!childrenByParent[rel.parent]) childrenByParent[rel.parent] = [];
       childrenByParent[rel.parent].push(rel);
     }
 
-    // Generate route files for each table
+    // Generate exactly ONE route file per table at its correct nested path.
+    // Intermediate tables (both child and parent) get a hybrid route file
+    // that scopes their own CRUD by an ancestor FK and mounts their children.
     for (const m of meta) {
-      if (nestedChildren.has(m.table)) continue;
-
-      const children = childrenByParent[m.table] || [];
-      if (children.length > 0) {
-        // Parent with children: generates index.js that mounts child routes
+      const tableName = m.table;
+      const chain = ancestors[tableName];
+      const hasChildren = (childrenByParent[tableName] || []).length > 0;
+      const hasParent = chain.length > 0;
+
+      const pathParts = [...chain, tableName];
+      const relPath = `routes/${pathParts.join("/")}/index.js`;
+
+      if (hasChildren) {
+        const children = childrenByParent[tableName];
+        if (hasParent) {
+          // Intermediate node: own CRUD scoped by parent PK + mounts children
+          const immediateParent = chain[chain.length - 1];
+          const parentFk = schema.tables[immediateParent].pk;
+          planned.push({
+            relPath,
+            content: generateParentRouteFile(tableName, children, parentFk),
+          });
+        } else {
+          // Root parent: own CRUD unscoped + mounts children
+          planned.push({
+            relPath,
+            content: generateParentRouteFile(tableName, children),
+          });
+        }
+      } else if (hasParent) {
+        // Leaf child
+        const immediateParent = chain[chain.length - 1];
+        const parentFk = schema.tables[immediateParent].pk;
         planned.push({
-          relPath: `routes/${m.table}/index.js`,
-          content: generateParentRouteFile(m.table, children),
+          relPath,
+          content: generateChildRouteFile(tableName, immediateParent, parentFk),
         });
       } else {
-        // Simple table: just CRUD
+        // Root leaf
         planned.push({
-          relPath: `routes/${m.table}/index.js`,
-          content: generateRouteFile(m.table),
+          relPath,
+          content: generateRouteFile(tableName),
         });
       }
     }
 
-    // Child route files inside parent folders: routes/<parent>/<child>/index.js
-    for (const rel of relationships) {
-      planned.push({
-        relPath: `routes/${rel.parent}/${rel.child}/index.js`,
-        content: generateChildRouteFile(rel.child, rel.parent, rel.foreignKey),
-      });
-    }
-
     // Routes index file (include docs route when openapi is being generated)
     planned.push({
       relPath: "routes/index.js",
-      content: generateRoutesIndexFile(tableNames, relationships, {
+      content: generateRoutesIndexFile(tableNames, routeRelationships, {
         includeDocs: genOpenapi,
       }),
     });
@@ -192,7 +236,7 @@ async function generate(args, flags, ctx) {
 
   // --- OpenAPI spec + docs route ---
   if (genOpenapi) {
-    const spec = generateOpenAPISpec(meta, { relationships });
+    const spec = generateOpenAPISpec(meta, { relationships: routeRelationships });
 
     // Merge SaaS routes into the OpenAPI spec when saas-structure is active
     // SaaS routes appear BEFORE product routes in the docs
@@ -239,33 +283,33 @@ async function generate(args, flags, ctx) {
 
   // --- Test files ---
   if (genTests) {
-    // Collect child tables to skip generating top-level test files for them
-    const nestedChildrenForTests = new Set();
-    for (const rel of relationships) {
-      nestedChildrenForTests.add(rel.child);
-    }
-
     for (const m of meta) {
-      if (nestedChildrenForTests.has(m.table)) continue;
-      planned.push({
-        relPath: `test/${m.table}.test.js`,
-        content: generateTestFile(m.table, m.primary_key, m.structure),
-      });
-    }
-
-    // Child test files in subfolders: test/<parent>/<child>.test.js
-    for (const rel of relationships) {
-      const childMeta = meta.find((m) => m.table === rel.child);
-      const pk = childMeta ? childMeta.primary_key : "id";
-      planned.push({
-        relPath: `test/${rel.parent}/${rel.child}.test.js`,
-        content: generateChildTestFile(
-          rel.child,
-          rel.parent,
-          rel.foreignKey,
-          pk,
-        ),
-      });
+      const tableName = m.table;
+      const chain = ancestors[tableName];
+      const hasParent = chain.length > 0;
+
+      if (hasParent) {
+        const immediateParent = chain[chain.length - 1];
+        const parentFk = schema.tables[immediateParent].pk;
+        const pathParts = [...chain, tableName];
+        const depth = pathParts.length;
+        const modelsRelPath = "../".repeat(depth) + "models/";
+        planned.push({
+          relPath: `test/${pathParts.join("/")}.test.js`,
+          content: generateChildTestFile(
+            tableName,
+            immediateParent,
+            parentFk,
+            m.primary_key,
+            modelsRelPath,
+          ),
+        });
+      } else {
+        planned.push({
+          relPath: `test/${tableName}.test.js`,
+          content: generateTestFile(tableName, m.primary_key, m.structure),
+        });
+      }
     }
   }
 
@@ -292,8 +336,9 @@ async function generate(args, flags, ctx) {
       json: flags.json,
       timestamp: new Date(),
       tableNames,
-      relationships,
+      relationships: routeRelationships,
       routeOptions: { includeDocs: genOpenapi },
+      baseDir,
     });
 
     // The SaaS generator produces a combined routes/index.js that includes

package/src/cli/commands/init.js

@@ -11,6 +11,7 @@ const {
   ensurePackageJson,
 } = require("../init");
 const { promptUser } = require("../init/prompt");
+const generateCmd = require("./generate");
 
 /**
  * Default answers used when --yes is provided and no schema is available.
@@ -86,6 +87,12 @@ async function init(args, flags, ctx) {
       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);
+    }
+    if (!flags.json) {
       ctx.log("\nNo files were written.");
     }
     return;
@@ -106,6 +113,12 @@ async function init(args, flags, ctx) {
     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
   const allFiles = [
     ...generated.files,