@effect/platform 0.64.1 → 0.65.1

package/src/internal/httpClient.ts

@@ -7,25 +7,23 @@ import type * as Fiber from "effect/Fiber"
 import * as FiberRef from "effect/FiberRef"
 import { constFalse, dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
+import * as Inspectable from "effect/Inspectable"
 import * as Layer from "effect/Layer"
 import { pipeArguments } from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import * as Ref from "effect/Ref"
 import type * as Schedule from "effect/Schedule"
 import * as Scope from "effect/Scope"
-import * as Stream from "effect/Stream"
 import * as Cookies from "../Cookies.js"
 import * as Headers from "../Headers.js"
 import type * as Client from "../HttpClient.js"
 import * as Error from "../HttpClientError.js"
 import type * as ClientRequest from "../HttpClientRequest.js"
 import type * as ClientResponse from "../HttpClientResponse.js"
-import * as Method from "../HttpMethod.js"
 import * as TraceContext from "../HttpTraceContext.js"
 import * as UrlParams from "../UrlParams.js"
 import * as internalBody from "./httpBody.js"
 import * as internalRequest from "./httpClientRequest.js"
-import * as internalResponse from "./httpClientResponse.js"
 
 /** @internal */
 export const TypeId: Client.TypeId = Symbol.for(
@@ -33,7 +31,7 @@ export const TypeId: Client.TypeId = Symbol.for(
 ) as Client.TypeId
 
 /** @internal */
-export const tag = Context.GenericTag<Client.HttpClient.Default>("@effect/platform/HttpClient")
+export const tag = Context.GenericTag<Client.HttpClient.Service>("@effect/platform/HttpClient")
 
 /** @internal */
 export const currentTracerDisabledWhen = globalValue(
@@ -69,57 +67,72 @@ export const withTracerPropagation = dual<
   ) => Effect.Effect<A, E, R>
 >(2, (self, enabled) => Effect.locally(self, currentTracerPropagation, enabled))
 
-/** @internal */
-export const currentFetchOptions = globalValue(
-  Symbol.for("@effect/platform/HttpClient/currentFetchOptions"),
-  () => FiberRef.unsafeMake<RequestInit>({})
-)
-
-/** @internal */
-export const withFetchOptions = dual<
-  (
-    options: RequestInit
-  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
-  <A, E, R>(
-    effect: Effect.Effect<A, E, R>,
-    options: RequestInit
-  ) => Effect.Effect<A, E, R>
->(2, (self, options) => Effect.locally(self, currentFetchOptions, options))
-
-const clientProto = {
+const ClientProto = {
   [TypeId]: TypeId,
   pipe() {
     return pipeArguments(this, arguments)
+  },
+  ...Inspectable.BaseProto,
+  toJSON() {
+    return {
+      _id: "@effect/platform/HttpClient"
+    }
+  },
+  get(this: Client.HttpClient.Service, url: string | URL, options?: ClientRequest.Options.NoBody) {
+    return this.execute(internalRequest.get(url, options))
+  },
+  head(this: Client.HttpClient.Service, url: string | URL, options?: ClientRequest.Options.NoBody) {
+    return this.execute(internalRequest.head(url, options))
+  },
+  post(this: Client.HttpClient.Service, url: string | URL, options: ClientRequest.Options.NoUrl) {
+    return this.execute(internalRequest.post(url, options))
+  },
+  put(this: Client.HttpClient.Service, url: string | URL, options: ClientRequest.Options.NoUrl) {
+    return this.execute(internalRequest.put(url, options))
+  },
+  patch(this: Client.HttpClient.Service, url: string | URL, options: ClientRequest.Options.NoUrl) {
+    return this.execute(internalRequest.patch(url, options))
+  },
+  del(this: Client.HttpClient.Service, url: string | URL, options?: ClientRequest.Options.NoUrl) {
+    return this.execute(internalRequest.del(url, options))
+  },
+  options(this: Client.HttpClient.Service, url: string | URL, options?: ClientRequest.Options.NoBody) {
+    return this.execute(internalRequest.options(url, options))
   }
 }
 
 const isClient = (u: unknown): u is Client.HttpClient<unknown, unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
+interface HttpClientImpl<A, E, R> extends Client.HttpClient<A, E, R> {
+  readonly preprocess: Client.HttpClient.Preprocess<E, R>
+  readonly postprocess: Client.HttpClient.Postprocess<A, E, R>
+}
+
 /** @internal */
 export const make = <E2, R2, A, E, R>(
-  execute: (
+  postprocess: (
     request: Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => Effect.Effect<A, E, R>,
   preprocess: Client.HttpClient.Preprocess<E2, R2>
 ): Client.HttpClient<A, E, R> => {
-  function client(request: ClientRequest.HttpClientRequest) {
-    return execute(preprocess(request))
+  const self = Object.create(ClientProto)
+  self.preprocess = preprocess
+  self.postprocess = postprocess
+  self.execute = function(request: ClientRequest.HttpClientRequest) {
+    return postprocess(preprocess(request))
   }
-  Object.setPrototypeOf(client, clientProto)
-  ;(client as any).preprocess = preprocess
-  ;(client as any).execute = execute
-  return client as any
+  return self
 }
 
 /** @internal */
-export const makeDefault = (
+export const makeService = (
   f: (
     request: ClientRequest.HttpClientRequest,
     url: URL,
     signal: AbortSignal,
     fiber: Fiber.RuntimeFiber<ClientResponse.HttpClientResponse, Error.HttpClientError>
   ) => Effect.Effect<ClientResponse.HttpClientResponse, Error.HttpClientError, Scope.Scope>
-): Client.HttpClient.Default =>
+): Client.HttpClient.Service =>
   make((effect) =>
     Effect.flatMap(effect, (request) =>
       Effect.withFiberRuntime((fiber) => {
@@ -188,52 +201,6 @@ export const makeDefault = (
         )
       })), Effect.succeed as Client.HttpClient.Preprocess<never, never>)
 
-/** @internal */
-export const Fetch = Context.GenericTag<Client.Fetch, typeof globalThis.fetch>(
-  "@effect/platform/HttpClient/Fetch"
-)
-
-/** @internal */
-export const fetch: Client.HttpClient.Default = makeDefault((request, url, signal, fiber) => {
-  const context = fiber.getFiberRef(FiberRef.currentContext)
-  const fetch: typeof globalThis.fetch = context.unsafeMap.get(Fetch.key) ?? globalThis.fetch
-  const options = fiber.getFiberRef(currentFetchOptions)
-  const headers = new globalThis.Headers(request.headers)
-  const send = (body: BodyInit | undefined) =>
-    Effect.map(
-      Effect.tryPromise({
-        try: () =>
-          fetch(url, {
-            ...options,
-            method: request.method,
-            headers,
-            body,
-            duplex: request.body._tag === "Stream" ? "half" : undefined,
-            signal
-          } as any),
-        catch: (cause) =>
-          new Error.RequestError({
-            request,
-            reason: "Transport",
-            cause
-          })
-      }),
-      (response) => internalResponse.fromWeb(request, response)
-    )
-  if (Method.hasBody(request.method)) {
-    switch (request.body._tag) {
-      case "Raw":
-      case "Uint8Array":
-        return send(request.body.body as any)
-      case "FormData":
-        return send(request.body.formData)
-      case "Stream":
-        return Effect.flatMap(Stream.toReadableStreamEffect(request.body.stream), send)
-    }
-  }
-  return send(undefined)
-})
-
 /** @internal */
 export const transform = dual<
   <A, E, R, A1, E1, R1>(
@@ -249,11 +216,13 @@ export const transform = dual<
       request: ClientRequest.HttpClientRequest
     ) => Effect.Effect<A1, E1, R1>
   ) => Client.HttpClient<A1, E | E1, R | R1>
->(2, (self, f) =>
-  make(
-    Effect.flatMap((request) => f(self.execute(Effect.succeed(request)), request)),
-    self.preprocess
-  ))
+>(2, (self, f) => {
+  const client = self as HttpClientImpl<any, any, any>
+  return make(
+    Effect.flatMap((request) => f(client.postprocess(Effect.succeed(request)), request)),
+    client.preprocess
+  )
+})
 
 /** @internal */
 export const filterStatus = dual<
@@ -297,12 +266,6 @@ export const filterStatusOk = <E, R>(
         })
     ))
 
-/** @internal */
-export const fetchOk: Client.HttpClient.Default = filterStatusOk(fetch)
-
-/** @internal */
-export const layer = Layer.succeed(tag, fetch)
-
 /** @internal */
 export const transformResponse = dual<
   <A, E, R, A1, E1, R1>(
@@ -312,7 +275,10 @@ export const transformResponse = dual<
     self: Client.HttpClient<A, E, R>,
     f: (effect: Effect.Effect<A, E, R>) => Effect.Effect<A1, E1, R1>
   ) => Client.HttpClient<A1, E1, R1>
->(2, (self, f) => make((request) => f(self.execute(request)), self.preprocess))
+>(2, (self, f) => {
+  const client = self as HttpClientImpl<any, any, any>
+  return make((request) => f(client.postprocess(request)), client.preprocess)
+})
 
 /** @internal */
 export const catchTag: {
@@ -510,32 +476,50 @@ export const catchAll: {
 )
 
 /** @internal */
-export const filterOrElse = dual<
+export const filterOrElse: {
+  <A, B extends A, C, E2, R2>(
+    refinement: Predicate.Refinement<NoInfer<A>, B>,
+    orElse: (a: NoInfer<A>) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B | C, E | E2, R | R2>
   <A, B, E2, R2>(
-    f: Predicate.Predicate<A>,
-    orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ) => <E, R>(
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => Effect.Effect<B, E2, R2>
+  ): <E, R>(
     self: Client.HttpClient<A, E, R>
-  ) => Client.HttpClient<A | B, E2 | E, R2 | R>,
+  ) => Client.HttpClient<A | B, E2 | E, R2 | R>
+  <A, E, R, B extends A, C, E2, R2>(
+    self: Client.HttpClient<A, E, R>,
+    refinement: Predicate.Refinement<A, B>,
+    orElse: (a: A) => Effect.Effect<C, E2, R2>
+  ): Client.HttpClient<B | C, E | E2, R | R2>
   <A, E, R, B, E2, R2>(
     self: Client.HttpClient<A, E, R>,
-    f: Predicate.Predicate<A>,
+    predicate: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<B, E2, R2>
-  ) => Client.HttpClient<A | B, E2 | E, R2 | R>
->(3, (self, f, orElse) => transformResponse(self, Effect.filterOrElse(f, orElse)))
+  ): Client.HttpClient<A | B, E2 | E, R2 | R>
+} = dual(3, (self, f, orElse) => transformResponse(self, Effect.filterOrElse(f, orElse)))
 
 /** @internal */
-export const filterOrFail = dual<
+export const filterOrFail: {
+  <A, B extends A, E2>(
+    refinement: Predicate.Refinement<NoInfer<A>, B>,
+    orFailWith: (a: NoInfer<A>) => E2
+  ): <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<B, E | E2, R>
   <A, E2>(
-    f: Predicate.Predicate<A>,
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orFailWith: (a: NoInfer<A>) => E2
+  ): <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E2 | E, R>
+  <A, B extends A, E, R, E2>(
+    self: Client.HttpClient<A, E, R>,
+    refinement: Predicate.Refinement<A, B>,
     orFailWith: (a: A) => E2
-  ) => <E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E2 | E, R>,
+  ): Client.HttpClient<B, E2 | E, R>
   <A, E, R, E2>(
     self: Client.HttpClient<A, E, R>,
-    f: Predicate.Predicate<A>,
+    predicate: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
-  ) => Client.HttpClient<A, E2 | E, R>
->(3, (self, f, orFailWith) => transformResponse(self, Effect.filterOrFail(f, orFailWith)))
+  ): Client.HttpClient<A, E2 | E, R>
+} = dual(3, (self, f, orFailWith) => transformResponse(self, Effect.filterOrFail(f, orFailWith)))
 
 /** @internal */
 export const map = dual<
@@ -584,7 +568,10 @@ export const mapRequest = dual<
     self: Client.HttpClient<A, E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
   ) => Client.HttpClient<A, E, R>
