on-zero 0.9.7 → 0.10.0

package/src/generate-helpers.test.ts

@@ -30,38 +30,6 @@ function expectNoDuplicates(source: string) {
 }
 
 describe('generated module identifiers', () => {
-  test('grouped queries keep distinct aliases when one namespace is another plus Source', () => {
-    const source = generateGroupedQueriesFile([
-      { name: 'appById', sourceFile: 'app', importPath: '../app/queries' },
-      {
-        name: 'appSourceByAppId',
-        sourceFile: 'appSource',
-        importPath: '../appSource/queries',
-      },
-    ])
-
-    expectNoDuplicates(source)
-    // each namespace still exports its own queries, reading from its own module
-    const appExport = source.match(/export const app = \{([^}]*)\}/)![1]!
-    const appSourceExport = source.match(/export const appSource = \{([^}]*)\}/)![1]!
-    expect(appExport).toContain('appById')
-    expect(appSourceExport).toContain('appSourceByAppId')
-    expect(appExport).not.toContain('appSourceByAppId')
-  })
-
-  test('models keep distinct aliases when user and userPublic both exist', () => {
-    const source = generateModelsFile([
-      { name: 'user', importPath: '../user' },
-      { name: 'userPublic', importPath: '../userPublic' },
-    ] as Parameters<typeof generateModelsFile>[0])
-
-    expectNoDuplicates(source)
-    // both namespaces survive as distinct keys bound to their own module
-    const modelsObject = source.match(/export const models = \{([\s\S]*)\}/)![1]!
-    expect(modelsObject).toMatch(/\buser:/)
-    expect(modelsObject).toMatch(/\buserPublic\b/)
-  })
-
   test('table re-exports keep distinct names when user and userPublic both exist', () => {
     const source = generateTablesFile([
       { name: 'user', importPath: '../user' },
@@ -70,12 +38,4 @@ describe('generated module identifiers', () => {
 
     expectNoDuplicates(source)
   })
-
-  test('a namespace with no collision keeps its plain alias', () => {
-    const source = generateGroupedQueriesFile([
-      { name: 'todoById', sourceFile: 'todo', importPath: '../todo/queries' },
-    ])
-
-    expect(source).toContain(`import * as todoSource from '../todo/queries'`)
-  })
 })

package/src/generate-lite.test.ts

@@ -27,463 +27,6 @@ afterEach(() => {
 })
 
 describe('generateLite', () => {
-  test('emits models.ts, syncedMutations.ts, and README.md from inline types', () => {
-    const files: Record<string, string> = {
-      [`${DIR}/todo.ts`]: '// fake source, parser returns fixture',
-      [`${DIR}/user.ts`]: '// fake source, parser returns fixture',
-    }
-
-    const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/todo.ts`]: {
-        mutations: [
-          {
-            modelName: 'todo',
-            handlers: [
-              {
-                name: 'toggle',
-                paramTypeText: '{ id: string; isActive: boolean }',
-              },
-              {
-                name: 'rename',
-                paramTypeText: '{ id: string; title: string }',
-              },
-            ],
-            schema: null,
-          },
-        ],
-        queries: [],
-      },
-      [`${DIR}/user.ts`]: {
-        mutations: [
-          {
-            modelName: 'user',
-            handlers: [
-              {
-                name: 'finishOnboarding',
-                // null = no second param / void
-                paramTypeText: null,
-              },
-            ],
-            schema: null,
-          },
-        ],
-        queries: [],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    // 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 '../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 = {')
-
-    // syncedMutations.ts: inline types resolve to v.object validators
-    const syncedMutations = result.files['syncedMutations.ts']!
-    expect(syncedMutations).toContain('toggle:')
-    expect(syncedMutations).toContain('v.object({')
-    expect(syncedMutations).toContain('id: v.string()')
-    expect(syncedMutations).toContain('isActive: v.boolean()')
-    expect(syncedMutations).toContain('rename:')
-    expect(syncedMutations).toContain('title: v.string()')
-    // null param → v.void_()
-    expect(syncedMutations).toContain('finishOnboarding: v.void_()')
-
-    expect(result.modelCount).toBe(2)
-    expect(result.schemaCount).toBe(0)
-    expect(result.mutationCount).toBe(3)
-  })
-
-  test('parses newline-separated mutation object types', () => {
-    const files: Record<string, string> = {
-      [`${DIR}/agentEvent.ts`]: '// fake',
-      [`${DIR}/deployment.ts`]: '// fake',
-    }
-
-    const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/agentEvent.ts`]: {
-        mutations: [
-          {
-            modelName: 'agentEvent',
-            handlers: [
-              {
-                name: 'claimReviewLease',
-                paramTypeText: `{
-                  id: string
-                  projectId: string
-                  createdAt: number
-                }`,
-              },
-            ],
-            schema: null,
-          },
-        ],
-        queries: [],
-      },
-      [`${DIR}/deployment.ts`]: {
-        mutations: [
-          {
-            modelName: 'deployment',
-            handlers: [
-              {
-                name: 'deploy',
-                paramTypeText: `{
-                  id: string
-                  platform?: string // 'web' | 'ios'
-                  buildTier?: string // 'dev' | 'testflight' | 'production'
-                }`,
-              },
-            ],
-            schema: null,
-          },
-        ],
-        queries: [],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    const synced = result.files['syncedMutations.ts']!
-    expect(synced).toContain('claimReviewLease:')
-    expect(synced).toContain('projectId: v.string()')
-    expect(synced).toContain('createdAt: v.number()')
-    expect(synced).toContain('deploy:')
-    expect(synced).toContain('platform: v.optional(v.string())')
-    expect(synced).toContain('buildTier: v.optional(v.string())')
-    expect(synced).not.toContain('claimReviewLease: v.object({})')
-    expect(synced).not.toContain('deploy: v.object({})')
-  })
-
-  test('parses object intersections and skips index signatures', () => {
-    const files: Record<string, string> = {
-      [`${DIR}/agent.ts`]: '// fake',
-    }
-
-    const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/agent.ts`]: {
-        mutations: [
-          {
-            modelName: 'agent',
-            handlers: [
-              {
-                name: 'update',
-                paramTypeText: `{
-                  id: string
-                } & {
-                  status?: string
-                  currentTaskId?: string
-                  [key: string]: unknown
-                }`,
-              },
-            ],
-            schema: null,
-          },
-        ],
-        queries: [],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    const synced = result.files['syncedMutations.ts']!
-    expect(synced).toContain('update:')
-    expect(synced).toContain('id: v.string()')
-    expect(synced).toContain('status: v.optional(v.string())')
-    expect(synced).toContain('currentTaskId: v.optional(v.string())')
-    expect(synced).not.toContain('[key')
-    expect(synced).not.toContain('update: v.object({})')
-  })
-
-  test('falls back to v.unknown() for type references', () => {
-    const files: Record<string, string> = {
-      [`${DIR}/post.ts`]: `export const allPosts = () => zql.post`,
-    }
-
-    const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/post.ts`]: {
-        mutations: [
-          {
-            modelName: 'post',
-            handlers: [
-              {
-                name: 'archive',
-                // bare type reference — parseTypeString returns null, so
-                // generate-lite should fall back to v.unknown() rather than
-                // attempting cross-file type resolution.
-                paramTypeText: 'ArchiveParams',
-              },
-              {
-                name: 'publish',
-                // primitive, should resolve
-                paramTypeText: 'string',
-              },
-            ],
-            schema: null,
-          },
-        ],
-        queries: [],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    const synced = result.files['syncedMutations.ts']!
-    expect(synced).toContain('archive: v.unknown()')
-    expect(synced).toContain('publish: v.string()')
-  })
-
-  test('uses v.unknown() for explicitly unknown mutation params', () => {
-    const files: Record<string, string> = {
-      [`${DIR}/project.ts`]: '// fake',
-    }
-
-    const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/project.ts`]: {
-        mutations: [
-          {
-            modelName: 'project',
-            handlers: [{ name: 'insert', paramTypeText: 'unknown' }],
-            schema: null,
-          },
-        ],
-        queries: [],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    expect(result.files['syncedMutations.ts']!).toContain('insert: v.unknown()')
-  })
-
-  test('emits query files with v.unknown() fallback for references', () => {
-    const files: Record<string, string> = {
-      [`${DIR}/post.ts`]: '// fake',
-    }
-
-    const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/post.ts`]: {
-        mutations: [],
-        queries: [
-          // no-arg query → void
-          { name: 'allPosts', rootTable: 'post', paramTypeText: null, relatedPaths: [] },
-          // inline object → real validator
-          {
-            name: 'postById',
-            rootTable: 'post',
-            paramTypeText: '{ id: string }',
-            relatedPaths: [],
-          },
-          // primitive
-          {
-            name: 'byAuthorId',
-            rootTable: 'post',
-            paramTypeText: 'string',
-            relatedPaths: [],
-          },
-          // optional nullable inline object
-          {
-            name: 'paged',
-            rootTable: 'post',
-            paramTypeText:
-              '{ pageSize: number; cursor?: { id: string; createdAt: number } | null }',
-            relatedPaths: [],
-          },
-          // type reference → fallback
-          {
-            name: 'filtered',
-            rootTable: 'post',
-            paramTypeText: 'PostFilter',
-            relatedPaths: [],
-          },
-          // permission should be skipped
-          {
-            name: 'permission',
-            rootTable: 'post',
-            paramTypeText: null,
-            relatedPaths: [],
-          },
-        ],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    // expect both query files
-    expect(result.files['groupedQueries.ts']).toBeDefined()
-    expect(result.files['syncedQueries.ts']).toBeDefined()
-
-    const grouped = result.files['groupedQueries.ts']!
-    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())')
-    expect(synced).toContain('postById: defineQuery(')
-    expect(synced).toContain('id: v.string()')
-    expect(synced).toContain('byAuthorId: defineQuery(')
-    // primitive string param shows up as v.string() validator
-    expect(synced).toMatch(/byAuthorId: defineQuery\(\s*v\.string\(\)/)
-    expect(synced).toContain('paged: defineQuery(')
-    expect(synced).toContain('cursor: v.optional(v.nullable(v.object({')
-    // type reference fallback
-    expect(synced).toContain('filtered: defineQuery(')
-    expect(synced).toMatch(/filtered: defineQuery\(\s*v\.unknown\(\)/)
-    // permission export skipped
-    expect(synced).not.toContain('permission: defineQuery')
-
-    expect(result.queryCount).toBe(5) // permission excluded
-  })
-
-  test('emits types.ts and tables.ts when a model declares a schema inline', () => {
-    const files: Record<string, string> = {
-      [`${DIR}/task.ts`]: '// fake',
-    }
-
-    const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/task.ts`]: {
-        mutations: [
-          {
-            modelName: 'task',
-            handlers: [],
-            schema: {
-              tableName: 'task',
-              primaryKeys: ['id'],
-              columns: [
-                { name: 'id', builderText: 'string()' },
-                { name: 'title', builderText: 'string()' },
-                { name: 'priority', builderText: 'number()' },
-                { name: 'done', builderText: 'boolean()' },
-                { name: 'note', builderText: 'string().optional()' },
-              ],
-            },
-          },
-        ],
-        queries: [],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    expect(result.schemaCount).toBe(1)
-    expect(result.files['types.ts']).toBeDefined()
-    expect(result.files['tables.ts']).toBeDefined()
-
-    const types = result.files['types.ts']!
-    expect(types).toContain('export type Task = TableInsertRow<typeof schema.task>')
-
-    const tables = result.files['tables.ts']!
-    expect(tables).toContain("export { schema as task } from '../task'")
-
-    // crud validators emitted in syncedMutations.ts
-    const synced = result.files['syncedMutations.ts']!
-    expect(synced).toContain('insert:')
-    expect(synced).toContain('update:')
-    expect(synced).toContain('delete:')
-    // crud count is 3
-    expect(result.mutationCount).toBe(3)
-  })
-
-  test('ignores private files inside a namespace folder', () => {
-    const files: Record<string, string> = {
-      [`${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}/post/mutations.ts`]: {
-        mutations: [{ modelName: 'post', handlers: [], schema: null }],
-        queries: [],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    expect(result.modelCount).toBe(1)
-    const models = result.files['models.ts']!
-    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('supports a split namespace folder', () => {
-    const files: Record<string, string> = {
-      [`${DIR}/post/mutations.ts`]: '// fake',
-    }
-
-    const fixtures: Record<string, LiteParsedFile> = {
-      [`${DIR}/post/mutations.ts`]: {
-        mutations: [
-          {
-            modelName: 'post',
-            handlers: [{ name: 'publish', paramTypeText: '{ id: string }' }],
-            schema: null,
-          },
-        ],
-        queries: [],
-      },
-    }
-
-    const result = generateLite({
-      files,
-      dir: DIR,
-      parse: makeParse(fixtures),
-    })
-
-    const models = result.files['models.ts']!
-    expect(models).toContain("from '../post/mutations'")
-  })
-
   test('derives single-file namespaces from data exports', () => {
     const files = {
       [`${DIR}/server.ts`]: `export const serverRows = () => zql.server`,
@@ -559,135 +102,6 @@ describe('generateLite', () => {
     ).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',
-              rootTable: 'message',
-              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 query membership from the query root instead of its namespace', () => {
-    const files = {
-      [`${DIR}/category/mutations.ts`]: '// fake category model',
-      [`${DIR}/dashboard/queries.ts`]: `export const monthSummary = () => zql.category.related('expenses')`,
-      ['/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}/category/mutations.ts`]: {
-          ...empty,
-          mutations: [
-            {
-              modelName: 'category',
-              handlers: [],
-              schema: null,
-            },
-          ],
-        },
-        [`${DIR}/dashboard/queries.ts`]: {
-          ...empty,
-          queries: [
-            {
-              name: 'monthSummary',
-              rootTable: 'category',
-              paramTypeText: null,
-              relatedPaths: [['expenses']],
-            },
-          ],
-        },
-        '/proj/src/database/relations.ts': {
-          ...empty,
-          relations: [
-            {
-              sourceTable: 'category',
-              name: 'expenses',
-              targetTable: 'expense',
-            },
-          ],
-        },
-        '/proj/src/database/schema.ts': {
-          ...empty,
-          tables: [
-            { name: 'category', columns: ['id'] },
-            { name: 'expense', columns: ['id', 'categoryId'] },
-          ],
-        },
-      }),
-    })
-
-    expect(result.instances[0]?.syncTables).toEqual(['category', 'expense'])
-    expect(result.instances[0]?.syncTables).not.toContain('dashboard')
-  })
-
   test('ignores related syntax mentioned only in a query-file comment', () => {
     const files = {
       [`${DIR}/dashboard/queries.ts`]: `// monthSummary moved to category/queries.ts because it uses .related()`,