@effect/platform 0.21.0 → 0.22.1

package/dist/middleware-ea618e68.esm.js

@@ -0,0 +1,41 @@
+import * as Effect from 'effect/Effect';
+import { s as set } from './Headers-58b56a08.esm.js';
+import { schemaExternalSpan } from '../Http/IncomingMessage/dist/effect-platform-Http-IncomingMessage.esm.js';
+import { S as ServerRequest } from './ServerRequest-078a4bb2.esm.js';
+
+/** @internal */
+const make = middleware => middleware;
+
+/** @internal */
+const logger = /*#__PURE__*/make(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 = /*#__PURE__*/make(httpApp => {
+  const appWithStatus = Effect.tap(httpApp, response => Effect.annotateCurrentSpan("http.status", response.status));
+  return Effect.flatMap(ServerRequest, request => Effect.flatMap(request.headers["x-b3-traceid"] || request.headers["b3"] ? Effect.orElseSucceed(schemaExternalSpan(request), () => undefined) : Effect.succeed(undefined), parent => Effect.withSpan(appWithStatus, `http ${request.method}`, {
+    attributes: {
+      "http.method": request.method,
+      "http.url": request.url
+    },
+    parent
+  })));
+});
+
+/** @internal */
+const xForwardedHeaders = /*#__PURE__*/make(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));
+
+export { logger as l, make as m, tracer as t, xForwardedHeaders as x };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "description": "Unified interfaces for common platform-specific services",
   "main": "dist/effect-platform.cjs.js",
   "module": "dist/effect-platform.esm.js",
@@ -34,7 +34,7 @@
     "path-browserify": "^1.0.1"
   },
   "devDependencies": {
-    "@effect/schema": "^0.43.0",
+    "@effect/schema": "^0.43.2",
     "@types/path-browserify": "^1.0.0",
     "effect": "2.0.0-next.48"
   },
@@ -55,7 +55,10 @@
     "HttpServer",
     "KeyValueStore",
     "Path",