->(2, (self, f) => make(self.execute, (request) => Effect.map(self.preprocess(request), f)))
+>(2, (self, f) => {
+  const client = self as HttpClientImpl<any, any, any>
+  return make(client.postprocess, (request) => Effect.map(client.preprocess(request), f))
+})
 
 /** @internal */
 export const mapRequestEffect = dual<
@@ -601,10 +588,13 @@ export const mapRequestEffect = dual<
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => Client.HttpClient<A, E | E2, R | R2>
->(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(self.preprocess(request), f)))
+>(2, (self, f) => {
+  const client = self as HttpClientImpl<any, any, any>
+  return make(client.postprocess as any, (request) => Effect.flatMap(client.preprocess(request), f))
+})
 
 /** @internal */
-export const mapInputRequest = dual<
+export const mapRequestInput = dual<
   (
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
   ) => <A, E, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R>,
@@ -612,10 +602,13 @@ export const mapInputRequest = dual<
     self: Client.HttpClient<A, E, R>,
     f: (a: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest
   ) => Client.HttpClient<A, E, R>
->(2, (self, f) => make(self.execute, (request) => self.preprocess(f(request))))
+>(2, (self, f) => {
+  const client = self as HttpClientImpl<any, any, any>
+  return make(client.postprocess, (request) => client.preprocess(f(request)))
+})
 
 /** @internal */
