@effect/platform 0.11.5 → 0.12.1

package/src/internal/http/client.ts

@@ -9,6 +9,7 @@ import type * as Body from "@effect/platform/Http/Body"
 import type * as Client from "@effect/platform/Http/Client"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
+import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
 import * as Method from "@effect/platform/Http/Method"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalBody from "@effect/platform/internal/http/body"
@@ -22,15 +23,33 @@ import * as Stream from "@effect/stream/Stream"
 /** @internal */
 export const tag = Context.Tag<Client.Client.Default>("@effect/platform/Http/Client")
 
+const clientProto = {
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const setProto = <R, E, A>(
+  f: (request: ClientRequest.ClientRequest.NonEffectBody) => Effect.Effect<R, E, A>
+) => {
+  Object.setPrototypeOf(f, clientProto)
+  return f as Client.Client<R, E, A>
+}
+
 /** @internal */
-export const make = <R, E, A>(
-  f: (request: ClientRequest.ClientRequest) => Effect.Effect<R, E, A>
-): Client.Client<R, E, A> =>
-  Object.assign(f, {
-    pipe() {
-      return pipeArguments(this, arguments)
-    }
-  })
+export const make = (
+  f: (
+    request: ClientRequest.ClientRequest.NonEffectBody
+  ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
+): Client.Client.Default => {
+  function client(request: ClientRequest.ClientRequest) {
+    return Effect.flatMap(
+      internalRequest.resolveBody(request),
+      (request) => f(request)
+    )
+  }
+  return setProto(client)
+}
 
 /** @internal */
 export const fetch = (
@@ -68,30 +87,20 @@ export const fetch = (
               (_) => internalResponse.fromWeb(request, _)
             )
           if (Method.hasBody(request.method)) {
-            return request.body._tag === "BytesEffect" ?
-              Effect.flatMap(
-                Effect.mapError(request.body.body, (error) =>
-                  internalError.requestError({
-                    reason: "Encode",
-                    request,
-                    error
-                  })),
-                (body) => send(body)
-              ) :
-              send(convertBody(request.body))
+            return send(convertBody(request.body))
           }
           return send(undefined)
         })
     )
   )
 
-const convertBody = (body: Exclude<Body.Body, Body.BytesEffect>): BodyInit | undefined => {
+const convertBody = (body: Body.NonEffect): BodyInit | undefined => {
   switch (body._tag) {
     case "Empty":
       return undefined
     case "Raw":
       return body.body as any
-    case "Bytes":
+    case "Uint8Array":
       return body.body
     case "FormData":
       return body.formData
@@ -105,7 +114,7 @@ export const fetchOk = (
 ): Client.Client.Default => filterStatusOk(fetch(options))
 
 /** @internal */
-export const fetchLayer = Layer.succeed(tag, fetch())
+export const layer = Layer.succeed(tag, fetch())
 
 /** @internal */
 export const catchTag: {
@@ -127,7 +136,7 @@ export const catchTag: {
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
   ): Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A> =>
-    make((request) => Effect.catchTag(self(request), tag, f))
+    setProto((request) => Effect.catchTag(self(request), tag, f))
 )
 
 /** @internal */
@@ -237,7 +246,7 @@ export const catchTags: {
       ) => Effect.Effect<any, any, infer A> ? A
         : never
     }[keyof Cases]
-  > => make((request) => Effect.catchTags(self(request), cases))
+  > => setProto((request) => Effect.catchTags(self(request), cases))
 )
 
 /** @internal */
@@ -254,7 +263,7 @@ export const catchAll: {
   <R, E, A, R2, E2, A2>(
     self: Client.Client<R, E, A>,
     f: (e: E) => Effect.Effect<R2, E2, A2>
-  ): Client.Client<R | R2, E2, A2 | A> => make((request) => Effect.catchAll(self(request), f))
+  ): Client.Client<R | R2, E2, A2 | A> => setProto((request) => Effect.catchAll(self(request), f))
 )
 
 /** @internal */
@@ -267,7 +276,7 @@ export const filterOrElse = dual<
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<R2, E2, B>
   ) => Client.Client<R2 | R, E2 | E, A | B>
->(3, (self, f, orElse) => make((request) => Effect.filterOrElse(self(request), f, orElse)))
+>(3, (self, f, orElse) => setProto((request) => Effect.filterOrElse(self(request), f, orElse)))
 
 /** @internal */
 export const filterOrFail = dual<
@@ -279,7 +288,7 @@ export const filterOrFail = dual<
     f: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
   ) => Client.Client<R, E2 | E, A>