-    "Runtime"
+    "Runtime",
+    "Worker",
+    "WorkerError",
+    "WorkerRunner"
   ],
   "exports": {
     ".": {
@@ -238,6 +241,24 @@
       "module": "./Runtime/dist/effect-platform-Runtime.esm.js",
       "import": "./Runtime/dist/effect-platform-Runtime.cjs.mjs",
       "default": "./Runtime/dist/effect-platform-Runtime.cjs.js"
+    },
+    "./Worker": {
+      "types": "./dist/declarations/src/Worker.d.ts",
+      "module": "./Worker/dist/effect-platform-Worker.esm.js",
+      "import": "./Worker/dist/effect-platform-Worker.cjs.mjs",
+      "default": "./Worker/dist/effect-platform-Worker.cjs.js"
+    },
+    "./WorkerError": {
+      "types": "./dist/declarations/src/WorkerError.d.ts",
+      "module": "./WorkerError/dist/effect-platform-WorkerError.esm.js",
+      "import": "./WorkerError/dist/effect-platform-WorkerError.cjs.mjs",
+      "default": "./WorkerError/dist/effect-platform-WorkerError.cjs.js"
+    },
+    "./WorkerRunner": {
+      "types": "./dist/declarations/src/WorkerRunner.d.ts",
+      "module": "./WorkerRunner/dist/effect-platform-WorkerRunner.esm.js",
+      "import": "./WorkerRunner/dist/effect-platform-WorkerRunner.cjs.mjs",
+      "default": "./WorkerRunner/dist/effect-platform-WorkerRunner.cjs.js"
     }
   },
   "scripts": {

package/src/Error.ts

@@ -33,7 +33,7 @@ export declare namespace PlatformError {
   export interface Base extends Data.Case {
     readonly [PlatformErrorTypeId]: typeof PlatformErrorTypeId
     readonly _tag: string
-    readonly module: "Command" | "FileSystem" | "Path" | "KeyValueStore" | "Clipboard"
+    readonly module: "Command" | "FileSystem" | "Path" | "KeyValueStore" | "Clipboard" | "Stream"
     readonly method: string
     readonly message: string
   }

package/src/Http/App.ts

@@ -6,6 +6,7 @@ import * as FiberRef from "effect/FiberRef"
 import { dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import * as ReadonlyArray from "effect/ReadonlyArray"
+import * as internalMiddleware from "../internal/http/middleware"
 import type * as ServerError from "./ServerError"
 import type * as ServerRequest from "./ServerRequest"
 import type * as ServerResponse from "./ServerResponse"
@@ -22,6 +23,14 @@ export interface HttpApp<R, E, A> extends Effect.Effect<R | ServerRequest.Server
  */
 export type Default<R, E> = HttpApp<R, E, ServerResponse.ServerResponse>
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const withDefaultMiddleware = <R, E>(
+  self: Default<R, E>
+): Default<R, E> => internalMiddleware.tracer(self)
+
 /**
  * @since 1.0.0
  * @category models

package/src/Http/Client.ts

@@ -9,7 +9,6 @@ import type * as Layer from "effect/Layer"
 import type { Pipeable } from "effect/Pipeable"
 import type * as Predicate from "effect/Predicate"
 import type * as Schedule from "effect/Schedule"
-import type * as Scope from "effect/Scope"
 import * as internal from "../internal/http/client"
 import type * as Error from "./ClientError"
 import type * as ClientRequest from "./ClientRequest"
@@ -206,6 +205,16 @@ export const filterStatusOk: <R, E>(
 export const make: <R, E, A>(f: (request: ClientRequest.ClientRequest) => Effect.Effect<R, E, A>) => Client<R, E, A> =
   internal.make
 
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeDefault: (
+  f: (
+    request: ClientRequest.ClientRequest
+  ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
+) => Client.Default = internal.makeDefault
+
 /**
  * @since 1.0.0
  * @category mapping & sequencing
@@ -306,13 +315,6 @@ export const schemaFunction: {
   ) => (a: SA) => Effect.Effect<R, Error.RequestError | ParseResult.ParseError | E, A>
 } = internal.schemaFunction
 
-/**
- * @since 1.0.0
- * @category tracing
- */
-export const withB3Propagation: <R, E>(self: Client.WithResponse<R, E>) => Client.WithResponse<R | Scope.Scope, E> =
-  internal.withB3Propagation
-
 /**
  * @since 1.0.0
  * @category mapping & sequencing

package/src/Http/Middleware.ts

@@ -36,18 +36,6 @@ export const make: <M extends Middleware>(middleware: M) => M = internal.make
  */
 export const logger: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.logger
 
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const tracer: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.tracer
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export const loggerTracer: <R, E>(httpApp: App.Default<R, E>) => App.Default<R, E> = internal.loggerTracer
-
 /**
  * @since 1.0.0
  * @category constructors

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/http/client.ts

@@ -2,19 +2,18 @@ import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
-import { dual, pipe } from "effect/Function"
+import { dual } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import { pipeArguments } from "effect/Pipeable"
 import type * as Predicate from "effect/Predicate"
 import type * as Schedule from "effect/Schedule"
-import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import type * as Body from "../../Http/Body"
 import type * as Client from "../../Http/Client"
 import type * as Error from "../../Http/ClientError"
 import type * as ClientRequest from "../../Http/ClientRequest"
-import * as IncomingMessage from "../../Http/IncomingMessage"
+import type * as ClientResponse from "../../Http/ClientResponse"
 import * as Method from "../../Http/Method"
 import * as UrlParams from "../../Http/UrlParams"
 import * as internalBody from "./body"
@@ -43,11 +42,41 @@ export const make = <R, E, A>(
   return f as Client.Client<R, E, A>
 }
 
+const withB3Propagation = <R, E>(
+  self: Client.Client.WithResponse<R, E>
+): Client.Client.WithResponse<R, E> =>
+  make((req) =>
+    Effect.flatMap(
+      Effect.map(
+        Effect.currentSpan,
+        Option.match({
+          onNone: () => req,
+          onSome: (span) =>
+            internalRequest.setHeader(
+              req,
+              "b3",
+              `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${
+                span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
+              }`
+            )
+        })
+      ),
+      self
+    )
+  )
+
+/** @internal */
+export const makeDefault = (
+  f: (
+    request: ClientRequest.ClientRequest
+  ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
+): Client.Client.Default => withB3Propagation(make(f))
+
 /** @internal */
 export const fetch = (
   options: RequestInit = {}
 ): Client.Client.Default =>
-  make((request) =>
+  makeDefault((request) =>
     Effect.flatMap(
       UrlParams.makeUrl(request.url, request.urlParams, (_) =>
         internalError.requestError({
@@ -378,35 +407,6 @@ export const mapRequestEffect = dual<
   ) => Client.Client<R | R2, E | E2, A>
 >(2, (self, f) => make((request) => Effect.flatMap(f(request), self)))
 
-/** @internal */
-export const withB3Propagation = <R, E>(
-  self: Client.Client.WithResponse<R, E>
-): Client.Client.WithResponse<R | Scope.Scope, E> =>
-  make((req) =>
-    pipe(
-      Effect.map(
-        Effect.currentSpan,
-        Option.match({
-          onNone: () => req,
-          onSome: (span) => {
-            const parentId = span.parent._tag === "Some" ? `-${span.parent.value.spanId}` : ""
-            return internalRequest.setHeader(
-              req,
-              "b3",
-              `${span.traceId}-${span.spanId}-1${parentId}`
-            )
-          }
-        })
-      ),
-      Effect.flatMap(self),
-      Effect.tap((res) =>
-        Effect.ignore(
-          Effect.flatMap(IncomingMessage.schemaExternalSpan(res), Effect.setParentSpan)
-        )
-      )
-    )
-  )
-
 /** @internal */
 export const retry: {
   <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(

package/src/internal/http/middleware.ts

@@ -1,11 +1,8 @@
 import * as Effect from "effect/Effect"
-import { flow } from "effect/Function"
-import * as App from "../../Http/App"
 import * as Headers from "../../Http/Headers"
 import * as IncomingMessage from "../../Http/IncomingMessage"
 import type * as Middleware from "../../Http/Middleware"
 import * as ServerRequest from "../../Http/ServerRequest"
-import * as ServerResponse from "../../Http/ServerResponse"
 
 /** @internal */
 export const make = <M extends Middleware.Middleware>(middleware: M): M => middleware
@@ -37,17 +34,16 @@ export const logger = make((httpApp) => {
 /** @internal */
 export const tracer = make((httpApp) => {
   const appWithStatus = Effect.tap(
-    Effect.zipRight(
-      App.appendPreResponseHandler(b3Response),
-      httpApp
-    ),
+    httpApp,
     (response) => Effect.annotateCurrentSpan("http.status", response.status)
   )
   return Effect.flatMap(
     ServerRequest.ServerRequest,
     (request) =>
       Effect.flatMap(
-        Effect.orElseSucceed(IncomingMessage.schemaExternalSpan(request), () => undefined),
+        request.headers["x-b3-traceid"] || request.headers["b3"] ?
+          Effect.orElseSucceed(IncomingMessage.schemaExternalSpan(request), () => undefined) :
+          Effect.succeed(undefined),
         (parent) =>
           Effect.withSpan(
             appWithStatus,
@@ -58,21 +54,6 @@ export const tracer = make((httpApp) => {
   )
 })
 
-const b3Response: App.PreResponseHandler = (_request, response) =>
-  Effect.flatMap(
-    Effect.currentSpan,
-    (span) =>
-      span._tag === "Some"
-        ? ServerResponse.setHeader(
-          response,
-          "b3",
-          `${span.value.traceId}-${span.value.spanId}-1${
-            span.value.parent._tag === "Some" ? `-${span.value.parent.value.spanId}` : ""
-          }`
-        )
-        : response
-  )
-
 /** @internal */
 export const xForwardedHeaders = make((httpApp) =>
   Effect.updateService(httpApp, ServerRequest.ServerRequest, (request) =>
@@ -87,6 +68,3 @@ export const xForwardedHeaders = make((httpApp) =>
       })
       : request)
 )
-
-/** @internal */
-export const loggerTracer = flow(tracer, logger)