@effect/platform 0.31.1 → 0.32.0

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
+      })
+    }
+  }
+}

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))