@effect/platform 0.58.26 → 0.59.0

package/src/Worker.ts

@@ -5,17 +5,14 @@ import type * as ParseResult from "@effect/schema/ParseResult"
 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 Deferred from "effect/Deferred"
 import type * as Duration from "effect/Duration"
 import type * as Effect from "effect/Effect"
-import type * as Fiber from "effect/Fiber"
 import type { LazyArg } from "effect/Function"
 import type * as Layer from "effect/Layer"
-import type * as Option from "effect/Option"
 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 type * as Tracer from "effect/Tracer"
 import * as internal from "./internal/worker.js"
 import type { WorkerError, WorkerErrorFrom } from "./WorkerError.js"
 
@@ -24,9 +21,10 @@ import type { WorkerError, WorkerErrorFrom } from "./WorkerError.js"
  * @category models
  */
 export interface BackingWorker<I, O> {
-  readonly fiber: Fiber.Fiber<never, WorkerError>
   readonly send: (message: I, transfers?: ReadonlyArray<unknown>) => Effect.Effect<void, WorkerError>
-  readonly queue: Queue.Dequeue<BackingWorker.Message<O>>
+  readonly run: <A, E, R>(
+    handler: (_: BackingWorker.Message<O>) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<never, E | WorkerError, R>
 }
 
 /**
@@ -59,9 +57,28 @@ export type PlatformWorkerTypeId = typeof PlatformWorkerTypeId
  */
 export interface PlatformWorker {
   readonly [PlatformWorkerTypeId]: PlatformWorkerTypeId
-  readonly spawn: <I, O>(worker: unknown) => Effect.Effect<BackingWorker<I, O>, WorkerError, Scope.Scope>
+  readonly spawn: <I, O>(id: number) => Effect.Effect<BackingWorker<I, O>, WorkerError, Spawner>
 }
 
+/**
+ * @since 1.0.0
+ */
+export const makePlatform: <W>() => <
+  P extends { readonly postMessage: (message: any, transfers?: any | undefined) => void }
+>(
+  options: {
+    readonly setup: (options: { readonly worker: W; readonly scope: Scope.Scope }) => Effect.Effect<P>
+    readonly listen: (
+      options: {
+        readonly port: P
+        readonly emit: (data: any) => void
+        readonly deferred: Deferred.Deferred<never, WorkerError>
+        readonly scope: Scope.Scope
+      }
+    ) => Effect.Effect<void>
+  }
+) => PlatformWorker = internal.makePlatform
+
 /**
  * @since 1.0.0
  * @category tags
@@ -86,6 +103,12 @@ export interface Spawner {
   readonly _: unique symbol
 }
 
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const Spawner: Context.Tag<Spawner, SpawnerFn<unknown>> = internal.Spawner
+
 /**
  * @since 1.0.0
  * @category models
@@ -105,8 +128,6 @@ export declare namespace Worker {
    */
   export interface Options<I> {
     readonly encode?: ((message: I) => Effect.Effect<unknown, WorkerError>) | undefined
-    readonly transfers?: ((message: I) => ReadonlyArray<unknown>) | undefined
-    readonly queue?: WorkerQueue<I> | undefined
     readonly initialMessage?: LazyArg<I> | undefined
   }
 
@@ -173,16 +194,6 @@ export declare namespace WorkerPool {
     })
 }
 
-/**
- * @category models
- * @since 1.0.0
- */
-export interface WorkerQueue<I> {
-  readonly offer: (id: number, item: I, span: Option.Option<Tracer.Span>) => Effect.Effect<void>
-  readonly take: Effect.Effect<readonly [id: number, item: I, span: Option.Option<Tracer.Span>]>
-  readonly shutdown: Effect.Effect<void>
-}
-
 /**
  * @since 1.0.0
  * @category type ids
@@ -268,20 +279,12 @@ export declare namespace SerializedWorker {
    * @since 1.0.0
    * @category models
    */