-export const mapInputRequestEffect = dual<
+export const mapRequestInputEffect = dual<
   <E2, R2>(
     f: (
       a: ClientRequest.HttpClientRequest
@@ -629,17 +622,29 @@ export const mapInputRequestEffect = dual<
       a: ClientRequest.HttpClientRequest
     ) => Effect.Effect<ClientRequest.HttpClientRequest, E2, R2>
   ) => Client.HttpClient<A, E | E2, R | R2>
->(2, (self, f) => make(self.execute as any, (request) => Effect.flatMap(f(request), self.preprocess)))
+>(2, (self, f) => {
+  const client = self as HttpClientImpl<any, any, any>
+  return make(client.postprocess as any, (request) => Effect.flatMap(f(request), client.preprocess))
+})
 
 /** @internal */
 export const retry: {
-  <R1, E extends E0, E0, B>(
-    policy: Schedule.Schedule<B, E0, R1>
+  <E, O extends Effect.Retry.Options<E>>(
+    options: O
+  ): <A, R>(
+    self: Client.HttpClient<A, E, R>
+  ) => Client.Retry.Return<R, E, A, O>
+  <B, E, R1>(
+    policy: Schedule.Schedule<B, NoInfer<E>, R1>
   ): <A, R>(self: Client.HttpClient<A, E, R>) => Client.HttpClient<A, E, R1 | R>
-  <A, E extends E0, E0, R, R1, B>(
+  <A, E, R, O extends Effect.Retry.Options<E>>(
     self: Client.HttpClient<A, E, R>,
-    policy: Schedule.Schedule<B, E0, R1>
-  ): Client.HttpClient<A, E, R | R1>
+    options: O
+  ): Client.Retry.Return<R, E, A, O>
+  <A, E, R, B, R1>(
+    self: Client.HttpClient<A, E, R>,
+    policy: Schedule.Schedule<B, E, R1>
+  ): Client.HttpClient<A, E, R1 | R>
 } = dual(
   2,
   <A, E extends E0, E0, R, R1, B>(
@@ -683,7 +688,7 @@ export const schemaFunction = dual<
           })
       }),
       (body) =>
