on-zero 0.7.10 → 0.8.0

package/src/generate.test.ts

@@ -4,32 +4,42 @@ import {
   readFileSync,
   rmSync,
   symlinkSync,
-  writeFileSync,
+  writeFileSync as writeFile,
 } from 'node:fs'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 import { runInNewContext } from 'node:vm'
 
 import * as zero from '@rocicorp/zero'
-import { afterEach, beforeEach, describe, expect, test } from 'vitest'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 
-import { generate, generateDrizzleSchemaFile } from './generate'
+import {
+  deriveDataMembership,
+  generate,
+  generateDrizzleSchemaFile,
+  generateDrizzleSchemaInputFile,
+} from './generate'
 
 const testDir = join(tmpdir(), 'on-zero-test-' + Date.now())
 
+function writeFileSync(path: string, content: string) {
+  mkdirSync(dirname(path), { recursive: true })
+  writeFile(path, content)
+}
+
 beforeEach(() => {
-  mkdirSync(join(testDir, 'models'), { recursive: true })
-  mkdirSync(join(testDir, 'queries'), { recursive: true })
+  mkdirSync(testDir, { recursive: true })
 })
 
 afterEach(() => {
+  vi.restoreAllMocks()
   rmSync(testDir, { recursive: true, force: true })
 })
 
 describe('generate', () => {
   test('generates models.ts, types.ts, tables.ts from model files', async () => {
     writeFileSync(
-      join(testDir, 'models/post.ts'),
+      join(testDir, 'post/mutations.ts'),
       `
 import { table, string, boolean } from 'on-zero'
 
@@ -38,11 +48,11 @@ export const schema = table('post', {
   title: string(),
   published: boolean(),
 })
-`,
+`
     )
 
     writeFileSync(
-      join(testDir, 'models/comment.ts'),
+      join(testDir, 'comment/mutations.ts'),
       `
 import { table, string } from 'on-zero'
 
@@ -51,16 +61,16 @@ export const schema = table('comment', {
   postId: string(),
   body: string(),
 })
-`,
+`
     )
 
     writeFileSync(
-      join(testDir, 'models/post.test.ts'),
-      `throw new Error('test files must not be generated as models')`,
+      join(testDir, 'post/post.test.ts'),
+      `throw new Error('test files must not be generated as models')`
     )
     writeFileSync(
-      join(testDir, 'queries/comment.spec.ts'),
-      `throw new Error('spec files must not be generated as queries')`,
+      join(testDir, 'comment/comment.spec.ts'),
+      `throw new Error('spec files must not be generated as queries')`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -76,37 +86,37 @@ export const schema = table('comment', {
 
     // check models.ts content
     const modelsContent = readFileSync(join(testDir, 'generated/models.ts'), 'utf-8')
-    expect(modelsContent).toContain("import * as comment from '../models/comment'")
-    expect(modelsContent).toContain("import * as post from '../models/post'")
+    expect(modelsContent).toContain("import * as comment from '../comment/mutations'")
+    expect(modelsContent).toContain("import * as post from '../post/mutations'")
     expect(modelsContent).not.toContain('post.test')
     expect(modelsContent).toContain('export const models = {')
 
     // check types.ts content
     const typesContent = readFileSync(join(testDir, 'generated/types.ts'), 'utf-8')
     expect(typesContent).toContain(
-      'export type Post = TableInsertRow<typeof schema.post>',
+      'export type Post = TableInsertRow<typeof schema.post>'
     )
     expect(typesContent).toContain(
-      'export type Comment = TableInsertRow<typeof schema.comment>',
+      'export type Comment = TableInsertRow<typeof schema.comment>'
     )
 
     // check tables.ts content
     const tablesContent = readFileSync(join(testDir, 'generated/tables.ts'), 'utf-8')
-    expect(tablesContent).toContain("export { schema as post } from '../models/post'")
+    expect(tablesContent).toContain("export { schema as post } from '../post/mutations'")
     expect(tablesContent).toContain(
-      "export { schema as comment } from '../models/comment'",
+      "export { schema as comment } from '../comment/mutations'"
     )
   })
 
   test('generates query validators from query files', async () => {
     // need at least one model
     writeFileSync(
-      join(testDir, 'models/post.ts'),
-      `export const schema = table('post', { id: string() })`,
+      join(testDir, 'post/mutations.ts'),
+      `export const schema = table('post', { id: string() })`
     )
 
     writeFileSync(
-      join(testDir, 'queries/post.ts'),
+      join(testDir, 'post/queries.ts'),
       `
 import { zero } from '../zero'
 
@@ -116,7 +126,7 @@ export const postById = ({ id }: { id: string }) => zero.query.post.where('id',
 
 export const postsByAuthor = ({ authorId, limit }: { authorId: string; limit?: number }) =>
   zero.query.post.where('authorId', authorId).limit(limit ?? 10)
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -130,14 +140,15 @@ export const postsByAuthor = ({ authorId, limit }: { authorId: string; limit?: n
     // check groupedQueries.ts
     const groupedContent = readFileSync(
       join(testDir, 'generated/groupedQueries.ts'),
-      'utf-8',
+      'utf-8'
     )
-    expect(groupedContent).toContain("export * as post from '../queries/post'")
+    expect(groupedContent).toContain("import * as postSource from '../post/queries'")
+    expect(groupedContent).toContain('postById: postSource.postById')
 
     // check syncedQueries.ts has validators
     const syncedContent = readFileSync(
       join(testDir, 'generated/syncedQueries.ts'),
-      'utf-8',
+      'utf-8'
     )
     expect(syncedContent).toContain('allPosts: defineQuery')
     expect(syncedContent).toContain('postById: defineQuery')
@@ -147,16 +158,16 @@ export const postsByAuthor = ({ authorId, limit }: { authorId: string; limit?: n
 
   test('skips permission exports in queries', async () => {
     writeFileSync(
-      join(testDir, 'models/post.ts'),
-      `export const schema = table('post', { id: string() })`,
+      join(testDir, 'post/mutations.ts'),
+      `export const schema = table('post', { id: string() })`
     )
 
     writeFileSync(
-      join(testDir, 'queries/post.ts'),
+      join(testDir, 'post/queries.ts'),
       `
 export const permission = () => ({ canRead: true })
 export const allPosts = () => zero.query.post
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -165,7 +176,7 @@ export const allPosts = () => zero.query.post
 
     const syncedContent = readFileSync(
       join(testDir, 'generated/syncedQueries.ts'),
-      'utf-8',
+      'utf-8'
     )
     expect(syncedContent).toContain('allPosts')
     expect(syncedContent).not.toContain('permission:')
@@ -173,14 +184,14 @@ export const allPosts = () => zero.query.post
 
   test('aliases user import without changing the model key', async () => {
     writeFileSync(
-      join(testDir, 'models/user.ts'),
-      `export const schema = table('user', { id: string(), name: string() })`,
+      join(testDir, 'user/mutations.ts'),
+      `export const schema = table('user', { id: string(), name: string() })`
     )
 
     await generate({ dir: testDir, silent: true })
 
     const modelsContent = readFileSync(join(testDir, 'generated/models.ts'), 'utf-8')
-    expect(modelsContent).toContain("import * as userPublic from '../models/user'")
+    expect(modelsContent).toContain("import * as userPublic from '../user/mutations'")
     expect(modelsContent).toContain('user: userPublic,')
     expect(modelsContent).not.toContain('\n  userPublic,')
 
@@ -190,8 +201,8 @@ export const allPosts = () => zero.query.post
 
   test('runs after command when files change', async () => {
     writeFileSync(
-      join(testDir, 'models/post.ts'),
-      `export const schema = table('post', { id: string() })`,
+      join(testDir, 'post/mutations.ts'),
+      `export const schema = table('post', { id: string() })`
     )
 
     // use a command that creates a marker file
@@ -208,8 +219,8 @@ export const allPosts = () => zero.query.post
 
   test('does not regenerate when nothing changed', async () => {
     writeFileSync(
-      join(testDir, 'models/post.ts'),
-      `export const schema = table('post', { id: string() })`,
+      join(testDir, 'post/mutations.ts'),
+      `export const schema = table('post', { id: string() })`
     )
 
     const first = await generate({ dir: testDir, silent: true })
@@ -221,12 +232,12 @@ export const allPosts = () => zero.query.post
 
   test('force regenerates without source changes', async () => {
     writeFileSync(
-      join(testDir, 'models/post.ts'),
-      `export const schema = table('post', { id: string() })`,
+      join(testDir, 'post/mutations.ts'),
+      `export const schema = table('post', { id: string() })`
     )
     writeFileSync(
-      join(testDir, 'queries/post.ts'),
-      `export const allPosts = () => zero.query.post`,
+      join(testDir, 'post/queries.ts'),
+      `export const allPosts = () => zero.query.post`
     )
     await generate({ dir: testDir, silent: true })
     const syncedQueriesPath = join(testDir, 'generated/syncedQueries.ts')
@@ -238,10 +249,461 @@ export const allPosts = () => zero.query.post
   })
 })
 
+describe('instance layout', () => {
+  const dataDir = () => join(testDir, 'src/data')
+
+  test('discovers file and folder namespaces and emits related sync closure', async () => {
+    writeFileSync(
+      join(dataDir(), 'control/reaction.ts'),
+      `export const allReactions = () => zql.reaction`
+    )
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`
+    )
+    writeFileSync(
+      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(
+      join(dataDir(), 'project/message/mutations.ts'),
+      `export const schema = table('message').columns({ id: string(), projectId: string() })`
+    )
+    writeFileSync(
+      join(dataDir(), 'project/message/helpers.ts'),
+      `export const privateHelper = () => 'ignored'`
+    )
+    writeFileSync(
+      join(testDir, 'src/database/relations.ts'),
+      `
+export const relations = defineRelations(schema, (r) => ({
+  message: { comments: r.many.comment({}) },
+  comment: { author: r.one.userPublic({}) },
+}))
+`
+    )
+    writeFileSync(
+      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() })
+`
+    )
+
+    const membership = await deriveDataMembership({ dir: dataDir() })
+    expect(membership.allTables).toEqual(['comment', 'message', 'reaction', 'userPublic'])
+    expect(membership.instances.project).toEqual({
+      tables: ['message'],
+      syncTables: ['comment', 'message', 'userPublic'],
+      supportTables: [],
+      scope: 'projectId',
+    })
+
+    await generate({ dir: dataDir(), silent: true })
+
+    const grouped = readFileSync(join(dataDir(), 'generated/groupedQueries.ts'), 'utf8')
+    expect(grouped).toContain("from '../control/reaction'")
+    expect(grouped).toContain("from '../project/message/queries'")
+    expect(grouped).not.toContain('privateHelper')
+
+    const manifest = readFileSync(join(dataDir(), 'generated/instances.ts'), 'utf8')
+    expect(manifest).toContain('control: {')
+    expect(manifest).toContain('project: {')
+    expect(manifest).toContain('tables: ["message"]')
+    expect(manifest).toContain('syncTables: ["comment","message","userPublic"]')
+    expect(manifest).toContain(
+      `defaultVisibility: (value: string) => ({ column: "projectId", value })`
+    )
+  })
+
+  test('derives single-file namespaces from data exports', async () => {
+    writeFileSync(
+      join(dataDir(), 'server.ts'),
+      `export const serverRows = () => zql.server`
+    )
+    writeFileSync(
+      join(dataDir(), 'types.ts'),
+      `export const formatRow = (value: string) => value`
+    )
+    writeFileSync(
+      join(dataDir(), 'auth.ts'),
+      `export function authId(auth: { id: string }) { return auth.id }`
+    )
+
+    await expect(deriveDataMembership({ dir: dataDir() })).resolves.toEqual({
+      instances: {
+        default: {
+          tables: ['server'],
+          syncTables: ['server'],
+          supportTables: [],
+          scope: null,
+        },
+      },
+      allTables: ['server'],
+    })
+  })
+
+  test('warns once and ignores an unparseable non-data file', async () => {
+    writeFileSync(join(dataDir(), 'post.ts'), `export const posts = () => zql.post`)
+    writeFileSync(join(dataDir(), 'types.ts'), `export type Broken = {`)
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    await expect(deriveDataMembership({ dir: dataDir() })).resolves.toMatchObject({
+      allTables: ['post'],
+    })
+    expect(warn).toHaveBeenCalledOnce()
+    expect(warn).toHaveBeenCalledWith(
+      '[on-zero] ignoring data/types.ts: no recognized data exports'
+    )
+    warn.mockRestore()
+  })
+
+  test('derives fileless support tables through mutation helpers', async () => {
+    writeFileSync(
+      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(
+      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(
+      join(dataDir(), 'helpers/readSettings.ts'),
+      `export const readSettings = (tx: Transaction) => tx.query.settings`
+    )
+
+    await expect(deriveDataMembership({ dir: dataDir() })).resolves.toEqual({
+      instances: {
+        default: {
+          tables: ['post'],
+          syncTables: ['post'],
+          supportTables: ['audit', 'settings'],
+          scope: null,
+        },
+      },
+      allTables: ['audit', 'post', 'settings'],
+    })
+  })
+
+  test('includes a fileless support table in every instance that uses it', async () => {
+    writeFileSync(
+      join(dataDir(), 'control/account.ts'),
+      `export const mutate = mutations('account', { save: async (ctx) => ctx.tx.mutate.audit.insert({}) })`
+    )
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`
+    )
+    writeFileSync(
+      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 expect(deriveDataMembership({ dir: dataDir() })).resolves.toMatchObject({
+      instances: {
+        control: { supportTables: ['audit'] },
+        project: { supportTables: ['audit'] },
+      },
+      allTables: ['account', 'audit', 'message'],
+    })
+  })
+
+  test('keeps a configured default instance at the data root', async () => {
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { default: { dir: '.', supportTables: ['accountGithubOrgLink', 'accountRepo', 'usageLedger'] }, project: { scope: 'projectId' } } })`
+    )
+    writeFileSync(
+      join(dataDir(), 'account.ts'),
+      `export const accounts = () => zql.account`
+    )
+    writeFileSync(
+      join(dataDir(), 'project/message.ts'),
+      `export const schema = table('message').columns({ id: string(), projectId: string() })`
+    )
+
+    await expect(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',
+      ],
+    })
+  })
+
+  test('emits only relations whose source and target are derived members', async () => {
+    writeFileSync(join(dataDir(), 'post.ts'), `export const posts = () => zql.post`)
+    writeFileSync(
+      join(dataDir(), 'comment.ts'),
+      `export const comments = () => zql.comment`
+    )
+    writeFileSync(
+      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({}) },
+}))
+`
+    )
+
+    const generated = await generateDrizzleSchemaInputFile({
+      dir: dataDir(),
+      schemaImportPath: '../../database/schema',
+    })
+    const 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 =')
+    const context = {
+      schema: { comment: {}, post: {} },
+      defineRelations: (_schema: unknown, factory: (relations: unknown) => unknown) =>
+        factory({
+          one: new Proxy({}, { get: (_target, table) => () => ({ table }) }),
+          many: new Proxy({}, { get: (_target, table) => () => ({ table }) }),
+        }),
+    } as { relations?: unknown }
+
+    runInNewContext(runnable, context)
+
+    expect(context.relations).toEqual({
+      comment: { post: { table: 'post' } },
+      post: { comments: { table: 'comment' } },
+    })
+  })
+
+  test('rejects a relation that crosses instance ownership', async () => {
+    writeFileSync(
+      join(dataDir(), 'control/userPublic.ts'),
+      `export const users = () => zql.userPublic`
+    )
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`
+    )
+    writeFileSync(
+      join(dataDir(), 'project/message.ts'),
+      `
+export const schema = table('message').columns({ id: string(), projectId: string() })
+export const messages = () => zql.message.related('author')
+`
+    )
+    writeFileSync(
+      join(testDir, 'src/database/relations.ts'),
+      `export const relations = defineRelations(schema, (r) => ({ message: { author: r.one.userPublic({}) } }))`
+    )
+
+    await expect(generate({ dir: dataDir(), silent: true })).rejects.toThrow(
+      /message\.messages.*instance 'project'.*userPublic.*instance 'control'/
+    )
+  })
+
+  test('rejects a scoped sync table without the scope column', async () => {
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { project: { scope: 'projectId' } } })`
+    )
+    writeFileSync(
+      join(dataDir(), 'project/message.ts'),
+      `export const schema = table('message').columns({ id: string() })`
+    )
+
+    await expect(generate({ dir: dataDir(), silent: true })).rejects.toThrow(
+      /table 'message'.*instance 'project'.*scope column 'projectId'/
+    )
+  })
+
+  test('rejects duplicate namespaces across instances', async () => {
+    writeFileSync(
+      join(dataDir(), 'control/message.ts'),
+      `export const messages = () => zql.message`
+    )
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { control: {}, project: { scope: 'projectId' } } })`
+    )
+    writeFileSync(
+      join(dataDir(), 'project/message.ts'),
+      `export const schema = table('message').columns({ projectId: string() })`
+    )
+
+    await expect(generate({ dir: dataDir(), silent: true })).rejects.toThrow(
+      /namespace 'message'.*instances 'control' and 'project'/
+    )
+  })
+
+  test('resolves configured instance directories relative to the config file', async () => {
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { control: { dir: './planes/control-data', supportTables: ['audit'] }, project: { dir: '../project-data', scope: 'projectId' } } })`
+    )
+    writeFileSync(
+      join(dataDir(), 'planes/control-data/account.ts'),
+      `export const accounts = () => zql.account`
+    )
+    writeFileSync(
+      join(testDir, 'src/project-data/message.ts'),
+      `export const schema = table('message').columns({ id: string(), projectId: string() })`
+    )
+
+    await expect(
+      deriveDataMembership({
+        dir: dataDir(),
+        config: 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 expect(
+      generate({
+        dir: dataDir(),
+        config: join(dataDir(), 'on-zero.config.ts'),
+        silent: true,
+      })
+    ).resolves.toMatchObject({ modelCount: 2, schemaCount: 1 })
+    expect(readFileSync(join(dataDir(), 'generated/models.ts'), 'utf8')).toContain(
+      "from '../../project-data/message'"
+    )
+  })
+
+  test('rejects missing configured instance directories', async () => {
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { project: { dir: './missing' } } })`
+    )
+
+    await expect(deriveDataMembership({ dir: dataDir() })).rejects.toThrow(
+      /instance 'project' directory does not exist.*missing/
+    )
+  })
+
+  test('rejects two instances that resolve to the same directory', async () => {
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { control: { dir: './shared' }, project: { dir: './shared' } } })`
+    )
+    writeFileSync(
+      join(dataDir(), 'shared/account.ts'),
+      `export const accounts = () => zql.account`
+    )
+
+    await expect(deriveDataMembership({ dir: dataDir() })).rejects.toThrow(
+      /instances 'control' and 'project' resolve to the same directory/
+    )
+  })
+
+  test('rejects root namespaces when instances are configured', async () => {
+    writeFileSync(
+      join(dataDir(), 'on-zero.config.ts'),
+      `export default defineConfig({ instances: { project: {} } })`
+    )
+    writeFileSync(
+      join(dataDir(), 'project/message.ts'),
+      `export const rows = () => zql.message`
+    )
+    writeFileSync(join(dataDir(), 'account.ts'), `export const rows = () => zql.account`)
+
+    await expect(deriveDataMembership({ dir: dataDir() })).rejects.toThrow(
+      /data namespace .*account\.ts.*outside every instance directory/
+    )
+  })
+
+  test('rejects removed instance.ts configuration', async () => {
+    writeFileSync(join(dataDir(), 'post.ts'), `export const posts = () => zql.post`)
+    writeFileSync(
+      join(dataDir(), 'project/instance.ts'),
+      `export default defineInstance({ scope: 'projectId' })`
+    )
+
+    await expect(deriveDataMembership({ dir: dataDir() })).rejects.toThrow(
+      /uses removed instance\.ts configuration/
+    )
+  })
+
+  test('rejects the removed top-level layout', async () => {
+    writeFileSync(
+      join(dataDir(), 'queries/message.ts'),
+      `export const messages = () => zql.message`
+    )
+
+    await expect(generate({ dir: dataDir(), silent: true })).rejects.toThrow(
+      /removed top-level queries\/ layout/
+    )
+  })
+
+  test('rejects dynamically named relations', async () => {
+    writeFileSync(
+      join(dataDir(), 'message.ts'),
+      `export const messages = (relation: string) => zql.message.related(relation)`
+    )
+
+    await expect(generate({ dir: dataDir(), silent: true })).rejects.toThrow(
+      /related\(\) without a string literal.*statically derivable/
+    )
+  })
+})
+
 describe('mutations', () => {
   test('generates validators for inline mutation param types', async () => {
     writeFileSync(
-      join(testDir, 'models/post.ts'),
+      join(testDir, 'post/mutations.ts'),
       `
 import { table, string } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
@@ -258,7 +720,7 @@ export const mutate = mutations(schema, perm, {
     await tx.mutate.post.update({ id, archived: true })
   },
 })
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -274,7 +736,7 @@ export const mutate = mutations(schema, perm, {
 
   test('generates CRUD validators from schema columns', async () => {
     writeFileSync(
-      join(testDir, 'models/task.ts'),
+      join(testDir, 'task/mutations.ts'),
       `
 import { table, string, number, boolean } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
@@ -290,7 +752,7 @@ export const schema = table('task').columns({
 const perm = serverWhere('task', () => true)
 
 export const mutate = mutations(schema, perm)
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -310,7 +772,7 @@ export const mutate = mutations(schema, perm)
 
   test('treats models without export const mutate as empty mutations', async () => {
     writeFileSync(
-      join(testDir, 'models/readonly.ts'),
+      join(testDir, 'readonly/mutations.ts'),
       `
 import { table, string } from 'on-zero'
 
@@ -318,7 +780,7 @@ export const schema = table('readonly').columns({
   id: string(),
   name: string(),
 }).primaryKey('id')
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -330,7 +792,7 @@ export const schema = table('readonly').columns({
 
   test('extracts custom mutations from bare mutations({})', async () => {
     writeFileSync(
-      join(testDir, 'models/admin.ts'),
+      join(testDir, 'admin/mutations.ts'),
       `
 import { mutations } from 'on-zero'
 
@@ -339,7 +801,7 @@ export const mutate = mutations({
     await tx.mutate.admin.delete({ id: targetId })
   },
 })
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -351,7 +813,7 @@ export const mutate = mutations({
 
   test('generates validators for string-model multiline mutation params', async () => {
     writeFileSync(
-      join(testDir, 'models/agentEvent.ts'),
+      join(testDir, 'agentEvent/mutations.ts'),
       `
 import { mutations, serverWhere } from 'on-zero'
 
@@ -374,7 +836,7 @@ export const mutate = mutations('agentEvent', perm, {
     await tx.mutate.agentEvent.insert(props)
   },
 })
-`,
+`
     )
 
     await generate({ dir: testDir, silent: true })
@@ -388,7 +850,7 @@ export const mutate = mutations('agentEvent', perm, {
 
   test('generates validators for object intersections', async () => {
     writeFileSync(
-      join(testDir, 'models/agent.ts'),
+      join(testDir, 'agent/mutations.ts'),
       `
 import { mutations, serverWhere } from 'on-zero'
 
@@ -408,7 +870,7 @@ export const mutate = mutations('agent', perm, {
     await tx.mutate.agent.update(props)
   },
 })
-`,
+`
     )
 
     await generate({ dir: testDir, silent: true })
@@ -424,7 +886,7 @@ export const mutate = mutations('agent', perm, {
 
   test('uses v.unknown for untyped mutation payloads', async () => {
     writeFileSync(
-      join(testDir, 'models/project.ts'),
+      join(testDir, 'project/mutations.ts'),
       `
 import { mutations, serverWhere } from 'on-zero'
 
@@ -435,7 +897,7 @@ export const mutate = mutations('project', perm, {
     await tx.mutate.project.insert(project)
   },
 })
-`,
+`
     )
 
     await generate({ dir: testDir, silent: true })
@@ -447,7 +909,7 @@ export const mutate = mutations('project', perm, {
 
   test('handles mutations with only context param (void)', async () => {
     writeFileSync(
-      join(testDir, 'models/user.ts'),
+      join(testDir, 'user/mutations.ts'),
       `
 import { table, string } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
@@ -464,7 +926,7 @@ export const mutate = mutations(schema, perm, {
     // no second param
   },
 })
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -476,7 +938,7 @@ export const mutate = mutations(schema, perm, {
 
   test('handles primitive param type', async () => {
     writeFileSync(
-      join(testDir, 'models/user.ts'),
+      join(testDir, 'user/mutations.ts'),
       `
 import { table, string } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
@@ -493,7 +955,7 @@ export const mutate = mutations(schema, perm, {
     await tx.mutate.user.update({ id: userId })
   },
 })
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -505,7 +967,7 @@ export const mutate = mutations(schema, perm, {
 
   test('handles array param type', async () => {
     writeFileSync(
-      join(testDir, 'models/batch.ts'),
+      join(testDir, 'batch/mutations.ts'),
       `
 import { mutations } from 'on-zero'
 
@@ -514,7 +976,7 @@ export const mutate = mutations({
     for (const { id } of ids) await tx.mutate.batch.delete({ id })
   },
 })
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -526,7 +988,7 @@ export const mutate = mutations({
 
   test('populates mutationCount and caching works', async () => {
     writeFileSync(
-      join(testDir, 'models/item.ts'),
+      join(testDir, 'item/mutations.ts'),
       `
 import { table, string } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
@@ -543,7 +1005,7 @@ export const mutate = mutations(schema, perm, {
     await tx.mutate.item.update({ id, name })
   },
 })
-`,
+`
     )
 
     const first = await generate({ dir: testDir, silent: true })
@@ -559,18 +1021,18 @@ describe('type resolution', () => {
   test('resolves imported type references for mutations', async () => {
     // types file that the model imports from
     writeFileSync(
-      join(testDir, 'models/types.ts'),
+      join(testDir, 'post/types.ts'),
       `
 export type ArchiveParams = {
   id: string
   reason: string
   archived: boolean
 }
-`,
+`
     )
 
     writeFileSync(
-      join(testDir, 'models/post.ts'),
+      join(testDir, 'post/mutations.ts'),
       `
 import { table, string, boolean } from 'on-zero'
 import { mutations } from 'on-zero'
@@ -581,7 +1043,7 @@ export const mutate = mutations({
     await tx.mutate.post.update(params)
   },
 })
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -596,7 +1058,7 @@ export const mutate = mutations({
 
   test('resolves utility types like Pick', async () => {
     writeFileSync(
-      join(testDir, 'models/types.ts'),
+      join(testDir, 'item/types.ts'),
       `
 export type Item = {
   id: string
@@ -604,11 +1066,11 @@ export type Item = {
   description: string
   count: number
 }
-`,
+`
     )
 
     writeFileSync(
-      join(testDir, 'models/item.ts'),
+      join(testDir, 'item/mutations.ts'),
       `
 import { table, string, number } from 'on-zero'
 import { mutations, serverWhere } from 'on-zero'
@@ -628,7 +1090,7 @@ export const mutate = mutations(schema, perm, {
     await tx.mutate.item.update(updates)
   },
 })
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -644,12 +1106,12 @@ export const mutate = mutations(schema, perm, {
 
   test('resolves instantiated Zero row fields through Partial and Omit', async () => {
     symlinkSync(
-      join(import.meta.dirname, '../../../node_modules'),
+      join(import.meta.dirname, '../node_modules'),
       join(testDir, 'node_modules'),
-      'dir',
+      'dir'
     )
     writeFileSync(
-      join(testDir, 'models/types.ts'),
+      join(testDir, 'item/types.ts'),
       `
 import type { Row } from '@rocicorp/zero'
 import { drizzleZeroConfig } from 'drizzle-zero-sqlite'
@@ -663,11 +1125,11 @@ const item = sqliteTable('item', {
 const schema = drizzleZeroConfig({ item })
 
 export type Item = Row<(typeof schema)['tables']['item']>
-`,
+`
     )
 
     writeFileSync(
-      join(testDir, 'models/item.ts'),
+      join(testDir, 'item/mutations.ts'),
       `
 import { mutations } from 'on-zero'
 import type { Item } from './types'
@@ -679,7 +1141,7 @@ export const mutate = mutations('item', {
     await tx.mutate.item.update(props)
   },
 })
-`,
+`
     )
 
     await generate({ dir: testDir, silent: true })
@@ -693,17 +1155,17 @@ export const mutate = mutations('item', {
 
   test('skips symbol-keyed properties when resolving imported mutation param types', async () => {
     writeFileSync(
-      join(testDir, 'models/types.ts'),
+      join(testDir, 'item/types.ts'),
       `
 export type WeirdParams = {
   id: string
   [Symbol.iterator]?: () => Iterator<string>
 }
-`,
+`
     )
 
     writeFileSync(
-      join(testDir, 'models/item.ts'),
+      join(testDir, 'item/mutations.ts'),
       `
 import { mutations } from 'on-zero'
 import type { WeirdParams } from './types'
@@ -713,7 +1175,7 @@ export const mutate = mutations({
     await tx.mutate.item.delete({ id: params.id })
   },
 })
-`,
+`
     )
 
     await generate({ dir: testDir, silent: true })
@@ -726,27 +1188,27 @@ export const mutate = mutations({
 
   test('resolves imported types in query params', async () => {
     writeFileSync(
-      join(testDir, 'models/post.ts'),
-      `export const schema = table('post', { id: string() })`,
+      join(testDir, 'post/mutations.ts'),
+      `export const schema = table('post', { id: string() })`
     )
 
     writeFileSync(
-      join(testDir, 'queries/types.ts'),
+      join(testDir, 'post/types.ts'),
       `
 export type PostFilter = {
   authorId: string
   published: boolean
 }
-`,
+`
     )
 
     writeFileSync(
-      join(testDir, 'queries/post.ts'),
+      join(testDir, 'post/queries.ts'),
       `
 import type { PostFilter } from './types'
 
 export const filteredPosts = (filter: PostFilter) => zero.query.post
-`,
+`
     )
 
     const result = await generate({ dir: testDir, silent: true })
@@ -810,7 +1272,7 @@ describe('generateDrizzleSchemaFile', () => {
     const executableSource = source
       .replace(
         "import { boolean, createSchema, json, number, relationships, string, table } from '@rocicorp/zero'",
-        '',
+        ''
       )
       .replace('export const schema =', 'globalThis.generatedSchema =')
     const context: Record<string, unknown> = { ...zero }