@effect/platform 0.44.7 → 0.45.1

package/src/internal/http/client.ts

@@ -2,11 +2,12 @@ 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 } from "effect/Function"
+import { dual, pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
 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.js"
 import type * as Client from "../../Http/Client.js"
@@ -68,7 +69,7 @@ const addB3Headers = (req: ClientRequest.ClientRequest) =>
 export const makeDefault = (
   f: (
     request: ClientRequest.ClientRequest
-  ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError>
+  ) => Effect.Effect<ClientResponse.ClientResponse, Error.HttpClientError, Scope.Scope>
 ): Client.Client.Default => make(Effect.flatMap(f), addB3Headers)
 
 /** @internal */
@@ -91,25 +92,31 @@ export const fetch = (options?: RequestInit): Client.Client.Default =>
           const fetch = fetch_._tag === "Some" ? fetch_.value : globalThis.fetch
           const headers = new Headers(request.headers)
           const send = (body: BodyInit | undefined) =>
-            Effect.map(
-              Effect.tryPromise({
-                try: (signal) =>
-                  fetch(url, {
-                    ...options,
-                    method: request.method,
-                    headers,
-                    body,
-                    duplex: request.body._tag === "Stream" ? "half" : undefined,
-                    signal
-                  } as any),
-                catch: (_) =>
-                  internalError.requestError({
-                    request,
-                    reason: "Transport",
-                    error: _
-                  })
-              }),
-              (_) => internalResponse.fromWeb(request, _)
+            pipe(
+              Effect.acquireRelease(
+                Effect.sync(() => new AbortController()),
+                (controller) => Effect.sync(() => controller.abort())
+              ),
+              Effect.flatMap((controller) =>
+                Effect.tryPromise({
+                  try: () =>
+                    fetch(url, {
+                      ...options,
+                      method: request.method,
+                      headers,
+                      body,
+                      duplex: request.body._tag === "Stream" ? "half" : undefined,
+                      signal: controller.signal
+                    } as any),
+                  catch: (_) =>
+                    internalError.requestError({
+                      request,
+                      reason: "Transport",
+                      error: _
+                    })
+                })
+              ),
+              Effect.map((_) => internalResponse.fromWeb(request, _))
             )
           if (Method.hasBody(request.method)) {
             return send(convertBody(request.body))
@@ -449,6 +456,22 @@ export const mapEffect = dual<
   ) => Client.Client<R | R2, E | E2, B>
 >(2, (self, f) => transformResponse(self, Effect.flatMap(f)))
 
+/** @internal */
+export const scoped = <R, E, A>(
+  self: Client.Client<R, E, A>
+): Client.Client<Exclude<R, Scope.Scope>, E, A> => transformResponse(self, Effect.scoped)
+
+/** @internal */
+export const mapEffectScoped = dual<
+  <A, R2, E2, B>(
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<Exclude<R | R2, Scope.Scope>, E | E2, B>,
+  <R, E, A, R2, E2, B>(
+    self: Client.Client<R, E, A>,
+    f: (a: A) => Effect.Effect<B, E2, R2>
+  ) => Client.Client<Exclude<R | R2, Scope.Scope>, E | E2, B>
+>(2, (self, f) => scoped(mapEffect(self, f)))
+
 /** @internal */
 export const mapRequest = dual<
   (
@@ -532,7 +555,7 @@ export const schemaFunction = dual<
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>,
+  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, Exclude<SR | R, Scope.Scope>>,
   <R, E, A, SA, SI, SR>(
     self: Client.Client<R, E, A>,
     schema: Schema.Schema<SA, SI, SR>
@@ -540,27 +563,29 @@ export const schemaFunction = dual<
     request: ClientRequest.ClientRequest
   ) => (
     a: SA
-  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, SR | R>
+  ) => Effect.Effect<A, E | ParseResult.ParseError | Error.RequestError, Exclude<SR | R, Scope.Scope>>
 >(2, (self, schema) => {
   const encode = Schema.encode(schema)
   return (request) => (a) =>
-    Effect.flatMap(
-      Effect.tryMap(encode(a), {
-        try: (body) => new TextEncoder().encode(JSON.stringify(body)),
-        catch: (error) =>
-          internalError.requestError({
-            request,
-            reason: "Encode",
-            error
-          })
-      }),
-      (body) =>
-        self(
-          internalRequest.setBody(
-            request,
-            internalBody.uint8Array(body, "application/json")
+    Effect.scoped(
+      Effect.flatMap(
+        Effect.tryMap(encode(a), {
+          try: (body) => new TextEncoder().encode(JSON.stringify(body)),
+          catch: (error) =>
+            internalError.requestError({
+              request,
+              reason: "Encode",
+              error
+            })
+        }),
+        (body) =>
+          self(
+            internalRequest.setBody(
+              request,
+              internalBody.uint8Array(body, "application/json")
+            )
           )
-        )
+      )
     )
 })
 

package/src/internal/http/clientResponse.ts

@@ -170,3 +170,56 @@ export const schemaNoBody = <
       headers: self.headers
     })
 }
+
+/** @internal */
+export const arrayBuffer = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.arrayBuffer))
+
+/** @internal */
+export const text = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.text))
+
+/** @internal */
+export const json = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.json))
+
+/** @internal */
+export const urlParamsBody = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.urlParamsBody))
+
+/** @internal */
+export const formData = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Effect.scoped(Effect.flatMap(effect, (_) => _.formData))
+
+/** @internal */
+export const stream = <E, R>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R>) =>
+  Stream.unwrapScoped(Effect.map(effect, (_) => _.stream))
+
+/** @internal */
+export const schemaJsonEffect = <
+  R,
+  I extends {
+    readonly status?: number | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
+    readonly body?: unknown | undefined
+  },
+  A
+>(schema: Schema.Schema<A, I, R>) => {
+  const decode = schemaJson(schema)
+  return <E, R2>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R2>) =>
+    Effect.scoped(Effect.flatMap(effect, decode))
+}
+
+/** @internal */
+export const schemaNoBodyEffect = <
+  R,
+  I extends {
+    readonly status?: number | undefined
+    readonly headers?: Readonly<Record<string, string>> | undefined
+  },
+  A
+>(schema: Schema.Schema<A, I, R>) => {
+  const decode = schemaNoBody(schema)
+  return <E, R2>(effect: Effect.Effect<ClientResponse.ClientResponse, E, R2>) =>
+    Effect.scoped(Effect.flatMap(effect, decode))
+}