-        self(
+        self.execute(
           internalRequest.setBody(
             request,
             internalBody.uint8Array(body, "application/json")
@@ -714,7 +719,10 @@ export const tapRequest = dual<
     self: Client.HttpClient<A, E, R>,
     f: (a: ClientRequest.HttpClientRequest) => Effect.Effect<_, E2, R2>
   ) => Client.HttpClient<A, E | E2, R | R2>
->(2, (self, f) => make(self.execute as any, (request) => Effect.tap(self.preprocess(request), f)))
+>(2, (self, f) => {
+  const client = self as HttpClientImpl<any, any, any>
+  return make(client.postprocess as any, (request) => Effect.tap(client.preprocess(request), f))
+})
 
 /** @internal */
 export const withCookiesRef = dual<
@@ -730,15 +738,16 @@ export const withCookiesRef = dual<
   <E, R>(
     self: Client.HttpClient.WithResponse<E, R>,
     ref: Ref.Ref<Cookies.Cookies>
-  ): Client.HttpClient.WithResponse<E, R> =>
-    make(
+  ): Client.HttpClient.WithResponse<E, R> => {
+    const client = self as HttpClientImpl<ClientResponse.HttpClientResponse, E, R>
+    return make(
       (request: Effect.Effect<ClientRequest.HttpClientRequest, E, R>) =>
         Effect.tap(
-          self.execute(request),
+          client.postprocess(request),
           (response) => Ref.update(ref, (cookies) => Cookies.merge(cookies, response.cookies))
         ),
       (request) =>
-        Effect.flatMap(self.preprocess(request), (request) =>
+        Effect.flatMap(client.preprocess(request), (request) =>
           Effect.map(
             Ref.get(ref),
             (cookies) =>
@@ -747,6 +756,7 @@ export const withCookiesRef = dual<
                 : internalRequest.setHeader(request, "cookie", Cookies.toCookieHeader(cookies))
           ))
     )
+  }
 )
 
 /** @internal */
@@ -761,15 +771,16 @@ export const followRedirects = dual<
 >((args) => isClient(args[0]), <E, R>(
   self: Client.HttpClient.WithResponse<E, R>,
   maxRedirects?: number | undefined
-): Client.HttpClient.WithResponse<E, R> =>
-  make(
+): Client.HttpClient.WithResponse<E, R> => {
+  const client = self as HttpClientImpl<ClientResponse.HttpClientResponse, E, R>
+  return make(
     (request) => {
       const loop = (
         request: ClientRequest.HttpClientRequest,
         redirects: number
       ): Effect.Effect<ClientResponse.HttpClientResponse, E, R> =>
         Effect.flatMap(
-          self.execute(Effect.succeed(request)),
+          client.postprocess(Effect.succeed(request)),
           (response) =>
             response.status >= 300 && response.status < 400 && response.headers.location &&
               redirects < (maxRedirects ?? 10)
@@ -784,5 +795,18 @@ export const followRedirects = dual<
         )
       return Effect.flatMap(request, (request) => loop(request, 0))
     },
-    self.preprocess
-  ))
+    client.preprocess
+  )
+})
+
+/** @internal */
+export const layerMergedContext = <E, R>(effect: Effect.Effect<Client.HttpClient.Service, E, R>) =>
+  Layer.effect(
+    tag,
+    Effect.flatMap(Effect.context<never>(), (context) =>
+      Effect.map(effect, (client) =>
+        transformResponse(
+          client,
+          Effect.mapInputContext((input: Context.Context<Scope.Scope>) => Context.merge(context, input))
+        )))
+  )

