@livestore/common-cf 0.4.0 → 0.5.0-dev.1

package/src/do-rpc/client.ts

@@ -1,59 +1,79 @@
 import {
+  Data,
   Effect,
   Fiber,
   FiberMap,
   Layer,
+  Option,
   RpcClient,
-  type RpcMessage,
+  RpcClientError,
+  RpcMessage,
   RpcSerialization,
+  Schema,
   type Scope,
 } from '@livestore/utils/effect'
 
 import type * as CfTypes from '../cf-types.ts'
 
-/**
- * Processes a ReadableStream response from streaming RPCs.
- * Reads chunks from the stream and writes them as RPC responses.
- */
+/** A transferred stream can lose Cloudflare's RPC error flags when its connection breaks. */
+export class DoRpcReadError extends Data.TaggedError('DoRpcReadError')<{ cause: unknown }> {}
+
+const isEncodedRpcMessage = Schema.is(RpcMessage.EncodedSchema)
+
+const isFromServerEncoded = (message: unknown): message is RpcMessage.FromServerEncoded => {
+  if (isEncodedRpcMessage(message) === false) return false
+
+  return (
+    message._tag === 'Chunk' ||
+    message._tag === 'Exit' ||
+    message._tag === 'Defect' ||
+    message._tag === 'Pong' ||
+    message._tag === 'Request'
+  )
+}
+
+/** Decodes a streaming-RPC `ReadableStream`'s binary frames, writing each out as it arrives. */
 const processReadableStream = (
   stream: CfTypes.ReadableStream,
-  parser: ReturnType<typeof RpcSerialization.msgPack.unsafeMake>,
-  writeResponse: (response: any) => Effect.Effect<void>,
-): Effect.Effect<void> =>
+  parser: RpcSerialization.Parser,
+  writeResponse: (response: RpcMessage.FromServerEncoded) => Effect.Effect<void>,
+): Effect.Effect<void, RpcClientError.RpcClientError> =>
   Effect.gen(function* () {
     const reader = stream.getReader()
 
     yield* Effect.gen(function* () {
       while (true) {
-        const { done, value } = yield* Effect.tryPromise(() => reader.read()).pipe(Effect.orDie)
+        const { done, value } = yield* Effect.tryPromise({
+          try: () => reader.read(),
+          catch: (cause) => transportFailure(new DoRpcReadError({ cause })),
+        })
 
         if (done === true) {
-          break
+          return yield* transportFailure(new DoRpcReadError({ cause: new Error('RPC stream ended before its exit') }))
         }
 
-        // Decode the chunk
-        const decoded = parser.decode(value as Uint8Array)
-
-        // Handle array of messages from server.
-        // Server sends `parser.encode([message])` per enqueue, so each decoded value is `[message]`.
-        // When CF DO RPC merges enqueues in production, we get `[[msg1], [msg2], ...]`.
-        // `flat(1)` normalizes both single and merged cases to `[msg1, msg2, ...]`.
-        let messages: any[]
-        if (Array.isArray(decoded) === true) {
-          messages = decoded.flat(1)
-        } else {
-          messages = [decoded]
+        if (value instanceof Uint8Array === false) {
+          return yield* Effect.die('Received a non-binary RPC response')
         }
 
-        // Write each message
-        for (const message of messages) {
+        for (const message of parser.decode(value)) {
+          if (isFromServerEncoded(message) === false) {
+            return yield* Effect.die('Received an invalid RPC response')
+          }
           yield* writeResponse(message)
+          // The RPC exit completes the request; do not wait for the transferred stream to close too.
+          if (message._tag === 'Exit') return
         }
       }
     }).pipe(
       Effect.withSpan('do-rpc-client:processReadableStream'),
+      // Cancelling an errored stream rejects with that same error; ignore it so the original failure surfaces.
       Effect.ensuring(
-        Effect.promise(() => reader.cancel()).pipe(Effect.andThen(() => Effect.sync(() => reader.releaseLock()))),
+        Effect.sync(() => {
+          // Cancellation is best effort: a disconnected remote producer may never acknowledge it.
+          void reader.cancel().catch(() => {})
+          reader.releaseLock()
+        }),
       ),
     )
   })
@@ -70,9 +90,10 @@ interface MakeDoRpcProtocolArgs {
  * Creates a Protocol layer that uses Cloudflare Durable Object RPC calls.
  * This enables direct RPC communication with Durable Objects using Cloudflare's native RPC.
  */
-export const layerProtocolDurableObject = (
-  args: MakeDoRpcProtocolArgs,
-): Layer.Layer<RpcClient.Protocol> => Layer.scoped(RpcClient.Protocol, makeProtocolDurableObject(args))
+export const layerProtocolDurableObject = (args: MakeDoRpcProtocolArgs): Layer.Layer<RpcClient.Protocol> =>
+  Layer.effect(RpcClient.Protocol, makeProtocolDurableObject(args)).pipe(
+    Layer.provide(RpcSerialization.layerSchemaBinary()),
+  )
 
 /**
  * Implementation of the RPC Protocol interface using Cloudflare Durable Object RPC calls.
@@ -80,73 +101,83 @@ export const layerProtocolDurableObject = (
  */
 const makeProtocolDurableObject = ({
   callRpc,
-}: MakeDoRpcProtocolArgs): Effect.Effect<RpcClient.Protocol['Type'], never, Scope.Scope> =>
+}: MakeDoRpcProtocolArgs): Effect.Effect<
+  RpcClient.Protocol['Service'],
+  never,
+  Scope.Scope | RpcSerialization.RpcSerialization
+> =>
   RpcClient.Protocol.make(
     Effect.fnUntraced(function* (writeResponse) {
-      const parser = RpcSerialization.msgPack.unsafeMake()
+      const serialization = yield* RpcSerialization.RpcSerialization
       // Not using an actual `FiberMap` here because it seems to shutdown to early
-      // const fiberMap = new Map<string, Fiber.RuntimeFiber<void, never>>()
-      const fiberMap = yield* FiberMap.make<string, void, never>()
+      // const fiberMap = new Map<string, Fiber.Fiber<void, never>>()
+      const fiberMap = yield* FiberMap.make<string, void, RpcClientError.RpcClientError>()
 
-  const send = (message: RpcMessage.FromClientEncoded): Effect.Effect<void> => {
+      const send = (
+        clientId: number,
+        message: RpcMessage.FromClientEncoded,
+      ): Effect.Effect<void, RpcClientError.RpcClientError> => {
         if (message._tag !== 'Request') {
           if (message._tag === 'Interrupt') {
             return Effect.gen(function* () {
               const fiber = yield* FiberMap.get(fiberMap, message.requestId)
-              yield* Fiber.interrupt(fiber)
+              if (Option.isSome(fiber) === true) {
+                yield* Fiber.interrupt(fiber.value)
+              }
             }).pipe(Effect.orDie)
           }
 
           return Effect.void
         }
 
+        // Binary parsers hold stream framing state, so scope one parser to one DO RPC call.
+        const parser = serialization.makeUnsafe()
+
         // Wrap single Request in array to match server expected format
-        const serializedPayload = parser.encode([message]) as Uint8Array
+        const serializedPayload = parser.encode([message])
+        if (serializedPayload instanceof Uint8Array === false) {
+          return Effect.die('SchemaBinary RPC serialization did not produce bytes')
+        }
 
         return Effect.gen(function* () {
-          const serializedResponse = yield* Effect.tryPromise(() => callRpc(serializedPayload)).pipe(Effect.orDie) // Convert errors to defects to match never error type
-
-          // Handle ReadableStream for streaming responses
-          if (serializedResponse instanceof ReadableStream) {
-            const fiber = yield* processReadableStream(
-              serializedResponse as CfTypes.ReadableStream,
-              parser,
-              writeResponse,
-            ).pipe(
-              // Effect.tapCauseLogPretty,
-              Effect.fork,
-            )
-
-            // fiberMap.set(message.id, fiber)
-            yield* FiberMap.set(fiberMap, message.id, fiber)
-
-            yield* fiber
-
+          const serializedResponse = yield* Effect.tryPromise({
+            try: () => callRpc(serializedPayload),
+            catch: transportFailure,
+          })
+
+          if (serializedResponse instanceof Uint8Array) {
+            for (const response of parser.decode(serializedResponse)) {
+              if (isFromServerEncoded(response) === false) {
+                return yield* Effect.die('Received an invalid RPC response')
+              }
+              yield* writeResponse(clientId, response)
+            }
             return
           }
 
-          // Handle regular Uint8Array responses
-          const decoded = parser.decode(serializedResponse as Uint8Array)
-
-          // Normalize nested arrays from server serialization (same as streaming path)
-          let responseArray: any[]
-          if (Array.isArray(decoded) === true) {
-            responseArray = decoded.flat(1)
-          } else {
-            responseArray = [decoded]
-          }
+          const fiber = yield* processReadableStream(serializedResponse, parser, (response) =>
+            writeResponse(clientId, response),
+          ).pipe(Effect.forkChild)
 
-          // Process each response
-          for (const response of responseArray) {
-            yield* writeResponse(response)
-          }
-        }).pipe(Effect.withSpan('do-rpc-client:send'), Effect.orDie) // Ensure never error type
+          yield* FiberMap.set(fiberMap, message.id, fiber)
+          yield* Fiber.join(fiber)
+        }).pipe(Effect.withSpan('do-rpc-client:send'))
       }
 
       return {
         send,
         supportsAck: false, // DO RPC doesn't support ack mechanism like WebSockets
         supportsTransferables: false, // DO RPC doesn't support transferables yet
+        codecFor: serialization.codecFor,
       }
     }),
   )
+
+/**
+ * A rejected DO call or stream read fails only the request that made it (Effect RPC routes `send` failures per
+ * request). `RpcClientError` reasons are a closed union, so the original rejection rides as `RpcClientDefect.cause`.
+ */
+const transportFailure = (cause: unknown) =>
+  new RpcClientError.RpcClientError({
+    reason: new RpcClientError.RpcClientDefect({ message: 'Durable Object RPC call failed', cause }),
+  })

package/src/do-rpc/mod.ts

@@ -1,3 +1,3 @@
 // Re-export client and server implementations for backward compatibility
-export { layerProtocolDurableObject } from './client.ts'
+export { DoRpcReadError, layerProtocolDurableObject } from './client.ts'
 export { type ClientDoWithRpcCallback, emitStreamResponse, toDurableObjectHandler } from './server.ts'

package/src/do-rpc/rpc.test.ts

@@ -1,15 +1,13 @@
 import { expect } from 'vitest'
 
 import { Vitest } from '@livestore/utils-dev/node-vitest'
-import { WranglerDevServerService } from '@livestore/utils-dev/wrangler'
+import { WranglerDevServer } from '@livestore/utils-dev/wrangler'
 import {
-  Chunk,
   Effect,
   FetchHttpClient,
   Layer,
-  Logger,
-  LogLevel,
   Option,
+  References,
   RpcClient,
   RpcSerialization,
   Stream,
@@ -23,22 +21,26 @@ const testTimeout = 60_000
 const withWranglerTest = Vitest.makeWithTestCtx({
   timeout: testTimeout,
   makeLayer: () =>
-    WranglerDevServerService.Default({
+    WranglerDevServer.layer({
       cwd: `${import.meta.dirname}/test-fixtures`,
     }).pipe(
       Layer.provide(
-        Layer.mergeAll(PlatformNode.NodeContext.layer, FetchHttpClient.layer, Logger.minimumLogLevel(LogLevel.Debug)),
+        Layer.mergeAll(
+          PlatformNode.NodeServices.layer,
+          FetchHttpClient.layer,
+          Layer.succeed(References.MinimumLogLevel, 'Debug'),
+        ),
       ),
     ),
 })
 
 const ProtocolLive = Layer.suspend(() =>
   Effect.gen(function* () {
-    const server = yield* WranglerDevServerService
+    const server = yield* WranglerDevServer.WranglerDevServer
     return RpcClient.layerProtocolHttp({
       url: `${server.url}/rpc`,
     }).pipe(Layer.provide([FetchHttpClient.layer, RpcSerialization.layerJson]))
-  }).pipe(Layer.unwrapEffect),
+  }).pipe(Layer.unwrap),
 )
 
 /**
@@ -61,7 +63,7 @@ const ProtocolLive = Layer.suspend(() =>
 
 Vitest.describe('Durable Object RPC', { timeout: testTimeout }, () => {
   // Direct HTTP RPC client tests
-  Vitest.scopedLive('should call ping method', (test) =>
+  Vitest.live('should call ping method', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Ping({ message: 'Hello HTTP RPC' })
@@ -69,7 +71,7 @@ Vitest.describe('Durable Object RPC', { timeout: testTimeout }, () => {
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive('should call echo method', (test) =>
+  Vitest.live('should call echo method', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Echo({ text: 'Echo' })
@@ -77,7 +79,7 @@ Vitest.describe('Durable Object RPC', { timeout: testTimeout }, () => {
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive('should call add method', (test) =>
+  Vitest.live('should call add method', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Add({ a: 15, b: 25 })
@@ -85,110 +87,78 @@ Vitest.describe('Durable Object RPC', { timeout: testTimeout }, () => {
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive('should handle RPC fail method', (test) =>
+  Vitest.live('should handle RPC fail method', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const error = yield* client.Fail({ message: 'test http failure' }).pipe(Effect.exit)
       expect(error.toString()).toMatchInlineSnapshot(`
-        "{
-          "_id": "Exit",
-          "_tag": "Failure",
-          "cause": {
-            "_id": "Cause",
-            "_tag": "Die",
-            "defect": "RPC failure: test http failure"
-          }
-        }"
+        "Failure(Cause([Die("RPC failure: test http failure")]))"
       `)
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive('should handle defect method', (test) =>
+  Vitest.live('should handle defect method', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const error = yield* client.Defect({ message: 'test http defect' }).pipe(Effect.exit)
       expect(error.toString()).toMatchInlineSnapshot(`
-        "{
-          "_id": "Exit",
-          "_tag": "Failure",
-          "cause": {
-            "_id": "Cause",
-            "_tag": "Die",
-            "defect": "some defect: test http defect"
-          }
-        }"
+        "Failure(Cause([Die("some defect: test http defect")]))"
       `)
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive('should handle streaming RPC via HTTP', (test) =>
+  Vitest.live('should handle streaming RPC via HTTP', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const stream = client.Stream({}).pipe(
         Stream.take(4),
         Stream.map((c) => c.maybeNumber.pipe(Option.getOrUndefined)),
       )
-      const chunks = yield* Stream.runCollect(stream)
-      expect(Chunk.toReadonlyArray(chunks)).toEqual([1, 4, 9, 16]) // squares of 1,2,3,4
+      const result = yield* Stream.runCollect(stream)
+      expect(result).toEqual([1, 4, 9, 16]) // squares of 1,2,3,4
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive('should handle streaming RPC with error via HTTP', (test) =>
+  Vitest.live('should handle streaming RPC with error via HTTP', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const stream = client.StreamError({ count: 5, errorAfter: 4 })
       const error = yield* Stream.runCollect(stream).pipe(Effect.exit)
       expect(error.toString()).toMatchInlineSnapshot(`
-        "{
-          "_id": "Exit",
-          "_tag": "Failure",
-          "cause": {
-            "_id": "Cause",
-            "_tag": "Fail",
-            "failure": "Stream error after 4: got 9"
-          }
-        }"
+        "Failure(Cause([Fail("Stream error after 4: got 9")]))"
       `)
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive('should handle streaming RPC with defect via HTTP', (test) =>
+  Vitest.live('should handle streaming RPC with defect via HTTP', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const stream = client.StreamDefect({ count: 4, defectAfter: 1 })
       const error = yield* Stream.runCollect(stream).pipe(Effect.exit)
       expect(error.toString()).toMatchInlineSnapshot(`
-        "{
-          "_id": "Exit",
-          "_tag": "Failure",
-          "cause": {
-            "_id": "Cause",
-            "_tag": "Die",
-            "defect": "Stream defect after 1: got 4"
-          }
-        }"
+        "Failure(Cause([Die("Stream defect after 1: got 4")]))"
       `)
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive('should handle stream interruption via HTTP', (test) =>
+  Vitest.live('should handle stream interruption via HTTP', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const stream = client.StreamInterruptible({ delay: 50, interruptAfterCount: 3 }).pipe(Stream.take(3))
-      const chunks = yield* Stream.runCollect(stream)
-      expect(Chunk.toReadonlyArray(chunks)).toEqual([1, 2, 3])
+      const result = yield* Stream.runCollect(stream)
+      expect(result).toEqual([1, 2, 3])
     }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
   // TODO @IMax153
-  Vitest.scopedLive.skip('should handle streaming RPC bug scenario', (test) =>
+  Vitest.live.skip('should handle streaming RPC bug scenario', (test) =>
     Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       yield* client.StreamBugScenarioDoClient({})
       /*
 
 
-      In `node_modules/.pnpm/@effect+rpc@0.68.4_@effect+platform@0.90.0_effect@3.17.7__effect@3.17.7/node_modules/@effect/rpc/dist/esm/RpcClient.js`:
+      In the installed `@effect/rpc` `RpcClient.js`:
       add the console log
       ```
       yield* Scope.addFinalizerExit(scope, exit => {
@@ -225,7 +195,7 @@ Vitest.describe('Durable Object RPC', { timeout: testTimeout }, () => {
         errorSchema: [Function: Never],
         annotations: { _id: 'Context', services: [] },
         middlewares: Set(0) {},
-        key: '@effect/rpc/Rpc/StreamBugScenarioDoServer'
+        key: 'effect/unstable/rpc/Rpc/StreamBugScenarioDoServer'
       } {}
 
       Killing wrangler process...