on-zero 0.16.16 → 0.16.17

package/src/generate-lite.ts

@@ -15,6 +15,7 @@
 // contexts without pulling in ~10mb of typescript.
 
 import {
+  CRUD_MUTATION_NAMES,
   generateAggregatesFile,
   generateGroupedQueriesFile,
   generateInstancesFile,
@@ -38,7 +39,7 @@ export type LiteMutationExport = {
   // this targets membership at the named table while the model file basename
   // remains the top-level key in syncedMutations.
   modelName: string
-  // handlers = keys of the last object literal arg to `mutations(...)`
+  // handlers = keys of the handler argument, before any options argument
   handlers: Array<{
     // handler property name, e.g. 'toggleActive'
     name: string
@@ -54,6 +55,12 @@ export type LiteMutationExport = {
   // model doesn't declare a schema inline (most templates use drizzle-zero,
   // so null is common).
   schema: LiteSchemaInfo | null
+  // the `crud` field of the fourth options argument, i.e. false for
+  // `mutations(table, permissions, handlers, { crud: false })`. omitted or
+  // undefined means the default, which generates the full crud slot set.
+  // permissions stay registered either way, so this only controls the
+  // generated insert/update/delete/upsert validators.
+  crud?: boolean
 }
 
 export type LiteSchemaInfo = {
@@ -514,15 +521,15 @@ export function generateLite(opts: LiteGenerateOptions): LiteGenerateResult {
     }
 
     // a model participates in crud only when it has a schema AND its mutate
-    // call is `mutations(schema, perm)` / `mutations(schema, perm, { ... })`.
-    // in the lite ast, we don't know the call arity directly, so we use the
-    // presence of a schema as the signal. this matches the real generator's
+    // call did not opt out with `{ crud: false }`. in the lite ast, we don't
+    // know the call arity directly, so we use the presence of a schema as the
+    // signal for a table registration. this matches the real generator's
     // behavior for schemas-with-mutate: hasCRUD is true whenever both exist.
     //
     // models without `export const mutate` still appear in the output as
     // empty entries — see the test "treats models without export const mutate
     // as empty mutations".
-    const hasCRUD = hasSchema && mutationExport !== null
+    const hasCRUD = hasSchema && mutationExport !== null && mutationExport.crud !== false
 
     const custom = (mutationExport?.handlers ?? []).map((h) => {
       // null or empty annotation → void (no second param) → v.void_()
@@ -821,13 +828,13 @@ export function generateLite(opts: LiteGenerateOptions): LiteGenerateResult {
     )
   }
 
-  // count mutations the same way `generate()` does: 3 per crud model plus
-  // non-crud custom mutations (the crud-ops set is excluded when hasCRUD).
+  // count mutations the same way `generate()` does: one per generated crud slot
+  // plus non-crud custom mutations (the crud-ops set is excluded when hasCRUD).
   let mutationCount = 0
   for (const m of allModelMutations) {
-    if (m.hasCRUD) mutationCount += 3
+    if (m.hasCRUD) mutationCount += CRUD_MUTATION_NAMES.length
     mutationCount += m.custom.filter(
-      (mut) => !m.hasCRUD || !['insert', 'update', 'delete', 'upsert'].includes(mut.name)
+      (mut) => !m.hasCRUD || !CRUD_MUTATION_NAMES.some((name) => name === mut.name)
     ).length
   }
 

package/src/generate.test.ts

@@ -11,6 +11,7 @@ import { dirname, join } from 'node:path'
 import { runInNewContext } from 'node:vm'
 
 import * as zero from '@rocicorp/zero'
+import * as v from 'valibot'
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 
 import {
@@ -85,6 +86,97 @@ describe('generate', () => {
 
     expect(existsSync(syncedQueriesPath)).toBe(true)
   })
+
+  test('generates every crud slot for a default table registration', async () => {
+    writeFileSync(
+      join(testDir, 'post/mutations.ts'),
+      `
+export const schema = table('post').columns({ id: string(), title: string() }).primaryKey('id')
+export const mutate = mutations(schema, permission, {
+  publish: async (ctx, args: { id: string }) => {},
+})
+`
+    )
+
+    await generate({ dir: testDir, silent: true })
+    const output = readFileSync(join(testDir, 'generated/syncedMutations.ts'), 'utf-8')
+
+    for (const slot of ['insert', 'update', 'delete', 'upsert']) {
+      expect(output).toContain(`    ${slot}: v.object({`)
+    }
+    expect(output).toContain('    publish: v.object({')
+
+    // the emitted module has to evaluate and actually validate payloads
+    const context = { v, exports: {} as { mutationValidators?: any } }
+    runInNewContext(
+      output
+        .replace(/^import .*$/m, '')
+        .replace('export const', 'exports.mutationValidators ='),
+      context
+    )
+    const validators = context.exports.mutationValidators!.post
+
+    expect(v.parse(validators.upsert, { id: 'a', title: 'hello' })).toEqual({
+      id: 'a',
+      title: 'hello',
+    })
+    // upsert takes the insert shape, so a missing non-optional column is rejected
+    expect(() => v.parse(validators.upsert, { id: 'a' })).toThrow()
+    // update keeps the primary key required and every other column optional
+    expect(v.parse(validators.update, { id: 'a' })).toEqual({ id: 'a' })
+    expect(() => v.parse(validators.update, { title: 'hello' })).toThrow()
+    // delete is keyed by the primary key alone
+    expect(v.parse(validators.delete, { id: 'a' })).toEqual({ id: 'a' })
+  })
+
+  test('emits only authored handlers when a registration opts out with crud false', async () => {
+    writeFileSync(
+      join(testDir, 'post/mutations.ts'),
+      `
+export const schema = table('post').columns({ id: string(), title: string() }).primaryKey('id')
+export const mutate = mutations(
+  schema,
+  permission,
+  {
+    publish: async (ctx, args: { id: string }) => {},
+  },
+  { crud: false }
+)
+`
+    )
+
+    await generate({ dir: testDir, silent: true })
+    const output = readFileSync(join(testDir, 'generated/syncedMutations.ts'), 'utf-8')
+
+    expect(output).toContain('    publish: v.object({')
+    for (const slot of ['insert', 'update', 'delete', 'upsert']) {
+      expect(output).not.toContain(`    ${slot}:`)
+    }
+    // the options object must never be read as the handlers object
+    expect(output).not.toContain('crud:')
+  })
+
+  test('reads handlers from the third argument, never the options or permissions argument', async () => {
+    writeFileSync(
+      join(testDir, 'post/mutations.ts'),
+      `
+export const schema = table('post').columns({ id: string() }).primaryKey('id')
+export const mutate = mutations(schema, permission, { publish: async (ctx, args: { id: string }) => {} }, { crud: true })
+`
+    )
+    writeFileSync(
+      join(testDir, 'note/mutations.ts'),
+      `export const mutate = mutations('note', { shouldNotBeAHandler: async (ctx, args: { id: string }) => {} })`
+    )
+
+    await generate({ dir: testDir, silent: true })
+    const output = readFileSync(join(testDir, 'generated/syncedMutations.ts'), 'utf-8')
+
+    expect(output).toContain('    publish: v.object({')
+    expect(output).not.toContain('crud:')
+    // arg 1 is permissions at runtime, so a two-arg named call authors no handlers
+    expect(output).not.toContain('shouldNotBeAHandler')
+  })
 })
 
 describe('instance layout', () => {

package/src/generate.ts

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from
 import { basename, dirname, resolve } from 'node:path'
 
 import {
+  CRUD_MUTATION_NAMES,
   formatObjectKey,
   generateAggregatesFile,
   generateGroupedQueriesFile,
@@ -221,6 +222,57 @@ function resolveParamType(
   return result
 }
 
+// positional shape of a `mutations(...)` call, matching the runtime overloads:
+//   mutations(handlers)
+//   mutations(table, permissions)
+//   mutations(table, permissions, handlers)
+//   mutations(table, permissions, handlers, { crud: false })
+// arg 1 is always permissions and arg 3 is always options, so neither may ever
+// be read as the handlers object.
+function readMutationsCall(
+  ts: typeof import('typescript'),
+  call: import('typescript').CallExpression
+): {
+  hasTable: boolean
+  crud: boolean
+  handlersArg: import('typescript').ObjectLiteralExpression | null
+} {
+  const args = call.arguments
+
+  if (args.length < 2) {
+    const only = args[0]
+    return {
+      hasTable: false,
+      crud: false,
+      handlersArg: only && ts.isObjectLiteralExpression(only) ? only : null,
+    }
+  }
+
+  const handlers = args[2]
+  const options = args[3]
+
+  let crud = true
+  if (options && ts.isObjectLiteralExpression(options)) {
+    for (const prop of options.properties) {
+      if (!ts.isPropertyAssignment(prop)) continue
+      if (
+        !(ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) ||
+        prop.name.text !== 'crud'
+      )
+        continue
+      // only a literal opt-out removes the generated slots. a computed value
+      // keeps them, since extra validators are inert but missing ones are not.
+      if (prop.initializer.kind === ts.SyntaxKind.FalseKeyword) crud = false
+    }
+  }
+
+  return {
+    hasTable: true,
+    crud,
+    handlersArg: handlers && ts.isObjectLiteralExpression(handlers) ? handlers : null,
+  }
+}
+
 // find mutation handler param types in a resolver-owned source file
 // walks `export const mutate = mutations(..., { handlerName: async (ctx, param: Type) => ... })`
 function resolveMutationParamTypes(
@@ -239,16 +291,8 @@ function resolveMutationParamTypes(
     if (decl.name.getText(sourceFile) !== 'mutate') return
 
     if (!decl.initializer || !ts.isCallExpression(decl.initializer)) return
-    const args = decl.initializer.arguments
-
-    // find the handlers object (last arg that is an object literal)
-    let handlersArg: import('typescript').ObjectLiteralExpression | null = null
-    for (let i = args.length - 1; i >= 0; i--) {
-      if (ts.isObjectLiteralExpression(args[i]!)) {
-        handlersArg = args[i] as import('typescript').ObjectLiteralExpression
-        break
-      }
-    }
+
+    const { handlersArg } = readMutationsCall(ts, decl.initializer)
     if (!handlersArg) return
 
     for (const prop of handlersArg.properties) {
@@ -317,28 +361,11 @@ function extractMutationsFromModel(
   }
 
   const call = mutateNode as import('typescript').CallExpression
-  const args = call.arguments
 
-  // determine overload
-  // 1-arg: mutations({ ... })
-  // schema model: mutations(schema, perm) / mutations(schema, perm, { ... })
-  // named model: mutations('name', handlers) / mutations('name', perm, { ... })
-  const firstArg = args[0]
-  const hasNamedModel = Boolean(firstArg && ts.isStringLiteralLike(firstArg))
-  const hasCRUD = args.length >= 2 && !hasNamedModel
-  let handlersArg: import('typescript').ObjectLiteralExpression | null = null
-
-  if (args.length === 1 && ts.isObjectLiteralExpression(args[0]!)) {
-    handlersArg = args[0] as import('typescript').ObjectLiteralExpression
-  } else if (hasNamedModel) {
-    if (args.length >= 3 && ts.isObjectLiteralExpression(args[2]!)) {
-      handlersArg = args[2] as import('typescript').ObjectLiteralExpression
-    } else if (args.length >= 2 && ts.isObjectLiteralExpression(args[1]!)) {
-      handlersArg = args[1] as import('typescript').ObjectLiteralExpression
-    }
-  } else if (args.length === 3 && ts.isObjectLiteralExpression(args[2]!)) {
-    handlersArg = args[2] as import('typescript').ObjectLiteralExpression
-  }
+  // string-named and table-builder registrations behave identically at runtime:
+  // any 2+ arg call registers permissions and generates crud unless it opted out
+  const { hasTable, crud, handlersArg } = readMutationsCall(ts, call)
+  const hasCRUD = hasTable && crud
 
   // extract schema columns for CRUD generation
   const columns: Record<string, SchemaColumn> = {}
@@ -1327,9 +1354,9 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
 
   // count total mutations (CRUD + custom)
   for (const model of allModelMutations) {
-    if (model.hasCRUD) mutationCount += 3 // insert, update, delete
+    if (model.hasCRUD) mutationCount += CRUD_MUTATION_NAMES.length
     mutationCount += model.custom.filter(
-      (m) => !model.hasCRUD || !['insert', 'update', 'delete', 'upsert'].includes(m.name)
+      (m) => !model.hasCRUD || !CRUD_MUTATION_NAMES.some((name) => name === m.name)
     ).length
   }
 

package/src/mutations.test.ts

@@ -1,9 +1,68 @@
-import { describe, expect, test } from 'vitest'
+import { AsyncLocalStorage } from 'node:async_hooks'
+import { DatabaseSync, type SQLInputValue } from 'node:sqlite'
 
+import { createSchema, string, table } from '@rocicorp/zero'
+import {
+  createSQLiteApplicationDatabase,
+  createSyncExecutor,
+  type ApplicationTransaction,
+} from 'orez-lite'
+import { createQueryCompiler } from 'orez-lite/cloudflare/query-compiler'
+import { executeTransactionQueryPlan } from 'orez-lite/cloudflare/transaction-query'
+import { afterAll, describe, expect, test, vi } from 'vitest'
+
+import { createZeroServerBindings, setupAsyncLocalStorage } from './server'
+
+const previousEnvironment = vi.hoisted(() => {
+  const previous = process.env.VITE_ENVIRONMENT
+  process.env.VITE_ENVIRONMENT = 'client'
+  return previous
+})
+
+afterAll(() => {
+  if (previousEnvironment === undefined) delete process.env.VITE_ENVIRONMENT
+  else process.env.VITE_ENVIRONMENT = previousEnvironment
+})
+
+import { getMutationsPermissions } from './modelRegistry'
 import { mutations } from './mutations'
 import { serverWhere } from './serverWhere'
 
 describe('mutations registry', () => {
+  test('explicit opt-out removes generated CRUD from existing proxies and retains permissions', async () => {
+    const record = table('closedRecord').columns({ id: string() }).primaryKey('id')
+    const permission = serverWhere('closedRecord', () => true)
+    const first = mutations(record, permission)
+    expect(Object.keys(first).sort()).toEqual(['delete', 'insert', 'update', 'upsert'])
+    const custom = vi.fn(async () => {})
+    const closed = mutations(record, permission, { custom }, { crud: false })
+    expect(closed).toBe(first)
+    expect(Object.keys(closed)).toEqual(['custom'])
+    expect('insert' in closed).toBe(false)
+    expect(Reflect.get(closed, 'upsert')).toBeUndefined()
+    expect(getMutationsPermissions('closedRecord')).toBe(permission)
+    await closed.custom()
+    expect(custom).toHaveBeenCalledOnce()
+    const reopened = mutations(record, permission, {}, { crud: true })
+    expect(Object.keys(reopened).sort()).toEqual([
+      'custom',
+      'delete',
+      'insert',
+      'update',
+      'upsert',
+    ])
+  })
+
+  test('opt-out preserves explicitly declared CRUD handlers', async () => {
+    const record = table('customRecord').columns({ id: string() }).primaryKey('id')
+    const permission = serverWhere('customRecord', () => true)
+    const insert = vi.fn(async () => {})
+    const custom = mutations(record, permission, { insert }, { crud: false })
+    expect(Object.keys(custom)).toEqual(['insert'])
+    await custom.insert()
+    expect(insert).toHaveBeenCalledOnce()
+  })
+
   test('re-registering a handler replaces it per key (HMR)', () => {
     const permissions = serverWhere('post', () => true)
     const v1 = async () => {}
@@ -15,3 +74,159 @@ describe('mutations registry', () => {
     expect(proxy.custom).toBe(v2)
   })
 })
+
+describe('generated CRUD authorization', () => {
+  test('authorizes both sides of composite-key writes through the server executor', async () => {
+    setupAsyncLocalStorage(AsyncLocalStorage)
+    const document = table('document')
+      .columns({
+        workspace: string(),
+        id: string(),
+        ownerId: string(),
+        title: string(),
+      })
+      .primaryKey('workspace', 'id')
+    const schema = createSchema({
+      tables: [document],
+      relationships: [],
+      enableLegacyQueries: true,
+    })
+    const sqlite = new DatabaseSync(':memory:')
+    sqlite.exec(
+      'CREATE TABLE document (workspace TEXT, id TEXT, ownerId TEXT, title TEXT, PRIMARY KEY (workspace, id))'
+    )
+    const compile = createQueryCompiler(schema)
+    const query: ApplicationTransaction['query'] = async (sql, params = []) =>
+      sqlite.prepare(sql).all(...params.map((value) => value as SQLInputValue)) as any
+    const tx: ApplicationTransaction = {
+      query,
+      exec: async (sql, params = []) => ({
+        changes: Number(
+          sqlite.prepare(sql).run(...params.map((value) => value as SQLInputValue))
+            .changes
+        ),
+      }),
+      queryAst: async (ast, format, queryName) =>
+        executeTransactionQueryPlan(
+          compile(ast, format),
+          (sql, params) =>
+            sqlite.prepare(sql).all(...params.map((value) => value as SQLInputValue)),
+          { queryName }
+        ),
+    }
+    const database = createSQLiteApplicationDatabase({
+      query,
+      transaction: async (work) => {
+        sqlite.exec('BEGIN')
+        try {
+          const result = await work(tx)
+          sqlite.exec('COMMIT')
+          return result
+        } catch (error) {
+          sqlite.exec('ROLLBACK')
+          throw error
+        }
+      },
+    })
+    const permission = serverWhere('document', (eb, auth) =>
+      eb.cmp(
+        'ownerId',
+        auth && 'id' in auth && typeof auth.id === 'string' ? auth.id : ''
+      )
+    )
+    const bindings = createZeroServerBindings({
+      schema,
+      models: { document: { mutate: mutations(document, permission) } },
+      createServerActions: () => ({}),
+    })
+    const executor = createSyncExecutor({
+      database,
+      schema,
+      mutators: bindings.mutators,
+      effects: {
+        runBackground: (promise) => promise,
+        report: (error) => {
+          throw error
+        },
+      },
+    })
+    const server = bindings.server(executor)
+    const auth = { authData: { id: 'alice' } }
+    const own = { workspace: 'a', id: 'same', ownerId: 'alice', title: 'own' }
+    const foreign = { workspace: 'b', id: 'same', ownerId: 'bob', title: 'foreign' }
+    try {
+      await server.mutate.document.insert(own, auth)
+      await server.mutate.document.insert(foreign, { authData: { id: 'bob' } })
+      await expect(
+        server.mutate.document.insert({ ...foreign, id: 'forbidden' }, auth)
+      ).rejects.toThrow()
+      await expect(
+        server.mutate.document.upsert({ ...foreign, ownerId: 'alice' }, auth)
+      ).rejects.toThrow()
+      await expect(
+        server.mutate.document.update({ ...own, ownerId: 'bob' }, auth)
+      ).rejects.toThrow()
+      await expect(
+        server.mutate.document.upsert({ ...own, ownerId: 'bob' }, auth)
+      ).rejects.toThrow()
+      await expect(
+        server.mutate.document.upsert({ ...foreign, id: 'missing' }, auth)
+      ).rejects.toThrow()
+      await server.mutate.document.upsert({ ...own, title: 'updated' }, auth)
+      await server.mutate.document.upsert({ ...own, title: 'updated' }, auth)
+      await server.mutate.document.upsert({ ...own, id: 'new' }, auth)
+      expect(
+        sqlite.prepare('SELECT * FROM document ORDER BY workspace, id').all()
+      ).toEqual([{ ...own, id: 'new' }, { ...own, title: 'updated' }, foreign])
+      const closedBindings = createZeroServerBindings({
+        schema,
+        models: {
+          document: {
+            mutate: mutations(
+              document,
+              permission,
+              {
+                rename: async (
+                  ctx,
+                  input: { workspace: string; id: string; title: string }
+                ) => {
+                  await ctx.can(permission, input)
+                  await ctx.tx.mutate.document.update(input)
+                },
+              },
+              { crud: false }
+            ),
+          },
+        },
+        createServerActions: () => ({}),
+      })
+      expect(Object.keys(closedBindings.mutators)).toEqual(['document|rename'])
+      const closedExecutor = createSyncExecutor({
+        database,
+        schema,
+        mutators: closedBindings.mutators,
+        effects: {
+          runBackground: (promise) => promise,
+          report: (error) => {
+            throw error
+          },
+        },
+      })
+      for (const action of ['insert', 'update', 'delete', 'upsert']) {
+        await expect(
+          closedExecutor.execute(`document|${action}`, own, { userID: 'alice' })
+        ).rejects.toThrow(`unknown mutator: document|${action}`)
+      }
+      await closedBindings
+        .server(closedExecutor)
+        .mutate.document.rename({ workspace: 'a', id: 'same', title: 'renamed' }, auth)
+      expect(
+        sqlite
+          .prepare('SELECT title FROM document WHERE workspace = ? AND id = ?')
+          .get('a', 'same')
+      ).toEqual({ title: 'renamed' })
+    } finally {
+      sqlite.close()
+    }
+  })
+})