on-zero 0.7.10 → 0.8.0

package/src/multiInstance.test.tsx

@@ -1,8 +1,9 @@
 import { createSchema, string, table } from '@rocicorp/zero'
-import { createEmitter } from '@take-out/helpers'
 import { describe, expect, test, vi } from 'vitest'
+
 import { combineZeroClients } from './combineZeroClients'
 import { createZeroClient } from './createZeroClient'
+import { createEmitter } from './helpers/emitter'
 import { runWithContext } from './helpers/mutatorContext'
 import {
   getInstanceForNamespace,
@@ -13,6 +14,7 @@ import { registerQuery } from './queryRegistry'
 import { run } from './run'
 import { setRunner, type ZeroRunner } from './zeroRunner'
 import { zql } from './zql'
+
 import type { ZeroEvent } from './types'
 import type { AnyQueryRegistry, Query } from '@rocicorp/zero'
 import type { ReactNode } from 'react'
@@ -107,8 +109,8 @@ describe('multi-instance namespace dispatch', () => {
           can: async () => {},
           tx: { run: txRun },
         } as any,
-        () => run(byId, { id: '1' }),
-      ),
+        () => run(byId, { id: '1' })
+      )
     ).rejects.toThrow(/run\(namedQuery\) cannot be used inside a Zero mutation/)
 
     expect(ownerRunner).not.toHaveBeenCalled()
@@ -129,8 +131,8 @@ describe('multi-instance namespace dispatch', () => {
           can: async () => {},
           tx: { run: txRun },
         } as any,
-        () => run(byId, { id: '1' }),
-      ),
+        () => run(byId, { id: '1' })
+      )
     ).resolves.toEqual({ from: 'owner' })
 
     expect(ownerRunner).toHaveBeenCalledTimes(1)
@@ -152,8 +154,8 @@ describe('multi-instance namespace dispatch', () => {
           can: async () => {},
           tx: { run: txRun },
         } as any,
-        () => run(query),
-      ),
+        () => run(query)
+      )
     ).resolves.toEqual({ from: 'tx' })
 
     expect(txRun).toHaveBeenCalledWith(query, undefined)
@@ -195,7 +197,7 @@ describe('multi-instance namespace dispatch', () => {
         models,
         groupedQueries: {},
         instanceName: 'mdl-b',
-      }),
+      })
     ).toThrow(/already claimed/)
   })
 })
@@ -211,10 +213,18 @@ describe('multi-instance isolation', () => {
 
     const seenByB: Array<ZeroEvent | null> = []
     b.zeroEvents.listen((event) => seenByB.push(event))
-    a.zeroEvents.emit({ type: 'error', message: 'a-only' })
+    a.zeroEvents.emit({
+      type: 'error',
+      reasonKey: 'connection-error',
+      message: 'a-only',
+    })
 
     expect(seenByB).toEqual([])
-    expect(a.zeroEvents.value).toEqual({ type: 'error', message: 'a-only' })
+    expect(a.zeroEvents.value).toEqual({
+      type: 'error',
+      reasonKey: 'connection-error',
+      message: 'a-only',
+    })
     expect(b.zeroEvents.value).toBe(null)
   })
 
@@ -345,7 +355,7 @@ describe('combineZeroClients facade', () => {
     expect(b.useQuery).not.toHaveBeenCalled()
 
     expect(() => combineZeroClients(a, b, { inner: 'nope' })).toThrow(
-      /not one of the passed clients/,
+      /not one of the passed clients/
     )
   })
 
