@effect/platform 0.31.0 → 0.31.2

package/src/Http/Middleware.ts

@@ -3,8 +3,10 @@
  */
 import type * as Effect from "effect/Effect"
 import type * as FiberRef from "effect/FiberRef"
+import type * as Predicate from "effect/Predicate"
 import * as internal from "../internal/http/middleware.js"
 import type * as App from "./App.js"
+import type * as ServerRequest from "./ServerRequest.js"
 
 /**
  * @since 1.0.0
@@ -51,6 +53,27 @@ export const loggerDisabled: FiberRef.FiberRef<boolean> = internal.loggerDisable
 export const withLoggerDisabled: <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A> =
   internal.withLoggerDisabled
 
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const currentTracerDisabledWhen: FiberRef.FiberRef<Predicate.Predicate<ServerRequest.ServerRequest>> =
+  internal.currentTracerDisabledWhen
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export const withTracerDisabledWhen: {
+  (
+    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+  ): <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  <R, E, A>(
+    effect: Effect.Effect<R, E, A>,
+    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+  ): Effect.Effect<R, E, A>
+} = internal.withTracerDisabledWhen
+
 /**
  * @since 1.0.0
  * @category constructors

package/src/Http/ServerRequest.ts

@@ -127,3 +127,9 @@ export const schemaFormDataJson: <I, A>(
   Error.RequestError | FormData.FormDataError | ParseResult.ParseError,
   A
 > = internal.schemaFormDataJson
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export const fromWeb: (request: Request) => ServerRequest = internal.fromWeb

package/src/Http/ServerResponse.ts

@@ -190,3 +190,9 @@ export const setStatus: {
   (status: number, statusText?: string | undefined): (self: ServerResponse) => ServerResponse
   (self: ServerResponse, status: number, statusText?: string | undefined): ServerResponse
 } = internal.setStatus
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export const toWeb: (response: ServerResponse, withoutBody?: boolean) => Response = internal.toWeb

package/src/internal/http/middleware.ts

@@ -1,6 +1,8 @@
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
+import * as Function from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
+import type * as Predicate from "effect/Predicate"
 import * as Headers from "../../Http/Headers.js"
 import * as IncomingMessage from "../../Http/IncomingMessage.js"
 import type * as Middleware from "../../Http/Middleware.js"
@@ -22,6 +24,23 @@ export const withLoggerDisabled = <R, E, A>(self: Effect.Effect<R, E, A>): Effec
     self
   )
 
+/** @internal */
+export const currentTracerDisabledWhen = globalValue(
+  Symbol.for("@effect/platform/Http/Middleware/tracerDisabledWhen"),
+  () => FiberRef.unsafeMake<Predicate.Predicate<ServerRequest.ServerRequest>>(Function.constFalse)
+)
+
+/** @internal */
+export const withTracerDisabledWhen = Function.dual<
+  (
+    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+  ) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  <R, E, A>(
+    effect: Effect.Effect<R, E, A>,
+    predicate: Predicate.Predicate<ServerRequest.ServerRequest>
+  ) => Effect.Effect<R, E, A>
+>(2, (self, pred) => Effect.locally(self, currentTracerDisabledWhen, pred))
+
 /** @internal */
 export const logger = make((httpApp) => {
   let counter = 0
@@ -61,18 +80,20 @@ export const tracer = make((httpApp) => {
     (response) => Effect.annotateCurrentSpan("http.status", response.status)
   )
   return Effect.flatMap(
-    ServerRequest.ServerRequest,
-    (request) =>
+    Effect.zip(ServerRequest.ServerRequest, FiberRef.get(currentTracerDisabledWhen)),
+    ([request, disabledWhen]) =>
       Effect.flatMap(
         request.headers["x-b3-traceid"] || request.headers["b3"] ?
           Effect.orElseSucceed(IncomingMessage.schemaExternalSpan(request), () => undefined) :
           Effect.succeed(undefined),
         (parent) =>
-          Effect.withSpan(
-            appWithStatus,
-            `http ${request.method}`,
-            { attributes: { "http.method": request.method, "http.url": request.url }, parent }
-          )
+          disabledWhen(request) ?
+            httpApp :
+            Effect.withSpan(
+              appWithStatus,
+              `http ${request.method}`,
+              { attributes: { "http.method": request.method, "http.url": request.url }, parent }
+            )
       )
   )
 })

package/src/internal/http/serverRequest.ts

@@ -1,10 +1,18 @@
 import type * as Schema from "@effect/schema/Schema"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+import type * as FileSystem from "../../FileSystem.js"
 import * as FormData from "../../Http/FormData.js"
+import * as Headers from "../../Http/Headers.js"
 import * as IncomingMessage from "../../Http/IncomingMessage.js"
+import type { Method } from "../../Http/Method.js"
 import * as Error from "../../Http/ServerError.js"
 import type * as ServerRequest from "../../Http/ServerRequest.js"
+import * as UrlParams from "../../Http/UrlParams.js"
+import type * as Path from "../../Path.js"
 
 /** @internal */
 export const TypeId: ServerRequest.TypeId = Symbol.for("@effect/platform/Http/ServerRequest") as ServerRequest.TypeId
@@ -63,3 +71,154 @@ export const schemaFormDataJson = <I, A>(schema: Schema.Schema<I, A>) => {
           )
       ))
 }
