effect 4.0.0-beta.3 → 4.0.0-beta.30

package/src/unstable/http/HttpServerError.ts

@@ -4,8 +4,11 @@
 import * as Cause from "../../Cause.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
+import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as Exit from "../../Exit.ts"
+import { constUndefined } from "../../Function.ts"
 import { hasProperty } from "../../Predicate.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Request from "./HttpServerRequest.ts"
 import * as Respondable from "./HttpServerRespondable.ts"
 import * as Response from "./HttpServerResponse.ts"
@@ -32,35 +35,24 @@ export class HttpServerError extends Data.TaggedError("HttpServerError")<{
     }
   }
 
-  /**
-   * @since 4.0.0
-   */
   readonly [TypeId] = TypeId
 
-  /**
-   * @since 4.0.0
-   */
   override stack = `${this.name}: ${this.message}`
 
-  /**
-   * @since 4.0.0
-   */
   get request(): Request.HttpServerRequest {
     return this.reason.request
   }
 
-  /**
-   * @since 4.0.0
-   */
   get response(): Response.HttpServerResponse | undefined {
     return "response" in this.reason ? this.reason.response : undefined
   }
 
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
-    return this.reason[Respondable.TypeId]()
+  [Respondable.symbol]() {
+    return this.reason[Respondable.symbol]()
+  }
+
+  override get [ErrorReporter.ignore](): boolean {
+    return this.reason[ErrorReporter.ignore] ?? false
   }
 
   override get message(): string {
@@ -80,7 +72,7 @@ export class RequestParseError extends Data.TaggedError("RequestParseError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 400 }))
   }
 
@@ -102,13 +94,12 @@ export class RouteNotFound extends Data.TaggedError("RouteNotFound")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 404 }))
   }
 
+  override readonly [ErrorReporter.ignore] = true
+
   get methodAndUrl() {
     return `${this.request.method} ${this.request.url}`
   }
