on-zero 0.6.14 → 0.6.16

package/src/createZeroServerCore.ts

@@ -1,47 +1,23 @@
-import { mustGetQuery } from '@rocicorp/zero'
 import {
   PushProcessor,
   handleQueryRequest as zeroHandleQueryRequest,
 } from '@rocicorp/zero/server'
 
-import { createPermissions } from './createPermissions'
-import { createMutators } from './helpers/createMutators'
+import { runAsyncTaskEntries } from './asyncTasks'
 import {
-  getScopedAuthData,
-  isInZeroMutation,
-  mutatorContext,
-  runWithAuthScope,
-} from './helpers/mutatorContext'
+  createAsyncTaskCollector,
+  createZeroDirectServerRuntime,
+  resolveServerQuery,
+  type TransactionAttemptLifecycle,
+  type ZeroServerCommonOptions,
+  type ZeroServerDatabase,
+} from './createZeroDirectServer'
+import { createMutators } from './helpers/createMutators'
+import { runWithAuthScope } from './helpers/mutatorContext'
 import { runWithQueryContext } from './helpers/queryContext'
-import { getMutationsPermissions } from './modelRegistry'
-import { setCustomQueries } from './run'
-import { getZQL, setEnvironment, setSchema } from './state'
-import { setEvaluatingPermission } from './where'
-import { setRunner } from './zeroRunner'
 