->(3, (self, f, orFailWith) => make((request) => Effect.filterOrFail(self(request), f, orFailWith)))
+>(3, (self, f, orFailWith) => setProto((request) => Effect.filterOrFail(self(request), f, orFailWith)))
 
 /** @internal */
 export const filterStatus = dual<
@@ -293,7 +302,7 @@ export const filterStatus = dual<
 >(
   2,
   (self, f) =>
-    make((request) =>
+    setProto((request) =>
       Effect.filterOrFail(
         self(request),
         (response) => f(response.status),
@@ -322,7 +331,7 @@ export const map = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => B
   ) => Client.Client<R, E, B>
->(2, (self, f) => make((request) => Effect.map(self(request), f)))
+>(2, (self, f) => setProto((request) => Effect.map(self(request), f)))
 
 /** @internal */
 export const mapEffect = dual<
@@ -333,7 +342,7 @@ export const mapEffect = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, B>
   ) => Client.Client<R | R2, E | E2, B>
->(2, (self, f) => make((request) => Effect.flatMap(self(request), f)))
+>(2, (self, f) => setProto((request) => Effect.flatMap(self(request), f)))
 
 /** @internal */
 export const mapRequest = dual<
@@ -344,7 +353,7 @@ export const mapRequest = dual<
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
   ) => Client.Client<R, E, A>
->(2, (self, f) => make((request) => self(f(request))))
+>(2, (self, f) => setProto((request) => self(f(request))))
 
 /** @internal */
 export const mapRequestEffect = dual<
@@ -355,7 +364,7 @@ export const mapRequestEffect = dual<
     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((request) => Effect.flatMap(f(request), self)))
+>(2, (self, f) => setProto((request) => Effect.flatMap(f(request), self)))
 
 /** @internal */
 export const retry: {
@@ -371,7 +380,7 @@ export const retry: {
   <R, E extends E0, E0, A, R1, B>(
     self: Client.Client<R, E, A>,
     policy: Schedule.Schedule<R1, E0, B>
-  ): Client.Client<R | R1, E, A> => make((request) => Effect.retry(self(request), policy))
+  ): Client.Client<R | R1, E, A> => setProto((request) => Effect.retry(self(request), policy))
 )
 
 /** @internal */
@@ -405,7 +414,7 @@ export const schemaFunction = dual<
       (body) =>
         self(internalRequest.setBody(
           request,
-          internalBody.bytes(body, "application/json")
+          internalBody.uint8Array(body, "application/json")
         ))
     )
 })
@@ -419,7 +428,7 @@ export const tap = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, _>
   ) => Client.Client<R | R2, E | E2, A>
->(2, (self, f) => make((request) => Effect.tap(self(request), f)))
+>(2, (self, f) => setProto((request) => Effect.tap(self(request), f)))
 
 /** @internal */
 export const tapRequest = dual<
@@ -430,4 +439,4 @@ export const tapRequest = dual<
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
   ) => Client.Client<R | R2, E | E2, A>
->(2, (self, f) => make((request) => Effect.zipRight(f(request), self(request))))
+>(2, (self, f) => setProto((request) => Effect.zipRight(f(request), self(request))))

package/src/internal/http/clientRequest.ts

@@ -1,5 +1,8 @@
 import { dual } from "@effect/data/Function"
 import { pipeArguments } from "@effect/data/Pipeable"
+import * as Effect from "@effect/io/Effect"
+import type * as PlatformError from "@effect/platform/Error"
+import type * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
@@ -7,6 +10,7 @@ import * as Headers from "@effect/platform/Http/Headers"
 import type { Method } from "@effect/platform/Http/Method"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalBody from "@effect/platform/internal/http/body"
+import * as internalError from "@effect/platform/internal/http/clientError"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Stream from "@effect/stream/Stream"
 
@@ -14,14 +18,16 @@ import type * as Stream from "@effect/stream/Stream"
 export const TypeId: ClientRequest.TypeId = Symbol.for("@effect/platform/Http/ClientRequest") as ClientRequest.TypeId
 
 class ClientRequestImpl implements ClientRequest.ClientRequest {
-  readonly [TypeId]: ClientRequest.TypeId = TypeId
+  readonly [TypeId]: ClientRequest.TypeId
   constructor(
     readonly method: Method,
     readonly url: string,
     readonly urlParams: UrlParams.UrlParams,
     readonly headers: Headers.Headers,
     readonly body: Body.Body
-  ) {}
+  ) {
+    this[TypeId] = TypeId
+  }
   pipe() {
     return pipeArguments(this, arguments)
   }
