@effect/platform 0.37.1 → 0.37.3

package/src/WorkerRunner.ts

@@ -5,7 +5,7 @@ import type * as Schema from "@effect/schema/Schema"
 import type * as Serializable from "@effect/schema/Serializable"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
-import type * as Fiber from "effect/Fiber"
+import type * as Layer from "effect/Layer"
 import type * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
@@ -17,7 +17,6 @@ import type { WorkerError } from "./WorkerError.js"
  * @category models
  */
 export interface BackingRunner<I, O> {
-  readonly fiber: Fiber.Fiber<WorkerError, never>
   readonly queue: Queue.Dequeue<I>
   readonly send: (message: O, transfers?: ReadonlyArray<unknown>) => Effect.Effect<never, never, void>
 }
@@ -70,9 +69,10 @@ export declare namespace Runner {
    * @since 1.0.0
    * @category models
    */
-  export interface Options<E, O> {
-    readonly encodeOutput?: (message: O) => Effect.Effect<never, WorkerError, unknown>
-    readonly encodeError?: (message: E) => Effect.Effect<never, WorkerError, unknown>
+  export interface Options<I, E, O> {
+    readonly decode?: (message: unknown) => Effect.Effect<never, WorkerError, I>
+    readonly encodeOutput?: (request: I, message: O) => Effect.Effect<never, WorkerError, unknown>
+    readonly encodeError?: (request: I, error: E) => Effect.Effect<never, WorkerError, unknown>
     readonly transfers?: (message: O | E) => ReadonlyArray<unknown>
   }
 }
@@ -83,8 +83,17 @@ export declare namespace Runner {
  */
 export const make: <I, R, E, O>(
   process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
-  options?: Runner.Options<E, O> | undefined
-) => Effect.Effect<Scope.Scope | R | PlatformRunner, WorkerError, never> = internal.make
+  options?: Runner.Options<I, E, O> | undefined
+) => Effect.Effect<Scope.Scope | R | PlatformRunner, WorkerError, void> = internal.make
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: <I, R, E, O>(
+  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
+  options?: Runner.Options<I, E, O> | undefined
+) => Layer.Layer<R | PlatformRunner, WorkerError, never> = internal.layer
 
 /**
  * @since 1.0.0
@@ -93,7 +102,7 @@ export const make: <I, R, E, O>(
 export const makeSerialized: <
   I,
   A extends Schema.TaggedRequest.Any,
-  Handlers extends {
+  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> :
@@ -107,5 +116,28 @@ export const makeSerialized: <
   | Scope.Scope
   | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
   WorkerError,
-  never
+  void
 > = internal.makeSerialized
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+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<
+  | PlatformRunner
+  | (ReturnType<Handlers[keyof Handlers]> extends Stream.Stream<infer R, infer _E, infer _A> ? R : never),
+  WorkerError,
+  never
+> = internal.layerSerialized

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,18 +1,20 @@
 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 Predicate from "effect/Predicate"
+import { identity, pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
 import * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Transferable from "../Transferable.js"
 import type * as Worker from "../Worker.js"
-import type * as WorkerError from "../WorkerError.js"
+import * as WorkerError from "../WorkerError.js"
 import type * as WorkerRunner from "../WorkerRunner.js"
 
 /** @internal */
@@ -28,15 +30,25 @@ export const PlatformRunner = Context.Tag<WorkerRunner.PlatformRunner>(
 /** @internal */
 export const make = <I, R, E, O>(
   process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
-  options?: WorkerRunner.Runner.Options<E, O>
+  options?: WorkerRunner.Runner.Options<I, E, O>
 ) =>
   Effect.gen(function*(_) {
     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),
+      options?.decode ?
+        Effect.flatMap((req): Effect.Effect<never, WorkerError.WorkerError, Worker.Worker.Request<I>> => {
+          if (req[1] === 1) {
+            return Effect.succeed(req)
+          }
+
+          return Effect.map(options.decode!(req[2]), (data) => [req[0], req[1], data])
+        }) :
+        identity,
       Effect.tap((req) => {
         const id = req[0]
         if (req[1] === 1) {
@@ -54,7 +66,7 @@ export const make = <I, R, E, O>(
                 onLeft: (error) => {
                   const transfers = options?.transfers ? options.transfers(error) : undefined
                   return pipe(
-                    options?.encodeError ? options.encodeError(error) : Effect.succeed(error),
+                    options?.encodeError ? options.encodeError(req[2], error) : Effect.succeed(error),
                     Effect.flatMap((payload) => backing.send([id, 2, payload as any], transfers)),
                     Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
                   )
@@ -64,18 +76,30 @@ export const make = <I, R, E, O>(
             onSuccess: (data) => {
               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)),
+                options?.encodeOutput ? options.encodeOutput(req[2], data) : Effect.succeed(data),
+                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!(req[2], data))
+                }),
                 (payload) => backing.send([id, 0, payload], transfers)
               )
             }),
@@ -86,7 +110,7 @@ export const make = <I, R, E, O>(
                   onLeft: (error) => {
                     const transfers = options?.transfers ? options.transfers(error) : undefined
                     return pipe(
-                      options?.encodeError ? options.encodeError(error) : Effect.succeed(error),
+                      options?.encodeError ? options.encodeError(req[2], error) : Effect.succeed(error),
                       Effect.flatMap((payload) => backing.send([id, 2, payload as any], transfers)),
                       Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
                     )
@@ -104,17 +128,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<I, E, O>
+): Layer.Layer<WorkerRunner.PlatformRunner | R, WorkerError.WorkerError, never> =>
+  Layer.scopedDiscard(make(process, options))
+
 /** @internal */
 export const makeSerialized = <
   I,
@@ -133,48 +159,50 @@ 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>()
-  return make((request: I) => {
-    if (Predicate.hasProperty(request, "_tag") && effectTags.has(request._tag as string)) {
-      return Effect.flatMap(parseRequest(request), (request: A) => {
-        const handler =
-          (handlers as unknown as Record<string, (req: unknown) => Effect.Effect<never, any, any>>)[request._tag]
-        if (!handler) {
-          return Effect.dieMessage(`No handler for ${request._tag}`)
-        }
-        const encodeSuccess = Schema.encode(Serializable.successSchema(request as any))
-        return pipe(
-          Effect.matchEffect(handler(request), {
-            onFailure: (error) => Effect.flatMap(Serializable.serializeFailure(request as any, error), Effect.fail),
-            onSuccess: encodeSuccess
-          })
-        )
-      })
-    }
-
-    return Stream.flatMap(parseRequest(request), (request: A) => {
-      const handler =
-        (handlers as unknown as Record<string, (req: unknown) => Stream.Stream<never, any, any>>)[request._tag]
-      if (!handler) {
-        return Stream.dieMessage(`No handler for ${request._tag}`)
-      }
-      const encodeSuccess = Schema.encode(Serializable.successSchema(request as any))
-      const stream = handler(request)
-      if (Effect.isEffect(stream)) {
-        effectTags.add(request._tag)
-      }
-      return pipe(
-        stream,
-        Stream.catchAll((error) => Effect.flatMap(Serializable.serializeFailure(request as any, error), Effect.fail)),
-        Stream.mapEffect(encodeSuccess)
-      )
-    })
-  }, {
+  const parseRequest = Schema.parse(schema)
+  return make((request: A) => (handlers as any)[request._tag](request), {
     transfers(message) {
       return Transferable.get(message)
+    },
+    decode(message) {
+      return Effect.mapError(
+        parseRequest(message),
+        (error) => WorkerError.WorkerError("decode", error)
+      )
+    },
+    encodeError(request, message) {
+      return Effect.mapError(
+        Serializable.serializeFailure(request as any, message),
+        (error) => WorkerError.WorkerError("encode", error)
+      )
+    },
+    encodeOutput(request, message) {
+      return Effect.mapError(
+        Serializable.serializeSuccess(request as any, message),
+        (error) => WorkerError.WorkerError("encode", error)
+      )
     }
   })
 }
+
+/** @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))