@@ -357,8 +367,16 @@ describe('combineZeroClients facade', () => {
     const seen: Array<ZeroEvent | null> = []
     combined.zeroEvents.listen((event) => seen.push(event))
 
-    a.zeroEvents.emit({ type: 'error', message: 'from-a' })
-    b.zeroEvents.emit({ type: 'error', message: 'from-b' })
+    a.zeroEvents.emit({
+      type: 'error',
+      reasonKey: 'connection-error',
+      message: 'from-a',
+    })
+    b.zeroEvents.emit({
+      type: 'error',
+      reasonKey: 'connection-error',
+      message: 'from-b',
+    })
 
     const messageOf = (event: ZeroEvent | null) =>
       event?.type === 'error' ? event.message : undefined

package/src/multiInstanceNested.test.tsx

@@ -185,7 +185,7 @@ test('outer-instance query reads the OUTER store under nested providers', async
       <project.ProvideZero server={null} userID="t1-prj">
         <ControlUserProbe id="u1" />
       </project.ProvideZero>
-    </control.ProvideZero>,
+    </control.ProvideZero>
   )
   await waitFor(() => probe.renders > 0, 'probe mount')
 
@@ -241,7 +241,7 @@ test('StrictMode: direct views survive the effect double-invoke', async () => {
           <ControlUserProbe id="u4" />
         </project.ProvideZero>
       </control.ProvideZero>
-    </StrictMode>,
+    </StrictMode>
   )
   await waitFor(() => probe.renders > 0, 'probe mount')
 

package/src/multiPartition.test.ts

@@ -1,38 +1,73 @@
+import { createSchema, string, table } from '@rocicorp/zero'
 import { describe, expect, test } from 'vitest'
 
-import { assertZeroInstancePartition } from './multi'
+import { createZeroClients } from './multi'
 
-describe('assertZeroInstancePartition', () => {
-  const control = { user: 1, workspace: 1 }
-  const project = { message: 1, thread: 1 }
+const schema = createSchema({
+  tables: [table('message').columns({ id: string() }).primaryKey('id')],
+})
 
-  test('passes when every namespace belongs to exactly one partition', () => {
-    expect(() =>
-      assertZeroInstancePartition(
-        'query namespace',
-        { user: {}, workspace: {}, message: {}, thread: {} },
-        { control, project },
-      ),
-    ).not.toThrow()
+describe('createZeroClients', () => {
+  test('builds generated partitions with default as the primary client', () => {
+    const instances = {
+      default: {
+        schema,
+        queries: { account: { current: () => ({}) as never } },
+        models: {},
+        tables: ['account'],
+        syncTables: ['account'],
+        supportTables: [],
+        scope: null,
+        defaultVisibility: null,
+      },
+      project: {
+        schema,
+        queries: { message: { all: () => ({}) as never } },
+        models: {},
+        tables: ['message'],
+        syncTables: ['message'],
+        supportTables: [],
+        scope: 'projectId',
+        defaultVisibility: (value: string) => ({ column: 'projectId', value }),
+      },
+    } as const
+
+    const result = createZeroClients(instances)
+
+    expect(Object.keys(result.clients)).toEqual(['project', 'default'])
+    expect(result.clients.default.instanceName).toBe('default')
+    expect(result.clients.project.instanceName).toBe('project')
+    expect(result.providers.default).toBe(result.clients.default.ProvideZero)
+    expect(result.providers.project).toBe(result.clients.project.ProvideZero)
+    expect(result.combined.run).toBeTypeOf('function')
   })
 
-  test('throws on a namespace missing from every partition (the planGrant drift)', () => {
-    expect(() =>
-      assertZeroInstancePartition(
-        'query namespace',
-        { user: {}, planGrant: {} },
-        { control, project },
-      ),
-    ).toThrow(/planGrant.*missing from the instance partition/)
+  test('requires at least one generated instance', () => {
+    expect(() => createZeroClients({})).toThrow(/at least one instance/)
   })
 
-  test('throws on a namespace claimed by more than one partition', () => {
+  test('replaces an existing partition atomically when a namespace moves', () => {
+    const entry = (queries: Record<string, Record<string, () => never>>) => ({
+      schema,
+      queries,
+      models: {},
+      tables: Object.keys(queries),
+      syncTables: Object.keys(queries),
+      supportTables: [],
+      scope: null,
+      defaultVisibility: null,
+    })
+
+    createZeroClients({
+      default: entry({ movedNamespace: { before: () => ({}) as never } }),
+      project: entry({ stableProject: { before: () => ({}) as never } }),
+    })
+
     expect(() =>
-      assertZeroInstancePartition(
-        'query namespace',
-        { user: {} },
-        { control, project: { user: 1 } },
-      ),
-    ).toThrow(/user.*more than one instance partition/)
+      createZeroClients({
+        default: entry({ stableDefault: { after: () => ({}) as never } }),
+        project: entry({ movedNamespace: { after: () => ({}) as never } }),
+      })
+    ).not.toThrow()
   })
 })

package/src/mutations.ts

@@ -1,7 +1,6 @@
-import { IS_SERVER_RUNTIME } from '@take-out/helpers'
+import { IS_SERVER_RUNTIME } from './helpers/platform'
 import { setMutationsPermissions } from './modelRegistry'
 
-import type { TableBuilderWithColumns } from '@rocicorp/zero'
 import type {
   MutatorContext,
   Schema,
@@ -10,6 +9,7 @@ import type {
   TableUpdateRow,
   Where,
 } from './types'
+import type { TableBuilderWithColumns } from '@rocicorp/zero'
 
 // derive a TableBuilderWithColumns from the global schema by table name
 type SchemaTableBuilder<TName extends TableName> = TableBuilderWithColumns<
@@ -37,7 +37,7 @@ function proxyRegistry(): Map<string, any> {
 // returns the SAME proxy object on subsequent calls so HMR works
 function getOrCreateMutationProxy<T extends Record<string, Function>>(
   tableName: string,
-  implementations: T,
+  implementations: T
 ): T {
   // merge with any prior registration for this table: multiple modules may
   // register mutators on the same table (a seed.ts alongside the table's own
@@ -47,7 +47,7 @@ function getOrCreateMutationProxy<T extends Record<string, Function>>(
   const prior = mutationRegistry().get(tableName)
   mutationRegistry().set(
     tableName,
-    prior ? { ...prior, ...implementations } : implementations,
+    prior ? { ...prior, ...implementations } : implementations
   )
 
   // return existing proxy if we have one (HMR case)
@@ -117,11 +117,11 @@ type MutationsWithCRUD<Table extends GenericTable, Mutations extends MutationBui
 }
 
 export function mutations<Mutations extends MutationBuilders>(
-  mutations: Mutations,
+  mutations: Mutations
 ): Mutations
 export function mutations<Table extends GenericTable, Permissions extends Where>(
   table: Table,
-  permissions: Permissions,
+  permissions: Permissions
 ): MutationsWithCRUD<Table, {}>
 export function mutations<
   Table extends GenericTable,
@@ -130,12 +130,12 @@ export function mutations<
 >(
   table: Table,
   permissions: Permissions,
-  mutations: Mutations,
+  mutations: Mutations
 ): MutationsWithCRUD<Table, Mutations>
 // string-based overloads (for drizzle-zero derived schemas where table builders aren't available)
 export function mutations<TName extends TableName, Permissions extends Where>(
   tableName: TName,
-  permissions: Permissions,
+  permissions: Permissions
 ): MutationsWithCRUD<SchemaTableBuilder<TName>, {}>
 export function mutations<
   TName extends TableName,
@@ -144,7 +144,7 @@ export function mutations<
 >(
   tableName: TName,
   permissions: Permissions,
-  mutations: Mutations,
+  mutations: Mutations
 ): MutationsWithCRUD<SchemaTableBuilder<TName>, Mutations>
 export function mutations<
   Table extends GenericTable,
@@ -152,7 +152,7 @@ export function mutations<
 >(
   table: Table | string | Mutations,
   permissions?: Where,
-  mutations?: Mutations,
+  mutations?: Mutations
 ): Mutations {
   if (permissions) {
     const tableName =

package/src/provideZero.hydration.test.tsx

@@ -17,12 +17,12 @@
 // stability is what keeps useId stable.
 
 import { createSchema, string, table } from '@rocicorp/zero'
-import { IS_SERVER, IS_SERVER_RUNTIME } from '@take-out/helpers'
 import { useId, type ReactNode } from 'react'
 import { renderToString } from 'react-dom/server'
 import { expect, test } from 'vitest'
 
 import { createZeroClient } from './createZeroClient'
+import { IS_SERVER, IS_SERVER_RUNTIME } from './helpers/platform'
 
 const todoTable = table('todo')
   .columns({ id: string(), title: string() })

package/src/resolveQuery.ts

@@ -31,7 +31,7 @@ export function resolveQuery<Schema extends ZeroSchema>({
     })
     throw new Error(
       `Query function '${fnName}' not registered. ` +
-        `Ensure it is exported from a queries file and passed to createZeroClient via groupedQueries.`,
+        `Ensure it is exported from a queries file and passed to createZeroClient via groupedQueries.`
     )
   }
 
@@ -43,7 +43,7 @@ export function resolveQuery<Schema extends ZeroSchema>({
   if (!customQuery) {
     throw new Error(
       `CustomQuery '${queryName}' not found. ` +
-        `Check that the query is exported and the namespace/name matches.`,
+        `Check that the query is exported and the namespace/name matches.`
     )
   }
 

package/src/run.ts

@@ -1,6 +1,6 @@
+import { isInZeroMutation, mutatorContext } from './helpers/mutatorContext'
 import { getInstanceForQueryFn } from './instanceRegistry'
 import { resolveQuery, type PlainQueryFn } from './resolveQuery'
-import { isInZeroMutation, mutatorContext } from './helpers/mutatorContext'
 import { getAmbientRunner, getRunner } from './zeroRunner'
 
 import type {
@@ -19,7 +19,7 @@ export function setCustomQueries(queries: AnyQueryRegistry) {
 function getCustomQueries(): AnyQueryRegistry {
   if (!customQueriesRef) {
     throw new Error(
-      'Custom queries not initialized. Ensure client or server bindings have been created.',
+      'Custom queries not initialized. Ensure client or server bindings have been created.'
     )
   }
   return customQueriesRef
@@ -33,7 +33,7 @@ export function run<
   TReturn,
 >(
   query: Query<TTable, Schema, TReturn>,
-  mode?: 'complete',
+  mode?: 'complete'
 ): Promise<HumanReadable<TReturn>>
 
 export function run<
@@ -44,7 +44,7 @@ export function run<
 >(
   fn: PlainQueryFn<TArg, Query<TTable, Schema, TReturn>>,
   params: TArg,
-  mode?: 'complete',
+  mode?: 'complete'
 ): Promise<HumanReadable<TReturn>>
 
 export function run<
@@ -53,13 +53,13 @@ export function run<
   TReturn,
 >(
   fn: PlainQueryFn<void, Query<TTable, Schema, TReturn>>,
-  mode?: 'complete',
+  mode?: 'complete'
 ): Promise<HumanReadable<TReturn>>
 
 export function run(
   queryOrFn: any,
   paramsOrMode?: any,
-  modeArg?: 'complete',
+  modeArg?: 'complete'
 ): Promise<any> {
   const hasParams = modeArg !== undefined || (paramsOrMode && paramsOrMode !== 'complete')
   const params = hasParams ? paramsOrMode : undefined
@@ -79,7 +79,7 @@ export function run(
   const inMutation = isInZeroMutation()
   if (inMutation && mutatorContext().environment === 'server') {
     throw new Error(
-      'run(namedQuery) cannot be used inside a Zero mutation. Use tx.run(zql...) for transactional mutation reads.',
+      'run(namedQuery) cannot be used inside a Zero mutation. Use tx.run(zql...) for transactional mutation reads.'
     )
   }
 

package/src/server.test.ts

@@ -1,15 +1,14 @@
 import { createSchema, defineQueries, defineQuery, string, table } from '@rocicorp/zero'
 import * as v from 'valibot'
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test, vi } from 'vitest'
 
+import { getScopedAuthData } from './helpers/mutatorContext'
 import {
-  authDataToClaims,
   createZeroServerBindings,
   type ZeroServerExecutor,
   type ZeroServerMutatorRegistry,
   type ZeroServerTransaction,
 } from './server'
-import { getScopedAuthData } from './helpers/mutatorContext'
 import { zql } from './zql'
 
 import type { AuthData, MutatorContext } from './types'
@@ -31,7 +30,7 @@ const schema = createSchema({
 const queries = defineQueries({
   project: {
     byOwner: defineQuery(v.object({ ownerId: v.string() }), ({ args }) =>
-      zql.project.where('ownerId', args.ownerId),
+      zql.project.where('ownerId', args.ownerId)
     ),
   },
 })
@@ -40,9 +39,10 @@ type ProjectRow = { id: string; ownerId: string; name: string }
 
 function createTestExecutor(
   mutators: ZeroServerMutatorRegistry<typeof schema>,
-  rows: ProjectRow[],
+  rows: ProjectRow[]
 ) {
   const scheduledBackground: Promise<void>[] = []
+  const queryClaims: unknown[] = []
   const tx = {
     mutate: {
       project: {
@@ -78,12 +78,13 @@ function createTestExecutor(
     async transaction(_claims, work) {
       return work(tx)
     },
-    async query(_claims, work) {
+    async query(claims, work) {
+      queryClaims.push(claims)
       return work(tx)
     },
   }
 
-  return { executor, scheduledBackground }
+  return { executor, queryClaims, scheduledBackground }
 }
 
 describe('createZeroServerBindings', () => {
@@ -114,7 +115,7 @@ describe('createZeroServerBindings', () => {
         id: 'project-1',
         ownerId: 'anon',
         name: 'sneaky',
-      }),
+      })
     ).rejects.toThrow('not authenticated')
     expect(seenAuthData).toBe(null)
     expect(rows).toEqual([])
@@ -136,7 +137,7 @@ describe('createZeroServerBindings', () => {
           mutate: {
             create: async (
               { authData, server, tx }: MutatorContext,
-              value: ProjectRow,
+              value: ProjectRow
             ) => {
               mutationRuns++
               expect(authData?.id).toBe('user-1')
@@ -145,7 +146,7 @@ describe('createZeroServerBindings', () => {
                 async () => {
                   barrierRuns++
                 },
-                { barrier: true },
+                { barrier: true }
               )
               server?.enqueueTask(async () => {
                 backgroundRuns++
@@ -166,11 +167,14 @@ describe('createZeroServerBindings', () => {
     })
 
     expect(Object.keys(bindings.mutators)).toEqual(['project|create'])
-    const { executor, scheduledBackground } = createTestExecutor(bindings.mutators, rows)
+    const { executor, queryClaims, scheduledBackground } = createTestExecutor(
+      bindings.mutators,
+      rows
+    )
     const server = bindings.server(executor)
     await server.mutate.project.create(
       { id: 'project-1', ownerId: 'user-1', name: 'first' },
-      { authData: { id: 'user-1' } },
+      { authData: { id: 'user-1' } }
     )
 
     expect(rows).toEqual([{ id: 'project-1', ownerId: 'user-1', name: 'first' }])
@@ -181,14 +185,109 @@ describe('createZeroServerBindings', () => {
     expect(backgroundRuns).toBe(1)
     expect(backgroundAuth).toBe('user-1')
 
-    const claims = authDataToClaims({ id: 'user-1' })
-    const ast = await bindings.resolveQuery(
-      'project|byOwner',
-      [{ ownerId: 'user-1' }],
-      claims,
-    )
+    const ast = await bindings.resolveQuery('project|byOwner', [{ ownerId: 'user-1' }], {
+      id: 'user-1',
+    })
     expect(JSON.stringify(ast)).toContain('ownerId')
     expect(JSON.stringify(ast)).toContain('user-1')
     expect(validatedQueryAuth).toBe('user-1')
+
+    await server.query({ id: 'user-1' }, () => zql.project)
+    expect(queryClaims).toEqual([{ userID: 'user-1', authData: { id: 'user-1' } }])
+  })
+
+  test('enqueues typed actions through the configured local executor', async () => {
+    type Action =
+      | { type: 'project.provisionNamespace'; projectId: string }
+      | { type: 'project.invalidateAccess'; projectId: string }
+
+    const executed: Action[] = []
+    let releaseBackground: () => void = () => {}
+    const backgroundGate = new Promise<void>((resolve) => {
+      releaseBackground = resolve
+    })
+    const bindings = createZeroServerBindings({
+      schema,
+      models: {
+        project: {
+          mutate: {
+            create: async ({ server }: MutatorContext, value: ProjectRow) => {
+              const enqueueAction = server?.enqueueAction as (
+                action: Action,
+                options?: { barrier?: boolean }
+              ) => void
+              enqueueAction(
+                { type: 'project.provisionNamespace', projectId: value.id },
+                { barrier: true }
+              )
+              enqueueAction({ type: 'project.invalidateAccess', projectId: value.id })
+            },
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      actions: {
+        async execute(action: Action) {
+          if (action.type === 'project.invalidateAccess') await backgroundGate
+          executed.push(action)
+        },
+      },
+    })
+    const { executor, scheduledBackground } = createTestExecutor(bindings.mutators, [])
+
+    await executor.execute(
+      'project|create',
+      { id: 'project-1', ownerId: 'user-1', name: 'first' },
+      { userID: 'user-1', authData: { id: 'user-1' } }
+    )
+    expect(executed).toEqual([
+      { type: 'project.provisionNamespace', projectId: 'project-1' },
+    ])
+    releaseBackground()
+    await Promise.all(scheduledBackground)
+    expect(executed).toEqual([
+      { type: 'project.provisionNamespace', projectId: 'project-1' },
+      { type: 'project.invalidateAccess', projectId: 'project-1' },
+    ])
+  })
+
+  test('selects remote dispatch once and never falls back to local execution', async () => {
+    type Action = { type: 'durable.run'; operationId: string }
+    const execute = vi.fn(async (_action: Action) => {})
+    const dispatchRemote = vi.fn(async (_action: Action) => {
+      throw new Error('remote unavailable')
+    })
+    const bindings = createZeroServerBindings({
+      schema,
+      models: {
+        project: {
+          mutate: {
+            create: async ({ server }: MutatorContext) => {
+              const enqueueAction = server?.enqueueAction as (
+                action: Action,
+                options?: { barrier?: boolean }
+              ) => void
+              enqueueAction(
+                { type: 'durable.run', operationId: 'operation-1' },
+                { barrier: true }
+              )
+            },
+          },
+        },
+      },
+      createServerActions: () => ({}),
+      actions: { execute, dispatchRemote },
+    })
+    const { executor } = createTestExecutor(bindings.mutators, [])
+
+    await expect(
+      executor.execute(
+        'project|create',
+        { id: 'project-1', ownerId: 'user-1', name: 'first' },
+        { userID: 'user-1', authData: { id: 'user-1' } }
+      )
+    ).rejects.toThrow('remote unavailable')
+    expect(dispatchRemote).toHaveBeenCalledOnce()
+    expect(execute).not.toHaveBeenCalled()
   })
 })