@@ -293,12 +299,26 @@ export const setBody = dual<
 })
 
 /** @internal */
-export const binaryBody = dual<
+export const uint8ArrayBody = dual<
   (body: Uint8Array, contentType?: string) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
   (self: ClientRequest.ClientRequest, body: Uint8Array, contentType?: string) => ClientRequest.ClientRequest
 >(
   (args) => isClientRequest(args[0]),
-  (self, body, contentType = "application/octet-stream") => setBody(self, internalBody.bytes(body, contentType))
+  (self, body, contentType = "application/octet-stream") => setBody(self, internalBody.uint8Array(body, contentType))
+)
+
+/** @internal */
+export const effectBody = dual<
+  (
+    body: Effect.Effect<never, unknown, Body.NonEffect>
+  ) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
+  (
+    self: ClientRequest.ClientRequest,
+    body: Effect.Effect<never, unknown, Body.NonEffect>
+  ) => ClientRequest.ClientRequest
+>(
+  2,
+  (self, body) => setBody(self, internalBody.effect(body))
 )
 
 /** @internal */
@@ -316,6 +336,30 @@ export const jsonBody = dual<
   (self: ClientRequest.ClientRequest, body: unknown) => ClientRequest.ClientRequest
 >(2, (self, body) => setBody(self, internalBody.json(body)))
 
+/** @internal */
+export const unsafeJsonBody = dual<
+  (body: unknown) => (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest,
+  (self: ClientRequest.ClientRequest, body: unknown) => ClientRequest.ClientRequest
+>(2, (self, body) => setBody(self, internalBody.unsafeJson(body)))
+
+/** @internal */
+export const fileBody = dual<
+  (
+    path: string,
+    options?: FileSystem.StreamOptions & { readonly contentType?: string }
+  ) => (
+    self: ClientRequest.ClientRequest
+  ) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest.ClientRequest>,
+  (
+    self: ClientRequest.ClientRequest,
+    path: string,
+    options?: FileSystem.StreamOptions & { readonly contentType?: string }
+  ) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ClientRequest.ClientRequest>
+>(
+  (args) => isClientRequest(args[0]),
+  (self, path, options) => Effect.map(internalBody.file(path, options), (body) => setBody(self, body))
+)
+
 /** @internal */
 export const schemaBody = <I, A>(schema: Schema.Schema<I, A>): {
   (body: A): (self: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
@@ -369,3 +413,19 @@ export const streamBody = dual<
   (self, body, { contentLength, contentType = "application/octet-stream" } = {}) =>
     setBody(self, internalBody.stream(body, contentType, contentLength))
 )
+
+/** @internal */
+export const resolveBody = (
+  self: ClientRequest.ClientRequest
+): Effect.Effect<never, Error.RequestError, ClientRequest.ClientRequest.NonEffectBody> =>
+  self.body._tag === "Effect"
+    ? Effect.map(
+      Effect.mapError(self.body.effect, (error) =>
+        internalError.requestError({
+          reason: "Encode",
+          request: self,
+          error
+        })),
+      (body) => setBody(self, body) as ClientRequest.ClientRequest.NonEffectBody
+    )
+    : Effect.succeed(self as ClientRequest.ClientRequest.NonEffectBody)

package/src/internal/http/clientResponse.ts

@@ -2,9 +2,9 @@ import * as Effect from "@effect/io/Effect"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
 import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
-import type * as FormData from "@effect/platform/Http/FormData"
 import * as Headers from "@effect/platform/Http/Headers"
 import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
+import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalError from "@effect/platform/internal/http/clientError"
 import * as Stream from "@effect/stream/Stream"
 
@@ -18,13 +18,16 @@ export const fromWeb = (
 ): ClientResponse.ClientResponse => new ClientResponseImpl(request, source)
 
 class ClientResponseImpl implements ClientResponse.ClientResponse {
-  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId = IncomingMessage.TypeId
-  readonly [TypeId]: ClientResponse.TypeId = TypeId
+  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
+  readonly [TypeId]: ClientResponse.TypeId
 
   constructor(
     private readonly request: ClientRequest.ClientRequest,
     private readonly source: globalThis.Response
-  ) {}
+  ) {
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId
+    this[TypeId] = TypeId
+  }
 
   get status(): number {
     return this.source.status
@@ -77,6 +80,20 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     })
   }
 
