on-zero 0.7.10 → 0.8.0

package/src/generate-lite.test.ts

@@ -1,6 +1,9 @@
-import { describe, expect, test } from 'vitest'
+import { runInNewContext } from 'node:vm'
+
+import { afterEach, describe, expect, test, vi } from 'vitest'
 
 import { generateLite } from './generate-lite'
+
 import type { LiteParseFn, LiteParsedFile } from './generate-lite'
 
 // minimal hand-rolled "parser" backed by a lookup table. the real caller
@@ -19,15 +22,19 @@ function makeParse(table: Record<string, LiteParsedFile>): LiteParseFn {
 
 const DIR = '/proj/src/data'
 
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
 describe('generateLite', () => {
   test('emits models.ts, syncedMutations.ts, and README.md from inline types', () => {
     const files: Record<string, string> = {
-      [`${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',
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/models/todo.ts`]: {
+      [`${DIR}/todo.ts`]: {
         mutations: [
           {
             modelName: 'todo',
@@ -46,7 +53,7 @@ describe('generateLite', () => {
         ],
         queries: [],
       },
-      [`${DIR}/models/user.ts`]: {
+      [`${DIR}/user.ts`]: {
         mutations: [
           {
             modelName: 'user',
@@ -73,14 +80,17 @@ describe('generateLite', () => {
     // output file set
     expect(Object.keys(result.files).sort()).toEqual([
       'README.md',
+      'groupedQueries.ts',
+      'instances.ts',
       'models.ts',
       'syncedMutations.ts',
+      'syncedQueries.ts',
     ])
 
     // models.ts: aliases the user import without changing the model key
     const models = result.files['models.ts']!
-    expect(models).toContain("import * as todo from '../models/todo'")
-    expect(models).toContain("import * as userPublic from '../models/user'")
+    expect(models).toContain("import * as todo from '../todo'")
+    expect(models).toContain("import * as userPublic from '../user'")
     expect(models).toContain('user: userPublic,')
     expect(models).not.toContain('\n  userPublic,')
     expect(models).toContain('export const models = {')
@@ -103,12 +113,12 @@ describe('generateLite', () => {
 
   test('parses newline-separated mutation object types', () => {
     const files: Record<string, string> = {
-      [`${DIR}/models/agentEvent.ts`]: '// fake',
-      [`${DIR}/models/deployment.ts`]: '// fake',
+      [`${DIR}/agentEvent.ts`]: '// fake',
+      [`${DIR}/deployment.ts`]: '// fake',
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/models/agentEvent.ts`]: {
+      [`${DIR}/agentEvent.ts`]: {
         mutations: [
           {
             modelName: 'agentEvent',
@@ -127,7 +137,7 @@ describe('generateLite', () => {
         ],
         queries: [],
       },
-      [`${DIR}/models/deployment.ts`]: {
+      [`${DIR}/deployment.ts`]: {
         mutations: [
           {
             modelName: 'deployment',
@@ -167,11 +177,11 @@ describe('generateLite', () => {
 
   test('parses object intersections and skips index signatures', () => {
     const files: Record<string, string> = {
-      [`${DIR}/models/agent.ts`]: '// fake',
+      [`${DIR}/agent.ts`]: '// fake',
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/models/agent.ts`]: {
+      [`${DIR}/agent.ts`]: {
         mutations: [
           {
             modelName: 'agent',
@@ -211,11 +221,11 @@ describe('generateLite', () => {
 
   test('falls back to v.unknown() for type references', () => {
     const files: Record<string, string> = {
-      [`${DIR}/models/post.ts`]: '// fake',
+      [`${DIR}/post.ts`]: `export const allPosts = () => zql.post`,
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/models/post.ts`]: {
+      [`${DIR}/post.ts`]: {
         mutations: [
           {
             modelName: 'post',
@@ -253,11 +263,11 @@ describe('generateLite', () => {
 
   test('uses v.unknown() for explicitly unknown mutation params', () => {
     const files: Record<string, string> = {
-      [`${DIR}/models/project.ts`]: '// fake',
+      [`${DIR}/project.ts`]: '// fake',
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/models/project.ts`]: {
+      [`${DIR}/project.ts`]: {
         mutations: [
           {
             modelName: 'project',
@@ -280,16 +290,11 @@ describe('generateLite', () => {
 
   test('emits query files with v.unknown() fallback for references', () => {
     const files: Record<string, string> = {
-      [`${DIR}/models/post.ts`]: '// fake',
-      [`${DIR}/queries/post.ts`]: '// fake',
+      [`${DIR}/post.ts`]: '// fake',
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/models/post.ts`]: {
-        mutations: [],
-        queries: [],
-      },
-      [`${DIR}/queries/post.ts`]: {
+      [`${DIR}/post.ts`]: {
         mutations: [],
         queries: [
           // no-arg query → void
@@ -323,7 +328,8 @@ describe('generateLite', () => {
     expect(result.files['syncedQueries.ts']).toBeDefined()
 
     const grouped = result.files['groupedQueries.ts']!
-    expect(grouped).toContain("export * as post from '../queries/post'")
+    expect(grouped).toContain("import * as postSource from '../post'")
+    expect(grouped).toContain('postById: postSource.postById')
 
     const synced = result.files['syncedQueries.ts']!
     expect(synced).toContain('allPosts: defineQuery(() => Queries.post.allPosts())')
@@ -345,11 +351,11 @@ describe('generateLite', () => {
 
   test('emits types.ts and tables.ts when a model declares a schema inline', () => {
     const files: Record<string, string> = {
-      [`${DIR}/models/task.ts`]: '// fake',
+      [`${DIR}/task.ts`]: '// fake',
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/models/task.ts`]: {
+      [`${DIR}/task.ts`]: {
         mutations: [
           {
             modelName: 'task',
@@ -385,7 +391,7 @@ describe('generateLite', () => {
     expect(types).toContain('export type Task = TableInsertRow<typeof schema.task>')
 
     const tables = result.files['tables.ts']!
-    expect(tables).toContain("export { schema as task } from '../models/task'")
+    expect(tables).toContain("export { schema as task } from '../task'")
 
     // crud validators emitted in syncedMutations.ts
     const synced = result.files['syncedMutations.ts']!
@@ -396,18 +402,18 @@ describe('generateLite', () => {
     expect(result.mutationCount).toBe(3)
   })
 
-  test('ignores nested files and non-ts files inside the models directory', () => {
+  test('ignores private files inside a namespace folder', () => {
     const files: Record<string, string> = {
-      [`${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',
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/models/post.ts`]: {
+      [`${DIR}/post/mutations.ts`]: {
         mutations: [{ modelName: 'post', handlers: [], schema: null }],
         queries: [],
       },
@@ -421,20 +427,20 @@ describe('generateLite', () => {
 
     expect(result.modelCount).toBe(1)
     const models = result.files['models.ts']!
-    expect(models).toContain("import * as post from '../models/post'")
+    expect(models).toContain("import * as post from '../post/mutations'")
     expect(models).not.toContain('util')
     expect(models).not.toContain('README')
     expect(models).not.toContain('post.test')
     expect(models).not.toContain('post.spec')
   })
 
-  test('infers mutations/ directory when present', () => {
+  test('supports a split namespace folder', () => {
     const files: Record<string, string> = {
-      [`${DIR}/mutations/post.ts`]: '// fake',
+      [`${DIR}/post/mutations.ts`]: '// fake',
     }
 
     const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/mutations/post.ts`]: {
+      [`${DIR}/post/mutations.ts`]: {
         mutations: [
           {
             modelName: 'post',
@@ -452,8 +458,381 @@ describe('generateLite', () => {
       parse: makeParse(fixtures),
     })
 
-    // should use mutations dir path in re-exports
     const models = result.files['models.ts']!
-    expect(models).toContain("from '../mutations/post'")
+    expect(models).toContain("from '../post/mutations'")
+  })
+
+  test('derives single-file namespaces from data exports', () => {
+    const files = {
+      [`${DIR}/server.ts`]: `export const serverRows = () => zql.server`,
+      [`${DIR}/types.ts`]: `export const formatRow = (value: string) => value`,
+    }
+    const result = generateLite({
+      files,
+      dir: DIR,
+      parse: makeParse({
+        [`${DIR}/server.ts`]: {
+          mutations: [],
+          queries: [{ name: 'serverRows', paramTypeText: null }],
+        },
+        [`${DIR}/types.ts`]: {
+          mutations: [],
+          queries: [],
+        },
+      }),
+    })
+
+    expect(result.modelCount).toBe(1)
+    expect(result.queryCount).toBe(1)
+  })
+
+  test('warns once and ignores an unparseable non-data file', () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const result = generateLite({
+      files: {
+        [`${DIR}/server.ts`]: `export const serverRows = () => zql.server`,
+        [`${DIR}/types.ts`]: `export type Broken = {`,
+      },
+      dir: DIR,
+      parse: (source, path) => {
+        if (path.endsWith('/types.ts')) throw new Error('parse failed')
+        return {
+          mutations: [],
+          queries: source.includes('zql.server')
+            ? [{ name: 'serverRows', paramTypeText: null }]
+            : [],
+        }
+      },
+    })
+
+    expect(result.modelCount).toBe(1)
+    expect(warn).toHaveBeenCalledOnce()
+    expect(warn).toHaveBeenCalledWith(
+      '[on-zero] ignoring data/types.ts: no recognized data exports'
+    )
+    warn.mockRestore()
+  })
+
+  test('rejects the removed top-level layout', () => {
+    expect(() =>
+      generateLite({
+        files: { [`${DIR}/queries/post.ts`]: '// fake' },
+        dir: DIR,
+        parse: makeParse({}),
+      })
+    ).toThrow(/removed top-level queries\/ layout/)
+  })
+
+  test('derives scoped related-table closure from lite metadata', () => {
+    const 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',
+    }
+    const empty = { mutations: [], queries: [] }
+    const result = 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'] },
+          ],
+        },
+      }),
+    })
+
+    expect(result.files['instances.ts']).toContain(
+      'syncTables: ["comment","message","userPublic"]'
+    )
+    // the returned membership mirrors what instances.ts serializes, so hosts
+    // read it structurally instead of re-parsing the emitted source
+    const instance = result.instances.find((entry) => entry.name === 'project')
+    expect(instance?.syncTables).toEqual(['comment', 'message', 'userPublic'])
+    expect(instance?.supportTables).toEqual([])
+  })
+
+  test('derives fileless support tables through parsed mutation helpers', () => {
+    const files = {
+      [`${DIR}/post.ts`]: '// namespace',
+      [`${DIR}/helpers/writeAudit.ts`]: '// helper',
+      [`${DIR}/helpers/readSettings.ts`]: '// nested helper',
+    }
+    const empty = { mutations: [], queries: [] }
+    const result = 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'],
+        },
+      }),
+    })
+    const 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', '')
+    const context = {
+      groupedQueries: {},
+      models: { post: {} },
+      schema: {},
+    } as { instances?: Record<string, { supportTables: string[] }> }
+
+    runInNewContext(runnable, context)
+
+    expect(context.instances?.default?.supportTables).toEqual(['audit', 'settings'])
+  })
+
+  test('includes a fileless support table in every lite instance that uses it', () => {
+    const 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',
+    }
+    const empty = { mutations: [], queries: [] }
+
+    const result = 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'] }],
+        },
+      }),
+    })
+    const 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', '')
+    const context = {
+      groupedQueries: {},
+      models: { account: {}, message: {} },
+      schema: {},
+    } as { instances?: Record<string, { supportTables: string[] }> }
+
+    runInNewContext(runnable, context)
+
+    expect(context.instances?.control?.supportTables).toEqual(['audit', 'manual'])
+    expect(context.instances?.project?.supportTables).toEqual(['audit'])
+  })
+
+  test('keeps a configured default lite instance at the data root', () => {
+    const 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',
+    }
+    const empty = { mutations: [], queries: [] }
+    const result = 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()' },
+                ],
+              },
+            },
+          ],
+        },
+      }),
+    })
+    const 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', '')
+    const context = {
+      groupedQueries: {},
+      models: { message: {} },
+      schema: {},
+    } as { instances?: Record<string, { supportTables: string[] }> }
+
+    runInNewContext(runnable, context)
+
+    expect(context.instances?.default?.supportTables).toEqual([
+      'accountRepo',
+      'usageLedger',
+    ])
+    expect(context.instances?.project?.supportTables).toEqual([])
+  })
+
+  test('rejects missing configured directories and instance.ts remnants', () => {
+    const empty = { mutations: [], queries: [] }
+    expect(() =>
+      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/)
+
+    expect(() =>
+      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/)
+
+    expect(() =>
+      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/)
   })
 })