on-zero 0.7.10 → 0.8.0

package/dist/cjs/generate-lite.test.native.js

@@ -1,5 +1,6 @@
 "use strict";
 
+var import_vm = require("vm");
 var import_vitest = require("vitest");
 var import_generate_lite = require("./generate-lite.native.js");
 function makeParse(table) {
@@ -12,14 +13,17 @@ function makeParse(table) {
   };
 }
 var DIR = "/proj/src/data";
+(0, import_vitest.afterEach)(function () {
+  import_vitest.vi.restoreAllMocks();
+});
 (0, import_vitest.describe)("generateLite", function () {
   (0, import_vitest.test)("emits models.ts, syncedMutations.ts, and README.md from inline types", function () {
     var files = {
-      [`${DIR}/models/todo.ts`]: "// fake source, parser returns fixture",
-      [`${DIR}/models/user.ts`]: "// fake source, parser returns fixture"
+      [`${DIR}/todo.ts`]: "// fake source, parser returns fixture",
+      [`${DIR}/user.ts`]: "// fake source, parser returns fixture"
     };
     var fixtures = {
-      [`${DIR}/models/todo.ts`]: {
+      [`${DIR}/todo.ts`]: {
         mutations: [{
           modelName: "todo",
           handlers: [{
@@ -33,7 +37,7 @@ var DIR = "/proj/src/data";
         }],
         queries: []
       },
-      [`${DIR}/models/user.ts`]: {
+      [`${DIR}/user.ts`]: {
         mutations: [{
           modelName: "user",
           handlers: [{
@@ -51,10 +55,10 @@ var DIR = "/proj/src/data";
       dir: DIR,
       parse: makeParse(fixtures)
     });
-    (0, import_vitest.expect)(Object.keys(result.files).sort()).toEqual(["README.md", "models.ts", "syncedMutations.ts"]);
+    (0, import_vitest.expect)(Object.keys(result.files).sort()).toEqual(["README.md", "groupedQueries.ts", "instances.ts", "models.ts", "syncedMutations.ts", "syncedQueries.ts"]);
     var models = result.files["models.ts"];
-    (0, import_vitest.expect)(models).toContain("import * as todo from '../models/todo'");
-    (0, import_vitest.expect)(models).toContain("import * as userPublic from '../models/user'");
+    (0, import_vitest.expect)(models).toContain("import * as todo from '../todo'");
+    (0, import_vitest.expect)(models).toContain("import * as userPublic from '../user'");
     (0, import_vitest.expect)(models).toContain("user: userPublic,");
     (0, import_vitest.expect)(models).not.toContain("\n  userPublic,");
     (0, import_vitest.expect)(models).toContain("export const models = {");
@@ -72,11 +76,11 @@ var DIR = "/proj/src/data";
   });
   (0, import_vitest.test)("parses newline-separated mutation object types", function () {
     var files = {
-      [`${DIR}/models/agentEvent.ts`]: "// fake",
-      [`${DIR}/models/deployment.ts`]: "// fake"
+      [`${DIR}/agentEvent.ts`]: "// fake",
+      [`${DIR}/deployment.ts`]: "// fake"
     };
     var fixtures = {
-      [`${DIR}/models/agentEvent.ts`]: {
+      [`${DIR}/agentEvent.ts`]: {
         mutations: [{
           modelName: "agentEvent",
           handlers: [{
@@ -91,7 +95,7 @@ var DIR = "/proj/src/data";
         }],
         queries: []
       },
-      [`${DIR}/models/deployment.ts`]: {
+      [`${DIR}/deployment.ts`]: {
         mutations: [{
           modelName: "deployment",
           handlers: [{
@@ -124,10 +128,10 @@ var DIR = "/proj/src/data";
   });
   (0, import_vitest.test)("parses object intersections and skips index signatures", function () {
     var files = {
-      [`${DIR}/models/agent.ts`]: "// fake"
+      [`${DIR}/agent.ts`]: "// fake"
     };
     var fixtures = {
-      [`${DIR}/models/agent.ts`]: {
+      [`${DIR}/agent.ts`]: {
         mutations: [{
           modelName: "agent",
           handlers: [{
@@ -160,10 +164,10 @@ var DIR = "/proj/src/data";
   });
   (0, import_vitest.test)("falls back to v.unknown() for type references", function () {
     var files = {
-      [`${DIR}/models/post.ts`]: "// fake"
+      [`${DIR}/post.ts`]: `export const allPosts = () => zql.post`
     };
     var fixtures = {
-      [`${DIR}/models/post.ts`]: {
+      [`${DIR}/post.ts`]: {
         mutations: [{
           modelName: "post",
           handlers: [{
@@ -193,10 +197,10 @@ var DIR = "/proj/src/data";
   });
   (0, import_vitest.test)("uses v.unknown() for explicitly unknown mutation params", function () {
     var files = {
-      [`${DIR}/models/project.ts`]: "// fake"
+      [`${DIR}/project.ts`]: "// fake"
     };
     var fixtures = {
-      [`${DIR}/models/project.ts`]: {
+      [`${DIR}/project.ts`]: {
         mutations: [{
           modelName: "project",
           handlers: [{
@@ -217,15 +221,10 @@ var DIR = "/proj/src/data";
   });
   (0, import_vitest.test)("emits query files with v.unknown() fallback for references", function () {
     var files = {
-      [`${DIR}/models/post.ts`]: "// fake",
-      [`${DIR}/queries/post.ts`]: "// fake"
+      [`${DIR}/post.ts`]: "// fake"
     };
     var fixtures = {
-      [`${DIR}/models/post.ts`]: {
-        mutations: [],
-        queries: []
-      },
-      [`${DIR}/queries/post.ts`]: {
+      [`${DIR}/post.ts`]: {
         mutations: [],
         queries: [
         // no-arg query → void
@@ -268,7 +267,8 @@ var DIR = "/proj/src/data";
     (0, import_vitest.expect)(result.files["groupedQueries.ts"]).toBeDefined();
     (0, import_vitest.expect)(result.files["syncedQueries.ts"]).toBeDefined();
     var grouped = result.files["groupedQueries.ts"];
-    (0, import_vitest.expect)(grouped).toContain("export * as post from '../queries/post'");
+    (0, import_vitest.expect)(grouped).toContain("import * as postSource from '../post'");
+    (0, import_vitest.expect)(grouped).toContain("postById: postSource.postById");
     var synced = result.files["syncedQueries.ts"];
     (0, import_vitest.expect)(synced).toContain("allPosts: defineQuery(() => Queries.post.allPosts())");
     (0, import_vitest.expect)(synced).toContain("postById: defineQuery(");
@@ -284,10 +284,10 @@ var DIR = "/proj/src/data";
   });
   (0, import_vitest.test)("emits types.ts and tables.ts when a model declares a schema inline", function () {
     var files = {
-      [`${DIR}/models/task.ts`]: "// fake"
+      [`${DIR}/task.ts`]: "// fake"
     };
     var fixtures = {
-      [`${DIR}/models/task.ts`]: {
+      [`${DIR}/task.ts`]: {
         mutations: [{
           modelName: "task",
           handlers: [],
@@ -326,24 +326,24 @@ var DIR = "/proj/src/data";
     var types = result.files["types.ts"];
     (0, import_vitest.expect)(types).toContain("export type Task = TableInsertRow<typeof schema.task>");
     var tables = result.files["tables.ts"];
-    (0, import_vitest.expect)(tables).toContain("export { schema as task } from '../models/task'");
+    (0, import_vitest.expect)(tables).toContain("export { schema as task } from '../task'");
     var synced = result.files["syncedMutations.ts"];
     (0, import_vitest.expect)(synced).toContain("insert:");
     (0, import_vitest.expect)(synced).toContain("update:");
     (0, import_vitest.expect)(synced).toContain("delete:");
     (0, import_vitest.expect)(result.mutationCount).toBe(3);
   });
-  (0, import_vitest.test)("ignores nested files and non-ts files inside the models directory", function () {
+  (0, import_vitest.test)("ignores private files inside a namespace folder", function () {
     var files = {
-      [`${DIR}/models/post.ts`]: "// fake",
-      [`${DIR}/models/README.md`]: "not a model",
-      [`${DIR}/models/helpers/util.ts`]: "nested should be ignored",
-      [`${DIR}/models/post.d.ts`]: "declaration file, ignored",
-      [`${DIR}/models/post.test.ts`]: "test file, ignored",
-      [`${DIR}/models/post.spec.ts`]: "spec file, ignored"
+      [`${DIR}/post/mutations.ts`]: "// fake",
+      [`${DIR}/post/README.md`]: "not a model",
+      [`${DIR}/post/helpers/util.ts`]: "private helper, ignored",
+      [`${DIR}/post/post.d.ts`]: "declaration file, ignored",
+      [`${DIR}/post/post.test.ts`]: "test file, ignored",
+      [`${DIR}/post/post.spec.ts`]: "spec file, ignored"
     };
     var fixtures = {
-      [`${DIR}/models/post.ts`]: {
+      [`${DIR}/post/mutations.ts`]: {
         mutations: [{
           modelName: "post",
           handlers: [],
@@ -359,18 +359,18 @@ var DIR = "/proj/src/data";
     });
     (0, import_vitest.expect)(result.modelCount).toBe(1);
     var models = result.files["models.ts"];
-    (0, import_vitest.expect)(models).toContain("import * as post from '../models/post'");
+    (0, import_vitest.expect)(models).toContain("import * as post from '../post/mutations'");
     (0, import_vitest.expect)(models).not.toContain("util");
     (0, import_vitest.expect)(models).not.toContain("README");
     (0, import_vitest.expect)(models).not.toContain("post.test");
     (0, import_vitest.expect)(models).not.toContain("post.spec");
   });
-  (0, import_vitest.test)("infers mutations/ directory when present", function () {
+  (0, import_vitest.test)("supports a split namespace folder", function () {
     var files = {
-      [`${DIR}/mutations/post.ts`]: "// fake"
+      [`${DIR}/post/mutations.ts`]: "// fake"
     };
     var fixtures = {
-      [`${DIR}/mutations/post.ts`]: {
+      [`${DIR}/post/mutations.ts`]: {
         mutations: [{
           modelName: "post",
           handlers: [{
@@ -388,7 +388,412 @@ var DIR = "/proj/src/data";
       parse: makeParse(fixtures)
     });
     var models = result.files["models.ts"];
-    (0, import_vitest.expect)(models).toContain("from '../mutations/post'");
+    (0, import_vitest.expect)(models).toContain("from '../post/mutations'");
+  });
+  (0, import_vitest.test)("derives single-file namespaces from data exports", function () {
+    var files = {
+      [`${DIR}/server.ts`]: `export const serverRows = () => zql.server`,
+      [`${DIR}/types.ts`]: `export const formatRow = (value: string) => value`
+    };
+    var result = (0, import_generate_lite.generateLite)({
+      files,
+      dir: DIR,
+      parse: makeParse({
+        [`${DIR}/server.ts`]: {
+          mutations: [],
+          queries: [{
+            name: "serverRows",
+            paramTypeText: null
+          }]
+        },
+        [`${DIR}/types.ts`]: {
+          mutations: [],
+          queries: []
+        }
+      })
+    });
+    (0, import_vitest.expect)(result.modelCount).toBe(1);
+    (0, import_vitest.expect)(result.queryCount).toBe(1);
+  });
+  (0, import_vitest.test)("warns once and ignores an unparseable non-data file", function () {
+    var warn = import_vitest.vi.spyOn(console, "warn").mockImplementation(function () {});
+    var result = (0, import_generate_lite.generateLite)({
+      files: {
+        [`${DIR}/server.ts`]: `export const serverRows = () => zql.server`,
+        [`${DIR}/types.ts`]: `export type Broken = {`
+      },
+      dir: DIR,
+      parse: function parse(source, path) {
+        if (path.endsWith("/types.ts")) throw new Error("parse failed");
+        return {
+          mutations: [],
+          queries: source.includes("zql.server") ? [{
+            name: "serverRows",
+            paramTypeText: null
+          }] : []
+        };
+      }
+    });
+    (0, import_vitest.expect)(result.modelCount).toBe(1);
+    (0, import_vitest.expect)(warn).toHaveBeenCalledOnce();
+    (0, import_vitest.expect)(warn).toHaveBeenCalledWith("[on-zero] ignoring data/types.ts: no recognized data exports");
+    warn.mockRestore();
+  });
+  (0, import_vitest.test)("rejects the removed top-level layout", function () {
+    (0, import_vitest.expect)(function () {
+      return (0, import_generate_lite.generateLite)({
+        files: {
+          [`${DIR}/queries/post.ts`]: "// fake"
+        },
+        dir: DIR,
+        parse: makeParse({})
+      });
+    }).toThrow(/removed top-level queries\/ layout/);
+  });
+  (0, import_vitest.test)("derives scoped related-table closure from lite metadata", function () {
+    var files = {
+      [`${DIR}/on-zero.config.ts`]: `export default defineConfig({ instances: { project: { scope: 'projectId' } } })`,
+      [`${DIR}/project/message/queries.ts`]: `export const messages = () => zql.message.related('comments')`,
+      [`${DIR}/project/message/mutations.ts`]: "// fake mutation",
+      ["/proj/src/database/relations.ts"]: "// fake relations",
+      ["/proj/src/database/schema.ts"]: "// fake tables"
+    };
+    var empty = {
+      mutations: [],
+      queries: []
+    };
+    var result = (0, import_generate_lite.generateLite)({
+      files,
+      dir: DIR,
+      parse: makeParse({
+        [`${DIR}/on-zero.config.ts`]: {
+          ...empty,
+          dataConfig: {
+            instances: {
+              project: {
+                scope: "projectId"
+              }
+            }
+          }
+        },
+        [`${DIR}/project/message/queries.ts`]: {
+          ...empty,
+          queries: [{
+            name: "messages",
+            paramTypeText: null,
+            relatedPaths: [["comments", "author"]]
+          }]
+        },
+        [`${DIR}/project/message/mutations.ts`]: {
+          ...empty,
+          mutations: [{
+            modelName: "message",
+            handlers: [],
+            schema: {
+              tableName: "message",
+              primaryKeys: ["id"],
+              columns: [{
+                name: "id",
+                builderText: "string()"
+              }, {
+                name: "projectId",
+                builderText: "string()"
+              }]
+            }
+          }]
+        },
+        "/proj/src/database/relations.ts": {
+          ...empty,
+          relations: [{
+            sourceTable: "message",
+            name: "comments",
+            targetTable: "comment"
+          }, {
+            sourceTable: "comment",
+            name: "author",
+            targetTable: "userPublic"
+          }]
+        },
+        "/proj/src/database/schema.ts": {
+          ...empty,
+          tables: [{
+            name: "comment",
+            columns: ["id", "projectId"]
+          }, {
+            name: "userPublic",
+            columns: ["id", "projectId"]
+          }]
+        }
+      })
+    });
+    (0, import_vitest.expect)(result.files["instances.ts"]).toContain('syncTables: ["comment","message","userPublic"]');
+    var instance = result.instances.find(function (entry) {
+      return entry.name === "project";
+    });
+    (0, import_vitest.expect)(instance === null || instance === void 0 ? void 0 : instance.syncTables).toEqual(["comment", "message", "userPublic"]);
+    (0, import_vitest.expect)(instance === null || instance === void 0 ? void 0 : instance.supportTables).toEqual([]);
+  });
+  (0, import_vitest.test)("derives fileless support tables through parsed mutation helpers", function () {
+    var _context_instances_default, _context_instances;
+    var files = {
+      [`${DIR}/post.ts`]: "// namespace",
+      [`${DIR}/helpers/writeAudit.ts`]: "// helper",
+      [`${DIR}/helpers/readSettings.ts`]: "// nested helper"
+    };
+    var empty = {
+      mutations: [],
+      queries: []
+    };
+    var result = (0, import_generate_lite.generateLite)({
+      files,
+      dir: DIR,
+      parse: makeParse({
+        [`${DIR}/post.ts`]: {
+          ...empty,
+          mutations: [{
+            modelName: "post",
+            handlers: [],
+            schema: null
+          }],
+          imports: ["./helpers/writeAudit"],
+          supportTables: ["post"]
+        },
+        [`${DIR}/helpers/writeAudit.ts`]: {
+          ...empty,
+          imports: ["./readSettings"],
+          supportTables: ["audit"]
+        },
+        [`${DIR}/helpers/readSettings.ts`]: {
+          ...empty,
+          supportTables: ["settings"]
+        }
+      })
+    });
+    var runnable = result.files["instances.ts"].replace("import { schema } from './schema'", "").replace("import * as groupedQueries from './groupedQueries'", "").replace("import { models } from './models'", "").replace("export const instances =", "globalThis.instances =").replace(/: string/g, "").replace(" as const", "");
+    var context = {
+      groupedQueries: {},
+      models: {
+        post: {}
+      },
+      schema: {}
+    };
+    (0, import_vm.runInNewContext)(runnable, context);
+    (0, import_vitest.expect)((_context_instances = context.instances) === null || _context_instances === void 0 ? void 0 : (_context_instances_default = _context_instances.default) === null || _context_instances_default === void 0 ? void 0 : _context_instances_default.supportTables).toEqual(["audit", "settings"]);
+  });
+  (0, import_vitest.test)("includes a fileless support table in every lite instance that uses it", function () {
+    var _context_instances_control, _context_instances, _context_instances_project, _context_instances1;
+    var files = {
+      [`${DIR}/on-zero.config.ts`]: `export default defineConfig({ instances: { control: { dir: './planes/control', supportTables: ['manual'] }, project: { scope: 'projectId' } } })`,
+      [`${DIR}/planes/control/account.ts`]: "// control namespace",
+      [`${DIR}/project/message.ts`]: "// project namespace",
+      ["/proj/src/database/schema.ts"]: "// table columns"
+    };
+    var empty = {
+      mutations: [],
+      queries: []
+    };
+    var result = (0, import_generate_lite.generateLite)({
+      files,
+      dir: DIR,
+      parse: makeParse({
+        [`${DIR}/on-zero.config.ts`]: {
+          ...empty,
+          dataConfig: {
+            instances: {
+              control: {
+                dir: "./planes/control",
+                supportTables: ["manual"]
+              },
+              project: {
+                scope: "projectId"
+              }
+            }
+          }
+        },
+        [`${DIR}/planes/control/account.ts`]: {
+          ...empty,
+          mutations: [{
+            modelName: "account",
+            handlers: [],
+            schema: null
+          }],
+          supportTables: ["audit"]
+        },
+        [`${DIR}/project/message.ts`]: {
+          ...empty,
+          mutations: [{
+            modelName: "message",
+            handlers: [],
+            schema: {
+              tableName: "message",
+              primaryKeys: ["id"],
+              columns: [{
+                name: "id",
+                builderText: "string()"
+              }, {
+                name: "projectId",
+                builderText: "string()"
+              }]
+            }
+          }],
+          supportTables: ["audit"]
+        },
+        "/proj/src/database/schema.ts": {
+          ...empty,
+          tables: [{
+            name: "message",
+            columns: ["id", "projectId"]
+          }]
+        }
+      })
+    });
+    var runnable = result.files["instances.ts"].replace("import { schema } from './schema'", "").replace("import * as groupedQueries from './groupedQueries'", "").replace("import { models } from './models'", "").replace("export const instances =", "globalThis.instances =").replace(/: string/g, "").replace(" as const", "");
+    var context = {
+      groupedQueries: {},
+      models: {
+        account: {},
+        message: {}
+      },
+      schema: {}
+    };
+    (0, import_vm.runInNewContext)(runnable, context);
+    (0, import_vitest.expect)((_context_instances = context.instances) === null || _context_instances === void 0 ? void 0 : (_context_instances_control = _context_instances.control) === null || _context_instances_control === void 0 ? void 0 : _context_instances_control.supportTables).toEqual(["audit", "manual"]);
+    (0, import_vitest.expect)((_context_instances1 = context.instances) === null || _context_instances1 === void 0 ? void 0 : (_context_instances_project = _context_instances1.project) === null || _context_instances_project === void 0 ? void 0 : _context_instances_project.supportTables).toEqual(["audit"]);
+  });
+  (0, import_vitest.test)("keeps a configured default lite instance at the data root", function () {
+    var _context_instances_default, _context_instances, _context_instances_project, _context_instances1;
+    var files = {
+      [`${DIR}/on-zero.config.ts`]: `export default defineConfig({ instances: { default: { dir: '.', supportTables: ['accountRepo', 'usageLedger'] }, project: { scope: 'projectId' } } })`,
+      [`${DIR}/account.ts`]: "// control namespace",
+      [`${DIR}/project/message.ts`]: "// project namespace"
+    };
+    var empty = {
+      mutations: [],
+      queries: []
+    };
+    var result = (0, import_generate_lite.generateLite)({
+      files,
+      dir: DIR,
+      parse: makeParse({
+        [`${DIR}/on-zero.config.ts`]: {
+          ...empty,
+          dataConfig: {
+            instances: {
+              default: {
+                dir: ".",
+                supportTables: ["accountRepo", "usageLedger"]
+              },
+              project: {
+                scope: "projectId"
+              }
+            }
+          }
+        },
+        [`${DIR}/account.ts`]: {
+          ...empty,
+          queries: [{
+            name: "accounts",
+            paramTypeText: null
+          }]
+        },
+        [`${DIR}/project/message.ts`]: {
+          ...empty,
+          mutations: [{
+            modelName: "message",
+            handlers: [],
+            schema: {
+              tableName: "message",
+              primaryKeys: ["id"],
+              columns: [{
+                name: "id",
+                builderText: "string()"
+              }, {
+                name: "projectId",
+                builderText: "string()"
+              }]
+            }
+          }]
+        }
+      })
+    });
+    var runnable = result.files["instances.ts"].replace("import { schema } from './schema'", "").replace("import * as groupedQueries from './groupedQueries'", "").replace("import { models } from './models'", "").replace("export const instances =", "globalThis.instances =").replace(/: string/g, "").replace(" as const", "");
+    var context = {
+      groupedQueries: {},
+      models: {
+        message: {}
+      },
+      schema: {}
+    };
+    (0, import_vm.runInNewContext)(runnable, context);
+    (0, import_vitest.expect)((_context_instances = context.instances) === null || _context_instances === void 0 ? void 0 : (_context_instances_default = _context_instances.default) === null || _context_instances_default === void 0 ? void 0 : _context_instances_default.supportTables).toEqual(["accountRepo", "usageLedger"]);
+    (0, import_vitest.expect)((_context_instances1 = context.instances) === null || _context_instances1 === void 0 ? void 0 : (_context_instances_project = _context_instances1.project) === null || _context_instances_project === void 0 ? void 0 : _context_instances_project.supportTables).toEqual([]);
+  });
+  (0, import_vitest.test)("rejects missing configured directories and instance.ts remnants", function () {
+    var empty = {
+      mutations: [],
+      queries: []
+    };
+    (0, import_vitest.expect)(function () {
+      return (0, import_generate_lite.generateLite)({
+        files: {
+          [`${DIR}/on-zero.config.ts`]: `export default defineConfig({ instances: { project: {} } })`
+        },
+        dir: DIR,
+        parse: makeParse({
+          [`${DIR}/on-zero.config.ts`]: {
+            ...empty,
+            dataConfig: {
+              instances: {
+                project: {}
+              }
+            }
+          }
+        })
+      });
+    }).toThrow(/instance 'project' directory does not exist/);
+    (0, import_vitest.expect)(function () {
+      return (0, import_generate_lite.generateLite)({
+        files: {
+          [`${DIR}/on-zero.config.ts`]: `export default defineConfig({ instances: { control: { dir: './shared' }, project: { dir: './shared' } } })`,
+          [`${DIR}/shared/account.ts`]: "// namespace"
+        },
+        dir: DIR,
+        parse: makeParse({
+          [`${DIR}/on-zero.config.ts`]: {
+            ...empty,
+            dataConfig: {
+              instances: {
+                control: {
+                  dir: "./shared"
+                },
+                project: {
+                  dir: "./shared"
+                }
+              }
+            }
+          }
+        })
+      });
+    }).toThrow(/instances 'control' and 'project' resolve to the same directory/);
+    (0, import_vitest.expect)(function () {
+      return (0, import_generate_lite.generateLite)({
+        files: {
+          [`${DIR}/post.ts`]: "// namespace",
+          [`${DIR}/project/instance.ts`]: `export default defineInstance({})`
+        },
+        dir: DIR,
+        parse: makeParse({
+          [`${DIR}/post.ts`]: {
+            ...empty,
+            mutations: [{
+              modelName: "post",
+              handlers: [],
+              schema: null
+            }]
+          }
+        })
+      });
+    }).toThrow(/uses removed instance\.ts configuration/);
   });
 });
 //# sourceMappingURL=generate-lite.test.native.js.map