@livestore/common-cf 0.4.0-dev.9 → 0.5.0-dev.0

package/src/declare/cf-declare.ts

@@ -4,13 +4,21 @@
 
 import type * as CF from '@cloudflare/workers-types'
 
-export const ReadableStream = globalThis.ReadableStream as unknown as typeof CF.ReadableStream
-export const Request = globalThis.Request as unknown as typeof CF.Request
-export const Response = globalThis.Response as unknown as typeof CF.Response
-export const WebSocket = globalThis.WebSocket as unknown as typeof CF.WebSocket
-export const Rpc = globalThis.Rpc as unknown as typeof CF.Rpc
-// @ts-expect-error WebSocketPair is not defined in the globalThis object
-export const WebSocketPair = globalThis.WebSocketPair as unknown as typeof CF.WebSocketPair
-export const WebSocketRequestResponsePair =
-  // @ts-expect-error WebSocketRequestResponsePair is not defined in the globalThis object
-  globalThis.WebSocketRequestResponsePair as unknown as typeof CF.WebSocketRequestResponsePair
+// oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- bridging standard Web API types to Cloudflare Worker types; inherent platform type mismatch
+const cfGlobalThis = globalThis as unknown as {
+  ReadableStream: typeof CF.ReadableStream
+  Request: typeof CF.Request
+  Response: typeof CF.Response
+  WebSocket: typeof CF.WebSocket
+  Rpc: typeof CF.Rpc
+  WebSocketPair: typeof CF.WebSocketPair
+  WebSocketRequestResponsePair: typeof CF.WebSocketRequestResponsePair
+}
+
+export const ReadableStream = cfGlobalThis.ReadableStream
+export const Request = cfGlobalThis.Request
+export const Response = cfGlobalThis.Response
+export const WebSocket = cfGlobalThis.WebSocket
+export const Rpc = cfGlobalThis.Rpc
+export const WebSocketPair = cfGlobalThis.WebSocketPair
+export const WebSocketRequestResponsePair = cfGlobalThis.WebSocketRequestResponsePair

package/src/do-rpc/README.md

@@ -68,7 +68,7 @@ async rpc(payload: Uint8Array): Promise<Uint8Array | ReadableStream> {
   return handler(payload).pipe(Effect.runPromise)
 }
 