package/src/internal/worker.ts

@@ -176,7 +176,7 @@ export const makeManager = Effect.gen(function*(_) {
                   queue[0],
                   response[1] === 2
                     ? Exit.fail(response[2])
-                    : Exit.die(response[2])
+                    : Exit.failCause(WorkerError.decodeCause(response[2]))
                 )
               }
             }
@@ -282,7 +282,7 @@ export const makeManager = Effect.gen(function*(_) {
           yield* _(
             Effect.sync(initialMessage),
             Effect.flatMap(executeEffect),
-            Effect.mapError((error) => WorkerError("spawn", error))
+            Effect.mapError((error) => new WorkerError({ reason: "spawn", error }))
           )
         }
 
@@ -363,7 +363,10 @@ export const makeSerialized = <
       manager.spawn({
         ...options as any,
         encode(message) {
-          return Effect.mapError(Serializable.serialize(message as any), (error) => WorkerError("encode", error))
+          return Effect.mapError(
+            Serializable.serialize(message as any),
+            (error) => new WorkerError({ reason: "encode", error })
+          )
         }
       })
     )

package/src/internal/workerError.ts

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

package/src/internal/workerRunner.ts

@@ -16,7 +16,7 @@ import * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
 import * as Transferable from "../Transferable.js"
 import type * as Worker from "../Worker.js"
