@effect/platform 0.31.2 → 0.32.0

package/src/internal/http/client.ts

@@ -22,7 +22,9 @@ import * as internalRequest from "./clientRequest.js"
 import * as internalResponse from "./clientResponse.js"
 
 /** @internal */
-export const TypeId: Client.TypeId = Symbol.for("@effect/platform/Http/Client") as Client.TypeId
+export const TypeId: Client.TypeId = Symbol.for(
+  "@effect/platform/Http/Client"
+) as Client.TypeId
 
 /** @internal */
 export const tag = Context.Tag<Client.Client.Default>(TypeId)
@@ -36,7 +38,9 @@ const clientProto = {
 
 /** @internal */
 export const make = <R, E, A, R2, E2>(
-  execute: (request: Effect.Effect<R2, E2, ClientRequest.ClientRequest>) => Effect.Effect<R, E, A>,
+  execute: (
+    request: Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+  ) => Effect.Effect<R, E, A>,
   preprocess: Client.Client.Preprocess<R2, E2>
 ): Client.Client<R, E, A> => {
   function client(request: ClientRequest.ClientRequest) {
@@ -68,13 +72,20 @@ const addB3Headers = (req: ClientRequest.ClientRequest) =>
 export const makeDefault = (
   f: (
     request: ClientRequest.ClientRequest
-  ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
+  ) => Effect.Effect<
+    never,
+    Error.HttpClientError,
+    ClientResponse.ClientResponse
+  >
 ): Client.Client.Default => make(Effect.flatMap(f), addB3Headers)
 
 /** @internal */
-export const fetch = (
-  options: RequestInit = {}
-): Client.Client.Default =>
+export const Fetch = Context.Tag<Client.Fetch, typeof globalThis.fetch>(
+  Symbol.for("@effect/platform/Http/Client/Fetch")
+)
+
+/** @internal */
+export const fetch = (options: RequestInit = {}): Client.Client.Default =>
   makeDefault((request) =>
     Effect.flatMap(
       UrlParams.makeUrl(request.url, request.urlParams, (_) =>
@@ -84,13 +95,14 @@ export const fetch = (
           error: _
         })),
       (url) =>
-        Effect.suspend(() => {
+        Effect.flatMap(Effect.serviceOption(Fetch), (fetch_) => {
+          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) =>
-                  globalThis.fetch(url, {
+                  fetch(url, {
                     ...options,
                     method: request.method,
                     headers,
@@ -130,9 +142,7 @@ const convertBody = (body: Body.Body): BodyInit | undefined => {
 }
 
 /** @internal */
-export const fetchOk = (
-  options: RequestInit = {}
-): Client.Client.Default => filterStatusOk(fetch(options))
+export const fetchOk = (options: RequestInit = {}): Client.Client.Default => filterStatusOk(fetch(options))
 
 /** @internal */
 export const layer = Layer.succeed(tag, fetch())
@@ -140,20 +150,23 @@ export const layer = Layer.succeed(tag, fetch())
 /** @internal */
 export const transform = dual<
   <R, E, A, R1, E1, A1>(
-    f: (effect: Effect.Effect<R, E, A>, request: ClientRequest.ClientRequest) => Effect.Effect<R1, E1, A1>
+    f: (
+      effect: Effect.Effect<R, E, A>,
+      request: ClientRequest.ClientRequest
+    ) => Effect.Effect<R1, E1, A1>
   ) => (self: Client.Client<R, E, A>) => Client.Client<R | R1, E | E1, A1>,
   <R, E, A, R1, E1, A1>(
     self: Client.Client<R, E, A>,
-    f: (effect: Effect.Effect<R, E, A>, request: ClientRequest.ClientRequest) => Effect.Effect<R1, E1, A1>
+    f: (
+      effect: Effect.Effect<R, E, A>,
+      request: ClientRequest.ClientRequest
+    ) => Effect.Effect<R1, E1, A1>
   ) => Client.Client<R | R1, E | E1, A1>
->(
-  2,
-  (self, f) =>
-    make(
-      Effect.flatMap((request) => f(self.execute(Effect.succeed(request)), request)),
-      self.preprocess
-    )
-)
+>(2, (self, f) =>
+  make(
+    Effect.flatMap((request) => f(self.execute(Effect.succeed(request)), request)),
+    self.preprocess
+  ))
 
 /** @internal */
 export const transformResponse = dual<
@@ -168,20 +181,36 @@ export const transformResponse = dual<
 
 /** @internal */
 export const catchTag: {
-  <K extends (E extends { _tag: string } ? E["_tag"] : never), E, R1, E1, A1>(
+  <K extends E extends { _tag: string } ? E["_tag"] : never, E, R1, E1, A1>(
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
   ): <R, A>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
-  <R, E, A, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1, A1>(
+  <
+    R,
+    E,
+    A,
+    K extends E extends { _tag: string } ? E["_tag"] : never,
+    R1,
+    E1,
+    A1
+  >(
     self: Client.Client<R, E, A>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
   ): Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A>
 } = dual(
   3,
-  <R, E, A, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1, A1>(
+  <
+    R,
+    E,
+    A,
+    K extends E extends { _tag: string } ? E["_tag"] : never,
+    R1,
+    E1,
+    A1
+  >(
     self: Client.Client<R, E, A>,
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
@@ -192,10 +221,21 @@ export const catchTag: {
 export const catchTags: {
   <
     E,
-    Cases
-      extends (E extends { _tag: string }
-        ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) }
-        : {})
+    Cases extends
+      & {
+        [K in Extract<E, { _tag: string }>["_tag"]]+?: (
+          error: Extract<E, { _tag: K }>
+        ) => Effect.Effect<any, any, any>
+      }
+      & (unknown extends E ? {}
+        : {
+          [
+            K in Exclude<
+              keyof Cases,
+              Extract<E, { _tag: string }>["_tag"]
+            >
+          ]: never
+        })
   >(
     cases: Cases
   ): <R, A>(
@@ -227,10 +267,21 @@ export const catchTags: {
     R,
     E extends { _tag: string },
     A,
-    Cases
-      extends (E extends { _tag: string }
-        ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) }
-        : {})
+    Cases extends
+      & {
+        [K in Extract<E, { _tag: string }>["_tag"]]+?: (
+          error: Extract<E, { _tag: K }>
+        ) => Effect.Effect<any, any, any>
+      }
+      & (unknown extends E ? {}
+        : {
+          [
+            K in Exclude<
+              keyof Cases,
+              Extract<E, { _tag: string }>["_tag"]
+            >
+          ]: never
+        })
   >(
     self: Client.Client<R, E, A>,
     cases: Cases
@@ -263,10 +314,21 @@ export const catchTags: {
     R,
     E extends { _tag: string },
     A,
-    Cases
-      extends (E extends { _tag: string }
-        ? { [K in E["_tag"]]+?: ((error: Extract<E, { _tag: K }>) => Effect.Effect<any, any, any>) }
-        : {})
+    Cases extends
+      & {
+        [K in Extract<E, { _tag: string }>["_tag"]]+?: (
+          error: Extract<E, { _tag: K }>
+        ) => Effect.Effect<any, any, any>
+      }
+      & (unknown extends E ? {}
+        : {
+          [
+            K in Exclude<
+              keyof Cases,
+              Extract<E, { _tag: string }>["_tag"]
+            >
+          ]: never
+        })
   >(
     self: Client.Client<R, E, A>,
     cases: Cases
@@ -297,9 +359,9 @@ export const catchTags: {
 
 /** @internal */
 export const catchAll: {
-  <E, R2, E2, A2>(f: (e: E) => Effect.Effect<R2, E2, A2>): <R, A>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R | R2, E2, A2 | A>
+  <E, R2, E2, A2>(
+    f: (e: E) => Effect.Effect<R2, E2, A2>
+  ): <R, A>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E2, A2 | A>
   <R, E, A, R2, E2, A2>(
     self: Client.Client<R, E, A>,
     f: (e: E) => Effect.Effect<R2, E2, A2>
@@ -314,7 +376,10 @@ export const catchAll: {
 
 /** @internal */
 export const filterOrElse = dual<
-  <A, R2, E2, B>(f: Predicate.Predicate<A>, orElse: (a: A) => Effect.Effect<R2, E2, B>) => <R, E>(
+  <A, R2, E2, B>(
+    f: Predicate.Predicate<A>,
+    orElse: (a: A) => Effect.Effect<R2, E2, B>
+  ) => <R, E>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R2 | R, E2 | E, A | B>,
   <R, E, A, R2, E2, B>(
@@ -326,9 +391,10 @@ export const filterOrElse = dual<
 
 /** @internal */
 export const filterOrFail = dual<
-  <A, E2>(f: Predicate.Predicate<A>, orFailWith: (a: A) => E2) => <R, E>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R, E2 | E, A>,
+  <A, E2>(
+    f: Predicate.Predicate<A>,
+    orFailWith: (a: A) => E2
+  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R, E2 | E, A>,
   <R, E, A, E2>(
     self: Client.Client<R, E, A>,
     f: Predicate.Predicate<A>,
@@ -338,40 +404,41 @@ export const filterOrFail = dual<
 
 /** @internal */
 export const filterStatus = dual<
-  (f: (status: number) => boolean) => <R, E>(
+  (
+    f: (status: number) => boolean
+  ) => <R, E>(
     self: Client.Client.WithResponse<R, E>
   ) => Client.Client.WithResponse<R, E | Error.ResponseError>,
   <R, E>(
     self: Client.Client.WithResponse<R, E>,
     f: (status: number) => boolean
   ) => Client.Client.WithResponse<R, E | Error.ResponseError>
->(
-  2,
-  (self, f) =>
-    transform(self, (effect, request) =>
-      Effect.filterOrFail(
-        effect,
-        (response) => f(response.status),
-        (response) =>
-          internalError.responseError({
-            request,
-            response,
-            reason: "StatusCode",
-            error: "non 2xx status code"
-          })
-      ))
-)
+>(2, (self, f) =>
+  transform(self, (effect, request) =>
+    Effect.filterOrFail(
+      effect,
+      (response) => f(response.status),
+      (response) =>
+        internalError.responseError({
+          request,
+          response,
+          reason: "StatusCode",
+          error: "non 2xx status code"
+        })
+    )))
 
 /** @internal */
 export const filterStatusOk: <R, E>(
   self: Client.Client.WithResponse<R, E>
-) => Client.Client.WithResponse<R, E | Error.ResponseError> = filterStatus((status) => status >= 200 && status < 300)
+) => Client.Client.WithResponse<R, E | Error.ResponseError> = filterStatus(
+  (status) => status >= 200 && status < 300
+)
 
 /** @internal */
 export const map = dual<
-  <A, B>(f: (a: A) => B) => <R, E>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R, E, B>,
+  <A, B>(
+    f: (a: A) => B
+  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R, E, B>,
   <R, E, A, B>(
     self: Client.Client<R, E, A>,
     f: (a: A) => B
@@ -380,9 +447,9 @@ export const map = dual<
 
 /** @internal */
 export const mapEffect = dual<
-  <A, R2, E2, B>(f: (a: A) => Effect.Effect<R2, E2, B>) => <R, E>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R | R2, E | E2, B>,
+  <A, R2, E2, B>(
+    f: (a: A) => Effect.Effect<R2, E2, B>
+  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E | E2, B>,
   <R, E, A, R2, E2, B>(
     self: Client.Client<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, B>
@@ -391,9 +458,9 @@ export const mapEffect = dual<
 
 /** @internal */
 export const mapRequest = dual<
-  (f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest) => <R, E, A>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R, E, A>,
+  (
+    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
+  ) => <R, E, A>(self: Client.Client<R, E, A>) => Client.Client<R, E, A>,
   <R, E, A>(
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
@@ -402,20 +469,54 @@ export const mapRequest = dual<
 
 /** @internal */
 export const mapRequestEffect = dual<
-  <R2, E2>(f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>) => <R, E, A>(
+  <R2, E2>(
+    f: (
+      a: ClientRequest.ClientRequest
+    ) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+  ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R | R2, E | E2, A>,
   <R, E, A, R2, E2>(
     self: Client.Client<R, E, A>,
-    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+    f: (
+      a: ClientRequest.ClientRequest
+    ) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
   ) => Client.Client<R | R2, E | E2, A>
 >(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(self.preprocess(request), f)))
 
 /** @internal */
-export const retry: {
-  <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(
+export const mapInputRequest = dual<
+  (
+    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
+  ) => <R, E, A>(self: Client.Client<R, E, A>) => Client.Client<R, E, A>,
+  <R, E, A>(
+    self: Client.Client<R, E, A>,
+    f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
+  ) => Client.Client<R, E, A>
+>(2, (self, f) => make(self.execute, (request) => self.preprocess(f(request))))
+
+/** @internal */
+export const mapInputRequestEffect = dual<
+  <R2, E2>(
+    f: (
+      a: ClientRequest.ClientRequest
+    ) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+  ) => <R, E, A>(
     self: Client.Client<R, E, A>
-  ) => Client.Client<R1 | R, E, A>
+  ) => Client.Client<R | R2, E | E2, A>,
+  <R, E, A, R2, E2>(
+    self: Client.Client<R, E, A>,
+    f: (
+      a: ClientRequest.ClientRequest
+    ) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
+  ) => Client.Client<R | R2, E | E2, A>
+>(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(f(request), self.preprocess)))
+
+/** @internal */
+export const retry: {
+  <R1, E extends E0, E0, B>(
+    policy: Schedule.Schedule<R1, E0, B>
+  ): <R, A>(self: Client.Client<R, E, A>) => Client.Client<R1 | R, E, A>
   <R, E extends E0, E0, A, R1, B>(
     self: Client.Client<R, E, A>,
     policy: Schedule.Schedule<R1, E0, B>
@@ -436,13 +537,17 @@ export const schemaFunction = dual<
     self: Client.Client<R, E, A>
   ) => (
     request: ClientRequest.ClientRequest
-  ) => (a: SA) => Effect.Effect<R, E | ParseResult.ParseError | Error.RequestError, A>,
+  ) => (
+    a: SA
+  ) => Effect.Effect<R, E | ParseResult.ParseError | Error.RequestError, A>,
   <R, E, A, SI, SA>(
     self: Client.Client<R, E, A>,
     schema: Schema.Schema<SI, SA>
   ) => (
     request: ClientRequest.ClientRequest
-  ) => (a: SA) => Effect.Effect<R, E | ParseResult.ParseError | Error.RequestError, A>
+  ) => (
+    a: SA
+  ) => Effect.Effect<R, E | ParseResult.ParseError | Error.RequestError, A>
 >(2, (self, schema) => {
   const encode = Schema.encode(schema)
   return (request) => (a) =>
@@ -457,18 +562,20 @@ export const schemaFunction = dual<
           })
       }),
       (body) =>
-        self(internalRequest.setBody(
-          request,
-          internalBody.uint8Array(body, "application/json")
-        ))
+        self(
+          internalRequest.setBody(
+            request,
+            internalBody.uint8Array(body, "application/json")
+          )
+        )
     )
 })
 
 /** @internal */
 export const tap = dual<
-  <A, R2, E2, _>(f: (a: A) => Effect.Effect<R2, E2, _>) => <R, E>(
-    self: Client.Client<R, E, A>
-  ) => Client.Client<R | R2, E | E2, A>,
+  <A, R2, E2, _>(
+    f: (a: A) => Effect.Effect<R2, E2, _>
+  ) => <R, E>(self: Client.Client<R, E, A>) => Client.Client<R | R2, E | E2, A>,
   <R, E, A, R2, E2, _>(
     self: Client.Client<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, _>
@@ -477,7 +584,9 @@ export const tap = dual<
 
 /** @internal */
 export const tapRequest = dual<
-  <R2, E2, _>(f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>) => <R, E, A>(
+  <R2, E2, _>(
+    f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
+  ) => <R, E, A>(
     self: Client.Client<R, E, A>
   ) => Client.Client<R | R2, E | E2, A>,
   <R, E, A, R2, E2, _>(

package/src/internal/http/router.ts

@@ -79,7 +79,8 @@ class RouterImpl<R, E> extends Effectable.StructuralClass<
     }
   }
   toString() {
-    return Inspectable.toString(this)
+    // TODO: remove any when fix lands
+    return (Inspectable as any).format(this)
   }
   [Inspectable.NodeInspectSymbol]() {
     return this.toJSON()

package/src/internal/worker.ts

@@ -283,11 +283,4 @@ export const makePoolLayer = <W>(managerLayer: Layer.Layer<never, never, Worker.
 <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)
-    )
-  )
+) => Layer.scoped(tag, makePool<W>()(options)).pipe(Layer.provide(managerLayer))