on-zero 0.7.10 → 0.8.0

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

@@ -33,15 +33,19 @@ var import_vitest = require("vitest");
 var import_generate = require("./generate.native.js");
 const import_meta = {};
 var testDir = (0, import_path.join)((0, import_os.tmpdir)(), "on-zero-test-" + Date.now());
-(0, import_vitest.beforeEach)(function () {
-  (0, import_fs.mkdirSync)((0, import_path.join)(testDir, "models"), {
+function writeFileSync(path, content) {
+  (0, import_fs.mkdirSync)((0, import_path.dirname)(path), {
     recursive: true
   });
-  (0, import_fs.mkdirSync)((0, import_path.join)(testDir, "queries"), {
+  (0, import_fs.writeFileSync)(path, content);
+}
+(0, import_vitest.beforeEach)(function () {
+  (0, import_fs.mkdirSync)(testDir, {
     recursive: true
   });
 });
 (0, import_vitest.afterEach)(function () {
+  import_vitest.vi.restoreAllMocks();
   (0, import_fs.rmSync)(testDir, {
     recursive: true,
     force: true
@@ -49,7 +53,7 @@ var testDir = (0, import_path.join)((0, import_os.tmpdir)(), "on-zero-test-" + D
 });
 (0, import_vitest.describe)("generate", function () {
   (0, import_vitest.test)("generates models.ts, types.ts, tables.ts from model files", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `
 import { table, string, boolean } from 'on-zero'
 
 export const schema = table('post', {
@@ -58,7 +62,7 @@ export const schema = table('post', {
   published: boolean(),
 })
 `);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/comment.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "comment/mutations.ts"), `
 import { table, string } from 'on-zero'
 
 export const schema = table('comment', {
@@ -67,8 +71,8 @@ export const schema = table('comment', {
   body: string(),
 })
 `);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.test.ts"), `throw new Error('test files must not be generated as models')`);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "queries/comment.spec.ts"), `throw new Error('spec files must not be generated as queries')`);
+    writeFileSync((0, import_path.join)(testDir, "post/post.test.ts"), `throw new Error('test files must not be generated as models')`);
+    writeFileSync((0, import_path.join)(testDir, "comment/comment.spec.ts"), `throw new Error('spec files must not be generated as queries')`);
     var result = await (0, import_generate.generate)({
       dir: testDir,
       silent: true
@@ -80,20 +84,20 @@ export const schema = table('comment', {
     (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/types.ts"))).toBe(true);
     (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/tables.ts"))).toBe(true);
     var modelsContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/models.ts"), "utf-8");
-    (0, import_vitest.expect)(modelsContent).toContain("import * as comment from '../models/comment'");
-    (0, import_vitest.expect)(modelsContent).toContain("import * as post from '../models/post'");
+    (0, import_vitest.expect)(modelsContent).toContain("import * as comment from '../comment/mutations'");
+    (0, import_vitest.expect)(modelsContent).toContain("import * as post from '../post/mutations'");
     (0, import_vitest.expect)(modelsContent).not.toContain("post.test");
     (0, import_vitest.expect)(modelsContent).toContain("export const models = {");
     var typesContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/types.ts"), "utf-8");
     (0, import_vitest.expect)(typesContent).toContain("export type Post = TableInsertRow<typeof schema.post>");
     (0, import_vitest.expect)(typesContent).toContain("export type Comment = TableInsertRow<typeof schema.comment>");
     var tablesContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/tables.ts"), "utf-8");
-    (0, import_vitest.expect)(tablesContent).toContain("export { schema as post } from '../models/post'");
-    (0, import_vitest.expect)(tablesContent).toContain("export { schema as comment } from '../models/comment'");
+    (0, import_vitest.expect)(tablesContent).toContain("export { schema as post } from '../post/mutations'");
+    (0, import_vitest.expect)(tablesContent).toContain("export { schema as comment } from '../comment/mutations'");
   });
   (0, import_vitest.test)("generates query validators from query files", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `export const schema = table('post', { id: string() })`);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "queries/post.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
+    writeFileSync((0, import_path.join)(testDir, "post/queries.ts"), `
 import { zero } from '../zero'
 
 export const allPosts = () => zero.query.post
@@ -111,7 +115,8 @@ export const postsByAuthor = ({ authorId, limit }: { authorId: string; limit?: n
     (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/groupedQueries.ts"))).toBe(true);
     (0, import_vitest.expect)((0, import_fs.existsSync)((0, import_path.join)(testDir, "generated/syncedQueries.ts"))).toBe(true);
     var groupedContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/groupedQueries.ts"), "utf-8");
-    (0, import_vitest.expect)(groupedContent).toContain("export * as post from '../queries/post'");
+    (0, import_vitest.expect)(groupedContent).toContain("import * as postSource from '../post/queries'");
+    (0, import_vitest.expect)(groupedContent).toContain("postById: postSource.postById");
     var syncedContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/syncedQueries.ts"), "utf-8");
     (0, import_vitest.expect)(syncedContent).toContain("allPosts: defineQuery");
     (0, import_vitest.expect)(syncedContent).toContain("postById: defineQuery");
@@ -119,8 +124,8 @@ export const postsByAuthor = ({ authorId, limit }: { authorId: string; limit?: n
     (0, import_vitest.expect)(syncedContent).toContain("v.object");
   });
   (0, import_vitest.test)("skips permission exports in queries", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `export const schema = table('post', { id: string() })`);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "queries/post.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
+    writeFileSync((0, import_path.join)(testDir, "post/queries.ts"), `
 export const permission = () => ({ canRead: true })
 export const allPosts = () => zero.query.post
 `);
@@ -134,20 +139,20 @@ export const allPosts = () => zero.query.post
     (0, import_vitest.expect)(syncedContent).not.toContain("permission:");
   });
   (0, import_vitest.test)("aliases user import without changing the model key", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/user.ts"), `export const schema = table('user', { id: string(), name: string() })`);
+    writeFileSync((0, import_path.join)(testDir, "user/mutations.ts"), `export const schema = table('user', { id: string(), name: string() })`);
     await (0, import_generate.generate)({
       dir: testDir,
       silent: true
     });
     var modelsContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/models.ts"), "utf-8");
-    (0, import_vitest.expect)(modelsContent).toContain("import * as userPublic from '../models/user'");
+    (0, import_vitest.expect)(modelsContent).toContain("import * as userPublic from '../user/mutations'");
     (0, import_vitest.expect)(modelsContent).toContain("user: userPublic,");
     (0, import_vitest.expect)(modelsContent).not.toContain("\n  userPublic,");
     var typesContent = (0, import_fs.readFileSync)((0, import_path.join)(testDir, "generated/types.ts"), "utf-8");
     (0, import_vitest.expect)(typesContent).toContain("typeof schema.userPublic");
   });
   (0, import_vitest.test)("runs after command when files change", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `export const schema = table('post', { id: string() })`);
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
     var markerFile = (0, import_path.join)(testDir, "after-ran");
     var result = await (0, import_generate.generate)({
       dir: testDir,
@@ -158,7 +163,7 @@ export const allPosts = () => zero.query.post
     (0, import_vitest.expect)((0, import_fs.existsSync)(markerFile)).toBe(true);
   });
   (0, import_vitest.test)("does not regenerate when nothing changed", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `export const schema = table('post', { id: string() })`);
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
     var first = await (0, import_generate.generate)({
       dir: testDir,
       silent: true
@@ -171,8 +176,8 @@ export const allPosts = () => zero.query.post
     (0, import_vitest.expect)(second.filesChanged).toBe(0);
   });
   (0, import_vitest.test)("force regenerates without source changes", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `export const schema = table('post', { id: string() })`);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "queries/post.ts"), `export const allPosts = () => zero.query.post`);
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
+    writeFileSync((0, import_path.join)(testDir, "post/queries.ts"), `export const allPosts = () => zero.query.post`);
     await (0, import_generate.generate)({
       dir: testDir,
       silent: true
@@ -187,9 +192,333 @@ export const allPosts = () => zero.query.post
     (0, import_vitest.expect)((0, import_fs.existsSync)(syncedQueriesPath)).toBe(true);
   });
 });
+(0, import_vitest.describe)("instance layout", function () {
+  var dataDir = function dataDir2() {
+    return (0, import_path.join)(testDir, "src/data");
+  };
+  (0, import_vitest.test)("discovers file and folder namespaces and emits related sync closure", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "control/reaction.ts"), `export const allReactions = () => zql.reaction`);
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message/queries.ts"), `
+const unused = () => zql.message.related('notARealRelation')
+const withComments = () => zql.message.related('comments', (q) => q.related('author'))
+export const messages = () => withComments()
+`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message/mutations.ts"), `export const schema = table('message').columns({ id: string(), projectId: string() })`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message/helpers.ts"), `export const privateHelper = () => 'ignored'`);
+    writeFileSync((0, import_path.join)(testDir, "src/database/relations.ts"), `
+export const relations = defineRelations(schema, (r) => ({
+  message: { comments: r.many.comment({}) },
+  comment: { author: r.one.userPublic({}) },
+}))
+`);
+    writeFileSync((0, import_path.join)(testDir, "src/database/schema.ts"), `
+export const comment = sqliteTable('comment', { id: text(), projectId: text() })
+export const userPublic = sqliteTable('user_public', { id: text(), projectId: text() })
+`);
+    var membership = await (0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    });
+    (0, import_vitest.expect)(membership.allTables).toEqual(["comment", "message", "reaction", "userPublic"]);
+    (0, import_vitest.expect)(membership.instances.project).toEqual({
+      tables: ["message"],
+      syncTables: ["comment", "message", "userPublic"],
+      supportTables: [],
+      scope: "projectId"
+    });
+    await (0, import_generate.generate)({
+      dir: dataDir(),
+      silent: true
+    });
+    var grouped = (0, import_fs.readFileSync)((0, import_path.join)(dataDir(), "generated/groupedQueries.ts"), "utf8");
+    (0, import_vitest.expect)(grouped).toContain("from '../control/reaction'");
+    (0, import_vitest.expect)(grouped).toContain("from '../project/message/queries'");
+    (0, import_vitest.expect)(grouped).not.toContain("privateHelper");
+    var manifest = (0, import_fs.readFileSync)((0, import_path.join)(dataDir(), "generated/instances.ts"), "utf8");
+    (0, import_vitest.expect)(manifest).toContain("control: {");
+    (0, import_vitest.expect)(manifest).toContain("project: {");
+    (0, import_vitest.expect)(manifest).toContain('tables: ["message"]');
+    (0, import_vitest.expect)(manifest).toContain('syncTables: ["comment","message","userPublic"]');
+    (0, import_vitest.expect)(manifest).toContain(`defaultVisibility: (value: string) => ({ column: "projectId", value })`);
+  });
+  (0, import_vitest.test)("derives single-file namespaces from data exports", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "server.ts"), `export const serverRows = () => zql.server`);
+    writeFileSync((0, import_path.join)(dataDir(), "types.ts"), `export const formatRow = (value: string) => value`);
+    writeFileSync((0, import_path.join)(dataDir(), "auth.ts"), `export function authId(auth: { id: string }) { return auth.id }`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).resolves.toEqual({
+      instances: {
+        default: {
+          tables: ["server"],
+          syncTables: ["server"],
+          supportTables: [],
+          scope: null
+        }
+      },
+      allTables: ["server"]
+    });
+  });
+  (0, import_vitest.test)("warns once and ignores an unparseable non-data file", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "post.ts"), `export const posts = () => zql.post`);
+    writeFileSync((0, import_path.join)(dataDir(), "types.ts"), `export type Broken = {`);
+    var warn = import_vitest.vi.spyOn(console, "warn").mockImplementation(function () {});
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).resolves.toMatchObject({
+      allTables: ["post"]
+    });
+    (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)("derives fileless support tables through mutation helpers", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "post.ts"), `
+import { writeAudit } from './helpers/writeAudit'
+export const posts = () => zql.post
+export const mutate = mutations('post', { save: async (ctx) => writeAudit(ctx.tx) })
+`);
+    writeFileSync((0, import_path.join)(dataDir(), "helpers/writeAudit.ts"), `
+import { readSettings } from './readSettings'
+export async function writeAudit(tx: Transaction) {
+  await tx.mutate.audit.insert({ id: 'audit' })
+  await tx.mutate.post.update({ id: 'post' })
+  await tx.mutate[tableName].insert({ id: 'dynamic' })
+  return readSettings(tx)
+}
+`);
+    writeFileSync((0, import_path.join)(dataDir(), "helpers/readSettings.ts"), `export const readSettings = (tx: Transaction) => tx.query.settings`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).resolves.toEqual({
+      instances: {
+        default: {
+          tables: ["post"],
+          syncTables: ["post"],
+          supportTables: ["audit", "settings"],
+          scope: null
+        }
+      },
+      allTables: ["audit", "post", "settings"]
+    });
+  });
+  (0, import_vitest.test)("includes a fileless support table in every instance that uses it", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "control/account.ts"), `export const mutate = mutations('account', { save: async (ctx) => ctx.tx.mutate.audit.insert({}) })`);
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message.ts"), `
+export const schema = table('message').columns({ id: string(), projectId: string() })
+export const mutate = mutations(schema, permission, {
+  save: async (ctx) => ctx.tx.mutate.audit.insert({}),
+})
+`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).resolves.toMatchObject({
+      instances: {
+        control: {
+          supportTables: ["audit"]
+        },
+        project: {
+          supportTables: ["audit"]
+        }
+      },
+      allTables: ["account", "audit", "message"]
+    });
+  });
+  (0, import_vitest.test)("keeps a configured default instance at the data root", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { default: { dir: '.', supportTables: ['accountGithubOrgLink', 'accountRepo', 'usageLedger'] }, project: { scope: 'projectId' } } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "account.ts"), `export const accounts = () => zql.account`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message.ts"), `export const schema = table('message').columns({ id: string(), projectId: string() })`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).resolves.toEqual({
+      instances: {
+        default: {
+          tables: ["account"],
+          syncTables: ["account"],
+          supportTables: ["accountGithubOrgLink", "accountRepo", "usageLedger"],
+          scope: null
+        },
+        project: {
+          tables: ["message"],
+          syncTables: ["message"],
+          supportTables: [],
+          scope: "projectId"
+        }
+      },
+      allTables: ["account", "accountGithubOrgLink", "accountRepo", "message", "usageLedger"]
+    });
+  });
+  (0, import_vitest.test)("emits only relations whose source and target are derived members", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "post.ts"), `export const posts = () => zql.post`);
+    writeFileSync((0, import_path.join)(dataDir(), "comment.ts"), `export const comments = () => zql.comment`);
+    writeFileSync((0, import_path.join)(testDir, "src/database/relations.ts"), `
+export const relations = defineRelations(schema, (r) => ({
+  post: {
+    comments: r.many.comment({}),
+    privateNotes: r.many.privateNote({}),
+  },
+  comment: { post: r.one.post({}), author: r.one.privateUser({}) },
+  privateNote: { post: r.one.post({}) },
+}))
+`);
+    var generated = await (0, import_generate.generateDrizzleSchemaInputFile)({
+      dir: dataDir(),
+      schemaImportPath: "../../database/schema"
+    });
+    var runnable = generated.replace(`import { defineRelations } from 'drizzle-orm'`, "").replace(`import * as schema from "../../database/schema"`, "").replace(/export \{[^\n]+\} from [^\n]+/, "").replace("export const relations =", "globalThis.relations =");
+    var context = {
+      schema: {
+        comment: {},
+        post: {}
+      },
+      defineRelations: function defineRelations(_schema, factory) {
+        return factory({
+          one: new Proxy({}, {
+            get: function get(_target, table) {
+              return function () {
+                return {
+                  table
+                };
+              };
+            }
+          }),
+          many: new Proxy({}, {
+            get: function get(_target, table) {
+              return function () {
+                return {
+                  table
+                };
+              };
+            }
+          })
+        });
+      }
+    };
+    (0, import_vm.runInNewContext)(runnable, context);
+    (0, import_vitest.expect)(context.relations).toEqual({
+      comment: {
+        post: {
+          table: "post"
+        }
+      },
+      post: {
+        comments: {
+          table: "comment"
+        }
+      }
+    });
+  });
+  (0, import_vitest.test)("rejects a relation that crosses instance ownership", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "control/userPublic.ts"), `export const users = () => zql.userPublic`);
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message.ts"), `
+export const schema = table('message').columns({ id: string(), projectId: string() })
+export const messages = () => zql.message.related('author')
+`);
+    writeFileSync((0, import_path.join)(testDir, "src/database/relations.ts"), `export const relations = defineRelations(schema, (r) => ({ message: { author: r.one.userPublic({}) } }))`);
+    await (0, import_vitest.expect)((0, import_generate.generate)({
+      dir: dataDir(),
+      silent: true
+    })).rejects.toThrow(/message\.messages.*instance 'project'.*userPublic.*instance 'control'/);
+  });
+  (0, import_vitest.test)("rejects a scoped sync table without the scope column", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { project: { scope: 'projectId' } } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message.ts"), `export const schema = table('message').columns({ id: string() })`);
+    await (0, import_vitest.expect)((0, import_generate.generate)({
+      dir: dataDir(),
+      silent: true
+    })).rejects.toThrow(/table 'message'.*instance 'project'.*scope column 'projectId'/);
+  });
+  (0, import_vitest.test)("rejects duplicate namespaces across instances", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "control/message.ts"), `export const messages = () => zql.message`);
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message.ts"), `export const schema = table('message').columns({ projectId: string() })`);
+    await (0, import_vitest.expect)((0, import_generate.generate)({
+      dir: dataDir(),
+      silent: true
+    })).rejects.toThrow(/namespace 'message'.*instances 'control' and 'project'/);
+  });
+  (0, import_vitest.test)("resolves configured instance directories relative to the config file", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { control: { dir: './planes/control-data', supportTables: ['audit'] }, project: { dir: '../project-data', scope: 'projectId' } } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "planes/control-data/account.ts"), `export const accounts = () => zql.account`);
+    writeFileSync((0, import_path.join)(testDir, "src/project-data/message.ts"), `export const schema = table('message').columns({ id: string(), projectId: string() })`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir(),
+      config: (0, import_path.join)(dataDir(), "on-zero.config.ts")
+    })).resolves.toEqual({
+      instances: {
+        control: {
+          tables: ["account"],
+          syncTables: ["account"],
+          supportTables: ["audit"],
+          scope: null
+        },
+        project: {
+          tables: ["message"],
+          syncTables: ["message"],
+          supportTables: [],
+          scope: "projectId"
+        }
+      },
+      allTables: ["account", "audit", "message"]
+    });
+    await (0, import_vitest.expect)((0, import_generate.generate)({
+      dir: dataDir(),
+      config: (0, import_path.join)(dataDir(), "on-zero.config.ts"),
+      silent: true
+    })).resolves.toMatchObject({
+      modelCount: 2,
+      schemaCount: 1
+    });
+    (0, import_vitest.expect)((0, import_fs.readFileSync)((0, import_path.join)(dataDir(), "generated/models.ts"), "utf8")).toContain("from '../../project-data/message'");
+  });
+  (0, import_vitest.test)("rejects missing configured instance directories", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { project: { dir: './missing' } } })`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).rejects.toThrow(/instance 'project' directory does not exist.*missing/);
+  });
+  (0, import_vitest.test)("rejects two instances that resolve to the same directory", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { control: { dir: './shared' }, project: { dir: './shared' } } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "shared/account.ts"), `export const accounts = () => zql.account`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).rejects.toThrow(/instances 'control' and 'project' resolve to the same directory/);
+  });
+  (0, import_vitest.test)("rejects root namespaces when instances are configured", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "on-zero.config.ts"), `export default defineConfig({ instances: { project: {} } })`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/message.ts"), `export const rows = () => zql.message`);
+    writeFileSync((0, import_path.join)(dataDir(), "account.ts"), `export const rows = () => zql.account`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).rejects.toThrow(/data namespace .*account\.ts.*outside every instance directory/);
+  });
+  (0, import_vitest.test)("rejects removed instance.ts configuration", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "post.ts"), `export const posts = () => zql.post`);
+    writeFileSync((0, import_path.join)(dataDir(), "project/instance.ts"), `export default defineInstance({ scope: 'projectId' })`);
+    await (0, import_vitest.expect)((0, import_generate.deriveDataMembership)({
+      dir: dataDir()
+    })).rejects.toThrow(/uses removed instance\.ts configuration/);
+  });
+  (0, import_vitest.test)("rejects the removed top-level layout", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "queries/message.ts"), `export const messages = () => zql.message`);
+    await (0, import_vitest.expect)((0, import_generate.generate)({
+      dir: dataDir(),
+      silent: true
+    })).rejects.toThrow(/removed top-level queries\/ layout/);
+  });
+  (0, import_vitest.test)("rejects dynamically named relations", async function () {
+    writeFileSync((0, import_path.join)(dataDir(), "message.ts"), `export const messages = (relation: string) => zql.message.related(relation)`);
+    await (0, import_vitest.expect)((0, import_generate.generate)({
+      dir: dataDir(),
+      silent: true
+    })).rejects.toThrow(/related\(\) without a string literal.*statically derivable/);
+  });
+});
 (0, import_vitest.describe)("mutations", function () {
   (0, import_vitest.test)("generates validators for inline mutation param types", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `
 import { table, string } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
 
@@ -218,7 +547,7 @@ export const mutate = mutations(schema, perm, {
     (0, import_vitest.expect)(content).toContain("v.string()");
   });
   (0, import_vitest.test)("generates CRUD validators from schema columns", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/task.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "task/mutations.ts"), `
 import { table, string, number, boolean } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
 
@@ -245,7 +574,7 @@ export const mutate = mutations(schema, perm)
     (0, import_vitest.expect)(content).toContain("delete:");
   });
   (0, import_vitest.test)("treats models without export const mutate as empty mutations", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/readonly.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "readonly/mutations.ts"), `
 import { table, string } from 'on-zero'
 
 export const schema = table('readonly').columns({
@@ -262,7 +591,7 @@ export const schema = table('readonly').columns({
     (0, import_vitest.expect)(content).toContain("readonly: {");
   });
   (0, import_vitest.test)("extracts custom mutations from bare mutations({})", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/admin.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "admin/mutations.ts"), `
 import { mutations } from 'on-zero'
 
 export const mutate = mutations({
@@ -280,7 +609,7 @@ export const mutate = mutations({
     (0, import_vitest.expect)(content).toContain("v.string()");
   });
   (0, import_vitest.test)("generates validators for string-model multiline mutation params", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/agentEvent.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "agentEvent/mutations.ts"), `
 import { mutations, serverWhere } from 'on-zero'
 
 const perm = serverWhere('agentEvent', () => true)
@@ -314,7 +643,7 @@ export const mutate = mutations('agentEvent', perm, {
     (0, import_vitest.expect)(content).not.toContain("claimReviewLease: v.object({})");
   });
   (0, import_vitest.test)("generates validators for object intersections", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/agent.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "agent/mutations.ts"), `
 import { mutations, serverWhere } from 'on-zero'
 
 const perm = serverWhere('agent', () => true)
@@ -347,7 +676,7 @@ export const mutate = mutations('agent', perm, {
     (0, import_vitest.expect)(content).not.toContain("[key");
   });
   (0, import_vitest.test)("uses v.unknown for untyped mutation payloads", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/project.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "project/mutations.ts"), `
 import { mutations, serverWhere } from 'on-zero'
 
 const perm = serverWhere('project', () => true)
@@ -367,7 +696,7 @@ export const mutate = mutations('project', perm, {
     (0, import_vitest.expect)(content).not.toContain("insert: v.void_()");
   });
   (0, import_vitest.test)("handles mutations with only context param (void)", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/user.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "user/mutations.ts"), `
 import { table, string } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
 
@@ -392,7 +721,7 @@ export const mutate = mutations(schema, perm, {
     (0, import_vitest.expect)(content).toContain("finishOnboarding");
   });
   (0, import_vitest.test)("handles primitive param type", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/user.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "user/mutations.ts"), `
 import { table, string } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
 
@@ -418,7 +747,7 @@ export const mutate = mutations(schema, perm, {
     (0, import_vitest.expect)(content).toContain("v.string()");
   });
   (0, import_vitest.test)("handles array param type", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/batch.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "batch/mutations.ts"), `
 import { mutations } from 'on-zero'
 
 export const mutate = mutations({
@@ -436,7 +765,7 @@ export const mutate = mutations({
     (0, import_vitest.expect)(content).toContain("v.array");
   });
   (0, import_vitest.test)("populates mutationCount and caching works", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/item.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "item/mutations.ts"), `
 import { table, string } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
 
@@ -468,14 +797,14 @@ export const mutate = mutations(schema, perm, {
 });
 (0, import_vitest.describe)("type resolution", function () {
   (0, import_vitest.test)("resolves imported type references for mutations", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/types.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "post/types.ts"), `
 export type ArchiveParams = {
   id: string
   reason: string
   archived: boolean
 }
 `);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `
 import { table, string, boolean } from 'on-zero'
 import { mutations } from 'on-zero'
 import type { ArchiveParams } from './types'
@@ -497,7 +826,7 @@ export const mutate = mutations({
     (0, import_vitest.expect)(content).toContain("archived");
   });
   (0, import_vitest.test)("resolves utility types like Pick", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/types.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "item/types.ts"), `
 export type Item = {
   id: string
   name: string
@@ -505,7 +834,7 @@ export type Item = {
   count: number
 }
 `);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/item.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "item/mutations.ts"), `
 import { table, string, number } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
 import type { Item } from './types'
@@ -536,8 +865,8 @@ export const mutate = mutations(schema, perm, {
     (0, import_vitest.expect)(content).not.toMatch(/rename:[\s\S]*count/);
   });
   (0, import_vitest.test)("resolves instantiated Zero row fields through Partial and Omit", async function () {
-    (0, import_fs.symlinkSync)((0, import_path.join)(import_meta.dirname, "../../../node_modules"), (0, import_path.join)(testDir, "node_modules"), "dir");
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/types.ts"), `
+    (0, import_fs.symlinkSync)((0, import_path.join)(import_meta.dirname, "../node_modules"), (0, import_path.join)(testDir, "node_modules"), "dir");
+    writeFileSync((0, import_path.join)(testDir, "item/types.ts"), `
 import type { Row } from '@rocicorp/zero'
 import { drizzleZeroConfig } from 'drizzle-zero-sqlite'
 import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
@@ -551,7 +880,7 @@ const schema = drizzleZeroConfig({ item })
 
 export type Item = Row<(typeof schema)['tables']['item']>
 `);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/item.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "item/mutations.ts"), `
 import { mutations } from 'on-zero'
 import type { Item } from './types'
 
@@ -574,13 +903,13 @@ export const mutate = mutations('item', {
     (0, import_vitest.expect)(content).not.toContain("description: v.optional(v.unknown())");
   });
   (0, import_vitest.test)("skips symbol-keyed properties when resolving imported mutation param types", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/types.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "item/types.ts"), `
 export type WeirdParams = {
   id: string
   [Symbol.iterator]?: () => Iterator<string>
 }
 `);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/item.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "item/mutations.ts"), `
 import { mutations } from 'on-zero'
 import type { WeirdParams } from './types'
 
@@ -600,14 +929,14 @@ export const mutate = mutations({
     (0, import_vitest.expect)(content).not.toContain("__@iterator");
   });
   (0, import_vitest.test)("resolves imported types in query params", async function () {
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "models/post.ts"), `export const schema = table('post', { id: string() })`);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "queries/types.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "post/mutations.ts"), `export const schema = table('post', { id: string() })`);
+    writeFileSync((0, import_path.join)(testDir, "post/types.ts"), `
 export type PostFilter = {
   authorId: string
   published: boolean
 }
 `);
-    (0, import_fs.writeFileSync)((0, import_path.join)(testDir, "queries/post.ts"), `
+    writeFileSync((0, import_path.join)(testDir, "post/queries.ts"), `
 import type { PostFilter } from './types'
 
 export const filteredPosts = (filter: PostFilter) => zero.query.post