-  export type Options<I> = Extract<I, { readonly _tag: "InitialMessage" }> extends never ? BaseOptions<I> & {
+  export type Options<I> = Extract<I, { readonly _tag: "InitialMessage" }> extends never ? {
       readonly initialMessage?: LazyArg<I>
     }
-    : BaseOptions<I> & {
+    : {
       readonly initialMessage: LazyArg<Extract<I, { readonly _tag: "InitialMessage" }>>
     }
-
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export interface BaseOptions<I> {
-    readonly queue?: WorkerQueue<I> | undefined
-  }
 }
 
 /**

package/src/WorkerError.ts

@@ -3,7 +3,6 @@
  */
 import * as Schema from "@effect/schema/Schema"
 import type * as Cause from "effect/Cause"
-import * as Inspectable from "effect/Inspectable"
 import * as Predicate from "effect/Predicate"
 import * as internal from "./internal/workerError.js"
 
@@ -31,7 +30,7 @@ export const isWorkerError = (u: unknown): u is WorkerError => Predicate.hasProp
  */
 export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError", {
   reason: Schema.Literal("spawn", "decode", "send", "unknown", "encode"),
-  error: Schema.CauseDefectUnknown
+  cause: Schema.CauseDefectUnknown
 }) {
   /**
    * @since 1.0.0
@@ -61,11 +60,19 @@ export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError"
   /**
    * @since 1.0.0
    */
-  get message() {
-    const message = Predicate.hasProperty(this.error, "message")
-      ? this.error.message
-      : Inspectable.toStringUnknown(this.error, undefined)
-    return `${this.reason}: ${message}`
+  get message(): string {
+    switch (this.reason) {
+      case "send":
+        return "An error occurred calling .postMessage"
+      case "spawn":
+        return "An error occurred while spawning a worker"
+      case "decode":
+        return "An error occurred during decoding"
+      case "encode":
+        return "An error occurred during encoding"
+      case "unknown":
+        return "An unexpected error occurred"
+    }
   }
 }
 
@@ -76,5 +83,5 @@ export class WorkerError extends Schema.TaggedError<WorkerError>()("WorkerError"
 export interface WorkerErrorFrom {
   readonly _tag: "WorkerError"
   readonly reason: "spawn" | "decode" | "send" | "unknown" | "encode"
-  readonly error: unknown
+  readonly cause: unknown
 }

package/src/WorkerRunner.ts

@@ -6,7 +6,6 @@ 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 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"
 import * as internal from "./internal/workerRunner.js"
@@ -17,7 +16,9 @@ import type { WorkerError } from "./WorkerError.js"
  * @category models
  */
 export interface BackingRunner<I, O> {
-  readonly queue: Queue.Dequeue<readonly [portId: number, message: I]>
+  readonly run: <A, E, R>(
+    handler: (portId: number, message: I) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<never, E | WorkerError, R>
   readonly send: (
     portId: number,
     message: O,
@@ -55,9 +56,7 @@ export type PlatformRunnerTypeId = typeof PlatformRunnerTypeId
  */
 export interface PlatformRunner {
   readonly [PlatformRunnerTypeId]: PlatformRunnerTypeId
-  readonly start: <I, O>(
-    shutdown: Effect.Effect<void>
-  ) => Effect.Effect<BackingRunner<I, O>, WorkerError, Scope.Scope>
+  readonly start: <I, O>() => Effect.Effect<BackingRunner<I, O>, WorkerError>
 }
 
 /**
@@ -87,18 +86,26 @@ export declare namespace Runner {
       request: I,
       error: E
     ) => Effect.Effect<unknown, WorkerError>
-    readonly transfers?: (message: O | E) => ReadonlyArray<unknown>
   }
 }
 
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const run: <I, E, R, O>(
+  process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
+  options?: Runner.Options<I, O, E>
+) => Effect.Effect<never, WorkerError, PlatformRunner | R> = internal.run
+
 /**
  * @since 1.0.0
  * @category constructors
  */
 export const make: <I, E, R, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
-  options?: Runner.Options<I, O, E> | undefined
-) => Effect.Effect<void, WorkerError, Scope.Scope | R | PlatformRunner> = internal.make
+  options?: Runner.Options<I, O, E>
+) => Effect.Effect<void, WorkerError, PlatformRunner | R | Scope.Scope> = internal.make
 
 /**
  * @since 1.0.0

package/src/internal/httpClient.ts

@@ -128,7 +128,7 @@ export const makeDefault = (
         const addAbort = Scope.addFinalizer(scope, Effect.sync(() => controller.abort()))
         const urlResult = UrlParams.makeUrl(request.url, request.urlParams, request.hash)
         if (urlResult._tag === "Left") {
-          return Effect.fail(new Error.RequestError({ request, reason: "InvalidUrl", error: urlResult.left }))
+          return Effect.fail(new Error.RequestError({ request, reason: "InvalidUrl", cause: urlResult.left }))
         }
         const url = urlResult.right
         const tracerDisabled = !fiber.getFiberRef(FiberRef.currentTracerEnabled) ||
@@ -211,11 +211,11 @@ export const fetch: Client.HttpClient.Default = makeDefault((request, url, signa
             duplex: request.body._tag === "Stream" ? "half" : undefined,
             signal
           } as any),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request,
             reason: "Transport",
-            error
+            cause
           })
       }),
       (response) => internalResponse.fromWeb(request, response)
@@ -276,7 +276,7 @@ export const filterStatus = dual<
           request,
           response,
           reason: "StatusCode",
-          error: "invalid status code"
+          description: "invalid status code"
         })
     )))
 
@@ -293,7 +293,7 @@ export const filterStatusOk = <E, R>(
           request,
           response,
           reason: "StatusCode",
-          error: "non 2xx status code"
+          description: "non 2xx status code"
         })
     ))
 
@@ -675,11 +675,11 @@ export const schemaFunction = dual<
     Effect.flatMap(
       Effect.tryMap(encode(a), {
         try: (body) => new TextEncoder().encode(JSON.stringify(body)),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request,
             reason: "Encode",
-            error
+            cause
           })
       }),
       (body) =>

package/src/internal/httpClientResponse.ts

@@ -67,19 +67,19 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
 
   get stream(): Stream.Stream<Uint8Array, Error.ResponseError> {
     return this.source.body
-      ? Stream.fromReadableStream(() => this.source.body!, (_) =>
+      ? Stream.fromReadableStream(() => this.source.body!, (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         }))
       : Stream.fail(
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "EmptyBody",
-          error: "can not create stream from empty body"
+          description: "can not create stream from empty body"
         })
       )
   }
@@ -87,12 +87,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
   get json(): Effect.Effect<unknown, Error.ResponseError> {
     return Effect.tryMap(this.text, {
       try: (text) => text === "" ? null : JSON.parse(text) as unknown,
-      catch: (_) =>
+      catch: (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         })
     })
   }
@@ -101,12 +101,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
   get text(): Effect.Effect<string, Error.ResponseError> {
     return this.textBody ??= Effect.tryPromise({
       try: () => this.source.text(),
-      catch: (_) =>
+      catch: (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         })
     }).pipe(Effect.cached, Effect.runSync)
   }
@@ -115,12 +115,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
     return Effect.flatMap(this.text, (_) =>
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
-        catch: (_) =>
+        catch: (cause) =>
           new Error.ResponseError({
             request: this.request,
             response: this,
             reason: "Decode",
-            error: _
+            cause
           })
       }))
   }
@@ -129,12 +129,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
   get formData(): Effect.Effect<FormData, Error.ResponseError> {
     return this.formDataBody ??= Effect.tryPromise({
       try: () => this.source.formData(),
-      catch: (_) =>
+      catch: (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         })
     }).pipe(Effect.cached, Effect.runSync)
   }
@@ -143,12 +143,12 @@ class ClientResponseImpl extends Inspectable.Class implements ClientResponse.Htt
   get arrayBuffer(): Effect.Effect<ArrayBuffer, Error.ResponseError> {
     return this.arrayBufferBody ??= Effect.tryPromise({
       try: () => this.source.arrayBuffer(),
-      catch: (_) =>
+      catch: (cause) =>
         new Error.ResponseError({
           request: this.request,
           response: this,
           reason: "Decode",
-          error: _
+          cause
         })
     }).pipe(Effect.cached, Effect.runSync)
   }

package/src/internal/httpServerRequest.ts

@@ -151,11 +151,11 @@ export const schemaBodyFormJson = <A, I, R>(schema: Schema.Schema<A, I, R>, opti
       > => {
         if (isMultipart(request)) {
           return Effect.flatMap(
-            Effect.mapError(request.multipart, (error) =>
+            Effect.mapError(request.multipart, (cause) =>
               new Error.RequestError({
                 request,
                 reason: "Decode",
-                error
+                cause
               })),
             parseMultipart(field)
           )
@@ -227,17 +227,17 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
 
   get stream(): Stream.Stream<Uint8Array, Error.RequestError> {
     return this.source.body
-      ? Stream.fromReadableStream(() => this.source.body as any, (_) =>
+      ? Stream.fromReadableStream(() => this.source.body as any, (cause) =>
         new Error.RequestError({
           request: this,
           reason: "Decode",
-          error: _
+          cause
         }))
       : Stream.fail(
         new Error.RequestError({
           request: this,
           reason: "Decode",
-          error: "can not create stream from empty body"
+          description: "can not create stream from empty body"
         })
       )
   }
@@ -250,11 +250,11 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
     this.textEffect = Effect.runSync(Effect.cached(
       Effect.tryPromise({
         try: () => this.source.text(),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request: this,
             reason: "Decode",
-            error
+            cause
           })
       })
     ))
@@ -264,11 +264,11 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
   get json(): Effect.Effect<unknown, Error.RequestError> {
     return Effect.tryMap(this.text, {
       try: (_) => JSON.parse(_) as unknown,
-      catch: (error) =>
+      catch: (cause) =>
         new Error.RequestError({
           request: this,
           reason: "Decode",
-          error
+          cause
         })
     })
   }
@@ -277,11 +277,11 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
     return Effect.flatMap(this.text, (_) =>
       Effect.try({
         try: () => UrlParams.fromInput(new URLSearchParams(_)),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request: this,
             reason: "Decode",
-            error
+            cause
           })
       }))
   }
@@ -309,7 +309,7 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
 
   get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError> {
     return Stream.pipeThroughChannel(
-      Stream.mapError(this.stream, (error) => new Multipart.MultipartError({ reason: "InternalError", error })),
+      Stream.mapError(this.stream, (cause) => new Multipart.MultipartError({ reason: "InternalError", cause })),
       Multipart.makeChannel(this.headers)
     )
   }
@@ -322,11 +322,11 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
     this.arrayBufferEffect = Effect.runSync(Effect.cached(
       Effect.tryPromise({
         try: () => this.source.arrayBuffer(),
-        catch: (error) =>
+        catch: (cause) =>
           new Error.RequestError({
             request: this,
             reason: "Decode",
-            error
+            cause
           })
       })
     ))
@@ -338,7 +338,7 @@ class ServerRequestImpl extends Inspectable.Class implements ServerRequest.HttpS
       new Error.RequestError({
         request: this,
         reason: "Decode",
-        error: "Not an upgradeable ServerRequest"
+        description: "Not an upgradeable ServerRequest"
       })
     )
   }

package/src/internal/multipart.ts

@@ -16,7 +16,7 @@ import type * as Scope from "effect/Scope"
 import type * as AsyncInput from "effect/SingleProducerAsyncInput"
 import * as Stream from "effect/Stream"
 import * as MP from "multipasta"
-import { RefailError } from "../Error.js"
+import { TypeIdError } from "../Error.js"
 import * as FileSystem from "../FileSystem.js"
 import * as IncomingMessage from "../HttpIncomingMessage.js"
 import type * as Multipart from "../Multipart.js"
@@ -44,11 +44,12 @@ export const ErrorTypeId: Multipart.ErrorTypeId = Symbol.for(
 ) as Multipart.ErrorTypeId
 
 /** @internal */
-export class MultipartError extends RefailError(ErrorTypeId, "MultipartError")<{
+export class MultipartError extends TypeIdError(ErrorTypeId, "MultipartError")<{
   readonly reason: "FileTooLarge" | "FieldTooLarge" | "BodyTooLarge" | "TooManyParts" | "InternalError" | "Parse"
+  readonly cause: unknown
 }> {
-  get message() {
-    return `${this.reason}: ${super.message}`
+  get message(): string {
+    return this.reason
   }
 }
 
@@ -320,26 +321,26 @@ const makeFromQueue = <IE>(
     return Channel.embedInput(partsChannel, input)
   })
 
-function convertError(error: MP.MultipartError): Multipart.MultipartError {
-  switch (error._tag) {
+function convertError(cause: MP.MultipartError): Multipart.MultipartError {
+  switch (cause._tag) {
     case "ReachedLimit": {
-      switch (error.limit) {
+      switch (cause.limit) {
         case "MaxParts": {
-          return new MultipartError({ reason: "TooManyParts", error })
+          return new MultipartError({ reason: "TooManyParts", cause })
         }
         case "MaxFieldSize": {
-          return new MultipartError({ reason: "FieldTooLarge", error })
+          return new MultipartError({ reason: "FieldTooLarge", cause })
         }
         case "MaxPartSize": {
-          return new MultipartError({ reason: "FileTooLarge", error })
+          return new MultipartError({ reason: "FileTooLarge", cause })
         }
         case "MaxTotalSize": {
-          return new MultipartError({ reason: "BodyTooLarge", error })
+          return new MultipartError({ reason: "BodyTooLarge", cause })
         }
       }
     }
     default: {
-      return new MultipartError({ reason: "Parse", error })
+      return new MultipartError({ reason: "Parse", cause })
     }
   }
 }
@@ -409,7 +410,7 @@ const defaultWriteFile = (path: string, file: Multipart.File) =>
     (fs) =>
       Effect.mapError(
         Stream.run(file.content, fs.sink(path)),
-        (error) => new MultipartError({ reason: "InternalError", error })
+        (cause) => new MultipartError({ reason: "InternalError", cause })
       )
   )
 
@@ -450,8 +451,8 @@ export const toPersisted = (
       )
     ),
     Effect.catchTags({
-      SystemError: (error) => Effect.fail(new MultipartError({ reason: "InternalError", error })),
-      BadArgument: (error) => Effect.fail(new MultipartError({ reason: "InternalError", error }))
+      SystemError: (cause) => Effect.fail(new MultipartError({ reason: "InternalError", cause })),
+      BadArgument: (cause) => Effect.fail(new MultipartError({ reason: "InternalError", cause }))
     })
   )