@@ -130,7 +121,7 @@ export class InternalError extends Data.TaggedError("InternalError")<{
   /**
    * @since 4.0.0
    */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 
@@ -159,10 +150,7 @@ export class ResponseError extends Data.TaggedError("ResponseError")<{
   readonly description?: string
   readonly cause?: unknown
 }> implements Respondable.Respondable {
-  /**
-   * @since 4.0.0
-   */
-  [Respondable.TypeId]() {
+  [Respondable.symbol]() {
     return Effect.succeed(Response.empty({ status: 500 }))
   }
 
@@ -196,16 +184,25 @@ export class ServeError extends Data.TaggedError("ServeError")<{
   readonly cause: unknown
 }> {}
 
+/**
+ * @since 4.0.0
+ * @category Annotations
+ */
+export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/http/HttpServerError/ClientAbort") {
+  static annotation = this.serviceMap(true).pipe(
+    ServiceMap.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}
+
 const formatRequestMessage = (reason: string, description: string | undefined, info: string) => {
   const prefix = `${reason} (${info})`
   return description ? `${prefix}: ${description}` : prefix
 }
 
-/**
- * @since 4.0.0
- */
-export const clientAbortFiberId = -499
-
 /**
  * @since 4.0.0
  */
@@ -215,37 +212,37 @@ export const causeResponse = <E>(
   let response: Response.HttpServerResponse | undefined
   let effect = succeedInternalServerError
   const failures: Array<Cause.Reason<E>> = []
-  let interrupt: Cause.Interrupt | undefined
+  let interrupts: Array<Cause.Interrupt> = []
   let isClientInterrupt = false
   for (let i = 0; i < cause.reasons.length; i++) {
-    const f = cause.reasons[i]
-    switch (f._tag) {
+    const reason = cause.reasons[i]
+    switch (reason._tag) {
       case "Fail": {
-        effect = Respondable.toResponseOrElse(f.error, internalServerError)
-        failures.push(f)
+        effect = Respondable.toResponseOrElse(reason.error, internalServerError)
+        failures.push(reason)
         break
       }
       case "Die": {
-        if (Response.isHttpServerResponse(f.defect)) {
-          response = f.defect
+        if (Response.isHttpServerResponse(reason.defect)) {
+          response = reason.defect
         } else {
-          effect = Respondable.toResponseOrElseDefect(f.defect, internalServerError)
-          failures.push(f)
+          effect = Respondable.toResponseOrElseDefect(reason.defect, internalServerError)
+          failures.push(reason)
         }
         break
       }
       case "Interrupt": {
-        isClientInterrupt = isClientInterrupt || f.fiberId === clientAbortFiberId
+        isClientInterrupt = reason.annotations.has(ClientAbort.key)
         if (failures.length > 0) break
-        interrupt = f
+        interrupts.push(reason)
         break
       }
     }
   }
   if (response) {
     return Effect.succeed([response, Cause.fromReasons(failures)] as const)
-  } else if (interrupt && failures.length === 0) {
-    failures.push(isClientInterrupt ? Cause.makeInterruptReason(clientAbortFiberId) : interrupt)
+  } else if (interrupts.length > 0 && failures.length === 0) {
+    failures.push(...interrupts)
     effect = isClientInterrupt ? clientAbortError : serverAbortError
   }
   return Effect.mapEager(effect, (response) => {

package/src/unstable/http/HttpServerRequest.ts

@@ -17,6 +17,8 @@ import * as Stream from "../../Stream.ts"
 import * as Socket from "../socket/Socket.ts"
 import * as Cookies from "./Cookies.ts"
 import * as Headers from "./Headers.ts"
+import * as HttpBody from "./HttpBody.ts"
+import * as HttpClientRequest from "./HttpClientRequest.ts"
 import * as HttpIncomingMessage from "./HttpIncomingMessage.ts"
 import { hasBody, type HttpMethod } from "./HttpMethod.ts"
 import { HttpServerError, type RequestError, RequestParseError } from "./HttpServerError.ts"
@@ -43,7 +45,7 @@ export const TypeId = "~effect/http/HttpServerRequest"
  */
 export interface HttpServerRequest extends HttpIncomingMessage.HttpIncomingMessage<HttpServerError> {
   readonly [TypeId]: typeof TypeId
-  readonly source: unknown
+  readonly source: object
   readonly url: string
   readonly originalUrl: string
   readonly method: HttpMethod
@@ -177,7 +179,8 @@ export const schemaBodyJson = <A, I, RD, RE>(
 }
 
 const isMultipart = (request: HttpServerRequest) =>
-  request.headers["content-type"]?.toLowerCase().includes("multipart/form-data")
+  request.headers["content-type"]?.toLowerCase().includes("multipart/form-data") === true ||
+  getFormDataBody(request) !== undefined
 
 /**
  * @since 4.0.0
@@ -276,6 +279,15 @@ export const schemaBodyFormJson = <A, I, RD, RE>(
   }
 }
 
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const fromClientRequest = (request: HttpClientRequest.HttpClientRequest): HttpServerRequest => {
+  const url = HttpClientRequest.toUrl(request)?.toString() ?? request.url
+  return new ClientRequestImpl(request, url)
+}
+
 /**
  * @since 4.0.0
  * @category conversions
@@ -283,6 +295,40 @@ export const schemaBodyFormJson = <A, I, RD, RE>(
 export const fromWeb = (request: globalThis.Request): HttpServerRequest =>
   new ServerRequestImpl(request, removeHost(request.url))
 
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const toClientRequest = (request: HttpServerRequest): HttpClientRequest.HttpClientRequest =>
+  HttpClientRequest.setUrl(
+    HttpClientRequest.makeWith(
+      request.method,
+      "",
+      UrlParams.empty,
+      undefined,
+      request.headers,
+      toClientBody(request)
+    ),
+    toURL(request) ?? request.url
+  )
+
+const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody =>
+  hasBody(request.method)
+    ? HttpBody.stream(
+      request.stream,
+      request.headers["content-type"],
+      parseContentLength(request.headers["content-length"])
+    )
+    : HttpBody.empty
+
+const parseContentLength = (contentLength: string | undefined): number | undefined => {
+  if (contentLength === undefined) {
+    return undefined
+  }
+  const parsed = Number.parseInt(contentLength, 10)
+  return Number.isNaN(parsed) ? undefined : parsed
+}
+
 const removeHost = (url: string) => {
   if (url[0] === "/") {
     return url
@@ -486,6 +532,347 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
   }
 }
 
+class ClientRequestImpl extends Inspectable.Class implements HttpServerRequest {
+  readonly [TypeId]: typeof TypeId
+  readonly [HttpIncomingMessage.TypeId]: typeof HttpIncomingMessage.TypeId
+  readonly source: HttpClientRequest.HttpClientRequest
+  public originalUrl: string
+  public headersOverride?: Headers.Headers | undefined
+  private remoteAddressOverride?: string | undefined
+  private urlOverride?: string | undefined
+
+  constructor(
+    source: HttpClientRequest.HttpClientRequest,
+    originalUrl: string,
+    urlOverride?: string,
+    headersOverride?: Headers.Headers,
+    remoteAddressOverride?: string
+  ) {
+    super()
+    this[TypeId] = TypeId
+    this[HttpIncomingMessage.TypeId] = HttpIncomingMessage.TypeId
+    this.source = source
+    this.originalUrl = originalUrl
+    this.urlOverride = urlOverride
+    this.headersOverride = headersOverride
+    this.remoteAddressOverride = remoteAddressOverride
+  }
+
+  toJSON(): unknown {
+    return HttpIncomingMessage.inspect(this, {
+      _id: "HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    })
+  }
+
+  modify(
+    options: {
+      readonly url?: string | undefined
+      readonly headers?: Headers.Headers | undefined
+      readonly remoteAddress?: string | undefined
+    }
+  ) {
+    return new ClientRequestImpl(
+      this.source,
+      this.originalUrl,
+      options.url ?? this.url,
+      options.headers ?? this.headersOverride,
+      options.remoteAddress ?? this.remoteAddressOverride
+    )
+  }
+
+  get method(): HttpMethod {
+    return this.source.method
+  }
+
+  get url(): string {
+    return this.urlOverride ?? removeHost(this.originalUrl)
+  }
+
+  get remoteAddress(): string | undefined {
+    return this.remoteAddressOverride ? this.remoteAddressOverride : undefined
+  }
+
+  get headers(): Headers.Headers {
+    return this.headersOverride ??= this.source.headers
+  }
+
+  private cachedCookies: ReadonlyRecord<string, string> | undefined
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies
+    }
+    return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? "")
+  }
+
+  get stream(): Stream.Stream<Uint8Array, HttpServerError> {
+    const body = this.source.body
+    switch (body._tag) {
+      case "Empty": {
+        return Stream.empty
+      }
+      case "Uint8Array": {
+        return Stream.succeed(body.body)
+      }
+      case "Stream": {
+        return Stream.mapError(body.stream, (cause) => requestParseError(this, undefined, cause))
+      }
+      case "FormData": {
+        return streamFromReadable(this, new Response(body.formData).body)
+      }
+      case "Raw": {
+        return rawBodyStream(this, body.body)
+      }
+    }
+  }
+
+  private bytesEffect: Effect.Effect<Uint8Array, HttpServerError> | undefined
+  private get bytes(): Effect.Effect<Uint8Array, HttpServerError> {
+    if (this.bytesEffect) {
+      return this.bytesEffect
+    }
+    const body = this.source.body
+    let effect: Effect.Effect<Uint8Array, HttpServerError>
+    switch (body._tag) {
+      case "Empty": {
+        effect = Effect.succeed(new Uint8Array(0))
+        break
+      }
+      case "Uint8Array": {
+        effect = Effect.succeed(body.body)
+        break
+      }
+      case "FormData": {
+        effect = bytesFromBodyInit(this, body.formData)
+        break
+      }
+      case "Stream": {
+        effect = Stream.mkUint8Array(this.stream)
+        break
+      }
+      case "Raw": {
+        effect = rawBodyBytes(this, body.body)
+        break
+      }
+    }
+    this.bytesEffect = Effect.runSync(Effect.cached(effect))
+    return this.bytesEffect
+  }
+
+  get text(): Effect.Effect<string, HttpServerError> {
+    return Effect.map(this.bytes, (bytes) => textDecoder.decode(bytes))
+  }
+
+  get json(): Effect.Effect<unknown, HttpServerError> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => text === "" ? null : JSON.parse(text) as unknown,
+        catch: (cause) => requestParseError(this, undefined, cause)
+      }))
+  }
+
+  get urlParamsBody(): Effect.Effect<UrlParams.UrlParams, HttpServerError> {
+    return Effect.flatMap(this.text, (_) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        catch: (cause) => requestParseError(this, undefined, cause)
+      }))
+  }
+
+  private multipartEffect:
+    | Effect.Effect<
+      Multipart.Persisted,
+      Multipart.MultipartError,
+      Scope.Scope | FileSystem.FileSystem | Path.Path
+    >
+    | undefined
+  get multipart(): Effect.Effect<
+    Multipart.Persisted,
+    Multipart.MultipartError,
+    Scope.Scope | FileSystem.FileSystem | Path.Path
+  > {
+    if (this.multipartEffect) {
+      return this.multipartEffect
+    }
+    this.multipartEffect = Effect.runSync(Effect.cached(
+      Multipart.toPersisted(this.multipartStream)
+    ))
+    return this.multipartEffect
+  }
+
+  get multipartStream(): Stream.Stream<Multipart.Part, Multipart.MultipartError> {
+    const formData = this.source.body._tag === "FormData" && this.source.body.formData
+    if (formData) {
+      return Stream.fromIterable(formDataToParts(formData))
+    }
+    return Stream.pipeThroughChannel(
+      Stream.mapError(this.stream, (cause) => Multipart.MultipartError.fromReason("InternalError", cause)),
+      Multipart.makeChannel(this.headers)
+    )
+  }
+
+  get arrayBuffer(): Effect.Effect<ArrayBuffer, HttpServerError> {
+    return Effect.map(this.bytes, (bytes) => bytes.slice().buffer)
+  }
+
+  get upgrade(): Effect.Effect<Socket.Socket, HttpServerError> {
+    return Effect.fail(requestParseError(this, "Not an upgradeable ServerRequest"))
+  }
+}
+
+const getFormDataBody = (request: HttpServerRequest): FormData | undefined => {
+  if (!HttpClientRequest.isHttpClientRequest(request.source)) {
+    return undefined
+  }
+  const body = request.source.body
+  if (body._tag === "FormData") {
+    return body.formData
+  }
+  if (body._tag === "Raw" && isFormData(body.body)) {
+    return body.body
+  }
+  return undefined
+}
+
+const rawBodyStream = (request: HttpServerRequest, body: unknown): Stream.Stream<Uint8Array, HttpServerError> => {
+  if (body instanceof Request) {
+    return streamFromReadable(request, body.body)
+  }
+  if (isFormData(body)) {
+    return streamFromReadable(request, new Response(body).body)
+  }
+  if (isReadableStream(body)) {
+    return streamFromReadable(request, body)
+  }
+  return Stream.fail(requestParseError(request, "Unsupported body type"))
+}
+
+const rawBodyBytes = (request: HttpServerRequest, body: unknown): Effect.Effect<Uint8Array, HttpServerError> => {
+  if (body instanceof Blob) {
+    return bytesFromBodyInit(request, body)
+  }
+  if (body instanceof Request) {
+    return Effect.tryPromise({
+      try: () => body.arrayBuffer().then((buffer) => new Uint8Array(buffer)),
+      catch: (cause) => requestParseError(request, undefined, cause)
+    })
+  }
+  return Effect.fail(requestParseError(request, "Unsupported body type"))
+}
+
+const bytesFromBodyInit = (request: HttpServerRequest, body: BodyInit): Effect.Effect<Uint8Array, HttpServerError> =>
+  Effect.tryPromise({
+    try: () => new Response(body).arrayBuffer().then((buffer) => new Uint8Array(buffer)),
+    catch: (cause) => requestParseError(request, undefined, cause)
+  })
+
+const streamFromReadable = (
+  request: HttpServerRequest,
+  body: ReadableStream<Uint8Array> | null | undefined
+): Stream.Stream<Uint8Array, HttpServerError> =>
+  body
+    ? Stream.fromReadableStream({
+      evaluate: () => body,
+      onError: (cause) => requestParseError(request, undefined, cause)
+    })
+    : Stream.empty
+
+const requestParseError = (
+  request: HttpServerRequest,
+  description?: string,
+  cause?: unknown
+) =>
+  new HttpServerError({
+    reason: new RequestParseError({
+      request,
+      ...(description === undefined ? undefined : { description }),
+      ...(cause === undefined ? undefined : { cause })
+    })
+  })
+
+const formDataToParts = (formData: FormData): Array<Multipart.Part> => {
+  const parts: Array<Multipart.Part> = []
+  for (const [key, value] of formData.entries()) {
+    parts.push(typeof value === "string" ? new MultipartFieldPart(key, value) : new MultipartFilePart(key, value))
+  }
+  return parts
+}
+
+class MultipartFieldPart extends Inspectable.Class implements Multipart.Field {
+  readonly [Multipart.TypeId]: typeof Multipart.TypeId
+  readonly _tag = "Field"
+  readonly contentType = "text/plain"
+  readonly key: string
+  readonly value: string
+
+  constructor(
+    key: string,
+    value: string
+  ) {
+    super()
+    this[Multipart.TypeId] = Multipart.TypeId
+    this.key = key
+    this.value = value
+  }
+
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "Field",
+      key: this.key,
+      contentType: this.contentType,
+      value: this.value
+    }
+  }
+}
+
+class MultipartFilePart extends Inspectable.Class implements Multipart.File {
+  readonly [Multipart.TypeId]: typeof Multipart.TypeId
+  readonly _tag = "File"
+  readonly key: string
+  readonly name: string
+  readonly contentType: string
+  readonly content: Stream.Stream<Uint8Array, Multipart.MultipartError>
+  readonly contentEffect: Effect.Effect<Uint8Array, Multipart.MultipartError>
+
+  constructor(
+    key: string,
+    file: File
+  ) {
+    super()
+    this[Multipart.TypeId] = Multipart.TypeId
+    this.key = key
+    this.name = file.name
+    this.contentType = file.type
+    this.content = Stream.fromReadableStream({
+      evaluate: () => file.stream() as ReadableStream<Uint8Array>,
+      onError: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+    })
+    this.contentEffect = Effect.tryPromise({
+      try: () => file.arrayBuffer().then((buffer) => new Uint8Array(buffer)),
+      catch: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+    })
+  }
+
+  toJSON(): unknown {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "File",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType
+    }
+  }
+}
+
+const isReadableStream = (u: unknown): u is ReadableStream<Uint8Array> =>
+  typeof ReadableStream !== "undefined" && u instanceof ReadableStream
+
+const isFormData = (u: unknown): u is FormData => typeof FormData !== "undefined" && u instanceof FormData
+
+const textDecoder = new TextDecoder()
+
 /**
  * @since 4.0.0
  * @category conversions

package/src/unstable/http/HttpServerRespondable.ts

@@ -12,21 +12,21 @@ import * as Response from "./HttpServerResponse.ts"
  * @since 4.0.0
  * @category Type IDs
  */
-export const TypeId = "~effect/http/HttpServerRespondable"
+export const symbol = "~effect/http/HttpServerRespondable"
 
 /**
  * @since 4.0.0
  * @category models
  */
 export interface Respondable {
-  readonly [TypeId]: () => Effect.Effect<HttpServerResponse, unknown>
+  [symbol](): Effect.Effect<HttpServerResponse, unknown>
 }
 
 /**
  * @since 4.0.0
  * @category guards
  */
-export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, TypeId)
+export const isRespondable = (u: unknown): u is Respondable => hasProperty(u, symbol)
 
 const badRequest = Response.empty({ status: 400 })
 const notFound = Response.empty({ status: 404 })
@@ -39,7 +39,7 @@ export const toResponse = (self: Respondable): Effect.Effect<HttpServerResponse>
   if (Response.isHttpServerResponse(self)) {
     return Effect.succeed(self)
   }
-  return Effect.orDie(self[TypeId]())
+  return Effect.orDie(self[symbol]())
 }
 
 /**
@@ -50,7 +50,7 @@ export const toResponseOrElse = (u: unknown, orElse: HttpServerResponse): Effect
   if (Response.isHttpServerResponse(u)) {
     return Effect.succeed(u)
   } else if (isRespondable(u)) {
-    return Effect.catchCause(u[TypeId](), () => Effect.succeed(orElse))
+    return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse))
     // add support for some commmon types
   } else if (Schema.isSchemaError(u)) {
     return Effect.succeed(badRequest)
@@ -68,7 +68,7 @@ export const toResponseOrElseDefect = (u: unknown, orElse: HttpServerResponse):
   if (Response.isHttpServerResponse(u)) {
     return Effect.succeed(u)
   } else if (isRespondable(u)) {
-    return Effect.catchCause(u[TypeId](), () => Effect.succeed(orElse))
+    return Effect.catchCause(u[symbol](), () => Effect.succeed(orElse))
   }
   return Effect.succeed(orElse)
 }