effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/unstable/http/HttpServerResponse.ts

@@ -1,23 +1,29 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
-import type * as Inspectable from "../../Inspectable.ts"
+import * as Inspectable from "../../Inspectable.ts"
 import { PipeInspectableProto } from "../../internal/core.ts"
-import type { Pipeable } from "../../Pipeable.ts"
+import * as Option from "../../Option.ts"
+import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import type { PlatformError } from "../../PlatformError.ts"
 import { hasProperty } from "../../Predicate.ts"
 import { redact } from "../../Redactable.ts"
 import type * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type { Mutable } from "../../Types.ts"
 import * as Cookies from "./Cookies.ts"
 import * as Headers from "./Headers.ts"
 import * as Body from "./HttpBody.ts"
+import * as HttpClientError from "./HttpClientError.ts"
+import * as HttpClientRequest from "./HttpClientRequest.ts"
+import * as HttpClientResponse from "./HttpClientResponse.ts"
+import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import type { HttpPlatform } from "./HttpPlatform.ts"
 import * as Template from "./Template.ts"
 import * as UrlParams from "./UrlParams.ts"
@@ -28,7 +34,7 @@ const TypeId = "~effect/http/HttpServerResponse"
  * @since 4.0.0
  * @category models
  */
-export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable {
+export interface HttpServerResponse extends Inspectable.Inspectable, Pipeable, ErrorReporter.Reportable {
   readonly [TypeId]: typeof TypeId
   readonly status: number
   readonly statusText?: string | undefined
@@ -201,10 +207,10 @@ export const htmlStream = <
   Template.Interpolated.Context<A[number]>
 > =>
   Effect.map(
-    Effect.services<Template.Interpolated.Context<A[number]>>(),
+    Effect.context<Template.Interpolated.Context<A[number]>>(),
     (context) =>
       stream(
-        Stream.provideServices(
+        Stream.provideContext(
           Stream.encodeText(Template.stream(strings, ...args)),
           context
         ),
@@ -354,7 +360,7 @@ export const stream = <E>(
   })
 }
 
-const HttpPlatformKey = ServiceMap.Service<
+const HttpPlatformKey = Context.Service<
   HttpPlatform,
   HttpPlatform["Service"]
 >("effect/http/HttpPlatform" satisfies typeof HttpPlatform.key)
@@ -523,6 +529,47 @@ export const setCookie: {
     )
 )
 
+/**
+ * @since 4.0.0
+ * @category combinators
+ */
+export const expireCookie: {
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    name: string,
+    options?: Omit<NonNullable<Cookies.Cookie["options"]>, "expires" | "maxAge">
+  ): (
+    self: HttpServerResponse
+  ) => Effect.Effect<HttpServerResponse, Cookies.CookiesError>
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    self: HttpServerResponse,
+    name: string,
+    options?: Omit<NonNullable<Cookies.Cookie["options"]>, "expires" | "maxAge">
+  ): Effect.Effect<HttpServerResponse, Cookies.CookiesError>
+} = dual(
+  (args) => isHttpServerResponse(args[0]),
+  (
+    self: HttpServerResponse,
+    name: string,
+    options?: Omit<NonNullable<Cookies.Cookie["options"]>, "expires" | "maxAge">
+  ): Effect.Effect<HttpServerResponse, Cookies.CookiesError> =>
+    Effect.map(
+      Cookies.expireCookie(self.cookies, name, options).asEffect(),
+      (cookies) =>
+        makeResponse({
+          ...self,
+          cookies
+        })
+    )
+)
+
 /**
  * @since 4.0.0
  * @category combinators
@@ -557,6 +604,41 @@ export const setCookieUnsafe: {
     })
 )
 
+/**
+ * @since 4.0.0
+ * @category combinators
+ */
+export const expireCookieUnsafe: {
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    name: string,
+    options?: Omit<NonNullable<Cookies.Cookie["options"]>, "expires" | "maxAge">
+  ): (self: HttpServerResponse) => HttpServerResponse
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (
+    self: HttpServerResponse,
+    name: string,
+    options?: Omit<NonNullable<Cookies.Cookie["options"]>, "expires" | "maxAge">
+  ): HttpServerResponse
+} = dual(
+  (args) => isHttpServerResponse(args[0]),
+  (
+    self: HttpServerResponse,
+    name: string,
+    options?: Omit<NonNullable<Cookies.Cookie["options"]>, "expires" | "maxAge">
+  ): HttpServerResponse =>
+    makeResponse({
+      ...self,
+      cookies: Cookies.expireCookieUnsafe(self.cookies, name, options)
+    })
+)
+
 /**
  * @since 4.0.0
  * @category combinators
@@ -765,7 +847,7 @@ export const toWeb = (
   response: HttpServerResponse,
   options?: {
     readonly withoutBody?: boolean | undefined
-    readonly services?: ServiceMap.ServiceMap<never> | undefined
+    readonly context?: Context.Context<never> | undefined
   }
 ): Response => {
   const headers = new globalThis.Headers(response.headers)
@@ -816,7 +898,7 @@ export const toWeb = (
       return new Response(
         Stream.toReadableStreamWith(
           body.stream,
-          options?.services ?? ServiceMap.empty()
+          options?.context ?? Context.empty()
         ),
         {
           status: response.status,
@@ -828,12 +910,264 @@ export const toWeb = (
   }
 }
 
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const toClientResponse = (
+  response: HttpServerResponse,
+  options?: {
+    readonly request?: HttpClientRequest.HttpClientRequest | undefined
+  }
+): HttpClientResponse.HttpClientResponse =>
+  new ServerHttpClientResponse(
+    options?.request ?? HttpClientRequest.empty,
+    response
+  )
+
+class ServerHttpClientResponse extends Inspectable.Class implements HttpClientResponse.HttpClientResponse, Pipeable {
+  readonly [HttpIncomingMessage.TypeId]: typeof HttpIncomingMessage.TypeId
+  readonly [HttpClientResponse.TypeId]: typeof HttpClientResponse.TypeId
+
+  readonly request: HttpClientRequest.HttpClientRequest
+  private readonly response: HttpServerResponse
+
+  constructor(
+    request: HttpClientRequest.HttpClientRequest,
+    response: HttpServerResponse
+  ) {
+    super()
+    this.request = request
+    this.response = response
+    this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId
+    this[HttpClientResponse.TypeId] = HttpClientResponse.TypeId
+  }
+
+  toJSON(): unknown {
+    return HttpIncomingMessage.inspect(this, {
+      _id: "HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    })
+  }
+
+  get status(): number {
+    return this.response.status
+  }
+
+  private cachedHeaders?: Headers.Headers
+  get headers(): Headers.Headers {
+    return this.cachedHeaders ??= this.response.body._tag === "FormData"
+      ? Headers.merge(this.response.headers, Headers.fromInput(this.getFormDataResponse().headers))
+      : this.response.headers
+  }
+
+  get cookies(): Cookies.Cookies {
+    return this.response.cookies
+  }
+
+  get remoteAddress(): Option.Option<string> {
+    return Option.none()
+  }
+
+  get stream(): Stream.Stream<Uint8Array, HttpClientError.HttpClientError> {
+    const body = this.response.body
+    switch (body._tag) {
+      case "Empty": {
+        return Stream.empty
+      }
+      case "Stream": {
+        return Stream.mapError(body.stream, (cause) => this.decodeError(cause))
+      }
+      case "Uint8Array": {
+        return Stream.succeed(body.body)
+      }
+      case "Raw": {
+        const rawBody = body.body
+        if (rawBody instanceof Response) {
+          return rawBody.body
+            ? Stream.fromReadableStream({
+              evaluate: () => rawBody.body!,
+              onError: (cause) => this.decodeError(cause)
+            })
+            : Stream.empty
+        }
+        if (isReadableStream(rawBody)) {
+          return Stream.fromReadableStream({
+            evaluate: () => rawBody,
+            onError: (cause) => this.decodeError(cause)
+          })
+        }
+        if (rawBody instanceof Blob) {
+          return Stream.fromReadableStream({
+            evaluate: () => rawBody.stream(),
+            onError: (cause) => this.decodeError(cause)
+          })
+        }
+        return Stream.unwrap(Effect.map(this.bytes, Stream.succeed))
+      }
+      case "FormData": {
+        const response = this.getFormDataResponse()
+        return Stream.fromReadableStream({
+          evaluate: () => response.body!,
+          onError: (cause) => this.decodeError(cause)
+        })
+      }
+    }
+  }
+
+  get json(): Effect.Effect<Schema.Json, HttpClientError.HttpClientError> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => text === "" ? null : JSON.parse(text),
+        catch: (cause) =>
+          new HttpClientError.HttpClientError({
+            reason: new HttpClientError.DecodeError({
+              request: this.request,
+              response: this,
+              cause
+            })
+          })
+      }))
+  }
+
+  private get bytes(): Effect.Effect<Uint8Array, HttpClientError.HttpClientError> {
+    const body = this.response.body
+    switch (body._tag) {
+      case "Empty": {
+        return Effect.succeed(new Uint8Array(0))
+      }
+      case "Uint8Array": {
+        return Effect.succeed(body.body)
+      }
+      case "Stream": {
+        return Stream.mkUint8Array(this.stream)
+      }
+      case "Raw": {
+        const rawBody = body.body
+        if (rawBody instanceof Response) {
+          return Effect.tryPromise({
+            try: () => rawBody.arrayBuffer().then((buffer) => new Uint8Array(buffer)),
+            catch: (cause) => this.decodeError(cause)
+          })
+        }
+        return Effect.tryPromise({
+          try: () => new Response(rawBody as any).arrayBuffer().then((buffer) => new Uint8Array(buffer)),
+          catch: (cause) => this.decodeError(cause)
+        })
+      }
+      case "FormData": {
+        return Effect.tryPromise({
+          try: () => new Response(body.formData).arrayBuffer().then((buffer) => new Uint8Array(buffer)),
+          catch: (cause) => this.decodeError(cause)
+        })
+      }
+    }
+  }
+
+  get text(): Effect.Effect<string, HttpClientError.HttpClientError> {
+    return Effect.map(this.bytes, (bytes) => textDecoder.decode(bytes))
+  }
+
+  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, HttpClientError.HttpClientError> {
+    return Effect.flatMap(this.text, (_) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        catch: (cause) =>
+          new HttpClientError.HttpClientError({
+            reason: new HttpClientError.DecodeError({
+              request: this.request,
+              response: this,
+              cause
+            })
+          })
+      }))
+  }
+
+  get formData(): Effect.Effect<FormData, HttpClientError.HttpClientError> {
+    const body = this.response.body
+    if (body._tag === "FormData") {
+      return Effect.succeed(body.formData)
+    }
+    return Effect.contextWith((context: Context.Context<never>) => {
+      const readableStream = Stream.toReadableStreamWith(this.stream, context)
+      return Effect.tryPromise({
+        try: () => new Response(readableStream, { headers: this.headers }).formData(),
+        catch: (cause) => this.decodeError(cause)
+      })
+    })
+  }
+
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, HttpClientError.HttpClientError> {
+    return Effect.map(this.bytes, (bytes) => bytes.slice().buffer)
+  }
+
+  private decodeError(cause: unknown): HttpClientError.HttpClientError {
+    return new HttpClientError.HttpClientError({
+      reason: new HttpClientError.DecodeError({
+        request: this.request,
+        response: this,
+        cause
+      })
+    })
+  }
+
+  private formDataResponse?: Response
+  private getFormDataResponse(): Response {
+    return this.formDataResponse ??= new Response((this.response.body as Body.FormData).formData)
+  }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const textDecoder = new TextDecoder()
+
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const fromClientResponse = (
+  response: HttpClientResponse.HttpClientResponse
+): HttpServerResponse => {
+  const headers = Headers.remove(response.headers, "set-cookie")
+  return makeResponse({
+    status: response.status,
+    headers,
+    cookies: response.cookies,
+    body: Body.stream(
+      Stream.catchIf(response.stream, isEmptyBodyError, () => Stream.empty),
+      Option.getOrUndefined(Headers.get(headers, "content-type")),
+      getContentLength(headers)
+    )
+  })
+}
+
+const isReadableStream = (u: unknown): u is ReadableStream<Uint8Array> =>
+  typeof ReadableStream !== "undefined" && u instanceof ReadableStream
+
+const isEmptyBodyError = (
+  error: HttpClientError.HttpClientError
+): error is HttpClientError.HttpClientError =>
+  HttpClientError.isHttpClientError(error) && error.reason._tag === "EmptyBodyError"
+
+const getContentLength = (headers: Headers.Headers): number | undefined => {
+  const contentLength = Option.getOrUndefined(Headers.get(headers, "content-length"))
+  if (contentLength === undefined) {
+    return undefined
+  }
+  const parsed = Number(contentLength)
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined
+}
+
 const Proto: Omit<
   HttpServerResponse,
   "status" | "statusText" | "headers" | "cookies" | "body"
 > = {
   ...PipeInspectableProto,
   [TypeId]: TypeId,
+  [ErrorReporter.ignore]: true,
   toJSON(this: HttpServerResponse) {
     return {
       _id: "HttpServerResponse",
@@ -891,12 +1225,16 @@ export const fromWeb = (response: Response): HttpServerResponse => {
     cookies: Cookies.fromSetCookie(setCookieHeaders)
   })
   if (response.body) {
+    const contentType = response.headers.get("content-type")
     self = setBody(
       self,
-      Body.stream(Stream.fromReadableStream({
-        evaluate: () => response.body!,
-        onError: (e) => e
-      }))
+      Body.stream(
+        Stream.fromReadableStream({
+          evaluate: () => response.body!,
+          onError: (e) => e
+        }),
+        contentType ?? undefined
+      )
     )
   }
   return self