@livestore/webmesh 0.4.0-dev.9 → 0.5.0-dev.0

package/src/websocket-edge.ts

@@ -1,11 +1,13 @@
-import type { HttpClient } from '@livestore/utils/effect'
 import {
+  type HttpClient,
   Deferred,
+  Duration,
   Effect,
-  Either,
+  Result,
   Exit,
+  Latch,
   Layer,
-  MsgPack,
+  Msgpack,
   Queue,
   Schedule,
   Schema,
@@ -18,18 +20,18 @@ import {
 import * as WebmeshSchema from './mesh-schema.ts'
 import type { MeshNode } from './node.ts'
 
-export class WSEdgeInit extends Schema.TaggedStruct('WSEdgeInit', {
+export const WSEdgeInit = Schema.TaggedStruct('WSEdgeInit', {
   from: Schema.String,
-}) {}
+})
 
-export class WSEdgePayload extends Schema.TaggedStruct('WSEdgePayload', {
+export const WSEdgePayload = Schema.TaggedStruct('WSEdgePayload', {
   from: Schema.String,
   payload: Schema.Any,
-}) {}
+})
 
-export class WSEdgeMessage extends Schema.Union(WSEdgeInit, WSEdgePayload) {}
+export const WSEdgeMessage = Schema.Union([WSEdgeInit, WSEdgePayload])
 
-export const MessageMsgPack = MsgPack.schema(WSEdgeMessage)
+export const MessageMsgpack = Msgpack.schema(WSEdgeMessage)
 
 export type SocketType =
   | {
@@ -50,7 +52,7 @@ export const connectViaWebSocket = ({
   openTimeout?: number
 }): Effect.Effect<void, never, Scope.Scope | HttpClient.HttpClient> =>
   Effect.gen(function* () {
-    const socket = yield* Socket.makeWebSocket(url, { openTimeout })
+    const socket = yield* Socket.makeWebSocket(url, openTimeout !== undefined ? { openTimeout } : undefined)
 
     const edgeChannel = yield* makeWebSocketEdge({
       socket,
@@ -58,11 +60,12 @@ export const connectViaWebSocket = ({
       debug: { id: `node:${node.nodeName}` },
     })
 
-    yield* node
-      .addEdge({ target: 'ws', edgeChannel: edgeChannel.webChannel, replaceIfExists: true })
-      .pipe(Effect.acquireRelease(() => node.removeEdge('ws').pipe(Effect.orDie)))
+    yield* Effect.acquireRelease(
+      node.addEdge({ target: 'ws', edgeChannel: edgeChannel.webChannel, replaceIfExists: true }),
+      () => node.removeEdge('ws').pipe(Effect.orDie),
+    )
 
-    yield* edgeChannel.webChannel.closedDeferred
+    yield* Deferred.await(edgeChannel.webChannel.closedDeferred)
   }).pipe(Effect.scoped, Effect.forever, Effect.interruptible, Effect.provide(binaryWebSocketConstructorLayer))
 
 const binaryWebSocketConstructorLayer = Layer.succeed(Socket.WebSocketConstructor, (url, protocols) => {
@@ -78,7 +81,7 @@ export const makeWebSocketEdge = ({
 }: {
   socket: Socket.Socket
   socketType: SocketType
-  debug?: { id?: string }
+  debug?: { id?: string | undefined } | undefined
 }): Effect.Effect<
   {
     webChannel: WebChannel.WebChannel<typeof WebmeshSchema.Packet.Type, typeof WebmeshSchema.Packet.Type>
@@ -91,46 +94,49 @@ export const makeWebSocketEdge = ({
     Effect.gen(function* () {
       const fromDeferred = yield* Deferred.make<string>()
 
-      const listenQueue = yield* Queue.unbounded<typeof WebmeshSchema.Packet.Type>().pipe(
-        Effect.acquireRelease(Queue.shutdown),
+      const listenQueue = yield* Effect.acquireRelease(
+        Queue.unbounded<typeof WebmeshSchema.Packet.Type>(),
+        Queue.shutdown,
       )
 
       const schema = WebChannel.mapSchema(WebmeshSchema.Packet)
 
-      const isConnectedLatch = yield* Effect.makeLatch(true)
+      const isConnectedLatch = yield* Latch.make(true)
 
-      const closedDeferred = yield* Deferred.make<void>().pipe(Effect.acquireRelease(Deferred.done(Exit.void)))
+      const closedDeferred = yield* Effect.acquireRelease(Deferred.make<void>(), Deferred.done(Exit.void))
 
-      const retryOpenTimeoutSchedule = Schedule.union(Schedule.exponential(100), Schedule.spaced(5000)).pipe(
-        Schedule.whileInput((_: Socket.SocketError) => _.reason === 'OpenTimeout' || _.reason === 'Open'),
+      const retryOpenErrorSchedule = Schedule.exponential(100).pipe(
+        Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.min(duration, Duration.millis(5000)))),
+        Schedule.setInputType<Socket.SocketError>(),
+        Schedule.while(({ input }) => input.reason._tag === 'SocketOpenError'),
       )
 
+      const sendToSocket = yield* socket.writer
+
       yield* Stream.never.pipe(
         Stream.pipeThroughChannel(Socket.toChannel(socket)),
-        Stream.catchTag(
-          'SocketError',
-          Effect.fnUntraced(function* (error) {
-            // yield* Effect.logError(`[websocket-edge] Socket error`, error, { socketType, debugId: debugInfo?.id })
-            // In the case of the socket being closed, we're interrupting the stream
-            // and close the WebChannel (which can be observed from the outside)
-            if (error.reason === 'Close') {
-              yield* Deferred.succeed(closedDeferred, undefined)
-              yield* isConnectedLatch.close
-              return yield* Effect.interrupt
-            } else {
-              return yield* Effect.fail(error)
-            }
-          }),
-        ),
-        Stream.retry(retryOpenTimeoutSchedule),
+        Stream.catchTag('SocketError', (error) => {
+          // In the case of the socket being closed, close the WebChannel
+          // which can be observed from the outside.
+          if (error.reason._tag === 'SocketCloseError') {
+            return Stream.fromEffectDrain(
+              Effect.gen(function* () {
+                yield* Deferred.succeed(closedDeferred, undefined)
+                yield* isConnectedLatch.close
+              }),
+            )
+          }
+
+          return Stream.fail(error)
+        }),
+        Stream.retry(retryOpenErrorSchedule),
         Stream.tap(
           Effect.fn(function* (bytes) {
-            const msg = yield* Schema.decode(MessageMsgPack)(new Uint8Array(bytes))
+            const msg = yield* Schema.decodeEffect(MessageMsgpack)(new Uint8Array(bytes))
             if (msg._tag === 'WSEdgeInit') {
               yield* Deferred.succeed(fromDeferred, msg.from)
             } else {
-              const decodedPayload = yield* Schema.decode(schema.listen)(msg.payload)
-              // yield* Effect.logDebug(`[websocket-edge] recv from ${msg.from}: ${decodedPayload._tag}`, decodedPayload)
+              const decodedPayload = yield* Schema.decodeEffect(schema.listen)(msg.payload)
               yield* Queue.offer(listenQueue, decodedPayload)
             }
           }),
@@ -148,16 +154,14 @@ export const makeWebSocketEdge = ({
         Effect.forkScoped,
       )
 
-      const sendToSocket = yield* socket.writer
-
       const initHandshake = (from: string) =>
-        sendToSocket(Schema.encodeSync(MessageMsgPack)({ _tag: 'WSEdgeInit', from }))
+        sendToSocket(Schema.encodeSync(MessageMsgpack)({ _tag: 'WSEdgeInit', from }))
 
       if (socketType._tag === 'leaf') {
         yield* initHandshake(socketType.from)
       }
 
-      const deferredResult = yield* fromDeferred
+      const deferredResult = yield* Deferred.await(fromDeferred)
       const from = socketType._tag === 'leaf' ? socketType.from : deferredResult
 
       if (socketType._tag === 'relay') {
@@ -167,12 +171,12 @@ export const makeWebSocketEdge = ({
       const send = (message: typeof WebmeshSchema.Packet.Type) =>
         Effect.gen(function* () {
           yield* isConnectedLatch.await
-          const payload = yield* Schema.encode(schema.send)(message)
-          yield* sendToSocket(Schema.encodeSync(MessageMsgPack)({ _tag: 'WSEdgePayload', payload, from }))
+          const payload = yield* Schema.encodeEffect(schema.send)(message)
+          yield* sendToSocket(yield* Schema.encodeEffect(MessageMsgpack)({ _tag: 'WSEdgePayload', payload, from }))
         }).pipe(Effect.orDie)
 
       const listen = Stream.fromQueue(listenQueue).pipe(
-        Stream.map(Either.right),
+        Stream.map(Result.succeed),
         WebChannel.listenToDebugPing('websocket-edge'),
       )
 
@@ -184,7 +188,7 @@ export const makeWebSocketEdge = ({
         schema,
         supportsTransferables: false,
         shutdown: Scope.close(scope, Exit.void),
-        debugInfo,
+        ...(debugInfo !== undefined ? { debugInfo } : {}),
       } satisfies WebChannel.WebChannel<typeof WebmeshSchema.Packet.Type, typeof WebmeshSchema.Packet.Type>
 
       return { webChannel, from }

package/src/worker/mod.ts

@@ -0,0 +1,89 @@
+import { LS_DEV } from '@livestore/utils'
+import { Context, Deferred, Effect, Layer, Queue, Stream, WebChannel } from '@livestore/utils/effect'
+
+import * as WebmeshSchema from '../mesh-schema.ts'
+import type { MeshNode } from '../node.ts'
+import { makeMeshNode } from '../node.ts'
+import * as WorkerSchema from './schema.ts'
+
+export * as Schema from './schema.ts'
+
+declare global {
+  var __debugWebmeshNode: any
+}
+
+export class CacheService extends Context.Service<CacheService, { node: MeshNode }>()(
+  '@livestore/webmesh:worker:CacheService',
+) {
+  static layer = ({ nodeName }: { nodeName: string }) =>
+    Effect.gen(function* () {
+      const node = yield* makeMeshNode(nodeName)
+
+      globalThis.__debugWebmeshNode = node
+
+      return CacheService.of({ node })
+    }).pipe(Layer.effect(CacheService))
+}
+
+export const CreateConnection = ({ from, port }: typeof WorkerSchema.CreateConnection.Type) =>
+  Stream.callback<{}, never, CacheService>((emit) =>
+    Effect.gen(function* () {
+      const { node } = yield* CacheService
+
+      const messagePortChannel = yield* WebChannel.messagePortChannel({ port, schema: WebmeshSchema.Packet })
+
+      yield* node.addEdge({ target: from, edgeChannel: messagePortChannel, replaceIfExists: true })
+
+      if (LS_DEV === true) {
+        yield* Effect.logDebug(`@livestore/webmesh:worker: accepted edge: ${node.nodeName} <- ${from}`)
+      }
+
+      // `Stream.callback` exposes a queue-like emitter in Effect v4. Emit the single success value
+      // and then end the stream to preserve the old one-response worker command behavior.
+      yield* Queue.offer(emit, {})
+      yield* Queue.end(emit)
+
+      yield* Effect.spanEvent({ connectedTo: [...node.edgeKeys] })
+    }).pipe(Effect.orDie),
+  ).pipe(Stream.withSpan(`@livestore/webmesh:worker:create-connection:${from}`))
+
+export const connectViaWorker = ({
+  node,
+  target,
+  worker,
+}: {
+  node: MeshNode
+  target: string
+  // Effect v4 removed the serialized worker pool type this package used to reference. Webmesh only
+  // needs this structural `execute` contract; adapter code can provide any compatible pool.
+  worker: { execute: (request: typeof WorkerSchema.Request.Type) => Stream.Stream<{}> }
+}) =>
+  Effect.gen(function* () {
+    const mc = new MessageChannel()
+
+    const isConnected = yield* Deferred.make<boolean>()
+
+    if (LS_DEV === true) {
+      yield* Effect.addFinalizerLog(`@livestore/webmesh:worker: closing message channel ${node.nodeName} -> ${target}`)
+    }
+
+    yield* worker.execute(WorkerSchema.CreateConnection.make({ from: node.nodeName, port: mc.port1 })).pipe(
+      Stream.tap(() => Deferred.succeed(isConnected, true)),
+      Stream.runDrain,
+      Effect.tapCauseLogPretty,
+      Effect.forkScoped,
+    )
+
+    yield* Deferred.await(isConnected)
+
+    const workerConnection = yield* WebChannel.messagePortChannel({
+      port: mc.port2,
+      schema: WebmeshSchema.Packet,
+    })
+
+    yield* node.addEdge({ target, edgeChannel: workerConnection, replaceIfExists: true })
+
+    if (LS_DEV === true) {
+      yield* Effect.logDebug(`@livestore/webmesh:worker: initiated connection: ${node.nodeName} -> ${target}`)
+    }
+  })

package/src/worker/schema.ts

@@ -0,0 +1,8 @@
+import { Schema, Transferable } from '@livestore/utils/effect'
+
+export const CreateConnection = Schema.TaggedStruct('WebmeshWorker.CreateConnection', {
+  from: Schema.String,
+  port: Transferable.MessagePort,
+})
+
+export const Request = Schema.Union([CreateConnection])