-import type {
-  AdminRoleMode,
-  AsyncAction,
-  AuthData,
-  GenericModels,
-  MutatorContext,
-  QueryBuilder,
-  Transaction,
-} from './types'
-import type {
-  AnyQueryRegistry,
-  HumanReadable,
-  Query,
-  Schema as ZeroSchema,
-} from '@rocicorp/zero'
-import type { Database, TransactionProviderInput } from '@rocicorp/zero/server'
-
-type MutateAuthData = Pick<AuthData, 'email' | 'id'> & Partial<AuthData>
-
-type MutateOptions = {
-  authData?: MutateAuthData
-  awaitEffects?: boolean
-}
+import type { AuthData, GenericModels } from './types'
+import type { Schema as ZeroSchema } from '@rocicorp/zero'
 
 type AlreadyProcessedMutation = {
   id: {
@@ -58,122 +34,12 @@ type PushRequestBody = {
   clientGroupID?: unknown
 }
 
-type ServerMutate<Models extends GenericModels> = {
-  [Key in keyof Models]: {
-    [K in keyof Models[Key]['mutate']]: Models[Key]['mutate'][K] extends (
-      ctx: MutatorContext,
-      arg: infer Arg,
-    ) => any
-      ? (arg: Arg, options?: MutateOptions) => Promise<void>
-      : (options?: MutateOptions) => Promise<void>
-  }
-}
-
-export type ValidateQueryArgs = {
-  authData: AuthData | null
-  queryName: string
-  params: unknown
-}
-
-export type ValidateMutationArgs = {
-  authData: AuthData | null
-  mutatorName: string
-  tableName: string
-  args: unknown
-}
-
-export type ValidateQueryFn = (args: ValidateQueryArgs) => void
-export type ValidateMutationFn = (args: ValidateMutationArgs) => void | Promise<void>
-
-export type ServerQueryResolverOptions = {
-  authData: AuthData | null
-  name: string
-  args: unknown
-  queries: AnyQueryRegistry
-  permissions: ReturnType<typeof createPermissions>
-  validateQuery?: ValidateQueryFn
-}
-
-export function resolveServerQuery({
-  authData,
-  name,
-  args,
-  queries,
-  permissions,
-  validateQuery,
-}: ServerQueryResolverOptions) {
-  if (name.startsWith('permission.')) {
-    const table = name.slice('permission.'.length)
-    const { objOrId } = args as {
-      objOrId: string | Record<string, any>
-    }
-    const permission = getMutationsPermissions(table)
-    if (!permission) {
-      throw new Error(`[permission] no permission defined for table: ${table}`)
-    }
-    setEvaluatingPermission(true)
-    try {
-      return (getZQL() as any)[table]
-        .where((eb: any) => {
-          return permissions.buildPermissionQuery(
-            authData,
-            eb,
-            permission,
-            objOrId,
-            table,
-          )
-        })
-        .one()
-    } finally {
-      setEvaluatingPermission(false)
-    }
-  }
-
-  if (validateQuery) {
-    validateQuery({ authData, queryName: name, params: args })
-  }
-
-  const query = (mustGetQuery as any)(queries, name)
-  return query.fn({ args, ctx: authData })
-}
-
-export type TransactionAttemptLifecycle = {
-  beginAttempt(): void
-  completeAttempt(): void
-  rollbackAttempt(): void
-  commitTransaction(): void
-  rollbackTransaction(): void
-}
-
-export type ZeroServerDatabase = Database<Transaction>
-
 export type PersistAlreadyProcessedArgs = {
   clientGroupID: string
   mutations: AlreadyProcessedMutation[]
   upstreamSchema: string
 }
 
-export type ZeroServerCommonOptions<
-  Schema extends ZeroSchema,
-  Models extends GenericModels,
-  ServerActions extends Record<string, unknown>,
-> = {
-  schema: Schema
-  models: Models
-  createServerActions: () => ServerActions
-  queries?: AnyQueryRegistry
-  /** generated validators keyed by model and mutation name */
-  mutations?: Record<string, Record<string, any>>
-  /** synchronous query authorization hook; throw to reject */
-  validateQuery?: ValidateQueryFn
-  /** mutation authorization hook; throw to reject */
-  validateMutation?: ValidateMutationFn
-  /** controls which operations the admin role bypasses */
-  defaultAllowAdminRole?: AdminRoleMode
-  /** auth data used by direct server mutations when no scope provides it */
-  defaultMutateAuthData?: MutateAuthData
-}
-
 type ZeroServerCoreOptions<
   Schema extends ZeroSchema,
   Models extends GenericModels,
@@ -183,60 +49,6 @@ type ZeroServerCoreOptions<
   persistAlreadyProcessed?: (args: PersistAlreadyProcessedArgs) => Promise<void>
 }
 
-function createAsyncTaskCollector() {
-  const committed: AsyncAction[] = []
-  let attempt: AsyncAction[] | undefined
-  let completedAttempt: AsyncAction[] | undefined
-  const current = () => attempt ?? committed
-  const queue = new Proxy([] as AsyncAction[], {
-    deleteProperty(_target, property) {
-      return Reflect.deleteProperty(current(), property)
-    },
-    get(_target, property) {
-      const target = current()
-      const value = Reflect.get(target, property, target)
-      return typeof value === 'function' ? value.bind(target) : value
-    },
-    getOwnPropertyDescriptor(_target, property) {
-      return Reflect.getOwnPropertyDescriptor(current(), property)
-    },
-    has(_target, property) {
-      return Reflect.has(current(), property)
-    },
-    ownKeys() {
-      return Reflect.ownKeys(current())
-    },
-    set(_target, property, value) {
-      return Reflect.set(current(), property, value)
-    },
-  })
-
-  const lifecycle: TransactionAttemptLifecycle = {
-    beginAttempt() {
-      attempt = []
-      completedAttempt = undefined
-    },
-    completeAttempt() {
-      completedAttempt = attempt
-      attempt = undefined
-    },
-    rollbackAttempt() {
-      attempt = undefined
-      completedAttempt = undefined
-    },
-    commitTransaction() {
-      if (completedAttempt) committed.push(...completedAttempt)
-      completedAttempt = undefined
-    },
-    rollbackTransaction() {
-      attempt = undefined
-      completedAttempt = undefined
-    },
-  }
-
-  return { committed, lifecycle, queue }
-}
-
 export function createZeroServerCore<
   Schema extends ZeroSchema,
   Models extends GenericModels,
@@ -245,7 +57,7 @@ export function createZeroServerCore<
   createDatabase,
   createServerActions,
   defaultAllowAdminRole = 'all',
-  defaultMutateAuthData = {} as MutateAuthData,
+  defaultMutateAuthData,
   models,
   mutations: mutationValidators,
   persistAlreadyProcessed,
@@ -254,13 +66,17 @@ export function createZeroServerCore<
   validateMutation,
   validateQuery,
 }: ZeroServerCoreOptions<Schema, Models, ServerActions>) {
-  setSchema(schema)
-  setEnvironment('server')
-
-  const permissions = createPermissions<Schema>({
-    environment: 'server',
+  const { permissions, server } = createZeroDirectServerRuntime({
+    createDatabase,
+    createServerActions,
+    defaultAllowAdminRole,
+    defaultMutateAuthData,
+    models,
+    mutations: mutationValidators,
+    queries,
     schema,
-    adminRoleMode: defaultAllowAdminRole,
+    validateMutation,
+    validateQuery,
   })
 
   const handleMutationRequest = async ({
@@ -275,7 +91,7 @@ export function createZeroServerCore<
     const tasks = createAsyncTaskCollector()
     const recoveryRequest = request.clone()
     const mutators = createMutators({
-      asyncTasks: tasks.queue,
+      enqueueTask: tasks.enqueueTask,
       can: permissions.can,
       createServerActions,
       environment: 'server',
@@ -295,11 +111,11 @@ export function createZeroServerCore<
     }
 
     if (!skipAsyncTasks && tasks.committed.length) {
-      Promise.all(tasks.committed.map((task) => runWithAuthScope(authData, task))).catch(
-        (err: unknown) => {
-          console.error('[push] async tasks failed', err)
-        },
-      )
+      const entries = tasks.committed.map((entry) => ({
+        ...entry,
+        task: () => runWithAuthScope(authData, entry.task),
+      }))
+      await runAsyncTaskEntries(entries, { background: () => undefined })
     }
 
     return {
@@ -342,135 +158,13 @@ export function createZeroServerCore<
           : zeroHandleQueryRequest({ handler, schema, request, userID }),
     )
 
-    return {
-      response,
-    }
-  }
-
-  async function runTransaction<
-    CB extends (tx: Transaction) => Promise<any>,
-    Returns extends CB extends (tx: Transaction) => Promise<infer X> ? X : never,
-  >(database: ZeroServerDatabase, query: CB): Promise<Returns> {
-    try {
-      if (isInZeroMutation()) {
-        const { tx } = mutatorContext()
-        return await query(tx)
-      }
-      return (await database.transaction(query, dummyTransactionInput)) as Returns
-    } catch (err) {
-      if ((err as any)?.name !== 'PermissionError') {
-        console.error(`Error running transaction(): ${err}`)
-      }
-      throw err
-    }
-  }
-
-  async function transaction<
-    CB extends (tx: Transaction) => Promise<any>,
-    Returns extends CB extends (tx: Transaction) => Promise<infer X> ? X : never,
-  >(query: CB): Promise<Returns> {
-    return runTransaction(createDatabase(), query)
-  }
-
-  async function runMutate(
-    modelName: string,
-    mutatorName: string,
-    mutatorArg: unknown,
-    options?: MutateOptions,
-  ) {
-    let authData = options?.authData
-    if (!authData) {
-      const scoped = getScopedAuthData()
-      if (scoped) authData = scoped as MutateAuthData
-    }
-
-    const tasks = createAsyncTaskCollector()
-    const mutators = createMutators({
-      models,
-      environment: 'server',
-      asyncTasks: tasks.queue,
-      authData: {
-        ...defaultMutateAuthData,
-        ...authData,
-      },
-      createServerActions,
-      can: permissions.can,
-      validateMutation,
-      mutationValidators,
-    })
-    const modelMutators = mutators[modelName as keyof typeof mutators] as Record<
-      string,
-      (tx: Transaction, arg?: unknown) => Promise<void>
-    >
-    const mutator = modelMutators[mutatorName]
-
-    await runTransaction(
-      withTransactionLifecycle(createDatabase(), tasks.lifecycle),
-      async (tx) => {
-        await mutator(tx, mutatorArg)
-      },
-    )
-
-    if (tasks.committed.length) {
-      const resolvedAuth = authData ?? null
-      const promise = Promise.all(
-        tasks.committed.map((task) => runWithAuthScope(resolvedAuth, task)),
-      )
-      if (options?.awaitEffects) {
-        await promise
-      } else {
-        promise.catch((err: unknown) => {
-          console.error('[mutate] async tasks failed', err)
-        })
-      }
-    }
-  }
-
-  const mutate = new Proxy({} as ServerMutate<Models>, {
-    get(_, modelName: string) {
-      return new Proxy(
-        {},
-        {
-          get(_, mutatorName: string) {
-            return (arg: unknown, options?: MutateOptions) =>
-              runMutate(modelName, mutatorName, arg, options)
-          },
-        },
-      )
-    },
-  })
-
-  function query<R>(
-    cb: (q: QueryBuilder) => Query<any, Schema, R>,
-    authData?: AuthData | null,
-  ): Promise<HumanReadable<R>> {
-    const run = () =>
-      transaction(async (tx) => {
-        return tx.run(cb(getZQL()))
-      }) as any
-
-    if (authData !== undefined) {
-      return runWithQueryContext({ authData }, run)
-    }
-    return run()
+    return { response }
   }
 
-  if (queries) {
-    setCustomQueries(queries)
-  }
-
-  setRunner((queryObj) => {
-    return transaction(async (tx) => {
-      return tx.run(queryObj)
-    })
-  })
-
   return {
     handleMutationRequest,
     handleQueryRequest,
-    transaction,
-    mutate,
-    query,
+    ...server,
   }
 }
 
@@ -549,9 +243,11 @@ function alreadyProcessedMutations(response: unknown): AlreadyProcessedMutation[
   })
 }
 
-const dummyTransactionInput: TransactionProviderInput = {
-  clientGroupID: 'unused',
-  clientID: 'unused',
-  mutationID: 42,
-  upstreamSchema: 'unused',
-}
+export type {
+  ValidateMutationArgs,
+  ValidateMutationFn,
+  ValidateQueryArgs,
+  ValidateQueryFn,
+  ZeroServerCommonOptions,
+  ZeroServerDatabase,
+} from './createZeroDirectServer'

package/src/generate.test.ts

@@ -1,4 +1,11 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { runInNewContext } from 'node:vm'
@@ -211,6 +218,24 @@ export const allPosts = () => zero.query.post
     const second = await generate({ dir: testDir, silent: true })
     expect(second.filesChanged).toBe(0)
   })