+  get urlParams(): Effect.Effect<never, Error.ResponseError, UrlParams.UrlParams> {
+    return Effect.flatMap(this.text, (_) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        catch: (_) =>
+          internalError.responseError({
+            request: this.request,
+            response: this,
+            reason: "Decode",
+            error: _
+          })
+      }))
+  }
+
   get formData(): Effect.Effect<never, Error.ResponseError, FormData> {
     return Effect.tryPromise({
       try: () => this.source.formData(),
@@ -90,15 +107,6 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
     })
   }
 
-  get formDataStream(): Stream.Stream<never, Error.ResponseError, FormData.Part> {
-    return Stream.fail(internalError.responseError({
-      request: this.request,
-      response: this,
-      reason: "Decode",
-      error: "not implemented"
-    }))
-  }
-
   get arrayBuffer(): Effect.Effect<never, Error.ResponseError, ArrayBuffer> {
     return Effect.tryPromise({
       try: () => this.source.arrayBuffer(),

package/src/internal/http/formData.ts

@@ -0,0 +1,140 @@
+import * as Chunk from "@effect/data/Chunk"
+import * as Data from "@effect/data/Data"
+import { dual, pipe } from "@effect/data/Function"
+import { globalValue } from "@effect/data/Global"
+import * as Option from "@effect/data/Option"
+import * as Predicate from "@effect/data/Predicate"
+import * as ReadonlyArray from "@effect/data/ReadonlyArray"
+import * as Effect from "@effect/io/Effect"
+import * as FiberRef from "@effect/io/FiberRef"
+import * as FileSystem from "@effect/platform/FileSystem"
+import type * as FormData from "@effect/platform/Http/FormData"
+import type * as ParseResult from "@effect/schema/ParseResult"
+import * as Schema from "@effect/schema/Schema"
+
+/** @internal */
+export const TypeId: FormData.TypeId = Symbol.for("@effect/platform/Http/FormData") as FormData.TypeId
+
+/** @internal */
+export const ErrorTypeId: FormData.ErrorTypeId = Symbol.for(
+  "@effect/platform/Http/FormData/FormDataError"
+) as FormData.ErrorTypeId
+
+/** @internal */
+export const FormDataError = (reason: FormData.FormDataError["reason"], error: unknown): FormData.FormDataError =>
+  Data.struct({
+    [ErrorTypeId]: ErrorTypeId,
+    _tag: "FormDataError",
+    reason,
+    error
+  })
+
+/** @internal */
+export const maxFieldSize: FiberRef.FiberRef<FileSystem.Size> = globalValue(
+  "@effect/platform/Http/FormData/maxFieldSize",
+  () => FiberRef.unsafeMake(FileSystem.Size(1024 * 1024))
+)
+
+/** @internal */
+export const withMaxFieldSize = dual<
+  (size: FileSystem.SizeInput) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: FileSystem.SizeInput) => Effect.Effect<R, E, A>
+>(2, (effect, size) => Effect.locally(effect, maxFieldSize, FileSystem.Size(size)))
+
+/** @internal */
+export const maxFileSize: FiberRef.FiberRef<Option.Option<FileSystem.Size>> = globalValue(
+  "@effect/platform/Http/FormData/maxFileSize",
+  () => FiberRef.unsafeMake(Option.none<FileSystem.Size>())
+)
+
+/** @internal */
+export const withMaxFileSize = dual<
+  (size: Option.Option<FileSystem.SizeInput>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, size: Option.Option<FileSystem.SizeInput>) => Effect.Effect<R, E, A>
+>(2, (effect, size) => Effect.locally(effect, maxFileSize, Option.map(size, FileSystem.Size)))
+
+/** @internal */
+export const fieldMimeTypes: FiberRef.FiberRef<Chunk.Chunk<string>> = globalValue(
+  "@effect/platform/Http/FormData/fieldMimeTypes",
+  () => FiberRef.unsafeMake(Chunk.make("application/json"))
+)
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withFieldMimeTypes = dual<
+  (mimeTypes: ReadonlyArray<string>) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(effect: Effect.Effect<R, E, A>, mimeTypes: ReadonlyArray<string>) => Effect.Effect<R, E, A>
+>(2, (effect, mimeTypes) => Effect.locally(effect, fieldMimeTypes, Chunk.fromIterable(mimeTypes)))
+
+/** @internal */
+export const toRecord = (formData: globalThis.FormData): Record<string, Array<globalThis.File> | string> =>
+  ReadonlyArray.reduce(
+    formData.entries(),
+    {} as Record<string, Array<globalThis.File> | string>,
+    (acc, [key, value]) => {
+      if (Predicate.isString(value)) {
+        acc[key] = value
+      } else {
+        const existing = acc[key]
+        if (Array.isArray(existing)) {
+          existing.push(value)
+        } else {
+          acc[key] = [value]
+        }
+      }
+      return acc
+    }
+  )
+/** @internal */
+export const filesSchema: Schema.Schema<ReadonlyArray<File>, ReadonlyArray<File>> = Schema.array(
+  pipe(
+    Schema.instanceOf(Blob),
+    Schema.filter(
+      (blob): blob is File => "name" in blob
+    )
+  ) as any as Schema.Schema<File, File>
+)
+
+/** @internal */
+export const schemaRecord = <I extends Readonly<Record<string, string | ReadonlyArray<globalThis.File>>>, A>(
+  schema: Schema.Schema<I, A>
+) => {
+  const parse = Schema.parse(schema)
+  return (formData: globalThis.FormData) => parse(toRecord(formData))
+}
+
+/** @internal */
+export const schemaJson = <I, A>(schema: Schema.Schema<I, A>): {
+  (
+    field: string
+  ): (formData: globalThis.FormData) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
+  (
+    formData: globalThis.FormData,
+    field: string
+  ): Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
+} => {
+  const parse = Schema.parse(schema)
+  return dual<
+    (
+      field: string
+    ) => (formData: globalThis.FormData) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>,
+    (
+      formData: globalThis.FormData,
+      field: string
+    ) => Effect.Effect<never, FormData.FormDataError | ParseResult.ParseError, A>
+  >(2, (formData, field) =>
+    pipe(
+      Effect.succeed(formData.get(field)),
+      Effect.filterOrFail(
+        (field) => Predicate.isString(field),
+        () => FormDataError("Parse", `schemaJson: field was not a string`)
+      ),
+      Effect.tryMap({
+        try: (field) => JSON.parse(field as string),
+        catch: (error) => FormDataError("Parse", `schemaJson: field was not valid json: ${error}`)
+      }),
+      Effect.flatMap(parse)
+    ))
+}

package/src/internal/http/middleware.ts

@@ -0,0 +1,72 @@
+import { dual } from "@effect/data/Function"
+import * as Effect from "@effect/io/Effect"
+import type * as App from "@effect/platform/Http/App"
+import * as Headers from "@effect/platform/Http/Headers"
+import type * as Middleware from "@effect/platform/Http/Middleware"
+import * as ServerRequest from "@effect/platform/Http/ServerRequest"
+
+/** @internal */
+export const make = <M extends Middleware.Middleware>(middleware: M): M => middleware
+
+/** @internal */
+export const logger = make((httpApp) =>
+  Effect.withLogSpan(
+    Effect.onExit(
+      httpApp,
+      (exit) =>
+        Effect.flatMap(
+          ServerRequest.ServerRequest,
+          (request) =>
+            Effect.annotateLogs(Effect.log("", exit._tag === "Failure" ? exit.cause : undefined), {
+              "http.method": request.method,
+              "http.url": request.url,
+              "http.status": exit._tag === "Success" ? exit.value.status : 500
+            })
+        )
+    ),
+    "http.span"
+  )
+)
+
+/** @internal */
+export const tracer = make((httpApp) =>
+  Effect.flatMap(
+    ServerRequest.ServerRequest,
+    (request) =>
+      Effect.withSpan(
+        Effect.tap(
+          httpApp,
+          (response) => Effect.annotateCurrentSpan("http.status", response.status)
+        ),
+        `http ${request.method}`,
+        { attributes: { "http.method": request.method, "http.url": request.url } }
+      )
+  )
+)
+
+/** @internal */
+export const xForwardedHeaders = make((httpApp) =>
+  Effect.flatMap(ServerRequest.ServerRequest, (request) => {
+    const forwardedHost = Headers.get(request.headers, "x-forwarded-host")
+    return forwardedHost._tag === "Some"
+      ? Effect.updateService(httpApp, ServerRequest.ServerRequest, (_) =>
+        _.replaceHeaders(Headers.set(request.headers, "host", forwardedHost.value)))
+      : httpApp
+  })
+)
+
+/** @internal */
+export const compose = dual<
+  <B extends App.Default<any, any>, C extends App.Default<any, any>>(
+    that: (b: B) => C
+  ) => <A extends App.Default<any, any>>(
+    self: (a: A) => B
+  ) => (a: A) => C,
+  <A extends App.Default<any, any>, B extends App.Default<any, any>, C extends App.Default<any, any>>(
+    self: (a: A) => B,
+    that: (b: B) => C
+  ) => (a: A) => C
+>(2, (self, that) => (inApp) => that(self(inApp)))
+
+/** @internal */
+export const loggerTracer = compose(tracer, logger)