orez-sync-cf-host 0.5.17 → 0.5.19

package/src/index.ts

@@ -1,5 +1,17 @@
 export { createSyncDurableObject, createSyncWorker } from './host.js'
-export { MutationApplicationError, registerMutators } from './types.js'
+export { createQueryCompiler } from './query-compiler.js'
+export {
+  MutationApplicationError,
+  isMutationApplicationError,
+  registerMutators,
+} from './types.js'
+export {
+  DEFAULT_TRANSACTION_QUERY_BUDGET,
+  TransactionQueryBudgetError,
+  executeTransactionQueryPlan,
+  executeTransactionQueryPlanAsync,
+} from './transaction-query.js'
+
 export type {
   DeferredEffect,
   JsonPrimitive,
@@ -20,3 +32,16 @@ export type {
   VisibilityFilter,
   ZeroSchemaConfig,
 } from './types.js'
+export type {
+  CompiledTransactionQueryNode,
+  CompiledTransactionQueryPlan,
+  CompiledTransactionQueryRelationship,
+  TransactionQueryBinding,
+  TransactionQueryBudget,
+  TransactionQueryColumn,
+  TransactionQueryColumnType,
+  TransactionQueryExecutionOptions,
+  TransactionQueryFormat,
+  TransactionQueryWireValue,
+} from './transaction-query.js'
+export type { TransactionQueryCompiler } from './query-compiler.js'

package/src/ingest-harness-worker.ts

@@ -24,6 +24,7 @@ type Fetcher = { fetch(input: string | Request, init?: RequestInit): Promise<Res
 interface Env extends SyncHostEnv {
   DATA: Fetcher
   APP: Fetcher
+  CAPPED_SYNC_DO: DurableObjectNamespace
   UPSTREAM_DO: DurableObjectNamespace
 }
 
@@ -32,15 +33,24 @@ const numericTextNamespaces = new Set<string>()
 const jsonValueNamespaces = new Set<string>()
 const hydratedNamespaces = new Set<string>()
 const heldSnapshots = new Set<string>()
+const holdSnapshotsAfterCursor = new Set<string>()
 const activeSnapshots = new Set<string>()
+const snapshotLimits = new Map<string, number[]>()
+const heldDelegatedPushes = new Set<string>()
+const activeDelegatedPushes = new Set<string>()
+const completedDelegatedPushes = new Set<string>()
+const heldChangeResponses = new Set<string>()
+const activeHeldChangeResponses = new Set<string>()
 let delegatedFailuresRemaining = 0
 let delegatedAttempts = 0
 let delegatedPushFailedRemaining = 0
+let delegatedUrl = ''
 
 const config: SyncHostConfig<Env> = {
   hostVersion: 'upstream-ingest-harness',
   schema,
-  mutateUrl: '/api/zero/push',
+  mutateUrl: '/api/zero/push?schema=feed_0&appID=feed',
+  mutateOrigin: 'https://app.internal',
   mutateBinding: 'APP',
   delegatedPushRetry: {
     maxAttempts: 3,
@@ -50,9 +60,11 @@ const config: SyncHostConfig<Env> = {
   },
   upstream: {
     binding: 'DATA',
-    namespacePath: (namespace) => `/${namespace}`,
+    namespacePath: (namespace) =>
+      namespace.startsWith('root-mount-') ? '/' : `/${namespace}`,
     changeLimit: 2,
     intervalMs: 1_000,
+    ingestBudgetRows: 600,
   },
   initialize(sql) {
     sql.exec(
@@ -63,12 +75,23 @@ const config: SyncHostConfig<Env> = {
     const userID = request.headers.get('authorization')?.match(/^Bearer token-(.+)$/)?.[1]
     return userID ? { userID } : null
   },
+  authorizeWake(request) {
+    return new URL(request.url).searchParams.get('wakeToken') === 'ingest-harness-wake'
+  },
+  authorizeNotify(request, env) {
+    return Boolean(env.ADMIN_KEY) && request.headers.get('x-admin-key') === env.ADMIN_KEY
+  },
   namespace(request) {
     return new URL(request.url).pathname.split('/')[1] || null
   },
 }
 
 export const SyncDurableObject = createSyncDurableObject(config)
+const cappedConfig: SyncHostConfig<Env> = {
+  ...config,
+  caps: { maxChangeRows: 10_000, maxChangeBytes: 1 },
+}
+export const CappedSyncDurableObject = createSyncDurableObject(cappedConfig)
 export { ZeroDO }
 
 async function upstreamFetch(request: Request, env: Env): Promise<Response> {
@@ -113,6 +136,35 @@ export class DataService extends WorkerEntrypoint<Env> {
         new Response('DATA route rejected non-feed request', { status: 418 })
       )
     }
+    if (pathname === '/changes') {
+      const cursor = Number(url.searchParams.get('watermark') ?? 0)
+      return Promise.resolve(
+        Response.json({
+          watermark: 1,
+          changes:
+            cursor >= 1
+              ? []
+              : [
+                  {
+                    watermark: 1,
+                    tableName: 'item',
+                    op: 'INSERT',
+                    rowData: {
+                      id: 'root-feed-row',
+                      label: 'root-mounted upstream feed',
+                      rank: 1,
+                      done: false,
+                      meta: null,
+                    },
+                    oldData: null,
+                  },
+                ],
+        })
+      )
+    }
+    if (pathname === '/_orez/write-budget') {
+      return Promise.resolve(Response.json({ enabled: true, rootMount: true }))
+    }
     const namespace = pathname.split('/')[1] ?? ''
     if (pathname.endsWith('/changes') && jsonValueNamespaces.has(namespace)) {
       const cursor = Number(new URL(request.url).searchParams.get('watermark') ?? 0)
@@ -210,11 +262,33 @@ export class DataService extends WorkerEntrypoint<Env> {
       )
     }
     const response = await upstreamFetch(request, this.env)
+    if (pathname.endsWith('/changes') && heldChangeResponses.has(namespace)) {
+      activeHeldChangeResponses.add(namespace)
+      try {
+        while (heldChangeResponses.has(namespace)) await scheduler.wait(10)
+      } finally {
+        activeHeldChangeResponses.delete(namespace)
+      }
+    }
     if (pathname.endsWith('/snapshot')) {
-      if (heldSnapshots.has(namespace)) {
+      const limit = Number(url.searchParams.get('limit'))
+      if (Number.isSafeInteger(limit)) {
+        const limits = snapshotLimits.get(namespace) ?? []
+        limits.push(limit)
+        snapshotLimits.set(namespace, limits)
+      }
+      const shouldHold =
+        heldSnapshots.has(namespace) &&
+        (!holdSnapshotsAfterCursor.has(namespace) || url.searchParams.has('cursor'))
+      if (shouldHold) {
         activeSnapshots.add(namespace)
         try {
-          while (heldSnapshots.has(namespace)) await scheduler.wait(10)
+          while (
+            heldSnapshots.has(namespace) &&
+            (!holdSnapshotsAfterCursor.has(namespace) || url.searchParams.has('cursor'))
+          ) {
+            await scheduler.wait(10)
+          }
         } finally {
           activeSnapshots.delete(namespace)
         }
@@ -226,7 +300,8 @@ export class DataService extends WorkerEntrypoint<Env> {
 }
 
 export class AppService extends WorkerEntrypoint<Env> {
-  fetch(request: Request): Promise<Response> {
+  async fetch(request: Request): Promise<Response> {
+    delegatedUrl = request.url
     if (!new URL(request.url).pathname.endsWith('/api/zero/push')) {
       return Promise.resolve(
         new Response('APP route rejected non-push request', { status: 418 })
@@ -257,14 +332,81 @@ export class AppService extends WorkerEntrypoint<Env> {
         Response.json({ error: 'synthetic delegated push failure' }, { status: 503 })
       )
     }
-    return upstreamFetch(request, this.env)
+    if (heldDelegatedPushes.has(namespace)) {
+      activeDelegatedPushes.add(namespace)
+      try {
+        while (heldDelegatedPushes.has(namespace)) await scheduler.wait(10)
+      } finally {
+        activeDelegatedPushes.delete(namespace)
+      }
+    }
+    const push = (await request.clone().json()) as {
+      mutations?: Array<{ clientID?: string; id?: number; name?: string }>
+    }
+    const cleanupIDs = new Set(
+      (push.mutations ?? [])
+        .filter((mutation) => mutation.name === '_zero_cleanupResults')
+        .map((mutation) => `${mutation.clientID}:${mutation.id}`)
+    )
+    const response = await upstreamFetch(request, this.env)
+    completedDelegatedPushes.add(namespace)
+    if (response.ok && cleanupIDs.size > 0) {
+      const body = (await response.json()) as {
+        mutations?: Array<{ id?: { clientID?: string; id?: number } }>
+        pushResponse?: {
+          mutations?: Array<{ id?: { clientID?: string; id?: number } }>
+        }
+      }
+      const mutations = body.pushResponse?.mutations ?? body.mutations
+      if (Array.isArray(mutations)) {
+        const filtered = mutations.filter(
+          (mutation) => !cleanupIDs.has(`${mutation.id?.clientID}:${mutation.id?.id}`)
+        )
+        if (body.pushResponse) body.pushResponse.mutations = filtered
+        else body.mutations = filtered
+      }
+      return Response.json(body, { status: response.status })
+    }
+    return response
   }
 }
 
 const syncWorker = createSyncWorker(config)
+const cappedSyncWorker = createSyncWorker(cappedConfig)
 export default {
   fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
     const url = new URL(request.url)
+    if (url.pathname.startsWith('/delegated-ingest-control/')) {
+      const namespace = url.pathname.slice('/delegated-ingest-control/'.length)
+      if (request.method === 'GET') {
+        return Promise.resolve(
+          Response.json({
+            appHeld: heldDelegatedPushes.has(namespace),
+            appActive: activeDelegatedPushes.has(namespace),
+            appCompleted: completedDelegatedPushes.has(namespace),
+            changesHeld: heldChangeResponses.has(namespace),
+            changesActive: activeHeldChangeResponses.has(namespace),
+          })
+        )
+      }
+      return request
+        .json()
+        .catch(() => ({}))
+        .then((body) => {
+          if ((body as { appHeld?: unknown }).appHeld === true) {
+            heldDelegatedPushes.add(namespace)
+            completedDelegatedPushes.delete(namespace)
+          } else if ((body as { appHeld?: unknown }).appHeld === false) {
+            heldDelegatedPushes.delete(namespace)
+          }
+          if ((body as { changesHeld?: unknown }).changesHeld === true) {
+            heldChangeResponses.add(namespace)
+          } else if ((body as { changesHeld?: unknown }).changesHeld === false) {
+            heldChangeResponses.delete(namespace)
+          }
+          return Response.json({ ok: true, namespace })
+        })
+    }
     if (url.pathname.startsWith('/snapshot-control/')) {
       const namespace = url.pathname.slice('/snapshot-control/'.length)
       if (request.method === 'GET') {
@@ -272,6 +414,8 @@ export default {
           Response.json({
             active: activeSnapshots.has(namespace),
             held: heldSnapshots.has(namespace),
+            afterCursor: holdSnapshotsAfterCursor.has(namespace),
+            limits: snapshotLimits.get(namespace) ?? [],
           })
         )
       }
@@ -281,12 +425,22 @@ export default {
         .then((body) => {
           if ((body as { hold?: unknown }).hold === true) {
             heldSnapshots.add(namespace)
+            if ((body as { afterCursor?: unknown }).afterCursor === true) {
+              holdSnapshotsAfterCursor.add(namespace)
+            } else {
+              holdSnapshotsAfterCursor.delete(namespace)
+            }
           } else {
             heldSnapshots.delete(namespace)
+            holdSnapshotsAfterCursor.delete(namespace)
           }
+          if ((body as { reset?: unknown }).reset === true)
+            snapshotLimits.set(namespace, [])
           return Response.json({
             active: activeSnapshots.has(namespace),
             held: heldSnapshots.has(namespace),
+            afterCursor: holdSnapshotsAfterCursor.has(namespace),
+            limits: snapshotLimits.get(namespace) ?? [],
           })
         })
     }
@@ -337,6 +491,7 @@ export default {
             delegatedFailuresRemaining,
             delegatedPushFailedRemaining,
             delegatedAttempts,
+            delegatedUrl,
           })
         )
       }
@@ -353,13 +508,24 @@ export default {
             Number((body as { pushFailed?: unknown }).pushFailed) || 0
           )
           delegatedAttempts = 0
+          delegatedUrl = ''
           return Response.json({
             delegatedFailuresRemaining,
             delegatedPushFailedRemaining,
             delegatedAttempts,
+            delegatedUrl,
           })
         })
     }
+    if (url.pathname.startsWith('/capped/')) {
+      url.pathname = url.pathname.slice('/capped'.length)
+      const cappedEnv = { ...env, SYNC_DO: env.CAPPED_SYNC_DO }
+      return cappedSyncWorker.fetch!(
+        new Request(url, request) as never,
+        cappedEnv,
+        ctx
+      ) as Promise<Response>
+    }
     if (url.pathname.startsWith('/upstream/')) {
       url.pathname = url.pathname.slice('/upstream'.length)
       return upstreamFetch(new Request(url, request), env)

package/src/mutation-error.ts

@@ -0,0 +1,28 @@
+// the app-rejection contract shared by every orez sync host and by
+// protocol-neutral authoring layers (on-zero adapters). classification is
+// STRUCTURAL, never instanceof: adapters must not depend on orez to reject a
+// mutation, and instanceof breaks across package copies (dual-package
+// installs, --into tarballs, workspace duplication). any error whose name is
+// 'MutationApplicationError' with string details/message is claiming this
+// contract deliberately.
+export class MutationApplicationError extends Error {
+  constructor(
+    readonly details: string,
+    message = details
+  ) {
+    super(message)
+    this.name = 'MutationApplicationError'
+  }
+}
+
+export function isMutationApplicationError(
+  error: unknown
+): error is { name: string; message: string; details: string } {
+  if (typeof error !== 'object' || error === null) return false
+  const shaped = error as { name?: unknown; message?: unknown; details?: unknown }
+  return (
+    shaped.name === 'MutationApplicationError' &&
+    typeof shaped.message === 'string' &&
+    typeof shaped.details === 'string'
+  )
+}

package/src/platform-probe-worker.ts

@@ -1,18 +1,21 @@
-import { DurableObject } from 'cloudflare:workers'
-
+import { ZeroDO } from '../../../src/cf-do/worker.js'
+import { createQueryCompiler } from './query-compiler.js'
+import {
+  SqlStorageDirect,
+  SqlStorageMutatorTransaction,
+  SqlStorageSyncDb,
+} from './sql-storage-adapter.js'
 import {
-  initSync,
   init_probe_schema,
   pull_snapshot,
   push_finalize,
   push_preflight,
   rust_panic_after_writes,
   value_round_trip,
-} from './generated/sync_wasm.js'
-import wasmModule from './generated/sync_wasm_bg.wasm'
-import { SqlStorageSyncDb } from './sql-storage-adapter.js'
+} from './wasm-platform.js'
 
-initSync({ module: wasmModule })
+import type { TransactionQueryFormat } from './transaction-query.js'
+import type { ZeroSchemaConfig } from './types.js'
 
 interface Env {
   PROBE_DO: DurableObjectNamespace<ProbeDurableObject>
@@ -21,6 +24,54 @@ interface Env {
 type DeferredEffect = { mutationID: string; kind: string }
 type MutatorName = 'read-then-write' | 'multi-table' | 'application-error'
 
+const transactionQuerySchema = {
+  tables: {
+    account: {
+      name: 'account',
+      serverName: 'accounts',
+      columns: {
+        id: { type: 'string' },
+        balance: { type: 'number' },
+      },
+      primaryKey: ['id'],
+    },
+    entry: {
+      name: 'entry',
+      serverName: 'ledger',
+      columns: {
+        id: { type: 'number' },
+        accountId: { type: 'string', serverName: 'account_id' },
+        amount: { type: 'number' },
+        note: { type: 'string' },
+      },
+      primaryKey: ['id'],
+    },
+  },
+} as const satisfies ZeroSchemaConfig
+
+const transactionQueryAst = {
+  table: 'account',
+  where: {
+    type: 'simple',
+    op: '=',
+    left: { type: 'column', name: 'id' },
+    right: { type: 'literal', value: 'primary' },
+  },
+  related: [
+    {
+      correlation: { parentField: ['id'], childField: ['accountId'] },
+      subquery: { table: 'entry', alias: 'entries', orderBy: [['id', 'asc']] },
+    },
+  ],
+}
+
+const transactionQueryFormat = {
+  singular: true,
+  relationships: { entries: { singular: false, relationships: {} } },
+} as const satisfies TransactionQueryFormat
+
+const compileTransactionQuery = createQueryCompiler(transactionQuerySchema)
+
 // Deterministic local analogue of normal DO idle eviction, matching the
 // harness/cf probe: discard all in-memory state after an idle gap while SQL
 // storage remains intact. This keeps the test sub-second instead of waiting
@@ -33,7 +84,7 @@ const json = (value: unknown, status = 200) =>
     headers: { 'cache-control': 'no-store' },
   })
 
-export class ProbeDurableObject extends DurableObject<Env> {
+export class ProbeDurableObject extends ZeroDO {
   readonly #db: SqlStorageSyncDb
   #bootID = crypto.randomUUID()
   #lastRequestAt = 0
@@ -41,7 +92,7 @@ export class ProbeDurableObject extends DurableObject<Env> {
   #effects: Array<DeferredEffect & { observedCommitted: boolean }> = []
 
   constructor(ctx: DurableObjectState, env: Env) {
-    super(ctx, env)
+    super(ctx, env as never)
     this.#db = new SqlStorageSyncDb(ctx.storage.sql)
     ctx.storage.transactionSync(() => init_probe_schema(this.#db))
   }
@@ -291,6 +342,68 @@ export class ProbeDurableObject extends DurableObject<Env> {
       return json({ errors })
     }
 
+    if (route === '/transaction-query') {
+      let plan: ReturnType<typeof compileTransactionQuery> | undefined
+      const tx = new SqlStorageMutatorTransaction(
+        new SqlStorageDirect(this.ctx.storage.sql),
+        (queryAst, queryFormat) => {
+          plan = compileTransactionQuery(queryAst, queryFormat)
+          return plan
+        }
+      )
+      const result = await tx.queryAst(
+        transactionQueryAst,
+        transactionQueryFormat,
+        'platformTransactionQuery'
+      )
+      let malformedFormatStatus: unknown
+      try {
+        await tx.queryAst(transactionQueryAst, undefined as never)
+      } catch (error) {
+        malformedFormatStatus = (error as { status?: unknown }).status
+      }
+      return json({ result, malformedFormatStatus, plan })
+    }
+
+    if (route === '/application-transaction-query') {
+      const result = await this.runApplicationTransaction(
+        compileTransactionQuery,
+        (tx) =>
+          tx.queryAst(
+            transactionQueryAst,
+            transactionQueryFormat,
+            'applicationTransactionQuery'
+          ),
+        { maxSelects: 8, maxRows: 20 }
+      )
+      return json({ result })
+    }
+
+    if (route === '/application-transaction-query-budget') {
+      try {
+        await this.runApplicationTransaction(
+          compileTransactionQuery,
+          (tx) =>
+            tx.queryAst(
+              transactionQueryAst,
+              transactionQueryFormat,
+              'budgetedApplicationTransactionQuery'
+            ),
+          { maxSelects: 1 }
+        )
+      } catch (error) {
+        return json(
+          {
+            code: Reflect.get(error as object, 'code'),
+            query: Reflect.get(error as object, 'query'),
+            selects: Reflect.get(error as object, 'selects'),
+          },
+          409
+        )
+      }
+      return json({ error: 'query budget did not abort the transaction' }, 500)
+    }
+
     return json({ error: 'not found', route }, 404)
   }
 }

package/src/post-commit.ts

@@ -0,0 +1,40 @@
+export type DeferredEffect = () => void | Promise<void>
+
+export type PostCommitEffects = {
+  /** discard effects from a storage-transaction attempt before starting another */
+  beginAttempt(): void
+  defer(effect: DeferredEffect): void
+  /** run the committed attempt's effects in order without rejecting */
+  runAfterCommit(onError: (error: unknown) => void): Promise<void>
+}
+
+/**
+ * collect external work during a retryable transaction and run only the effects
+ * belonging to the attempt that commits.
+ */
+export function createPostCommitEffects(): PostCommitEffects {
+  const effects: DeferredEffect[] = []
+
+  return {
+    beginAttempt() {
+      effects.length = 0
+    },
+    defer(effect) {
+      effects.push(effect)
+    },
+    async runAfterCommit(onError) {
+      const committed = effects.splice(0)
+      for (const effect of committed) {
+        try {
+          await effect()
+        } catch (error) {
+          try {
+            onError(error)
+          } catch {
+            // reporting must not turn a committed effect failure into a rejection
+          }
+        }
+      }
+    },
+  }
+}

package/src/query-compiler.ts

@@ -0,0 +1,16 @@
+import { engine_compile_query } from './wasm.js'
+
+import type {
+  CompiledTransactionQueryPlan,
+  TransactionQueryFormat,
+} from './transaction-query.js'
+import type { ZeroSchemaConfig } from './types.js'
+
+export type TransactionQueryCompiler = (
+  ast: unknown,
+  format: TransactionQueryFormat
+) => CompiledTransactionQueryPlan
+
+export function createQueryCompiler(schema: ZeroSchemaConfig): TransactionQueryCompiler {
+  return (ast, format) => engine_compile_query(schema, ast, format)
+}