-import * as WorkerError from "../WorkerError.js"
+import { WorkerError } from "../WorkerError.js"
 import type * as WorkerRunner from "../WorkerRunner.js"
 
 /** @internal */
@@ -51,7 +51,7 @@ export const make = <I, R, E, O>(
     yield* _(
       Queue.take(backing.queue),
       options?.decode ?
-        Effect.flatMap((req): Effect.Effect<Worker.Worker.Request<I>, WorkerError.WorkerError> => {
+        Effect.flatMap((req): Effect.Effect<Worker.Worker.Request<I>, WorkerError> => {
           if (req[1] === 1) {
             return Effect.succeed(req)
           }
@@ -86,10 +86,10 @@ export const make = <I, R, E, O>(
                         ...collector.unsafeRead()
                       ])
                     ),
-                    Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
+                    Effect.catchAllCause((cause) => backing.send([id, 3, WorkerError.encodeCause(cause)]))
                   )
                 },
-                onRight: (cause) => backing.send([id, 3, Cause.squash(cause)])
+                onRight: (cause) => backing.send([id, 3, WorkerError.encodeCause(cause)])
               }),
             onSuccess: (data) => {
               const transfers = options?.transfers ? options.transfers(data) : []
@@ -103,7 +103,7 @@ export const make = <I, R, E, O>(
                     ...collector.unsafeRead()
                   ])
                 ),
-                Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
+                Effect.catchAllCause((cause) => backing.send([id, 3, WorkerError.encodeCause(cause)]))
               )
             }
           }) :
@@ -152,10 +152,10 @@ export const make = <I, R, E, O>(
                           ...collector.unsafeRead()
                         ])
                       ),
-                      Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
+                      Effect.catchAllCause((cause) => backing.send([id, 3, WorkerError.encodeCause(cause)]))
                     )
                   },
-                  onRight: (cause) => backing.send([id, 3, Cause.squash(cause)])
+                  onRight: (cause) => backing.send([id, 3, WorkerError.encodeCause(cause)])
                 }),
               onSuccess: () => backing.send([id, 1])
             })
@@ -188,8 +188,7 @@ export const make = <I, R, E, O>(
 export const layer = <I, R, E, O>(
   process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: WorkerRunner.Runner.Options<I, E, O>
-): Layer.Layer<never, WorkerError.WorkerError, WorkerRunner.PlatformRunner | R> =>
-  Layer.scopedDiscard(make(process, options))
+): Layer.Layer<never, WorkerError, WorkerRunner.PlatformRunner | R> => Layer.scopedDiscard(make(process, options))
 
 /** @internal */
 export const makeSerialized = <
@@ -202,7 +201,7 @@ export const makeSerialized = <
   handlers: Handlers
 ): Effect.Effect<
   void,
-  WorkerError.WorkerError,
+  WorkerError,
   | R
   | WorkerRunner.PlatformRunner
   | Scope.Scope
@@ -228,19 +227,19 @@ export const makeSerialized = <
       decode(message) {
         return Effect.mapError(
           parseRequest(message),
-          (error) => WorkerError.WorkerError("decode", error)
+          (error) => new WorkerError({ reason: "decode", error })
         )
       },
       encodeError(request, message) {
         return Effect.mapError(
           Serializable.serializeFailure(request as any, message),
-          (error) => WorkerError.WorkerError("encode", error)
+          (error) => new WorkerError({ reason: "encode", error })
         )
       },
       encodeOutput(request, message) {
-        return Effect.mapError(
+        return Effect.catchAllCause(
           Serializable.serializeSuccess(request as any, message),
-          (error) => WorkerError.WorkerError("encode", error)
+          (error) => new WorkerError({ reason: "encode", error })
         )
       }
     }))
@@ -257,7 +256,7 @@ export const layerSerialized = <
   handlers: Handlers
 ): Layer.Layer<
   never,
-  WorkerError.WorkerError,
+  WorkerError,
   | R
   | WorkerRunner.PlatformRunner
   | WorkerRunner.SerializedRunner.HandlersContext<Handlers>