orez-sync-cf-host 0.5.19 → 0.5.21

package/src/index.ts

@@ -1,47 +0,0 @@
-export { createSyncDurableObject, createSyncWorker } from './host.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,
-  JsonValue,
-  MutatorContext,
-  MutatorRegistry,
-  MutatorSql,
-  NormalizedClaims,
-  PullCaps,
-  QueryResolver,
-  RegisteredMutator,
-  SyncHostConfig,
-  SyncHostEnv,
-  ServiceBinding,
-  SyncSql,
-  UpstreamConfig,
-  VisibilityConfig,
-  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

@@ -1,535 +0,0 @@
-import { WorkerEntrypoint } from 'cloudflare:workers'
-
-import { ZeroDO } from '../../../src/cf-do/worker.js'
-import { createSyncDurableObject, createSyncWorker } from './index.js'
-
-import type { SyncHostConfig, SyncHostEnv, ZeroSchemaConfig } from './index.js'
-
-const schema = {
-  tables: {
-    item: {
-      columns: {
-        id: { type: 'string' },
-        label: { type: 'string' },
-        rank: { type: 'number' },
-        done: { type: 'boolean' },
-        meta: { type: 'json' },
-      },
-      primaryKey: ['id'],
-    },
-  },
-} as const satisfies ZeroSchemaConfig
-
-type Fetcher = { fetch(input: string | Request, init?: RequestInit): Promise<Response> }
-interface Env extends SyncHostEnv {
-  DATA: Fetcher
-  APP: Fetcher
-  CAPPED_SYNC_DO: DurableObjectNamespace
-  UPSTREAM_DO: DurableObjectNamespace
-}
-
-const runawayNamespaces = new Set<string>()
-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?schema=feed_0&appID=feed',
-  mutateOrigin: 'https://app.internal',
-  mutateBinding: 'APP',
-  delegatedPushRetry: {
-    maxAttempts: 3,
-    initialBackoffMs: 10,
-    maxBackoffMs: 20,
-    timeoutMs: 1_000,
-  },
-  upstream: {
-    binding: 'DATA',
-    namespacePath: (namespace) =>
-      namespace.startsWith('root-mount-') ? '/' : `/${namespace}`,
-    changeLimit: 2,
-    intervalMs: 1_000,
-    ingestBudgetRows: 600,
-  },
-  initialize(sql) {
-    sql.exec(
-      'CREATE TABLE IF NOT EXISTS item (id TEXT PRIMARY KEY, label TEXT NOT NULL, rank REAL NOT NULL, done INTEGER NOT NULL, meta TEXT)'
-    )
-  },
-  authenticate(request) {
-    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> {
-  const url = new URL(request.url)
-  const [, namespace, ...rest] = url.pathname.split('/')
-  if (!namespace) return new Response('namespace required', { status: 400 })
-  const stub = env.UPSTREAM_DO.get(env.UPSTREAM_DO.idFromName(namespace))
-  url.pathname = `/${rest.join('/')}`
-  if (url.pathname === '/_orez/write-budget') return stub.fetch(new Request(url, request))
-  const exec = async (sql: string, params: unknown[] = []) => {
-    const response = await stub.fetch('https://upstream.invalid/exec', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ sql, params }),
-    })
-    if (!response.ok) throw new Error(`upstream init failed: ${await response.text()}`)
-  }
-  await exec(
-    'CREATE TABLE IF NOT EXISTS item (id TEXT PRIMARY KEY, label TEXT NOT NULL, rank REAL NOT NULL, done INTEGER NOT NULL, meta TEXT)'
-  )
-  await exec(
-    'CREATE TABLE IF NOT EXISTS _zero_schema_tables (name TEXT PRIMARY KEY, schema_json TEXT NOT NULL)'
-  )
-  await exec(
-    'INSERT OR IGNORE INTO _zero_schema_tables (name, schema_json) VALUES (?, ?)',
-    ['item', JSON.stringify(schema.tables.item)]
-  )
-  return stub.fetch(new Request(url, request))
-}
-
-/** Self service-binding target backed by the real ZeroSqlDO. */
-export class DataService extends WorkerEntrypoint<Env> {
-  async fetch(request: Request): Promise<Response> {
-    const url = new URL(request.url)
-    const pathname = url.pathname
-    if (
-      !pathname.endsWith('/changes') &&
-      !pathname.endsWith('/snapshot') &&
-      !pathname.endsWith('/_orez/write-budget')
-    ) {
-      return Promise.resolve(
-        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)
-      const values = [
-        { nested: { tags: ['a', 2, true] } },
-        [1, 'two', null],
-        '42',
-        'true',
-        'null',
-        '{"looks":"encoded"}',
-        42.5,
-        true,
-      ]
-      return Promise.resolve(
-        Response.json({
-          watermark: values.length,
-          changes: values
-            .map((meta, index) => ({
-              watermark: index + 1,
-              tableName: 'item',
-              op: 'INSERT',
-              rowData: {
-                id: `json-${index}`,
-                label: 'json round trip',
-                rank: index,
-                done: false,
-                meta,
-              },
-              oldData: null,
-            }))
-            .filter((change) => change.watermark > cursor)
-            .slice(0, 2),
-        })
-      )
-    }
-    if (pathname.endsWith('/changes') && numericTextNamespaces.has(namespace)) {
-      const watermark = Number(new URL(request.url).searchParams.get('watermark') ?? 0)
-      return Promise.resolve(
-        Response.json({
-          watermark: 2,
-          changes:
-            watermark >= 2
-              ? []
-              : [
-                  {
-                    watermark: 1,
-                    tableName: 'item',
-                    op: 'INSERT',
-                    rowData: {
-                      id: 'numeric-text',
-                      label: 'SQL timestamp text',
-                      rank: '2026-07-11 13:34:46',
-                      done: false,
-                      meta: null,
-                    },
-                    oldData: null,
-                  },
-                  {
-                    watermark: 2,
-                    tableName: 'item',
-                    op: 'INSERT',
-                    rowData: {
-                      id: 'numeric-native',
-                      label: 'native JSON number',
-                      rank: 1783776886000,
-                      done: false,
-                      meta: null,
-                    },
-                    oldData: null,
-                  },
-                ],
-        })
-      )
-    }
-    if (pathname.endsWith('/changes') && runawayNamespaces.has(namespace)) {
-      return Promise.resolve(
-        Response.json({
-          watermark: 100,
-          changes: [
-            {
-              watermark: 1,
-              tableName: 'item',
-              op: 'INSERT',
-              rowData: {
-                id: 'runaway-replay',
-                label: 'replayed without cursor progress',
-                rank: 1,
-                done: false,
-                meta: null,
-              },
-              oldData: null,
-            },
-          ],
-        })
-      )
-    }
-    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')) {
-      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) &&
-            (!holdSnapshotsAfterCursor.has(namespace) || url.searchParams.has('cursor'))
-          ) {
-            await scheduler.wait(10)
-          }
-        } finally {
-          activeSnapshots.delete(namespace)
-        }
-      }
-    }
-    if (pathname.endsWith('/changes') && response.ok) hydratedNamespaces.add(namespace)
-    return response
-  }
-}
-
-export class AppService extends WorkerEntrypoint<Env> {
-  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 })
-      )
-    }
-    const namespace = new URL(request.url).pathname.split('/')[1] ?? ''
-    if (!hydratedNamespaces.has(namespace)) {
-      return Promise.resolve(
-        Response.json({ error: 'schema provisioning has not completed' }, { status: 500 })
-      )
-    }
-    delegatedAttempts++
-    if (delegatedPushFailedRemaining > 0) {
-      delegatedPushFailedRemaining--
-      return Promise.resolve(
-        Response.json({
-          kind: 'PushFailed',
-          origin: 'server',
-          reason: 'database',
-          mutationIDs: [{ clientID: 'writer', id: 2 }],
-          message: 'synthetic mutation result persistence failure',
-        })
-      )
-    }
-    if (delegatedFailuresRemaining > 0) {
-      delegatedFailuresRemaining--
-      return Promise.resolve(
-        Response.json({ error: 'synthetic delegated push failure' }, { status: 503 })
-      )
-    }
-    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') {
-        return Promise.resolve(
-          Response.json({
-            active: activeSnapshots.has(namespace),
-            held: heldSnapshots.has(namespace),
-            afterCursor: holdSnapshotsAfterCursor.has(namespace),
-            limits: snapshotLimits.get(namespace) ?? [],
-          })
-        )
-      }
-      return request
-        .json()
-        .catch(() => ({}))
-        .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) ?? [],
-          })
-        })
-    }
-    if (url.pathname.startsWith('/json-values-control/')) {
-      const namespace = url.pathname.slice('/json-values-control/'.length)
-      return request
-        .json()
-        .catch(() => ({}))
-        .then((body) => {
-          if ((body as { enabled?: unknown }).enabled === true)
-            jsonValueNamespaces.add(namespace)
-          else jsonValueNamespaces.delete(namespace)
-          return Response.json({ ok: true, namespace })
-        })
-    }
-    if (url.pathname.startsWith('/numeric-text-control/')) {
-      const namespace = url.pathname.slice('/numeric-text-control/'.length)
-      return request
-        .json()
-        .catch(() => ({}))
-        .then((body) => {
-          if ((body as { enabled?: unknown }).enabled === true)
-            numericTextNamespaces.add(namespace)
-          else numericTextNamespaces.delete(namespace)
-          return Response.json({ ok: true, namespace })
-        })
-    }
-    if (url.pathname.startsWith('/runaway-control/')) {
-      const namespace = url.pathname.slice('/runaway-control/'.length)
-      return request
-        .json()
-        .catch(() => ({}))
-        .then((body) => {
-          if ((body as { enabled?: unknown }).enabled === true)
-            runawayNamespaces.add(namespace)
-          else runawayNamespaces.delete(namespace)
-          return Response.json({
-            ok: true,
-            namespace,
-            enabled: runawayNamespaces.has(namespace),
-          })
-        })
-    }
-    if (url.pathname === '/delegation-control') {
-      if (request.method === 'GET') {
-        return Promise.resolve(
-          Response.json({
-            delegatedFailuresRemaining,
-            delegatedPushFailedRemaining,
-            delegatedAttempts,
-            delegatedUrl,
-          })
-        )
-      }
-      return request
-        .json()
-        .catch(() => ({}))
-        .then((body) => {
-          delegatedFailuresRemaining = Math.max(
-            0,
-            Number((body as { failures?: unknown }).failures) || 0
-          )
-          delegatedPushFailedRemaining = Math.max(
-            0,
-            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)
-    }
-    return syncWorker.fetch!(request as never, env, ctx) as Promise<Response>
-  },
-}

package/src/mutation-error.ts

@@ -1,28 +0,0 @@
-// 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'
-  )
-}