+
+  test('force regenerates without source changes', async () => {
+    writeFileSync(
+      join(testDir, 'models/post.ts'),
+      `export const schema = table('post', { id: string() })`,
+    )
+    writeFileSync(
+      join(testDir, 'queries/post.ts'),
+      `export const allPosts = () => zero.query.post`,
+    )
+    await generate({ dir: testDir, silent: true })
+    const syncedQueriesPath = join(testDir, 'generated/syncedQueries.ts')
+    rmSync(syncedQueriesPath)
+
+    await generate({ dir: testDir, silent: true, force: true })
+
+    expect(existsSync(syncedQueriesPath)).toBe(true)
+  })
 })
 
 describe('mutations', () => {
@@ -617,6 +642,55 @@ export const mutate = mutations(schema, perm, {
     expect(content).not.toMatch(/rename:[\s\S]*count/)
   })
 
+  test('resolves instantiated Zero row fields through Partial and Omit', async () => {
+    symlinkSync(
+      join(import.meta.dirname, '../../../node_modules'),
+      join(testDir, 'node_modules'),
+      'dir',
+    )
+    writeFileSync(
+      join(testDir, 'models/types.ts'),
+      `
+import type { Row } from '@rocicorp/zero'
+import { drizzleZeroConfig } from 'drizzle-zero-sqlite'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+const item = sqliteTable('item', {
+  id: text().primaryKey(),
+  name: text().notNull(),
+  description: text().notNull(),
+})
+const schema = drizzleZeroConfig({ item })
+
+export type Item = Row<(typeof schema)['tables']['item']>
+`,
+    )
+
+    writeFileSync(
+      join(testDir, 'models/item.ts'),
+      `
+import { mutations } from 'on-zero'
+import type { Item } from './types'
+
+type ItemUpdate = { id: string } & Partial<Omit<Item, 'id'>>
+
+export const mutate = mutations('item', {
+  update: async ({ tx }, props: ItemUpdate) => {
+    await tx.mutate.item.update(props)
+  },
+})
+`,
+    )
+
+    await generate({ dir: testDir, silent: true })
+
+    const content = readFileSync(join(testDir, 'generated/syncedMutations.ts'), 'utf-8')
+    expect(content).toContain('name: v.optional(v.string())')
+    expect(content).toContain('description: v.optional(v.string())')
+    expect(content).not.toContain('name: v.optional(v.unknown())')
+    expect(content).not.toContain('description: v.optional(v.unknown())')
+  })
+
   test('skips symbol-keyed properties when resolving imported mutation param types', async () => {
     writeFileSync(
       join(testDir, 'models/types.ts'),

package/src/generate.ts

@@ -17,6 +17,7 @@ import {
 import type { ExtractedMutation, ModelMutations, SchemaColumn } from './generate-helpers'
 
 const hash = (s: string) => createHash('sha256').update(s).digest('hex')
+const GENERATOR_CACHE_VERSION = '1'
 
 const isGeneratorSourceFile = (name: string) =>
   name.endsWith('.ts') &&
@@ -442,6 +443,19 @@ function extractSchemaColumns(
   visit(sourceFile)
 }
 
+function getInstantiatedPropertyType(
+  checker: import('typescript').TypeChecker,
+  parent: import('typescript').Type,
+  name: string,
+) {
+  const resolveProperty: unknown = Reflect.get(checker, 'getTypeOfPropertyOfType')
+  if (typeof resolveProperty !== 'function') return undefined
+  // typescript exposes this runtime method but omits it from TypeChecker.
+  return Reflect.apply(resolveProperty, checker, [parent, name]) as
+    | import('typescript').Type
+    | undefined
+}
+
 // convert a ts.Type to valibot code by walking the type checker AST
 function tsTypeToValibot(
   ts: typeof import('typescript'),
@@ -528,7 +542,14 @@ function tsTypeToValibot(
   }
 
   // resolve symbol property type with fallbacks
-  const resolveSymbolType = (prop: import('typescript').Symbol) => {
+  const resolveSymbolType = (
+    parent: import('typescript').Type,
+    prop: import('typescript').Symbol,
+  ) => {
+    // mapped and conditional types can expose transient symbols with no
+    // declaration, so resolve each property against its concrete parent.
+    const instantiated = getInstantiatedPropertyType(checker, parent, prop.getName())
+    if (instantiated) return instantiated
     if (prop.valueDeclaration)
       return checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration)
     if ((prop as any).declarations?.[0])
@@ -544,7 +565,7 @@ function tsTypeToValibot(
     for (const prop of props) {
       const name = prop.getName()
       if (shouldSkipObjectKey(name)) continue
-      const propType = resolveSymbolType(prop)
+      const propType = resolveSymbolType(type, prop)
       const isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional)
       let val = recurse(propType)
       if (isOptional && !val.startsWith('v.optional(')) {
@@ -589,7 +610,7 @@ function tsTypeToValibot(
     for (const prop of props) {
       const name = prop.getName()
       if (shouldSkipObjectKey(name)) continue
-      const propType = resolveSymbolType(prop)
+      const propType = resolveSymbolType(type, prop)
       const isOptional = !!(prop.getFlags() & ts.SymbolFlags.Optional)
       let val = recurse(propType)
       if (isOptional && !val.startsWith('v.optional(')) {
@@ -773,6 +794,8 @@ export interface GenerateOptions {
   after?: string
   /** suppress output */
   silent?: boolean
+  /** ignore the generation cache */
+  force?: boolean
 }
 
 export interface WatchOptions extends GenerateOptions {
@@ -789,7 +812,7 @@ export interface GenerateResult {
 }
 
 export async function generate(options: GenerateOptions): Promise<GenerateResult> {
-  const { dir, after, silent } = options
+  const { dir, after, silent, force } = options
   const baseDir = resolve(dir)
   // support both mutations/ (new) and models/ (legacy) directories
   const mutationsDir = resolve(baseDir, 'mutations')
@@ -812,6 +835,8 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
   // still re-runs generate on real model/query edits.
   const inputHash = hashInputTree(baseDir, generatedDir)
   if (
+    !force &&
+    generateCache.__generatorVersion === GENERATOR_CACHE_VERSION &&
     generateCache.__inputHash === inputHash &&
     existsSync(resolve(generatedDir, 'models.ts'))
   ) {
@@ -1134,6 +1159,7 @@ export async function generate(options: GenerateOptions): Promise<GenerateResult
   }
 
   // record the input hash + counts so the next boot can skip a no-op regen.
+  generateCache.__generatorVersion = GENERATOR_CACHE_VERSION
   generateCache.__inputHash = inputHash
   generateCache.__counts = JSON.stringify({
     modelCount: allModelFiles.length,

package/src/helpers/createMutators.ts

@@ -25,7 +25,7 @@ export function createMutators<Models extends GenericModels>({
   environment,
   authData,
   createServerActions,
-  asyncTasks = [],
+  enqueueTask = () => {},
   can,
   models,
   validateMutation,
@@ -35,7 +35,7 @@ export function createMutators<Models extends GenericModels>({
   authData: AuthData | null
   can: Can
   models: Models
-  asyncTasks?: Array<() => Promise<void>>
+  enqueueTask?: NonNullable<MutatorContext['server']>['enqueueTask']
   createServerActions?: () => Record<string, any>
   validateMutation?: ValidateMutationFn
   /** valibot schemas keyed by model.mutationName, auto-validates args before running */
@@ -61,7 +61,7 @@ export function createMutators<Models extends GenericModels>({
           environment === 'server'
             ? ({
                 actions: serverActions || {},
-                asyncTasks: asyncTasks || {},
+                enqueueTask,
               } as MutatorContext['server'])
             : undefined,
       }

package/src/helpers/mutatorContext.ts

@@ -13,7 +13,7 @@ const asyncContext =
   contextStore.__onZeroMutatorContext__ ??
   (contextStore.__onZeroMutatorContext__ = createAsyncContext<MutatorContext>())
 
-// lightweight auth-only scope for asyncTasks (where mutation context is gone but authData is needed)
+// lightweight auth-only scope for async tasks (where mutation context is gone but authData is needed)
 const authScopeContext =
   contextStore.__onZeroAuthScopeContext__ ??
   (contextStore.__onZeroAuthScopeContext__ = createAsyncContext<AuthData | null>())

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from './createPermissions'
+export * from './asyncTasks'
 export * from './queryRegistry'
 export * from './helpers/batchQuery'
 export * from './helpers/createMutators'

package/src/server.ts

@@ -1,2 +1,4 @@
 export * from './createZeroServer'
 export * from './createZeroSQLiteServer'
+export * from './asyncTasks'
+export type { AsyncTask, AsyncTaskEntry, AsyncTaskOptions } from './types'