@effect/platform 0.22.0 → 0.22.1

package/src/Worker.ts

@@ -0,0 +1,207 @@
+/**
+ * @since 1.0.0
+ */
+import type { Effect } from "effect"
+import type * as Context from "effect/Context"
+import type * as Duration from "effect/Duration"
+import type * as Layer from "effect/Layer"
+import type * as Pool from "effect/Pool"
+import type * as Queue from "effect/Queue"
+import type * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
+import * as internal from "./internal/worker"
+import type { WorkerError } from "./WorkerError"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface BackingWorker<I, O> {
+  readonly join: Effect.Effect<never, WorkerError, never>
+  readonly send: (message: I, transfers?: ReadonlyArray<unknown>) => Effect.Effect<never, never, void>
+  readonly queue: Queue.Dequeue<BackingWorker.Message<O>>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace BackingWorker {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Message<O> = readonly [ready: 0] | readonly [data: 1, O]
+}
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const PlatformWorkerTypeId: unique symbol = internal.PlatformWorkerTypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type PlatformWorkerTypeId = typeof PlatformWorkerTypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface PlatformWorker {
+  readonly [PlatformWorkerTypeId]: PlatformWorkerTypeId
+  readonly spawn: <I, O>(worker: unknown) => Effect.Effect<Scope.Scope, WorkerError, BackingWorker<I, O>>
+}
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const PlatformWorker: Context.Tag<PlatformWorker, PlatformWorker> = internal.PlatformWorker
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Worker<I, E, O> {
+  readonly id: number
+  readonly join: Effect.Effect<never, WorkerError, never>
+  readonly execute: (message: I) => Stream.Stream<never, E, O>
+  readonly executeEffect: (message: I) => Effect.Effect<never, E, O>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace Worker {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Options<I, W = unknown> {
+    readonly spawn: (id: number) => W
+    readonly transfers?: (message: I) => ReadonlyArray<unknown>
+    readonly permits?: number
+    readonly queue?: WorkerQueue<I>
+  }
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Request<I> = readonly [id: number, data: 0, I] | readonly [id: number, interrupt: 1]
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Response<E, O> =
+    | readonly [id: number, data: 0, O]
+    | readonly [id: number, end: 1]
+    | readonly [id: number, end: 1, O]
+    | readonly [id: number, error: 2, E]
+    | readonly [id: number, defect: 3, unknown]
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface WorkerPool<I, E, O> {
+  readonly backing: Pool.Pool<WorkerError, Worker<I, E, O>>
+  readonly execute: (message: I) => Stream.Stream<never, E | WorkerError, O>
+  readonly executeEffect: (message: I) => Effect.Effect<never, E | WorkerError, O>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace WorkerPool {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Options<I, W = unknown> =
+    & Worker.Options<I, W>
+    & ({
+      readonly size: number
+    } | {
+      readonly minSize: number
+      readonly maxSize: number
+      readonly timeToLive: Duration.DurationInput
+    })
+}
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface WorkerQueue<I> {
+  readonly offer: (id: number, item: I) => Effect.Effect<never, never, void>
+  readonly take: Effect.Effect<never, never, readonly [id: number, item: I]>
+  readonly shutdown: Effect.Effect<never, never, void>
+}
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const WorkerManagerTypeId: unique symbol = internal.WorkerManagerTypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type WorkerManagerTypeId = typeof WorkerManagerTypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface WorkerManager {
+  readonly [WorkerManagerTypeId]: WorkerManagerTypeId
+  readonly spawn: <I, E, O>(
+    options: Worker.Options<I>
+  ) => Effect.Effect<Scope.Scope, WorkerError, Worker<I, E, O>>
+}
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const WorkerManager: Context.Tag<WorkerManager, WorkerManager> = internal.WorkerManager
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeManager: Effect.Effect<PlatformWorker, never, WorkerManager> = internal.makeManager
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerManager: Layer.Layer<PlatformWorker, never, WorkerManager> = internal.layerManager
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePool: <W>() => <I, E, O>(
+  options: WorkerPool.Options<I, W>
+) => Effect.Effect<WorkerManager | Scope.Scope, never, WorkerPool<I, E, O>> = internal.makePool
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePoolLayer: <W>(
+  managerLayer: Layer.Layer<never, never, WorkerManager>
+) => <Tag, I, E, O>(
+  tag: Context.Tag<Tag, WorkerPool<I, E, O>>,
+  options: WorkerPool.Options<I, W>
+) => Layer.Layer<never, never, Tag> = internal.makePoolLayer

package/src/WorkerError.ts

@@ -0,0 +1,34 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Data from "effect/Data"
+import * as internal from "./internal/workerError"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const WorkerErrorTypeId: unique symbol = internal.WorkerErrorTypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type WorkerErrorTypeId = typeof WorkerErrorTypeId
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export interface WorkerError extends Data.Case {
+  readonly [WorkerErrorTypeId]: WorkerErrorTypeId
+  readonly _tag: "WorkerError"
+  readonly reason: "spawn" | "decode" | "unknown"
+  readonly error: unknown
+}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export const WorkerError: (reason: "spawn" | "decode" | "unknown", error: unknown) => WorkerError = internal.WorkerError

package/src/WorkerRunner.ts

@@ -0,0 +1,83 @@
+/**
+ * @since 1.0.0
+ */
+import type { Effect } from "effect"
+import type * as Context from "effect/Context"
+import type * as Fiber from "effect/Fiber"
+import type * as Queue from "effect/Queue"
+import type * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
+import * as internal from "./internal/workerRunner"
+import type { WorkerError } from "./WorkerError"
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface BackingRunner<I, O> {
+  readonly fiber: Fiber.Fiber<WorkerError, void>
+  readonly queue: Queue.Dequeue<I>
+  readonly send: (message: O, transfers?: ReadonlyArray<unknown>) => Effect.Effect<never, never, void>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace BackingRunner {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Message<I> = readonly [request: 0, I] | readonly [close: 1]
+}
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const PlatformRunnerTypeId: unique symbol = internal.PlatformRunnerTypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type PlatformRunnerTypeId = typeof PlatformRunnerTypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface PlatformRunner {
+  readonly [PlatformRunnerTypeId]: PlatformRunnerTypeId
+  readonly start: <I, O>() => Effect.Effect<Scope.Scope, WorkerError, BackingRunner<I, O>>
+}
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const PlatformRunner: Context.Tag<PlatformRunner, PlatformRunner> = internal.PlatformRunner
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace Runner {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Options<O> {
+    readonly transfers?: (message: O) => ReadonlyArray<unknown>
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: <I, R, E, O>(
+  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
+  options?: Runner.Options<O> | undefined
+) => Effect.Effect<Scope.Scope | R | PlatformRunner, WorkerError, void> = internal.make

package/src/index.ts

@@ -47,3 +47,18 @@ export * as Path from "@effect/platform/Path"
  * @since 1.0.0
  */
 export * as Runtime from "@effect/platform/Runtime"
+
+/**
+ * @since 1.0.0
+ */
+export * as Worker from "@effect/platform/Worker"
+
+/**
+ * @since 1.0.0
+ */
+export * as WorkerError from "@effect/platform/WorkerError"
+
+/**
+ * @since 1.0.0
+ */
+export * as WorkerRunner from "@effect/platform/WorkerRunner"

package/src/internal/worker.ts

@@ -0,0 +1,262 @@
+import * as Context from "effect/Context"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Pool from "effect/Pool"
+import * as Queue from "effect/Queue"
+import * as Stream from "effect/Stream"
+import type * as Worker from "../Worker"
+import type { WorkerError } from "../WorkerError"
+
+/** @internal */
+export const defaultQueue = <I>() =>
+  Effect.map(
+    Queue.unbounded<readonly [id: number, item: I]>(),
+    (queue): Worker.WorkerQueue<I> => ({
+      offer: (id, item) => Queue.offer(queue, [id, item]),
+      take: Queue.take(queue),
+      shutdown: Queue.shutdown(queue)
+    })
+  )
+
+/** @internal */
+export const PlatformWorkerTypeId: Worker.PlatformWorkerTypeId = Symbol.for(
+  "@effect/platform/Worker/PlatformWorker"
+) as Worker.PlatformWorkerTypeId
+
+/** @internal */
+export const PlatformWorker = Context.Tag<Worker.PlatformWorker>(
+  PlatformWorkerTypeId
+)
+
+/** @internal */
+export const WorkerManagerTypeId: Worker.WorkerManagerTypeId = Symbol.for(
+  "@effect/platform/Worker/WorkerManager"
+) as Worker.WorkerManagerTypeId
+
+/** @internal */
+export const WorkerManager = Context.Tag<Worker.WorkerManager>(
+  WorkerManagerTypeId
+)
+
+/** @internal */
+export const makeManager = Effect.gen(function*(_) {
+  const platform = yield* _(PlatformWorker)
+  let idCounter = 0
+  return WorkerManager.of({
+    [WorkerManagerTypeId]: WorkerManagerTypeId,
+    spawn<I, E, O>({ permits = 1, queue, spawn, transfers = (_) => [] }: Worker.Worker.Options<I>) {
+      return Effect.gen(function*(_) {
+        const id = idCounter++
+        const fiberId = yield* _(Effect.fiberId)
+        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, O>>, Deferred.Deferred<never, void>]>()
+
+        const outbound = queue ?? (yield* _(defaultQueue<I>()))
+        yield* _(Effect.addFinalizer(() => outbound.shutdown))
+
+        const backing = yield* _(
+          platform.spawn<Worker.Worker.Request<I>, Worker.Worker.Response<E, O>>(spawn(id))
+        )
+
+        yield* _(Effect.addFinalizer(() =>
+          Effect.zipRight(
+            Effect.forEach(requestMap.values(), ([queue]) => Queue.shutdown(queue), { discard: true }),
+            Effect.sync(() => requestMap.clear())
+          )
+        ))
+
+        const handleMessage = (msg: Worker.BackingWorker.Message<Worker.Worker.Response<E, O>>) =>
+          Effect.suspend(() => {
+            switch (msg[0]) {
+              case 0: {
+                return Deferred.complete(readyLatch, Effect.unit)
+              }
+              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.shutdown(queue[0]) :
+                      Effect.zipRight(
+                        Queue.offer(queue[0], Exit.succeed(response[2])),
+                        Queue.shutdown(queue[0])
+                      )
+                  }
+                  // error / defect
+                  case 2:
+                  case 3: {
+                    return Effect.zipRight(
+                      Queue.offer(
+                        queue[0],
+                        response[1] === 2
+                          ? Exit.fail(response[2])
+                          : Exit.die(response[2])
+                      ),
+                      Queue.shutdown(queue[0])
+                    )
+                  }
+                }
+              }
+            }
+          })
+
+        const executeAcquire = (request: I) =>
+          Effect.tap(
+            Effect.all([
+              Effect.sync(() => requestIdCounter++),
+              Queue.unbounded<Exit.Exit<E, O>>(),
+              Deferred.make<never, void>()
+            ]),
+            ([id, queue, deferred]) =>
+              Effect.suspend(() => {
+                requestMap.set(id, [queue, deferred])
+                return outbound.offer(id, request)
+              })
+          )
+
+        const executeRelease = (
+          [id, , deferred]: [number, Queue.Queue<Exit.Exit<E, O>>, Deferred.Deferred<never, void>],
+          exit: Exit.Exit<unknown, unknown>
+        ) => {
+          const release = Effect.zipRight(
+            Deferred.complete(deferred, Effect.unit),
+            Effect.sync(() => requestMap.delete(id))
+          )
+          return Exit.isInterrupted(exit) ?
+            Effect.zipRight(
+              backing.send([id, 1]),
+              release
+            ) :
+            release
+        }
+
+        const execute = (request: I) =>
+          Stream.flatMap(
+            Stream.acquireRelease(
+              executeAcquire(request),
+              executeRelease
+            ),
+            ([, queue]) => Stream.flatten(Stream.fromQueue(queue))
+          )
+
+        const executeEffect = (request: I) =>
+          Effect.acquireUseRelease(
+            executeAcquire(request),
+            ([, queue]) => Effect.flatten(Queue.take(queue)),
+            executeRelease
+          )
+
+        const handleMessages = yield* _(
+          Queue.take(backing.queue),
+          Effect.flatMap(handleMessage),
+          Effect.forever,
+          Effect.forkDaemon
+        )
+        yield* _(Effect.addFinalizer(() => handleMessages.interruptAsFork(fiberId)))
+
+        const postMessages = yield* _(
+          semaphore.take(1),
+          Effect.zipRight(outbound.take),
+          Effect.flatMap(([id, request]) =>
+            pipe(
+              Effect.suspend(() => {
+                const result = requestMap.get(id)
+                if (!result) return Effect.unit
+                const transferables = transfers(request)
+                return Effect.zipRight(
+                  backing.send([id, 0, request], transferables),
+                  Deferred.await(result[1])
+                )
+              }),
+              Effect.ensuring(semaphore.release(1)),
+              Effect.fork
+            )
+          ),
+          Effect.forever,
+          Effect.forkDaemon
+        )
+        yield* _(Effect.addFinalizer(() => postMessages.interruptAsFork(fiberId)))
+
+        const join = Effect.race(
+          Fiber.joinAll([
+            handleMessages,
+            postMessages
+          ]),
+          backing.join
+        ) as Effect.Effect<never, WorkerError, never>
+
+        return { id, join, execute, executeEffect }
+      })
+    }
+  })
+})
+
+/** @internal */
+export const layerManager = Layer.effect(WorkerManager, makeManager)
+
+/** @internal */
+export const makePool = <W>() =>
+<I, E, O>(
+  options: Worker.WorkerPool.Options<I, W>
+) =>
+  Effect.gen(function*(_) {
+    const manager = yield* _(WorkerManager)
+    const backing = yield* _(
+      "timeToLive" in options ?
+        Pool.makeWithTTL({
+          acquire: manager.spawn<I, E, O>(options),
+          min: options.minSize,
+          max: options.maxSize,
+          timeToLive: options.timeToLive
+        }) :
+        Pool.make({
+          acquire: manager.spawn<I, E, O>(options),
+          size: options.size
+        })
+    )
+    const pool: Worker.WorkerPool<I, E, O> = {
+      backing,
+      execute: (message: I) =>
+        Stream.unwrap(
+          Effect.map(
+            Effect.scoped(backing.get()),
+            (worker) => worker.execute(message)
+          )
+        ),
+      executeEffect: (message: I) =>
+        Effect.flatMap(
+          Effect.scoped(backing.get()),
+          (worker) => worker.executeEffect(message)
+        )
+    }
+
+    return pool
+  })
+
+/** @internal */
+export const makePoolLayer = <W>(managerLayer: Layer.Layer<never, never, Worker.WorkerManager>) =>
+<Tag, I, E, O>(
+  tag: Context.Tag<Tag, Worker.WorkerPool<I, E, O>>,
+  options: Worker.WorkerPool.Options<I, W>
+) =>
+  Layer.provide(
+    managerLayer,
+    Layer.scoped(
+      tag,
+      makePool<W>()(options)
+    )
+  )

package/src/internal/workerError.ts

@@ -0,0 +1,16 @@
+import * as Data from "effect/Data"
+import type * as WorkerError_ from "../WorkerError"
+
+/** @internal */
+export const WorkerErrorTypeId: WorkerError_.WorkerErrorTypeId = Symbol.for(
+  "@effect-ts/platform/Worker/WorkerError"
+) as WorkerError_.WorkerErrorTypeId
+
+/** @internal */
+export const WorkerError = (reason: WorkerError_.WorkerError["reason"], error: unknown): WorkerError_.WorkerError =>
+  Data.struct({
+    [WorkerErrorTypeId]: WorkerErrorTypeId,
+    _tag: "WorkerError",
+    reason,
+    error
+  })

package/src/internal/workerRunner.ts

@@ -0,0 +1,83 @@
+import * as Cause from "effect/Cause"
+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 Queue from "effect/Queue"
+import * as Stream from "effect/Stream"
+import type * as Worker from "../Worker"
+import type * as WorkerRunner from "../WorkerRunner"
+
+/** @internal */
+export const PlatformRunnerTypeId: WorkerRunner.PlatformRunnerTypeId = Symbol.for(
+  "@effect/platform/Runner/PlatformRunner"
+) as WorkerRunner.PlatformRunnerTypeId
+
+/** @internal */
+export const PlatformRunner = Context.Tag<WorkerRunner.PlatformRunner>(
+  PlatformRunnerTypeId
+)
+
+/** @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<O>
+) =>
+  Effect.gen(function*(_) {
+    const platform = yield* _(PlatformRunner)
+    const backing = yield* _(platform.start<Worker.Worker.Request<I>, Worker.Worker.Response<E, O>>())
+    const fiberMap = new Map<number, Fiber.Fiber<never, void>>()
+
+    const handleRequests = pipe(
+      Queue.take(backing.queue),
+      Effect.tap((req) => {
+        const id = req[0]
+        if (req[1] === 1) {
+          const fiber = fiberMap.get(id)
+          if (!fiber) return Effect.unit
+          return Fiber.interrupt(fiber)
+        }
+
+        const stream = process(req[2])
+
+        const effect = Effect.isEffect(stream) ?
+          Effect.matchCauseEffect(stream, {
+            onFailure: (cause) =>
+              Either.match(Cause.failureOrCause(cause), {
+                onLeft: (error) => backing.send([id, 2, error]),
+                onRight: (cause) => backing.send([id, 3, Cause.squash(cause)])
+              }),
+            onSuccess: (data) => backing.send([id, 1, data])
+          }) :
+          pipe(
+            stream,
+            Stream.tap((item) => backing.send([id, 0, item], options?.transfers ? options.transfers(item) : undefined)),
+            Stream.runDrain,
+            Effect.matchCauseEffect({
+              onFailure: (cause) =>
+                Either.match(Cause.failureOrCause(cause), {
+                  onLeft: (error) => backing.send([id, 2, error]),
+                  onRight: (cause) => backing.send([id, 3, Cause.squash(cause)])
+                }),
+              onSuccess: () => backing.send([id, 1])
+            })
+          )
+
+        return pipe(
+          effect,
+          Effect.ensuring(Effect.sync(() => fiberMap.delete(id))),
+          Effect.fork,
+          Effect.tap((fiber) => Effect.sync(() => fiberMap.set(id, fiber)))
+        )
+      }),
+      Effect.forever
+    )
+
+    return yield* _(
+      Effect.all([
+        handleRequests,
+        Fiber.join(backing.fiber)
+      ], { concurrency: "unbounded", discard: true })
+    )
+  })