package/src/internal/httpClientRequest.ts

@@ -6,6 +6,7 @@ import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
+import * as Redacted from "effect/Redacted"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "../Error.js"
 import type * as FileSystem from "../FileSystem.js"
@@ -21,14 +22,14 @@ import * as internalBody from "./httpBody.js"
 export const TypeId: ClientRequest.TypeId = Symbol.for("@effect/platform/HttpClientRequest") as ClientRequest.TypeId
 
 /** @internal */
-export const clientTag = Context.GenericTag<HttpClient.Default>("@effect/platform/HttpClient")
+export const clientTag = Context.GenericTag<HttpClient.Service>("@effect/platform/HttpClient")
 
 const Proto = {
   [TypeId]: TypeId,
   ...Effectable.CommitPrototype,
   ...Inspectable.BaseProto,
   commit(this: ClientRequest.HttpClientRequest) {
-    return Effect.flatMap(clientTag, (client) => client(this))
+    return Effect.flatMap(clientTag, (client) => client.execute(this))
   },
   toJSON(this: ClientRequest.HttpClientRequest): unknown {
     return {
@@ -171,17 +172,31 @@ export const setHeaders = dual<
     self.body
   ))
 
+const stringOrRedacted = (value: string | Redacted.Redacted): string =>
+  typeof value === "string" ? value : Redacted.value(value)
+
 /** @internal */
 export const basicAuth = dual<
-  (username: string, password: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
-  (self: ClientRequest.HttpClientRequest, username: string, password: string) => ClientRequest.HttpClientRequest
->(3, (self, username, password) => setHeader(self, "Authorization", `Basic ${btoa(`${username}:${password}`)}`))
+  (
+    username: string | Redacted.Redacted,
+    password: string | Redacted.Redacted
+  ) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (
+    self: ClientRequest.HttpClientRequest,
+    username: string | Redacted.Redacted,
+    password: string | Redacted.Redacted
+  ) => ClientRequest.HttpClientRequest
+>(
+  3,
+  (self, username, password) =>
+    setHeader(self, "Authorization", `Basic ${btoa(`${stringOrRedacted(username)}:${stringOrRedacted(password)}`)}`)
+)
 
 /** @internal */
 export const bearerToken = dual<
-  (token: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
-  (self: ClientRequest.HttpClientRequest, token: string) => ClientRequest.HttpClientRequest
->(2, (self, token) => setHeader(self, "Authorization", `Bearer ${token}`))
+  (token: string | Redacted.Redacted) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
+  (self: ClientRequest.HttpClientRequest, token: string | Redacted.Redacted) => ClientRequest.HttpClientRequest
+>(2, (self, token) => setHeader(self, "Authorization", `Bearer ${stringOrRedacted(token)}`))
 
 /** @internal */
 export const accept = dual<
@@ -393,7 +408,7 @@ export const setBody = dual<
 })
 
 /** @internal */
-export const uint8ArrayBody = dual<
+export const bodyUint8Array = dual<
   (
     body: Uint8Array,
     contentType?: string
@@ -405,7 +420,7 @@ export const uint8ArrayBody = dual<
 )
 
 /** @internal */
-export const textBody = dual<
+export const bodyText = dual<
   (body: string, contentType?: string) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
   (self: ClientRequest.HttpClientRequest, body: string, contentType?: string) => ClientRequest.HttpClientRequest
 >(
@@ -414,7 +429,7 @@ export const textBody = dual<
 )
 
 /** @internal */
-export const jsonBody = dual<
+export const bodyJson = dual<
   (
     body: unknown
   ) => (self: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, Body.HttpBodyError>,
@@ -425,13 +440,13 @@ export const jsonBody = dual<
 >(2, (self, body) => Effect.map(internalBody.json(body), (body) => setBody(self, body)))
 
 /** @internal */
-export const unsafeJsonBody = dual<
+export const bodyUnsafeJson = dual<
   (body: unknown) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
   (self: ClientRequest.HttpClientRequest, body: unknown) => ClientRequest.HttpClientRequest
 >(2, (self, body) => setBody(self, internalBody.unsafeJson(body)))
 
 /** @internal */
-export const fileBody = dual<
+export const bodyFile = dual<
   (
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
@@ -449,13 +464,13 @@ export const fileBody = dual<
 )
 
 /** @internal */
-export const fileWebBody = dual<
+export const bodyFileWeb = dual<
   (file: Body.HttpBody.FileLike) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
   (self: ClientRequest.HttpClientRequest, file: Body.HttpBody.FileLike) => ClientRequest.HttpClientRequest
 >(2, (self, file) => setBody(self, internalBody.fileWeb(file)))
 
 /** @internal */
-export const schemaBody = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined): {
+export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined): {
   (
     body: A
   ): (self: ClientRequest.HttpClientRequest) => Effect.Effect<ClientRequest.HttpClientRequest, Body.HttpBodyError, R>
@@ -479,7 +494,7 @@ export const schemaBody = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: Pa
 }
 
 /** @internal */
-export const urlParamsBody = dual<
+export const bodyUrlParams = dual<
   (input: UrlParams.Input) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
   (self: ClientRequest.HttpClientRequest, input: UrlParams.Input) => ClientRequest.HttpClientRequest
 >(2, (self, body) =>
@@ -492,13 +507,13 @@ export const urlParamsBody = dual<
   ))
 
 /** @internal */
-export const formDataBody = dual<
+export const bodyFormData = dual<
   (body: FormData) => (self: ClientRequest.HttpClientRequest) => ClientRequest.HttpClientRequest,
   (self: ClientRequest.HttpClientRequest, body: FormData) => ClientRequest.HttpClientRequest
 >(2, (self, body) => setBody(self, internalBody.formData(body)))
 
 /** @internal */
-export const streamBody = dual<
+export const bodyStream = dual<
   (
     body: Stream.Stream<Uint8Array, unknown>,
     options?: {