@livestore/common-cf 0.4.0-dev.5 → 0.4.0-dev.7

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

@@ -8,24 +8,29 @@ import {
   RpcSerialization,
   Stream,
 } from '@livestore/utils/effect'
-import { startWranglerDevServerPromise } from '@livestore/utils-dev/node'
+import { PlatformNode } from '@livestore/utils/node'
+import { WranglerDevServerService } from '@livestore/utils-dev/node'
 import { Vitest } from '@livestore/utils-dev/node-vitest'
-import { beforeAll, expect } from 'vitest'
+import { expect } from 'vitest'
 import { TestRpcs } from './test-fixtures/rpc-schema.ts'
 
-let port: number
+const testTimeout = 60_000
 
-beforeAll(async () => {
-  const { port: wranglerPort } = await startWranglerDevServerPromise({
-    cwd: `${import.meta.dirname}/test-fixtures`,
-  })
-  port = wranglerPort
+const withWranglerTest = Vitest.makeWithTestCtx({
+  timeout: testTimeout,
+  makeLayer: () =>
+    WranglerDevServerService.Default({
+      cwd: `${import.meta.dirname}/test-fixtures`,
+    }).pipe(Layer.provide(PlatformNode.NodeContext.layer), Layer.provide(FetchHttpClient.layer)),
 })
 
 const ProtocolLive = Layer.suspend(() =>
-  RpcClient.layerProtocolHttp({
-    url: `http://localhost:${port}/rpc`,
-  }).pipe(Layer.provide([FetchHttpClient.layer, RpcSerialization.layerJson])),
+  Effect.gen(function* () {
+    const server = yield* WranglerDevServerService
+    return RpcClient.layerProtocolHttp({
+      url: `${server.url}/rpc`,
+    }).pipe(Layer.provide([FetchHttpClient.layer, RpcSerialization.layerJson]))
+  }).pipe(Layer.unwrapEffect),
 )
 
 /**
@@ -46,38 +51,34 @@ const ProtocolLive = Layer.suspend(() =>
  * Test Path: Test → Worker /rpc → Server DO (HTTP RPC)
  */
 
-Vitest.describe('Durable Object RPC', { timeout: 5000 }, () => {
+Vitest.describe('Durable Object RPC', { timeout: testTimeout }, () => {
   // Direct HTTP RPC client tests
-  Vitest.scopedLive(
-    'should call ping method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should call ping method', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Ping({ message: 'Hello HTTP RPC' })
       expect(result).toEqual({ response: 'Pong: Hello HTTP RPC' })
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should call echo method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should call echo method', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Echo({ text: 'Echo' })
       expect(result).toEqual({ echo: 'Echo: Echo' })
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should call add method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should call add method', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Add({ a: 15, b: 25 })
       expect(result).toEqual({ result: 40 })
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle RPC fail method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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(`
@@ -91,12 +92,11 @@ Vitest.describe('Durable Object RPC', { timeout: 5000 }, () => {
           }
         }"
       `)
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle defect method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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(`
@@ -110,12 +110,11 @@ Vitest.describe('Durable Object RPC', { timeout: 5000 }, () => {
           }
         }"
       `)
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle streaming RPC via HTTP',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should handle streaming RPC via HTTP', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const stream = client.Stream({}).pipe(
         Stream.take(4),
@@ -123,12 +122,11 @@ Vitest.describe('Durable Object RPC', { timeout: 5000 }, () => {
       )
       const chunks = yield* Stream.runCollect(stream)
       expect(Chunk.toReadonlyArray(chunks)).toEqual([1, 4, 9, 16]) // squares of 1,2,3,4
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle streaming RPC with error via HTTP',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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)
@@ -143,12 +141,11 @@ Vitest.describe('Durable Object RPC', { timeout: 5000 }, () => {
           }
         }"
       `)
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle streaming RPC with defect via HTTP',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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)
@@ -163,23 +160,21 @@ Vitest.describe('Durable Object RPC', { timeout: 5000 }, () => {
           }
         }"
       `)
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle stream interruption via HTTP',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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])
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
   // TODO @IMax153
-  Vitest.scopedLive.skip(
-    'should handle streaming RPC bug scenario',
-    Effect.fn(function* () {
+  Vitest.scopedLive.skip('should handle streaming RPC bug scenario', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       yield* client.StreamBugScenarioDoClient({})
       /*
@@ -230,6 +225,6 @@ Vitest.describe('Durable Object RPC', { timeout: 5000 }, () => {
       ```
 
       */
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 })

package/src/ws-rpc/ws-rpc-server.ts

@@ -15,7 +15,7 @@
  * @see {@link https://developers.cloudflare.com/durable-objects/best-practices/websockets/ Cloudflare WebSocket Best Practices}
  */
 
-import { notYetImplemented } from '@livestore/utils'
+import { notYetImplemented, omitUndefineds } from '@livestore/utils'
 import {
   constVoid,
   Effect,
@@ -147,7 +147,7 @@ export const setupDurableObjectWebSocketRpc = ({
       const ProtocolLive = layerRpcServerWebsocket({
         ws,
         incomingQueue,
-        onMessage,
+        ...omitUndefineds({ onMessage }),
       }).pipe(Layer.provide(RpcSerialization.layerJson))
 
       const ServerLive = rpcLayer.pipe(Layer.provide(ProtocolLive))

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

@@ -1,58 +1,69 @@
-import { Chunk, Effect, Layer, Option, RpcClient, RpcSerialization, Socket, Stream } from '@livestore/utils/effect'
-import { startWranglerDevServerPromise } from '@livestore/utils-dev/node'
+import {
+  Chunk,
+  Effect,
+  FetchHttpClient,
+  Layer,
+  Option,
+  RpcClient,
+  RpcSerialization,
+  Socket,
+  Stream,
+} from '@livestore/utils/effect'
+import { PlatformNode } from '@livestore/utils/node'
+import { WranglerDevServerService } from '@livestore/utils-dev/node'
 import { Vitest } from '@livestore/utils-dev/node-vitest'
-import { beforeAll, expect } from 'vitest'
+import { expect } from 'vitest'
 import { TestRpcs } from './test-fixtures/rpc-schema.ts'
 
-let port: number
+const testTimeout = 60_000
 
-beforeAll(async () => {
-  const { port: wranglerPort } = await startWranglerDevServerPromise({
-    cwd: `${import.meta.dirname}/test-fixtures`,
-  })
-  port = wranglerPort
+const withWranglerTest = Vitest.makeWithTestCtx({
+  timeout: testTimeout,
+  makeLayer: () =>
+    WranglerDevServerService.Default({
+      cwd: `${import.meta.dirname}/test-fixtures`,
+    }).pipe(Layer.provide(PlatformNode.NodeContext.layer), Layer.provide(FetchHttpClient.layer)),
 })
 
 const ProtocolLive = Layer.suspend(() =>
-  RpcClient.layerProtocolSocket().pipe(
-    Layer.provide(Socket.layerWebSocket(`ws://localhost:${port}`)),
-    Layer.provide(Socket.layerWebSocketConstructorGlobal),
-    Layer.provide(RpcSerialization.layerJson),
-  ),
+  Effect.gen(function* () {
+    const server = yield* WranglerDevServerService
+    return RpcClient.layerProtocolSocket().pipe(
+      Layer.provide(Socket.layerWebSocket(`ws://localhost:${server.port}`)),
+      Layer.provide(Socket.layerWebSocketConstructorGlobal),
+      Layer.provide(RpcSerialization.layerJson),
+    )
+  }).pipe(Layer.unwrapEffect),
 )
 
-Vitest.describe('Durable Object WebSocket RPC', { timeout: 5000 }, () => {
+Vitest.describe('Durable Object WebSocket RPC', { timeout: testTimeout }, () => {
   // Direct HTTP RPC client tests
-  Vitest.scopedLive(
-    'should call ping method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should call ping method', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Ping({ message: 'Hello HTTP RPC' })
       expect(result).toEqual({ response: 'Pong: Hello HTTP RPC' })
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should call echo method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should call echo method', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Echo({ text: 'Echo' })
       expect(result).toEqual({ echo: 'Echo: Echo' })
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should call add method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should call add method', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const result = yield* client.Add({ a: 15, b: 25 })
       expect(result).toEqual({ result: 40 })
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle RPC fail method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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(`
@@ -66,12 +77,11 @@ Vitest.describe('Durable Object WebSocket RPC', { timeout: 5000 }, () => {
           }
         }"
       `)
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle defect method',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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(`
@@ -85,12 +95,11 @@ Vitest.describe('Durable Object WebSocket RPC', { timeout: 5000 }, () => {
           }
         }"
       `)
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle streaming RPC via HTTP',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should handle streaming RPC via HTTP', (test) =>
+    Effect.gen(function* () {
       const client = yield* RpcClient.make(TestRpcs)
       const stream = client.Stream({}).pipe(
         Stream.take(4),
@@ -98,12 +107,11 @@ Vitest.describe('Durable Object WebSocket RPC', { timeout: 5000 }, () => {
       )
       const chunks = yield* Stream.runCollect(stream)
       expect(Chunk.toReadonlyArray(chunks)).toEqual([1, 4, 9, 16]) // squares of 1,2,3,4
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle streaming RPC with error via HTTP',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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)
@@ -118,12 +126,11 @@ Vitest.describe('Durable Object WebSocket RPC', { timeout: 5000 }, () => {
           }
         }"
       `)
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle streaming RPC with defect via HTTP',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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)
@@ -138,24 +145,22 @@ Vitest.describe('Durable Object WebSocket RPC', { timeout: 5000 }, () => {
           }
         }"
       `)
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle stream interruption via HTTP',
-    Effect.fn(function* () {
+  Vitest.scopedLive('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])
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 })
 
 Vitest.describe('Hibernation Tests', { timeout: 25000 }, () => {
-  Vitest.scopedLive(
-    'should maintain RPC functionality after hibernation',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should maintain RPC functionality after hibernation', (test) =>
+    Effect.gen(function* () {
       console.log('🧪 Testing RPC server persistence across hibernation...')
 
       // Step 1: Create client and test initial functionality
@@ -214,12 +219,11 @@ Vitest.describe('Hibernation Tests', { timeout: 25000 }, () => {
       console.log('✅ Streaming after hibernation successful')
 
       console.log('🎉 All RPC operations successful after hibernation!')
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 
-  Vitest.scopedLive(
-    'should handle rapid operations after hibernation',
-    Effect.fn(function* () {
+  Vitest.scopedLive('should handle rapid operations after hibernation', (test) =>
+    Effect.gen(function* () {
       console.log('🧪 Testing rapid operations after hibernation...')
 
       console.log('Step 1: Establishing initial connection...')
@@ -266,6 +270,6 @@ Vitest.describe('Hibernation Tests', { timeout: 25000 }, () => {
         results.map((r) => r.operation),
       )
       console.log('🎉 Rapid operations work correctly after hibernation!')
-    }, Effect.provide(ProtocolLive)),
+    }).pipe(Effect.provide(ProtocolLive), withWranglerTest(test)),
   )
 })