@effect/platform 0.21.0 → 0.22.1

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 })
+    )
+  })

package/dist/Middleware-04ddadf1.esm.js

@@ -1,100 +0,0 @@
-import * as Effect from 'effect/Effect';
-import { flow } from 'effect/Function';
-import { a as appendPreResponseHandler } from './App-1ca51fa7.esm.js';
-import { s as set } from './Headers-58b56a08.esm.js';
-import { schemaExternalSpan } from '../Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
-import { a as ServerRequest } from './ServerRequest-41c7e979.esm.js';
-import { s as setHeader } from './ServerResponse-03c252ea.esm.js';
-
-/** @internal */
-const make$1 = middleware => middleware;
-
-/** @internal */
-const logger$1 = /*#__PURE__*/make$1(httpApp => {
-  let counter = 0;
-  return Effect.flatMap(ServerRequest, request => Effect.withLogSpan(Effect.onExit(httpApp, exit => exit._tag === "Failure" ? Effect.annotateLogs(Effect.log(exit.cause), {
-    "http.method": request.method,
-    "http.url": request.url,
-    "http.status": 500
-  }) : Effect.annotateLogs(Effect.log(""), {
-    "http.method": request.method,
-    "http.url": request.url,
-    "http.status": exit.value.status
-  })), `http.span.${++counter}`));
-});
-
-/** @internal */
-const tracer$1 = /*#__PURE__*/make$1(httpApp => {
-  const appWithStatus = Effect.tap(Effect.zipRight(appendPreResponseHandler(b3Response), httpApp), response => Effect.annotateCurrentSpan("http.status", response.status));
-  return Effect.flatMap(ServerRequest, request => Effect.flatMap(Effect.orElseSucceed(schemaExternalSpan(request), () => undefined), parent => Effect.withSpan(appWithStatus, `http ${request.method}`, {
-    attributes: {
-      "http.method": request.method,
-      "http.url": request.url
-    },
-    parent
-  })));
-});
-const b3Response = (_request, response) => Effect.flatMap(Effect.currentSpan, span => span._tag === "Some" ? setHeader(response, "b3", `${span.value.traceId}-${span.value.spanId}-1${span.value.parent._tag === "Some" ? `-${span.value.parent.value.spanId}` : ""}`) : response);
-
-/** @internal */
-const xForwardedHeaders$1 = /*#__PURE__*/make$1(httpApp => Effect.updateService(httpApp, ServerRequest, request => request.headers["x-forwarded-host"] ? request.modify({
-  headers: set(request.headers, "host", request.headers["x-forwarded-host"]),
-  remoteAddress: request.headers["x-forwarded-for"]?.split(",")[0].trim()
-}) : request));
-
-/** @internal */
-const loggerTracer$1 = /*#__PURE__*/flow(tracer$1, logger$1);
-
-/**
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const make = make$1;
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const logger = logger$1;
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const tracer = tracer$1;
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const loggerTracer = loggerTracer$1;
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const xForwardedHeaders = xForwardedHeaders$1;
-
-var Middleware = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  make: make,
-  logger: logger,
-  tracer: tracer,
-  loggerTracer: loggerTracer,
-  xForwardedHeaders: xForwardedHeaders
-});
-
-export { Middleware as M, loggerTracer as a, logger as l, make as m, tracer as t, xForwardedHeaders as x };

package/dist/Middleware-3e264366.cjs.dev.js

@@ -1,127 +0,0 @@
-'use strict';
-
-var Effect = require('effect/Effect');
-var Function = require('effect/Function');
-var Http_App_dist_effectPlatformHttpApp = require('./App-18152f12.cjs.dev.js');
-var Http_Headers_dist_effectPlatformHttpHeaders = require('./Headers-f56bc667.cjs.dev.js');
-var Http_IncomingMessage_dist_effectPlatformHttpIncomingMessage = require('../Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.cjs.dev.js');
-var Http_ServerRequest_dist_effectPlatformHttpServerRequest = require('./ServerRequest-8e9629a5.cjs.dev.js');
-var Http_ServerResponse_dist_effectPlatformHttpServerResponse = require('./ServerResponse-9af42ecb.cjs.dev.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
-
-/** @internal */
-const make$1 = middleware => middleware;
-
-/** @internal */
-const logger$1 = /*#__PURE__*/make$1(httpApp => {
-  let counter = 0;
-  return Effect__namespace.flatMap(Http_ServerRequest_dist_effectPlatformHttpServerRequest.ServerRequest$1, request => Effect__namespace.withLogSpan(Effect__namespace.onExit(httpApp, exit => exit._tag === "Failure" ? Effect__namespace.annotateLogs(Effect__namespace.log(exit.cause), {
-    "http.method": request.method,
-    "http.url": request.url,
-    "http.status": 500
-  }) : Effect__namespace.annotateLogs(Effect__namespace.log(""), {
-    "http.method": request.method,
-    "http.url": request.url,
-    "http.status": exit.value.status
-  })), `http.span.${++counter}`));
-});
-
-/** @internal */
-const tracer$1 = /*#__PURE__*/make$1(httpApp => {
-  const appWithStatus = Effect__namespace.tap(Effect__namespace.zipRight(Http_App_dist_effectPlatformHttpApp.appendPreResponseHandler(b3Response), httpApp), response => Effect__namespace.annotateCurrentSpan("http.status", response.status));
-  return Effect__namespace.flatMap(Http_ServerRequest_dist_effectPlatformHttpServerRequest.ServerRequest$1, request => Effect__namespace.flatMap(Effect__namespace.orElseSucceed(Http_IncomingMessage_dist_effectPlatformHttpIncomingMessage.schemaExternalSpan(request), () => undefined), parent => Effect__namespace.withSpan(appWithStatus, `http ${request.method}`, {
-    attributes: {
-      "http.method": request.method,
-      "http.url": request.url
-    },
-    parent
-  })));
-});
-const b3Response = (_request, response) => Effect__namespace.flatMap(Effect__namespace.currentSpan, span => span._tag === "Some" ? Http_ServerResponse_dist_effectPlatformHttpServerResponse.setHeader(response, "b3", `${span.value.traceId}-${span.value.spanId}-1${span.value.parent._tag === "Some" ? `-${span.value.parent.value.spanId}` : ""}`) : response);
-
-/** @internal */
-const xForwardedHeaders$1 = /*#__PURE__*/make$1(httpApp => Effect__namespace.updateService(httpApp, Http_ServerRequest_dist_effectPlatformHttpServerRequest.ServerRequest$1, request => request.headers["x-forwarded-host"] ? request.modify({
-  headers: Http_Headers_dist_effectPlatformHttpHeaders.set(request.headers, "host", request.headers["x-forwarded-host"]),
-  remoteAddress: request.headers["x-forwarded-for"]?.split(",")[0].trim()
-}) : request));
-
-/** @internal */
-const loggerTracer$1 = /*#__PURE__*/Function.flow(tracer$1, logger$1);
-
-/**
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- * @category models
- */
-
-/**
- * @since 1.0.0
- */
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const make = make$1;
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const logger = logger$1;
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const tracer = tracer$1;
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const loggerTracer = loggerTracer$1;
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-const xForwardedHeaders = xForwardedHeaders$1;
-
-var Middleware = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  make: make,
-  logger: logger,
-  tracer: tracer,
-  loggerTracer: loggerTracer,
-  xForwardedHeaders: xForwardedHeaders
-});
-
-exports.Middleware = Middleware;
-exports.logger = logger;
-exports.loggerTracer = loggerTracer;
-exports.make = make;
-exports.tracer = tracer;
-exports.xForwardedHeaders = xForwardedHeaders;