-// Client setup  
+// Client setup
 const client = RpcClient.make(MyRpcs, {
   layer: layerProtocolDurableObject(
     (payload) => serverDO.rpc(payload)
@@ -82,4 +82,3 @@ const result3 = yield* client.CountUp({ startValue: 0 }).pipe(Stream.take(10), S
 ```
 
 ## Effect RPC reference
-

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

@@ -0,0 +1,122 @@
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { Effect, Fiber, Rpc, RpcClient, RpcGroup, Schema, Stream } from '@livestore/utils/effect'
+
+import type * as CfTypes from '../cf-types.ts'
+import { layerProtocolDurableObject } from './client.ts'
+import { toDurableObjectHandler } from './server.ts'
+
+class Rpcs extends RpcGroup.make(
+  Rpc.make('BigStream', {
+    payload: Schema.Struct({ n: Schema.Finite }),
+    success: Schema.Struct({
+      seqNum: Schema.Finite,
+      name: Schema.String,
+      args: Schema.Struct({ a: Schema.Finite, b: Schema.String }),
+    }),
+    stream: true,
+  }),
+  Rpc.make('Echo', {
+    payload: Schema.Struct({ text: Schema.String }),
+    success: Schema.Struct({ echo: Schema.String }),
+  }),
+) {}
+
+const READ_CHUNK_SIZE = 4096
+
+const expectedRows = [
+  {
+    seqNum: 0,
+    name: 'event-0',
+    args: { a: 0, b: 'x'.repeat(READ_CHUNK_SIZE) },
+  },
+]
+
+const ServerLive = Rpcs.toLayer({
+  BigStream: ({ n }) => Stream.fromIterable(expectedRows.slice(0, n)),
+  Echo: ({ text }) => Effect.succeed({ echo: `Echo: ${text}` }),
+})
+
+Vitest.live('keeps a straddling stream frame isolated from a concurrent unary response', () =>
+  Effect.gen(function* () {
+    let signalFirstStreamRead = () => {}
+    const firstStreamReadDone = new Promise<void>((resolve) => {
+      signalFirstStreamRead = resolve
+    })
+    let releaseStreamTail = () => {}
+    const streamTailReleased = new Promise<void>((resolve) => {
+      releaseStreamTail = resolve
+    })
+
+    const streamWithGatedTail = (bytes: Uint8Array) => {
+      let pos = 0
+      let isFirstRead = true
+      const stream = new ReadableStream<Uint8Array>({
+        async pull(controller) {
+          if (pos >= bytes.length) return controller.close()
+          if (isFirstRead === false) await streamTailReleased
+          controller.enqueue(bytes.subarray(pos, pos + READ_CHUNK_SIZE))
+          pos += READ_CHUNK_SIZE
+          if (isFirstRead === true) {
+            isFirstRead = false
+            signalFirstStreamRead()
+          }
+        },
+      })
+      // oxlint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- bridge platform ReadableStream to the CF type, like server.ts
+      return stream as unknown as CfTypes.ReadableStream
+    }
+
+    const ProtocolLive = layerProtocolDurableObject({
+      callRpc: makeGatedCallRpc(streamWithGatedTail),
+      callerContext: { bindingName: 'TEST', durableObjectId: 'id' },
+    })
+
+    const result = yield* Effect.gen(function* () {
+      const client = yield* RpcClient.make(Rpcs)
+      const streamFiber = yield* client.BigStream({ n: expectedRows.length }).pipe(Stream.runCollect, Effect.forkChild)
+
+      yield* Effect.promise(() => firstStreamReadDone)
+      const echo = yield* client.Echo({ text: 'hi' }).pipe(Effect.timeout('500 millis'))
+      yield* Effect.sync(() => releaseStreamTail())
+
+      const rows = yield* Fiber.join(streamFiber)
+      return { rows: Array.from(rows), echo }
+    }).pipe(Effect.provide(ProtocolLive), Effect.timeout('2 seconds'))
+
+    Vitest.expect(result.echo).toEqual({ echo: 'Echo: hi' })
+    Vitest.expect(result.rows).toEqual(expectedRows)
+  }),
+)
+
+const makeGatedCallRpc =
+  (gateStream: (bytes: Uint8Array) => CfTypes.ReadableStream) =>
+  (payload: Uint8Array): Promise<Uint8Array | CfTypes.ReadableStream> =>
+    toDurableObjectHandler(Rpcs, { layer: ServerLive })(new Uint8Array(payload)).pipe(
+      Effect.flatMap(
+        // Narrow on `Uint8Array`; the `ReadableStream` global differs from `CfTypes` across envs.
+        (result): Effect.Effect<Uint8Array | CfTypes.ReadableStream> =>
+          result instanceof Uint8Array
+            ? Effect.succeed(result)
+            : Effect.promise(() => collectBytes(result)).pipe(Effect.map(gateStream)),
+      ),
+      Effect.runPromise,
+    )
+
+const collectBytes = async (stream: CfTypes.ReadableStream) => {
+  const reader = stream.getReader()
+  const parts: Uint8Array[] = []
+  let total = 0
+  for (;;) {
+    const { done, value } = await reader.read()
+    if (done === true) break
+    parts.push(value)
+    total += value.length
+  }
+  const out = new Uint8Array(total)
+  let offset = 0
+  for (const part of parts) {
+    out.set(part, offset)
+    offset += part.length
+  }
+  return out
+}

package/src/do-rpc/client.ts

@@ -3,52 +3,36 @@ import {
   Fiber,
   FiberMap,
   Layer,
+  Option,
   RpcClient,
   type RpcMessage,
   RpcSerialization,
   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.
- */
+/** Decodes a streaming-RPC `ReadableStream`'s msgpack frames, writing each out as it arrives. */
 const processReadableStream = (
   stream: CfTypes.ReadableStream,
-  parser: ReturnType<typeof RpcSerialization.msgPack.unsafeMake>,
-  writeResponse: (response: any) => Effect.Effect<void, never, never>,
-): Effect.Effect<void, never, never> =>
+  parser: ReturnType<typeof RpcSerialization.msgPack.makeUnsafe>,
+  writeResponse: (response: any) => Effect.Effect<void>,
+): Effect.Effect<void> =>
   Effect.gen(function* () {
     const reader = stream.getReader()
 
     yield* Effect.gen(function* () {
       while (true) {
-        const { done, value } = yield* Effect.tryPromise({
-          try: () => reader.read(),
-          catch: (cause) => cause,
-        }).pipe(Effect.orDie)
+        const { done, value } = yield* Effect.tryPromise(() => reader.read()).pipe(Effect.orDie)
 
-        if (done) {
+        if (done === true) {
           break
         }
 
-        // Decode the chunk
+        // Server encodes `[message]` per enqueue; merged enqueues arrive as
+        // `[[msg1], [msg2], ...]`. `flat(1)` normalizes both to `[msg1, ...]`.
         const decoded = parser.decode(value as Uint8Array)
-
-        // Handle array of messages - we get [[message]] from server
-        let messages: any[]
-        if (Array.isArray(decoded) && decoded.length === 1 && Array.isArray(decoded[0])) {
-          // Double-wrapped array [[message]] -> [message]
-          messages = decoded[0]
-        } else if (Array.isArray(decoded)) {
-          // Single array [message]
-          messages = decoded
-        } else {
-          messages = [decoded]
-        }
-
-        // Write each message
+        const messages = Array.isArray(decoded) === true ? decoded.flat(1) : [decoded]
         for (const message of messages) {
           yield* writeResponse(message)
         }
@@ -73,9 +57,8 @@ 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, never, never> => Layer.scoped(RpcClient.Protocol, makeProtocolDurableObject(args))
+export const layerProtocolDurableObject = (args: MakeDoRpcProtocolArgs): Layer.Layer<RpcClient.Protocol> =>
+  Layer.effect(RpcClient.Protocol, makeProtocolDurableObject(args))
 
 /**
  * Implementation of the RPC Protocol interface using Cloudflare Durable Object RPC calls.
@@ -83,50 +66,51 @@ export const layerProtocolDurableObject = (
  */
 const makeProtocolDurableObject = ({
   callRpc,
-}: MakeDoRpcProtocolArgs): Effect.Effect<RpcClient.Protocol['Type'], never, Scope.Scope> =>
+}: MakeDoRpcProtocolArgs): Effect.Effect<RpcClient.Protocol['Service'], never, Scope.Scope> =>
   RpcClient.Protocol.make(
     Effect.fnUntraced(function* (writeResponse) {
-      const parser = RpcSerialization.msgPack.unsafeMake()
       // Not using an actual `FiberMap` here because it seems to shutdown to early
-      // const fiberMap = new Map<string, Fiber.RuntimeFiber<void, never>>()
+      // const fiberMap = new Map<string, Fiber.Fiber<void, never>>()
       const fiberMap = yield* FiberMap.make<string, void, never>()
 
-      const send = (message: RpcMessage.FromClientEncoded): Effect.Effect<void, never, never> => {
+      const send = (clientId: number, message: RpcMessage.FromClientEncoded): Effect.Effect<void> => {
         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
         }
 
+        // MessagePack parsers buffer incomplete frames, so scope one parser to one DO RPC call.
+        const parser = RpcSerialization.msgPack.makeUnsafe()
+
         // Wrap single Request in array to match server expected format
         const serializedPayload = parser.encode([message]) as Uint8Array
 
         return Effect.gen(function* () {
-          const serializedResponse = yield* Effect.tryPromise({
-            try: () => callRpc(serializedPayload),
-            catch: (cause) => cause,
-          }).pipe(Effect.orDie) // Convert errors to defects to match never error type
+          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,
+              (response) => writeResponse(clientId, response),
             ).pipe(
               // Effect.tapCauseLogPretty,
-              Effect.fork,
+              Effect.forkChild,
             )
 
             // fiberMap.set(message.id, fiber)
             yield* FiberMap.set(fiberMap, message.id, fiber)
 
-            yield* fiber
+            yield* Fiber.join(fiber)
 
             return
           }
@@ -134,21 +118,17 @@ const makeProtocolDurableObject = ({
           // Handle regular Uint8Array responses
           const decoded = parser.decode(serializedResponse as Uint8Array)
 
-          // Handle potential nested array from server serialization
+          // Normalize nested arrays from server serialization (same as streaming path)
           let responseArray: any[]
-          if (Array.isArray(decoded) && decoded.length === 1 && Array.isArray(decoded[0])) {
-            // Double-wrapped array [[Exit]] -> [Exit]
-            responseArray = decoded[0]
-          } else if (Array.isArray(decoded)) {
-            // Single array [Exit]
-            responseArray = decoded
+          if (Array.isArray(decoded) === true) {
+            responseArray = decoded.flat(1)
           } else {
             responseArray = [decoded]
           }
 
           // Process each response
           for (const response of responseArray) {
-            yield* writeResponse(response)
+            yield* writeResponse(clientId, response)
           }
         }).pipe(Effect.withSpan('do-rpc-client:send'), Effect.orDie) // Ensure never error type
       }

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

@@ -1,19 +1,19 @@
+import { expect } from 'vitest'
+
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { WranglerDevServer } from '@livestore/utils-dev/wrangler'
 import {
-  Chunk,
   Effect,
   FetchHttpClient,
   Layer,
-  Logger,
-  LogLevel,
   Option,
+  References,
   RpcClient,
   RpcSerialization,
   Stream,
 } from '@livestore/utils/effect'
 import { PlatformNode } from '@livestore/utils/node'
-import { Vitest } from '@livestore/utils-dev/node-vitest'
-import { WranglerDevServerService } from '@livestore/utils-dev/wrangler'
-import { expect } from 'vitest'
+
 import { TestRpcs } from './test-fixtures/rpc-schema.ts'
 
 const testTimeout = 60_000
@@ -21,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),
 )
 
 /**
@@ -59,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' })
@@ -67,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' })
@@ -75,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 })
@@ -83,103 +87,71 @@ 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({})
@@ -223,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...