db-model-router 1.0.11 → 1.0.13

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.11",
+  "version": "1.0.13",
   "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`.
 
@@ -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/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).
@@ -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,7 +336,7 @@ async function generate(args, flags, ctx) {
       json: flags.json,
       timestamp: new Date(),
       tableNames,
-      relationships,
+      relationships: routeRelationships,
       routeOptions: { includeDocs: genOpenapi },
     });
 

package/src/cli/diff-engine.js

@@ -51,53 +51,69 @@ function lineDiff(expected, actual) {
  */
 function buildExpectedFiles(meta, relationships) {
   const expected = new Map();
-  const modelsRelPath = "../models";
   const tableNames = meta.map((m) => m.table).sort();
 
-  // Collect child tables
-  const nestedChildren = new Set();
+  // Build children map
   const childrenByParent = {};
   for (const rel of relationships) {
-    nestedChildren.add(rel.child);
     if (!childrenByParent[rel.parent]) childrenByParent[rel.parent] = [];
     childrenByParent[rel.parent].push(rel);
   }
 
+  // Build ancestry chains from relationships
+  const parentMap = {};
+  for (const rel of relationships) {
+    parentMap[rel.child] = rel.parent;
+  }
+  const ancestors = {};
+  for (const m of meta) {
+    const chain = [];
+    let current = m.table;
+    while (parentMap[current]) {
+      chain.unshift(parentMap[current]);
+      current = parentMap[current];
+    }
+    ancestors[m.table] = chain;
+  }
+
+  const getPk = (table) => {
+    const m = meta.find((x) => x.table === table);
+    return m ? m.primary_key : "id";
+  };
+
   // Model files
   for (const m of meta) {
     expected.set(`models/${m.table}.js`, generateModelFile(m));
   }
 
-  // Route files (top-level only, skip children)
+  // Route files: exactly one per table at its correct nested path
   for (const m of meta) {
-    if (nestedChildren.has(m.table)) continue;
-    const children = childrenByParent[m.table] || [];
-    if (children.length > 0) {
-      expected.set(
-        `routes/${m.table}/index.js`,
-        generateParentRouteFile(m.table, children),
-      );
+    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) {
+        const immediateParent = chain[chain.length - 1];
+        const parentFk = getPk(immediateParent);
+        expected.set(relPath, generateParentRouteFile(tableName, children, parentFk));
+      } else {
+        expected.set(relPath, generateParentRouteFile(tableName, children));
+      }
+    } else if (hasParent) {
+      const immediateParent = chain[chain.length - 1];
+      const parentFk = getPk(immediateParent);
+      expected.set(relPath, generateChildRouteFile(tableName, immediateParent, parentFk));
     } else {
-      expected.set(
-        `routes/${m.table}/index.js`,
-        generateRouteFile(m.table, modelsRelPath),
-      );
+      expected.set(relPath, generateRouteFile(tableName));
     }
   }
 
-  // Child route files inside parent folders: routes/<parent>/<child>/index.js
-  for (const rel of relationships) {
-    expected.set(
-      `routes/${rel.parent}/${rel.child}/index.js`,
-      generateChildRouteFile(
-        rel.child,
-        rel.parent,
-        rel.foreignKey,
-        `../../models`,
-      ),
-    );
-  }
-
   // Routes index file (with docs route)
   expected.set(
     "routes/index.js",
@@ -107,23 +123,28 @@ function buildExpectedFiles(meta, relationships) {
   // Docs route (Swagger UI)
   expected.set("routes/docs.js", generateDocsRoute());
 
-  // Test files (top-level only, skip children)
+  // Test files at correct nested paths
   for (const m of meta) {
-    if (nestedChildren.has(m.table)) continue;
-    expected.set(
-      `test/${m.table}.test.js`,
-      generateTestFile(m.table, m.primary_key, m.structure),
-    );
-  }
+    const tableName = m.table;
+    const chain = ancestors[tableName];
+    const hasParent = chain.length > 0;
 
-  // 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";
-    expected.set(
-      `test/${rel.parent}/${rel.child}.test.js`,
-      generateChildTestFile(rel.child, rel.parent, rel.foreignKey, pk),
-    );
+    if (hasParent) {
+      const immediateParent = chain[chain.length - 1];
+      const parentFk = getPk(immediateParent);
+      const pathParts = [...chain, tableName];
+      const depth = pathParts.length;
+      const modelsRelPath = "../".repeat(depth) + "models/";
+      expected.set(
+        `test/${pathParts.join("/")}.test.js`,
+        generateChildTestFile(tableName, immediateParent, parentFk, m.primary_key, modelsRelPath),
+      );
+    } else {
+      expected.set(
+        `test/${tableName}.test.js`,
+        generateTestFile(tableName, m.primary_key, m.structure),
+      );
+    }
   }
 
   // OpenAPI spec