effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/unstable/http/HttpServerRequest.ts

@@ -6,6 +6,7 @@ import * as Channel from "../../Channel.ts"
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import * as Inspectable from "../../Inspectable.ts"
+import * as Option from "../../Option.ts"
 import type * as Path from "../../Path.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Result from "../../Result.ts"
@@ -17,6 +18,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 +46,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
@@ -62,7 +65,7 @@ export interface HttpServerRequest extends HttpIncomingMessage.HttpIncomingMessa
     options: {
       readonly url?: string
       readonly headers?: Headers.Headers
-      readonly remoteAddress?: string
+      readonly remoteAddress?: Option.Option<string>
     }
   ) => HttpServerRequest
 }
@@ -177,7 +180,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 +280,18 @@ export const schemaBodyFormJson = <A, I, RD, RE>(
   }
 }
 
+/**
+ * @since 4.0.0
+ * @category conversions
+ */
+export const fromClientRequest = (request: HttpClientRequest.HttpClientRequest): HttpServerRequest => {
+  const url = Option.match(HttpClientRequest.toUrl(request), {
+    onNone: () => request.url,
+    onSome: (url) => url.toString()
+  })
+  return new ClientRequestImpl(request, url)
+}
+
 /**
  * @since 4.0.0
  * @category conversions
@@ -283,6 +299,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,
+      Option.none(),
+      request.headers,
+      toClientBody(request)
+    ),
+    Option.getOrElse(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
@@ -297,13 +347,13 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
   readonly source: Request
   readonly url: string
   public headersOverride?: Headers.Headers | undefined
-  private remoteAddressOverride?: string | undefined
+  private remoteAddressOverride?: Option.Option<string> | undefined
 
   constructor(
     source: Request,
     url: string,
     headersOverride?: Headers.Headers,
-    remoteAddressOverride?: string
+    remoteAddressOverride?: Option.Option<string>
   ) {
     super()
     this[TypeId] = TypeId
@@ -324,14 +374,14 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
     options: {
       readonly url?: string | undefined
       readonly headers?: Headers.Headers | undefined
-      readonly remoteAddress?: string | undefined
+      readonly remoteAddress?: Option.Option<string> | undefined
     }
   ) {
     return new ServerRequestImpl(
       this.source,
       options.url ?? this.url,
       options.headers ?? this.headersOverride,
-      options.remoteAddress ?? this.remoteAddressOverride
+      "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride
     )
   }
   get method(): HttpMethod {
@@ -340,8 +390,8 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
   get originalUrl() {
     return this.source.url
   }
-  get remoteAddress(): string | undefined {
-    return this.remoteAddressOverride ? this.remoteAddressOverride : undefined
+  get remoteAddress(): Option.Option<string> {
+    return this.remoteAddressOverride ?? Option.none()
   }
   get headers(): Headers.Headers {
     this.headersOverride ??= Headers.fromInput(this.source.headers as any)
@@ -398,10 +448,10 @@ class ServerRequestImpl extends Inspectable.Class implements HttpServerRequest {
     return this.textEffect
   }
 
-  get json(): Effect.Effect<unknown, HttpServerError> {
+  get json(): Effect.Effect<Schema.Json, HttpServerError> {
     return Effect.flatMap(this.text, (text) =>
       Effect.try({
-        try: () => JSON.parse(text) as unknown,
+        try: () => JSON.parse(text) as Schema.Json,
         catch: (cause) =>
           new HttpServerError({
             reason: new RequestParseError({
@@ -486,17 +536,358 @@ 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?: Option.Option<string> | undefined
+  private urlOverride?: string | undefined
+
+  constructor(
+    source: HttpClientRequest.HttpClientRequest,
+    originalUrl: string,
+    urlOverride?: string,
+    headersOverride?: Headers.Headers,
+    remoteAddressOverride?: Option.Option<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?: Option.Option<string> | undefined
+    }
+  ) {
+    return new ClientRequestImpl(
+      this.source,
+      this.originalUrl,
+      options.url ?? this.url,
+      options.headers ?? this.headersOverride,
+      "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride
+    )
+  }
+
+  get method(): HttpMethod {
+    return this.source.method
+  }
+
+  get url(): string {
+    return this.urlOverride ?? removeHost(this.originalUrl)
+  }
+
+  get remoteAddress(): Option.Option<string> {
+    return this.remoteAddressOverride ?? Option.none()
+  }
+
+  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<Schema.Json, HttpServerError> {
+    return Effect.flatMap(this.text, (text) =>
+      Effect.try({
+        try: () => text === "" ? null : JSON.parse(text),
+        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
  */
-export const toURL = (self: HttpServerRequest): URL | undefined => {
+export const toURL = (self: HttpServerRequest): Option.Option<URL> => {
   const host = self.headers.host ?? "localhost"
   const protocol = self.headers["x-forwarded-proto"] === "https" ? "https" : "http"
   try {
-    return new URL(self.url, `${protocol}://${host}`)
+    return Option.some(new URL(self.url, `${protocol}://${host}`))
   } catch {
-    return undefined
+    return Option.none()
   }
 }
 
@@ -512,7 +903,7 @@ export const toWebResult = (self: HttpServerRequest, options?: {
     return Result.succeed(self.source)
   }
   const url = toURL(self)
-  if (url === undefined) {
+  if (Option.isNone(url)) {
     return Result.fail(
       new RequestParseError({
         request: self,
@@ -531,7 +922,7 @@ export const toWebResult = (self: HttpServerRequest, options?: {
     requestInit.body = Stream.toReadableStreamWith(self.stream, options?.services ?? ServiceMap.empty())
     ;(requestInit as any).duplex = "half"
   }
-  return Result.succeed(new Request(url, requestInit))
+  return Result.succeed(new Request(url.value, requestInit))
 }
 
 /**

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