orez-sync-cf-host 0.4.63 → 0.4.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orez-sync-cf-host",
-  "version": "0.4.63",
+  "version": "0.4.65",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

package/src/host.ts

@@ -73,6 +73,13 @@ type MutationResult = {
   result: Record<string, unknown>
 }
 
+type DelegatedMutationResult = { id?: { clientID?: unknown; id?: unknown } }
+type DelegatedPushBody = {
+  mutations?: DelegatedMutationResult[]
+  pushResponse?: unknown
+  [key: string]: unknown
+}
+
 type EngineState = { watermark: string; floor: string; upstreamWatermark: string }
 type UpstreamBatch = {
   watermark: number
@@ -135,6 +142,18 @@ function json(value: unknown, status = 200): Response {
   })
 }
 
+function isStructuredPushFailed(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== 'object' || value === null) return false
+  const body = value as Record<string, unknown>
+  return (
+    body.kind === 'PushFailed' &&
+    typeof body.origin === 'string' &&
+    typeof body.reason === 'string' &&
+    typeof body.message === 'string' &&
+    Array.isArray(body.mutationIDs)
+  )
+}
+
 function statusOf(error: unknown): number {
   if (typeof error === 'object' && error !== null && 'status' in error) {
     const status = Number(error.status)
@@ -690,7 +709,8 @@ export function createSyncDurableObject<Env extends SyncHostEnv>(
     async #fetchDelegatedPush(
       endpoint: URL,
       headers: Headers,
-      body: ArrayBuffer
+      body: ArrayBuffer,
+      provisioning = false
     ): Promise<Response> {
       const binding = this.#serviceBinding(
         config.mutateBinding ?? config.upstream?.binding
@@ -703,7 +723,9 @@ export function createSyncDurableObject<Env extends SyncHostEnv>(
             method: 'POST',
             headers,
             body,
-            signal: AbortSignal.timeout(delegateTimeoutMs),
+            signal: AbortSignal.timeout(
+              provisioning ? Math.max(delegateTimeoutMs, 25_000) : delegateTimeoutMs
+            ),
           })
         } catch (error) {
           lastError = error
@@ -1048,19 +1070,27 @@ export function createSyncDurableObject<Env extends SyncHostEnv>(
           const upstreamResponse = await this.#fetchDelegatedPush(
             endpoint,
             headers,
-            bytes
+            bytes,
+            this.#engineState()?.upstreamWatermark === '0'
           )
           if (!upstreamResponse.ok) {
             return new Response(upstreamResponse.body, upstreamResponse)
           }
-          const upstreamBody = (await upstreamResponse.json()) as {
-            mutations?: Array<{ id?: { clientID?: unknown; id?: unknown } }>
-            pushResponse?: {
-              mutations?: Array<{ id?: { clientID?: unknown; id?: unknown } }>
-            }
+          const upstreamBody = (await upstreamResponse.json()) as DelegatedPushBody
+          const delegatedResponse = upstreamBody.pushResponse ?? upstreamBody
+          if (isStructuredPushFailed(delegatedResponse)) {
+            // PushFailed is a successful protocol response describing an
+            // application-level failure. There are intentionally no mutation
+            // acknowledgements to finalize in the host; preserve the body so
+            // the Zero client can apply its retry/error policy.
+            return json({ pushResponse: delegatedResponse })
           }
           const acknowledged =
-            upstreamBody.pushResponse?.mutations ?? upstreamBody.mutations
+            typeof upstreamBody.pushResponse === 'object' &&
+            upstreamBody.pushResponse !== null &&
+            'mutations' in upstreamBody.pushResponse
+              ? upstreamBody.pushResponse.mutations
+              : upstreamBody.mutations
           if (!Array.isArray(acknowledged)) {
             throw new Error('delegated push returned no mutation results')
           }
@@ -1100,7 +1130,7 @@ export function createSyncDurableObject<Env extends SyncHostEnv>(
             )
           }
           await this.#ingest(upstreamPath)
-          return json({ pushResponse: upstreamBody.pushResponse ?? upstreamBody })
+          return json({ pushResponse: delegatedResponse })
         } catch (error) {
           const status = statusOf(error)
           return json(errorBody(error), status)
@@ -1477,6 +1507,17 @@ export function createSyncDurableObject<Env extends SyncHostEnv>(
         return this.#pull(request, claims, namespace)
       }
       if (route === '/push' && request.method === 'POST') {
+        // A push may be the first request for a fresh namespace. DATA's
+        // /changes call is also its schema-provisioning barrier, so complete it
+        // before delegating the mutation to APP. Pull already enforces this
+        // ordering above; skipping it here let APP race half-created tables and
+        // surface a terminal, bodyless 500 to Zero.
+        try {
+          await this.#ingest(upstreamPath)
+        } catch (error) {
+          await request.arrayBuffer()
+          return json(errorBody(error), statusOf(error))
+        }
         return this.#push(request, claims, namespace, upstreamPath)
       }
       return json({ error: 'not found' }, 404)

package/src/ingest-harness-worker.ts

@@ -29,8 +29,10 @@ interface Env extends SyncHostEnv {
 
 const runawayNamespaces = new Set<string>()
 const numericTextNamespaces = new Set<string>()
+const hydratedNamespaces = new Set<string>()
 let delegatedFailuresRemaining = 0
 let delegatedAttempts = 0
+let delegatedPushFailedRemaining = 0
 
 const config: SyncHostConfig<Env> = {
   hostVersion: 'upstream-ingest-harness',
@@ -96,7 +98,7 @@ async function upstreamFetch(request: Request, env: Env): Promise<Response> {
 
 /** Self service-binding target backed by the real ZeroSqlDO. */
 export class DataService extends WorkerEntrypoint<Env> {
-  fetch(request: Request): Promise<Response> {
+  async fetch(request: Request): Promise<Response> {
     const url = new URL(request.url)
     const pathname = url.pathname
     if (
@@ -170,7 +172,9 @@ export class DataService extends WorkerEntrypoint<Env> {
         })
       )
     }
-    return upstreamFetch(request, this.env)
+    const response = await upstreamFetch(request, this.env)
+    if (pathname.endsWith('/changes') && response.ok) hydratedNamespaces.add(namespace)
+    return response
   }
 }
 
@@ -181,7 +185,25 @@ export class AppService extends WorkerEntrypoint<Env> {
         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(
@@ -227,7 +249,11 @@ export default {
     if (url.pathname === '/delegation-control') {
       if (request.method === 'GET') {
         return Promise.resolve(
-          Response.json({ delegatedFailuresRemaining, delegatedAttempts })
+          Response.json({
+            delegatedFailuresRemaining,
+            delegatedPushFailedRemaining,
+            delegatedAttempts,
+          })
         )
       }
       return request
@@ -238,8 +264,16 @@ export default {
             0,
             Number((body as { failures?: unknown }).failures) || 0
           )
+          delegatedPushFailedRemaining = Math.max(
+            0,
+            Number((body as { pushFailed?: unknown }).pushFailed) || 0
+          )
           delegatedAttempts = 0
-          return Response.json({ delegatedFailuresRemaining, delegatedAttempts })
+          return Response.json({
+            delegatedFailuresRemaining,
+            delegatedPushFailedRemaining,
+            delegatedAttempts,
+          })
         })
     }
     if (url.pathname.startsWith('/upstream/')) {