@effect/platform-node 0.23.1 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform-node",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "Unified interfaces for common platform-specific services",
   "main": "dist/effect-platform-node.cjs.js",
   "module": "dist/effect-platform-node.esm.js",
@@ -33,20 +33,20 @@
   "license": "MIT",
   "sideEffects": false,
   "devDependencies": {
-    "@effect/schema": "^0.43.0",
+    "@effect/schema": "^0.44.0",
     "@types/busboy": "^1.5.1",
     "@types/mime": "^3.0.2",
     "@types/tar": "^6.1.6",
-    "effect": "2.0.0-next.48",
+    "effect": "2.0.0-next.49",
     "tar": "^6.2.0"
   },
   "peerDependencies": {
-    "effect": "2.0.0-next.48"
+    "effect": "2.0.0-next.49"
   },
   "dependencies": {
     "busboy": "^1.6.0",
     "mime": "^3.0.0",
-    "@effect/platform": "^0.22.0"
+    "@effect/platform": "^0.23.0"
   },
   "files": [
     "src",
@@ -64,7 +64,9 @@
     "Path",
     "Runtime",
     "Sink",
-    "Stream"
+    "Stream",
+    "Worker",
+    "WorkerRunner"
   ],
   "exports": {
     ".": {
@@ -181,10 +183,22 @@
       "module": "./Stream/dist/effect-platform-node-Stream.esm.js",
       "import": "./Stream/dist/effect-platform-node-Stream.cjs.mjs",
       "default": "./Stream/dist/effect-platform-node-Stream.cjs.js"
+    },
+    "./Worker": {
+      "types": "./dist/declarations/src/Worker.d.ts",
+      "module": "./Worker/dist/effect-platform-node-Worker.esm.js",
+      "import": "./Worker/dist/effect-platform-node-Worker.cjs.mjs",
+      "default": "./Worker/dist/effect-platform-node-Worker.cjs.js"
+    },
+    "./WorkerRunner": {
+      "types": "./dist/declarations/src/WorkerRunner.d.ts",
+      "module": "./WorkerRunner/dist/effect-platform-node-WorkerRunner.esm.js",
+      "import": "./WorkerRunner/dist/effect-platform-node-WorkerRunner.cjs.mjs",
+      "default": "./WorkerRunner/dist/effect-platform-node-WorkerRunner.cjs.js"
     }
   },
   "scripts": {
-    "example": "ts-node --project tsconfig.examples.json",
+    "example": "node -r ts-node/register",
     "lint": "eslint src/**/*.ts test/**/*.ts",
     "tc": "tsc --noEmit",
     "test": "vitest",

package/src/Worker.ts

@@ -0,0 +1,46 @@
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Worker`](https://effect-ts.github.io/platform/platform/Worker.ts.html).
+ */
+import type * as Worker from "@effect/platform/Worker"
+import type { Effect } from "effect"
+import type * as Context from "effect/Context"
+import type * as Layer from "effect/Layer"
+import type * as Scope from "effect/Scope"
+import type * as WorkerThreads from "node:worker_threads"
+import * as internal from "./internal/worker"
+
+/**
+ * @since 1.0.0
+ */
+export * from "@effect/platform/Worker"
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePool: <I, E, O>(
+  options: Worker.WorkerPool.Options<I, WorkerThreads.Worker>
+) => Effect.Effect<Worker.WorkerManager | Scope.Scope, never, Worker.WorkerPool<I, E, O>> = internal.makePool
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makePoolLayer: <Tag, I, E, O>(
+  tag: Context.Tag<Tag, Worker.WorkerPool<I, E, O>>,
+  options: Worker.WorkerPool.Options<I, WorkerThreads.Worker>
+) => Layer.Layer<never, never, Tag> = internal.makePoolLayer
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerManager: Layer.Layer<never, never, Worker.WorkerManager> = internal.layerManager
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerWorker: Layer.Layer<never, never, Worker.PlatformWorker> = internal.layerWorker

package/src/WorkerRunner.ts

@@ -0,0 +1,25 @@
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/WorkerRunner`](https://effect-ts.github.io/platform/platform/WorkerRunner.ts.html).
+ */
+import type { WorkerError } from "@effect/platform/WorkerError"
+import type * as Runner from "@effect/platform/WorkerRunner"
+import type { Effect } from "effect"
+import type * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
+import * as internal from "./internal/workerRunner"
+
+/**
+ * @since 1.0.0
+ */
+export * from "@effect/platform/WorkerRunner"
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: <I, R, E, O>(
+  process: (request: I) => Stream.Stream<R, E, O>,
+  options?: Runner.Runner.Options<O> | undefined
+) => Effect.Effect<R | Scope.Scope, WorkerError, void> = internal.make

package/src/index.ts

@@ -64,3 +64,17 @@ export * as Sink from "@effect/platform-node/Sink"
  * @since 1.0.0
  */
 export * as Stream from "@effect/platform-node/Stream"
+
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/Worker`](https://effect-ts.github.io/platform/platform/Worker.ts.html).
+ */
+export * as Worker from "@effect/platform-node/Worker"
+
+/**
+ * @since 1.0.0
+ *
+ * Also includes exports from [`@effect/platform/WorkerRunner`](https://effect-ts.github.io/platform/platform/WorkerRunner.ts.html).
+ */
+export * as WorkerRunner from "@effect/platform-node/WorkerRunner"

package/src/internal/sink.ts

@@ -23,29 +23,27 @@ const writeChannel = <IE, OE, A>(
 ): Channel.Channel<never, IE, Chunk.Chunk<A>, unknown, IE | OE, Chunk.Chunk<never>, void> =>
   Channel.flatMap(
     Deferred.make<IE | OE, void>(),
-    (deferred) => {
-      const input = writeInput<IE, A>(
-        writable,
-        (_) => Deferred.failCause(deferred, _),
-        options,
-        Deferred.complete(deferred, Effect.unit)
-      )
-      return Channel.embedInput(
+    (deferred) =>
+      Channel.embedInput(
         writableOutput(writable, deferred, onError),
-        input
+        writeInput<IE, A>(
+          writable,
+          (_) => Deferred.failCause(deferred, _),
+          options,
+          Deferred.complete(deferred, Effect.unit)
+        )
       )
-    }
   )
 
 const writableOutput = <IE, E>(
   writable: Writable | NodeJS.WritableStream,
   deferred: Deferred.Deferred<IE | E, void>,
   onError: (error: unknown) => E
-) => {
-  function handleError(err: unknown) {
-    Deferred.unsafeDone(deferred, Effect.fail(onError(err)))
-  }
-  return Effect.suspend(() => {
+) =>
+  Effect.suspend(() => {
+    function handleError(err: unknown) {
+      Deferred.unsafeDone(deferred, Effect.fail(onError(err)))
+    }
     writable.on("error", handleError)
     return Effect.ensuring(
       Deferred.await(deferred),
@@ -54,4 +52,3 @@ const writableOutput = <IE, E>(
       })
     )
   })
-}

package/src/internal/worker.ts

@@ -0,0 +1,63 @@
+import * as Worker from "@effect/platform/Worker"
+import { WorkerError } from "@effect/platform/WorkerError"
+import * as Effect from "effect/Effect"
+import * as Fiber from "effect/Fiber"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import type * as WorkerThreads from "node:worker_threads"
+
+const platformWorkerImpl = Worker.PlatformWorker.of({
+  [Worker.PlatformWorkerTypeId]: Worker.PlatformWorkerTypeId,
+  spawn<I, O>(worker_: unknown) {
+    return Effect.gen(function*(_) {
+      const worker = worker_ as WorkerThreads.Worker
+      yield* _(Effect.addFinalizer(() =>
+        Effect.suspend(() => {
+          worker.postMessage([1])
+          return Effect.async<never, never, void>((resume) => {
+            worker.once("exit", () => {
+              resume(Effect.unit)
+            })
+          })
+        })
+      ))
+      const fiberId = yield* _(Effect.fiberId)
+      const queue = yield* _(Queue.unbounded<Worker.BackingWorker.Message<O>>())
+      yield* _(Effect.addFinalizer(() => Queue.shutdown(queue)))
+      const fiber = yield* _(
+        Effect.async<never, WorkerError, never>((resume) => {
+          worker.on("message", (message: Worker.BackingWorker.Message<O>) => {
+            queue.unsafeOffer(message)
+          })
+          worker.on("messageerror", (error) => {
+            resume(Effect.fail(WorkerError("decode", error)))
+          })
+          worker.on("error", (error) => {
+            resume(Effect.fail(WorkerError("unknown", error)))
+          })
+          worker.on("exit", (code) => {
+            resume(Effect.fail(WorkerError("unknown", new Error(`exited with code ${code}`))))
+          })
+        }),
+        Effect.forkDaemon
+      )
+      yield* _(Effect.addFinalizer(() => fiber.interruptAsFork(fiberId)))
+      const join = Fiber.join(fiber)
+      const send = (message: I, transfers?: ReadonlyArray<unknown>) =>
+        Effect.sync(() => worker.postMessage([0, message], transfers as any))
+      return { join, queue, send }
+    })
+  }
+})
+
+/** @internal */
+export const layerWorker = Layer.succeed(Worker.PlatformWorker, platformWorkerImpl)
+
+/** @internal */
+export const layerManager = Layer.provide(layerWorker, Worker.layerManager)
+
+/** @internal */
+export const makePool = Worker.makePool<WorkerThreads.Worker>()
+
+/** @internal */
+export const makePoolLayer = Worker.makePoolLayer<WorkerThreads.Worker>(layerManager)

package/src/internal/workerRunner.ts

@@ -0,0 +1,53 @@
+import { WorkerError } from "@effect/platform/WorkerError"
+import * as Runner from "@effect/platform/WorkerRunner"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import type * as Scope from "effect/Scope"
+import type * as Stream from "effect/Stream"
+import * as WorkerThreads from "node:worker_threads"
+
+const platformRunnerImpl = Runner.PlatformRunner.of({
+  [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
+  start<I, O>() {
+    return Effect.gen(function*(_) {
+      if (!WorkerThreads.parentPort) {
+        return yield* _(Effect.fail(WorkerError("spawn", "not in worker")))
+      }
+      const port = WorkerThreads.parentPort
+      const queue = yield* _(Queue.unbounded<I>())
+      const fiber = yield* _(
+        Effect.async<never, WorkerError, never>((resume) => {
+          port.on("message", (message: Runner.BackingRunner.Message<I>) => {
+            if (message[0] === 0) {
+              queue.unsafeOffer(message[1])
+            } else {
+              Effect.runFork(Queue.shutdown(queue))
+            }
+          })
+          port.on("messageerror", (error) => {
+            resume(Effect.fail(WorkerError("decode", error)))
+          })
+          port.on("error", (error) => {
+            resume(Effect.fail(WorkerError("unknown", error)))
+          })
+        }),
+        Effect.forkScoped
+      )
+      const send = (message: O, transfers?: ReadonlyArray<unknown>) =>
+        Effect.sync(() => port.postMessage([1, message], transfers as any))
+      // ready
+      port.postMessage([0])
+      return { fiber, queue, send }
+    })
+  }
+})
+
+/** @internal */
+export const layer = Layer.succeed(Runner.PlatformRunner, platformRunnerImpl)
+
+/** @internal */
+export const make = <I, R, E, O>(
+  process: (request: I) => Stream.Stream<R, E, O>,
+  options?: Runner.Runner.Options<O>
+): Effect.Effect<Scope.Scope | R, WorkerError, void> => Effect.provide(Runner.make(process, options), layer)