@effect/platform 0.37.1 → 0.37.2

package/src/internal/worker.ts

@@ -12,6 +12,8 @@ import { identity, pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Pool from "effect/Pool"
 import * as Queue from "effect/Queue"
+import * as ReadonlyArray from "effect/ReadonlyArray"
+import * as Schedule from "effect/Schedule"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Transferable from "../Transferable.js"
@@ -66,18 +68,60 @@ export const makeManager = Effect.gen(function*(_) {
       return Effect.gen(function*(_) {
         const id = idCounter++
         let requestIdCounter = 0
-        const readyLatch = yield* _(Deferred.make<never, void>())
         const semaphore = yield* _(Effect.makeSemaphore(permits))
         const requestMap = new Map<
           number,
-          readonly [Queue.Queue<Exit.Exit<E | WorkerError, O>>, Deferred.Deferred<never, void>]
+          readonly [Queue.Queue<Exit.Exit<E | WorkerError, ReadonlyArray<O>>>, Deferred.Deferred<never, void>]
         >()
+        const sendQueue = yield* _(Effect.acquireRelease(
+          Queue.unbounded<readonly [message: Worker.Worker.Request, transfers?: ReadonlyArray<unknown>]>(),
+          Queue.shutdown
+        ))
 
         const outbound = queue ?? (yield* _(defaultQueue<I>()))
         yield* _(Effect.addFinalizer(() => outbound.shutdown))
 
-        const backing = yield* _(
-          platform.spawn<Worker.Worker.Request, Worker.Worker.Response<E, O>>(spawn(id))
+        yield* _(
+          Effect.gen(function*(_) {
+            const readyLatch = yield* _(Deferred.make<never, void>())
+            const backing = yield* _(
+              platform.spawn<Worker.Worker.Request, Worker.Worker.Response<E, O>>(spawn(id))
+            )
+            const send = pipe(
+              sendQueue.take,
+              Effect.flatMap(([message, transfers]) => backing.send(message, transfers)),
+              Effect.forever
+            )
+            const take = pipe(
+              Queue.take(backing.queue),
+              Effect.flatMap((msg) => {
+                if (msg[0] === 0) {
+                  return Deferred.complete(readyLatch, Effect.unit)
+                }
+                return handleMessage(msg[1])
+              }),
+              Effect.forever
+            )
+            return yield* _(Effect.all([
+              Fiber.join(backing.fiber),
+              Effect.zipRight(Deferred.await(readyLatch), send),
+              take
+            ], { concurrency: "unbounded" }))
+          }),
+          Effect.scoped,
+          Effect.onError((cause) =>
+            Effect.forEach(requestMap.values(), ([queue]) => Queue.offer(queue, Exit.failCause(cause)))
+          ),
+          Effect.retry(
+            Schedule.exponential("250 millis").pipe(
+              Schedule.union(Schedule.spaced("30 seconds"))
+            )
+          ),
+          Effect.annotateLogs({
+            package: "@effect/platform",
+            module: "Worker"
+          }),
+          Effect.forkScoped
         )
 
         yield* _(Effect.addFinalizer(() =>
@@ -89,42 +133,34 @@ export const makeManager = Effect.gen(function*(_) {
           )
         ))
 
-        const handleMessage = (msg: Worker.BackingWorker.Message<Worker.Worker.Response<E, O>>) =>
+        const handleMessage = (response: Worker.Worker.Response<E, O>) =>
           Effect.suspend(() => {
-            switch (msg[0]) {
+            const queue = requestMap.get(response[0])
+            if (!queue) return Effect.unit
+
+            switch (response[1]) {
+              // data
               case 0: {
-                return Deferred.complete(readyLatch, Effect.unit)
+                return Queue.offer(queue[0], Exit.succeed(response[2]))
               }
+              // end
               case 1: {
-                const response = msg[1]
-                const queue = requestMap.get(response[0])
-                if (!queue) return Effect.unit
-
-                switch (response[1]) {
-                  // data
-                  case 0: {
-                    return Queue.offer(queue[0], Exit.succeed(response[2]))
-                  }
-                  // end
-                  case 1: {
-                    return response.length === 2 ?
-                      Queue.offer(queue[0], Exit.failCause(Cause.empty)) :
-                      Effect.zipRight(
-                        Queue.offer(queue[0], Exit.succeed(response[2])),
-                        Queue.offer(queue[0], Exit.failCause(Cause.empty))
-                      )
-                  }
-                  // error / defect
-                  case 2:
-                  case 3: {
-                    return Queue.offer(
-                      queue[0],
-                      response[1] === 2
-                        ? Exit.fail(response[2])
-                        : Exit.die(response[2])
-                    )
-                  }
-                }
+                return response.length === 2 ?
+                  Queue.offer(queue[0], Exit.failCause(Cause.empty)) :
+                  Effect.zipRight(
+                    Queue.offer(queue[0], Exit.succeed(response[2])),
+                    Queue.offer(queue[0], Exit.failCause(Cause.empty))
+                  )
+              }
+              // error / defect
+              case 2:
+              case 3: {
+                return Queue.offer(
+                  queue[0],
+                  response[1] === 2
+                    ? Exit.fail(response[2])
+                    : Exit.die(response[2])
+                )
               }
             }
           })
@@ -133,7 +169,7 @@ export const makeManager = Effect.gen(function*(_) {
           Effect.tap(
             Effect.all([
               Effect.sync(() => requestIdCounter++),
-              Queue.unbounded<Exit.Exit<E | WorkerError, O>>(),
+              Queue.unbounded<Exit.Exit<E | WorkerError, ReadonlyArray<O>>>(),
               Deferred.make<never, void>()
             ]),
             ([id, queue, deferred]) =>
@@ -144,7 +180,11 @@ export const makeManager = Effect.gen(function*(_) {
           )
 
         const executeRelease = (
-          [id, , deferred]: [number, Queue.Queue<Exit.Exit<E | WorkerError, O>>, Deferred.Deferred<never, void>],
+          [id, , deferred]: [
+            number,
+            Queue.Queue<Exit.Exit<E | WorkerError, ReadonlyArray<O>>>,
+            Deferred.Deferred<never, void>
+          ],
           exit: Exit.Exit<unknown, unknown>
         ) => {
           const release = Effect.zipRight(
@@ -152,10 +192,7 @@ export const makeManager = Effect.gen(function*(_) {
             Effect.sync(() => requestMap.delete(id))
           )
           return Exit.isInterrupted(exit) ?
-            Effect.zipRight(
-              Effect.ignore(backing.send([id, 1])),
-              release
-            ) :
+            Effect.zipRight(sendQueue.offer([[id, 1]]), release) :
             release
         }
 
@@ -171,7 +208,7 @@ export const makeManager = Effect.gen(function*(_) {
                   Queue.take(queue),
                   Exit.match({
                     onFailure: (cause) => Cause.isEmpty(cause) ? Channel.unit : Channel.failCause(cause),
-                    onSuccess: (value) => Channel.flatMap(Channel.write(Chunk.of(value)), () => loop)
+                    onSuccess: (value) => Channel.flatMap(Channel.write(Chunk.unsafeFromArray(value)), () => loop)
                   })
                 )
               return Stream.fromChannel(loop)
@@ -181,18 +218,11 @@ export const makeManager = Effect.gen(function*(_) {
         const executeEffect = (request: I) =>
           Effect.acquireUseRelease(
             executeAcquire(request),
-            ([, queue]) => Effect.flatten(Queue.take(queue)),
+            ([, queue]) => Effect.flatMap(Queue.take(queue), Exit.map(ReadonlyArray.unsafeGet(0))),
             executeRelease
           )
 
-        const handleMessages = yield* _(
-          Queue.take(backing.queue),
-          Effect.flatMap(handleMessage),
-          Effect.forever,
-          Effect.forkScoped
-        )
-
-        const postMessages = pipe(
+        yield* _(
           semaphore.take(1),
           Effect.zipRight(outbound.take),
           Effect.flatMap(([id, request]) =>
@@ -204,7 +234,7 @@ export const makeManager = Effect.gen(function*(_) {
                 return pipe(
                   Effect.flatMap(
                     encode ? encode(request) : Effect.succeed(request),
-                    (payload) => backing.send([id, 0, payload], transferables)
+                    (payload) => sendQueue.offer([[id, 0, payload], transferables])
                   ),
                   Effect.catchAllCause((cause) => Queue.offer(result[0], Exit.failCause(cause))),
                   Effect.zipRight(Deferred.await(result[1]))
@@ -214,21 +244,10 @@ export const makeManager = Effect.gen(function*(_) {
               Effect.fork
             )
           ),
-          Effect.forever
-        )
-
-        const postMessagesFiber = yield* _(
-          Deferred.await(readyLatch),
-          Effect.zipRight(postMessages),
+          Effect.forever,
           Effect.forkScoped
         )
 
-        const join = Fiber.joinAll([backing.fiber, handleMessages, postMessagesFiber]) as Effect.Effect<
-          never,
-          WorkerError,
-          never
-        >
-
         if (initialMessage) {
           yield* _(
             Effect.sync(initialMessage),
@@ -237,7 +256,7 @@ export const makeManager = Effect.gen(function*(_) {
           )
         }
 
-        return { id, join, execute, executeEffect }
+        return { id, execute, executeEffect }
       }).pipe(Effect.parallelFinalizers)
     }
   })
@@ -343,7 +362,6 @@ export const makeSerialized = <
     }
     return identity<Worker.SerializedWorker<I>>({
       id: backing.id,
-      join: backing.join,
       execute: execute as any,
       executeEffect: executeEffect as any
     })

package/src/internal/workerRunner.ts

@@ -1,11 +1,14 @@
 import * as Schema from "@effect/schema/Schema"
 import * as Serializable from "@effect/schema/Serializable"
 import * as Cause from "effect/Cause"
+import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import * as Fiber from "effect/Fiber"
 import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
@@ -34,8 +37,9 @@ export const make = <I, R, E, O>(
     const platform = yield* _(PlatformRunner)
     const backing = yield* _(platform.start<Worker.Worker.Request<I>, Worker.Worker.Response<E>>())
     const fiberMap = new Map<number, Fiber.Fiber<never, void>>()
+    const parentFiber = Option.getOrThrow(Fiber.getCurrentFiber())
 
-    const handleRequests = pipe(
+    yield* _(
       Queue.take(backing.queue),
       Effect.tap((req) => {
         const id = req[0]
@@ -65,17 +69,29 @@ export const make = <I, R, E, O>(
               const transfers = options?.transfers ? options.transfers(data) : undefined
               return pipe(
                 options?.encodeOutput ? options.encodeOutput(data) : Effect.succeed(data),
-                Effect.flatMap((payload) => backing.send([id, 0, payload], transfers)),
+                Effect.flatMap((payload) => backing.send([id, 0, [payload]], transfers)),
                 Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
               )
             }
           }) :
           pipe(
             stream,
+            Stream.chunks,
             Stream.tap((data) => {
-              const transfers = options?.transfers ? options.transfers(data) : undefined
+              if (options?.encodeOutput === undefined) {
+                const payload = Chunk.toReadonlyArray(data)
+                const transfers = options?.transfers ? payload.flatMap(options.transfers) : undefined
+                return backing.send([id, 0, payload], transfers)
+              }
+
+              const transfers: Array<unknown> = []
               return Effect.flatMap(
-                options?.encodeOutput ? Effect.orDie(options.encodeOutput(data)) : Effect.succeed(data),
+                Effect.forEach(data, (data) => {
+                  if (options?.transfers) {
+                    transfers.push(...options.transfers(data))
+                  }
+                  return Effect.orDie(options.encodeOutput!(data))
+                }),
                 (payload) => backing.send([id, 0, payload], transfers)
               )
             }),
@@ -104,17 +120,19 @@ export const make = <I, R, E, O>(
           Effect.tap((fiber) => Effect.sync(() => fiberMap.set(id, fiber)))
         )
       }),
-      Effect.forever
-    )
-
-    return yield* _(
-      Effect.all([
-        handleRequests,
-        Fiber.join(backing.fiber)
-      ], { concurrency: "unbounded", discard: true }) as Effect.Effect<R, WorkerError.WorkerError, never>
+      Effect.forever,
+      Effect.onInterrupt(() => Fiber.interrupt(parentFiber)),
+      Effect.forkScoped
     )
   })
 
+/** @internal */
+export const layer = <I, R, E, O>(
+  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
+  options?: WorkerRunner.Runner.Options<E, O>
+): Layer.Layer<WorkerRunner.PlatformRunner | R, WorkerError.WorkerError, never> =>
+  Layer.scopedDiscard(make(process, options))
+
 /** @internal */
 export const makeSerialized = <
   I,
@@ -133,7 +151,7 @@ export const makeSerialized = <
   | Scope.Scope
   | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
   WorkerError.WorkerError,
-  never
+  void
 > => {
   const parseRequest = Schema.decode(schema)
   const effectTags = new Set<string>()
@@ -178,3 +196,23 @@ export const makeSerialized = <
     }
   })
 }
+
+/** @internal */
+export const layerSerialized = <
+  I,
+  A extends Schema.TaggedRequest.Any,
+  const Handlers extends {
+    readonly [K in A["_tag"]]: Extract<A, { readonly _tag: K }> extends
+      Serializable.SerializableWithResult<infer _IS, infer S, infer _IE, infer E, infer _IO, infer O>
+      ? (_: S) => Stream.Stream<any, E, O> | Effect.Effect<any, E, O> :
+      never
+  }
+>(
+  schema: Schema.Schema<I, A>,
+  handlers: Handlers
+): Layer.Layer<
+  | WorkerRunner.PlatformRunner
+  | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
+  WorkerError.WorkerError,
+  never
+> => Layer.scopedDiscard(makeSerialized(schema, handlers))