+
+/** @internal */
+export const fromWeb = (request: globalThis.Request): ServerRequest.ServerRequest =>
+  new ServerRequestImpl(request, request.url)
+
+class ServerRequestImpl implements ServerRequest.ServerRequest {
+  readonly [TypeId]: ServerRequest.TypeId
+  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
+  constructor(
+    readonly source: Request,
+    readonly url: string,
+    public headersOverride?: Headers.Headers,
+    private remoteAddressOverride?: string
+  ) {
+    this[TypeId] = TypeId
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId
+  }
+  modify(
+    options: {
+      readonly url?: string | undefined
+      readonly headers?: Headers.Headers | undefined
+      readonly remoteAddress?: string | undefined
+    }
+  ) {
+    return new ServerRequestImpl(
+      this.source,
+      options.url ?? this.url,
+      options.headers ?? this.headersOverride,
+      options.remoteAddress ?? this.remoteAddressOverride
+    )
+  }
+  get method(): Method {
+    return this.source.method.toUpperCase() as Method
+  }
+  get originalUrl() {
+    return this.source.url
+  }
+  get remoteAddress(): Option.Option<string> {
+    return this.remoteAddressOverride ? Option.some(this.remoteAddressOverride) : Option.none()
+  }
+  get headers(): Headers.Headers {
+    this.headersOverride ??= Headers.fromInput(this.source.headers)
+    return this.headersOverride
+  }
+
+  get stream(): Stream.Stream<never, Error.RequestError, Uint8Array> {
+    return this.source.body
+      ? Stream.fromReadableStream(() => this.source.body as any, (_) =>
+        Error.RequestError({
+          request: this,
+          reason: "Decode",
+          error: _
+        }))
+      : Stream.fail(Error.RequestError({
+        request: this,
+        reason: "Decode",
+        error: "can not create stream from empty body"
+      }))
+  }
+
+  private textEffect: Effect.Effect<never, Error.RequestError, string> | undefined
+  get text(): Effect.Effect<never, Error.RequestError, string> {
+    if (this.textEffect) {
+      return this.textEffect
+    }
+    this.textEffect = Effect.runSync(Effect.cached(
+      Effect.tryPromise({
+        try: () => this.source.text(),
+        catch: (error) =>
+          Error.RequestError({
+            request: this,
+            reason: "Decode",
+            error
+          })
+      })
+    ))
+    return this.textEffect
+  }
+
+  get json(): Effect.Effect<never, Error.RequestError, unknown> {
+    return Effect.tryMap(this.text, {
+      try: (_) => JSON.parse(_) as unknown,
+      catch: (error) =>
+        Error.RequestError({
+          request: this,
+          reason: "Decode",
+          error
+        })
+    })
+  }
+
+  get urlParamsBody(): Effect.Effect<never, Error.RequestError, UrlParams.UrlParams> {
+    return Effect.flatMap(this.text, (_) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        catch: (error) =>
+          Error.RequestError({
+            request: this,
+            reason: "Decode",
+            error
+          })
+      }))
+  }
+
+  private formDataEffect:
+    | Effect.Effect<
+      Scope.Scope | FileSystem.FileSystem | Path.Path,
+      FormData.FormDataError,
+      FormData.PersistedFormData
+    >
+    | undefined
+  get formData(): Effect.Effect<
+    Scope.Scope | FileSystem.FileSystem | Path.Path,
+    FormData.FormDataError,
+    FormData.PersistedFormData
+  > {
+    if (this.formDataEffect) {
+      return this.formDataEffect
+    }
+    this.formDataEffect = Effect.runSync(Effect.cached(
+      FormData.formData(this.formDataStream)
+    ))
+    return this.formDataEffect
+  }
+
+  get formDataStream(): Stream.Stream<never, FormData.FormDataError, FormData.Part> {
+    return Stream.pipeThroughChannel(
+      Stream.mapError(this.stream, (error) => FormData.FormDataError("InternalError", error)),
+      FormData.makeChannel(this.headers)
+    )
+  }
+
+  private arrayBufferEffect: Effect.Effect<never, Error.RequestError, ArrayBuffer> | undefined
+  get arrayBuffer(): Effect.Effect<never, Error.RequestError, ArrayBuffer> {
+    if (this.arrayBuffer) {
+      return this.arrayBuffer
+    }
+    this.arrayBufferEffect = Effect.runSync(Effect.cached(
+      Effect.tryPromise({
+        try: () => this.source.arrayBuffer(),
+        catch: (error) =>
+          Error.RequestError({
+            request: this,
+            reason: "Decode",
+            error
+          })
+      })
+    ))
+    return this.arrayBufferEffect
+  }
+}

package/src/internal/http/serverResponse.ts

@@ -2,7 +2,7 @@ import type * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
-import type * as Stream from "effect/Stream"
+import * as Stream from "effect/Stream"
 import type * as PlatformError from "../../Error.js"
 import type * as FileSystem from "../../FileSystem.js"
 import type * as Body from "../../Http/Body.js"
@@ -259,3 +259,46 @@ export const setBody = dual<
     body
   )
 })
+
+/** @internal */
+export const toWeb = (response: ServerResponse.ServerResponse, withoutBody = false): Response => {
+  if (withoutBody) {
+    return new Response(undefined, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    })
+  }
+  const body = response.body
+  switch (body._tag) {
+    case "Empty": {
+      return new Response(undefined, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      })
+    }
+    case "Uint8Array":
+    case "Raw": {
+      return new Response(body.body as any, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      })
+    }
+    case "FormData": {
+      return new Response(body.formData as any, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      })
+    }
+    case "Stream": {
+      return new Response(Stream.toReadableStream(body.stream), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      })
+    }
+  }
+}