orez-sync-cf-host 0.5.16 → 0.5.18

package/src/ingest-harness-worker.ts

@@ -32,15 +32,19 @@ 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[]>()
 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 +54,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,6 +69,12 @@ 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
   },
@@ -113,6 +125,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)
@@ -211,10 +252,24 @@ export class DataService extends WorkerEntrypoint<Env> {
     }
     const response = await upstreamFetch(request, this.env)
     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)
         }
@@ -227,6 +282,7 @@ export class DataService extends WorkerEntrypoint<Env> {
 
 export class AppService extends WorkerEntrypoint<Env> {
   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 })
@@ -272,6 +328,8 @@ export default {
           Response.json({
             active: activeSnapshots.has(namespace),
             held: heldSnapshots.has(namespace),
+            afterCursor: holdSnapshotsAfterCursor.has(namespace),
+            limits: snapshotLimits.get(namespace) ?? [],
           })
         )
       }
@@ -281,12 +339,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 +405,7 @@ export default {
             delegatedFailuresRemaining,
             delegatedPushFailedRemaining,
             delegatedAttempts,
+            delegatedUrl,
           })
         )
       }
@@ -353,10 +422,12 @@ export default {
             Number((body as { pushFailed?: unknown }).pushFailed) || 0
           )
           delegatedAttempts = 0
+          delegatedUrl = ''
           return Response.json({
             delegatedFailuresRemaining,
             delegatedPushFailedRemaining,
             delegatedAttempts,
+            delegatedUrl,
           })
         })
     }

package/src/types.ts

@@ -141,8 +141,10 @@ export type SyncHostConfig<Env extends SyncHostEnv = SyncHostEnv> = {
   hostVersion: string
   schema: ZeroSchemaConfig
   mutators?: MutatorRegistry
-  /** Relative app push endpoint on the upstream service binding. */
+  /** Absolute app push path on the upstream service binding. */
   mutateUrl?: string
+  /** Absolute origin used for delegated push requests through the service binding. */
+  mutateOrigin?: string
   /** Env binding for delegated pushes; defaults to upstream.binding. */
   mutateBinding?: string
   delegatedPushRetry?: DelegatedPushRetryConfig
@@ -154,6 +156,12 @@ export type SyncHostConfig<Env extends SyncHostEnv = SyncHostEnv> = {
     request: Request,
     env: Env
   ): NormalizedClaims | null | Promise<NormalizedClaims | null>
+  /** Authorize the advisory wake socket before selecting a namespace DO.
+   * Browser clients should present a short-lived, namespace-scoped capability
+   * in the query string because WebSocket cannot set request headers. */
+  authorizeWake(request: Request, env: Env): boolean | Promise<boolean>
+  /** Authorize upstream service notifications before selecting a namespace DO. */
+  authorizeNotify(request: Request, env: Env): boolean | Promise<boolean>
   /** Resolve the first path component or another consumer-defined namespace. */
   namespace(request: Request): string | null
   visibility?: VisibilityConfig

package/src/write-safeguards.ts

@@ -187,22 +187,21 @@ export function trackBillableCursorRows<Cursor extends BillableCursor>(
     accountedRows = current
     record(delta)
   }
-  const wrapIterator = (iterator: object): object =>
-    new Proxy(iterator, {
-      get(target, property) {
-        const value = Reflect.get(target, property, target)
-        if (property === 'next' && typeof value === 'function') {
-          return (...args: unknown[]) => {
-            try {
-              return Reflect.apply(value, target, args)
-            } finally {
-              account()
-            }
-          }
+  const wrapIterator = (iterator: Iterator<unknown>): IterableIterator<unknown> => {
+    const next = iterator.next.bind(iterator)
+    return {
+      next(...args: [] | [unknown]) {
+        try {
+          return next(...args)
+        } finally {
+          account()
         }
-        return typeof value === 'function' ? value.bind(target) : value
       },
-    })
+      [Symbol.iterator]() {
+        return this
+      },
+    }
+  }
   let proxy: Cursor
   proxy = new Proxy(cursor, {
     get(target, property) {
@@ -222,7 +221,7 @@ export function trackBillableCursorRows<Cursor extends BillableCursor>(
       }
       if (property === 'raw' && typeof value === 'function') {
         return (...args: unknown[]) =>
-          wrapIterator(Reflect.apply(value, target, args) as object)
+          wrapIterator(Reflect.apply(value, target, args) as Iterator<unknown>)
       }
       return typeof value === 'function' ? value.bind(target) : value
     },