@effect/platform-node 0.11.4 → 0.12.0

package/src/internal/http/server.ts

@@ -0,0 +1,323 @@
+import type { LazyArg } from "@effect/data/Function"
+import * as Option from "@effect/data/Option"
+import * as Config from "@effect/io/Config"
+import * as Effect from "@effect/io/Effect"
+import * as Fiber from "@effect/io/Fiber"
+import * as Layer from "@effect/io/Layer"
+import * as Runtime from "@effect/io/Runtime"
+import type * as Scope from "@effect/io/Scope"
+import * as internalFormData from "@effect/platform-node/internal/http/formData"
+import { IncomingMessageImpl } from "@effect/platform-node/internal/http/incomingMessage"
+import * as NodeSink from "@effect/platform-node/Sink"
+import * as FileSystem from "@effect/platform/FileSystem"
+import type * as FormData from "@effect/platform/Http/FormData"
+import * as Headers from "@effect/platform/Http/Headers"
+import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
+import type { Method } from "@effect/platform/Http/Method"
+import * as Middleware from "@effect/platform/Http/Middleware"
+import * as Server from "@effect/platform/Http/Server"
+import * as Error from "@effect/platform/Http/ServerError"
+import * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import * as ServerResponse from "@effect/platform/Http/ServerResponse"
+import type * as Path from "@effect/platform/Path"
+import * as Stream from "@effect/stream/Stream"
+import type * as Http from "node:http"
+import type * as Net from "node:net"
+import { Readable } from "node:stream"
+
+/** @internal */
+export const make = (
+  evaluate: LazyArg<Http.Server>,
+  options: Net.ListenOptions
+): Effect.Effect<Scope.Scope, never, Server.Server> =>
+  Effect.gen(function*(_) {
+    const server = evaluate()
+
+    const serverFiber = yield* _(
+      Effect.addFinalizer(() =>
+        Effect.async<never, never, void>((resume) => {
+          server.close((error) => {
+            if (error) {
+              resume(Effect.die(error))
+            } else {
+              resume(Effect.unit)
+            }
+          })
+        })
+      ),
+      Effect.zipRight(
+        Effect.async<never, Error.ServeError, never>((resume) => {
+          server.on("error", (error) => {
+            resume(Effect.fail(Error.ServeError({ error })))
+          })
+        })
+      ),
+      Effect.scoped,
+      Effect.forkScoped
+    )
+
+    yield* _(Effect.async<never, never, void>((resume) => {
+      server.listen(options, () => {
+        resume(Effect.unit)
+      })
+    }))
+
+    const address = server.address()!
+
+    return Server.make({
+      address: typeof address === "string" ?
+        {
+          _tag: "UnixAddress",
+          path: address
+        } :
+        {
+          _tag: "TcpAddress",
+          hostname: address.address,
+          port: address.port
+        },
+      serve: (httpApp, middleware) => {
+        const handledApp = middleware ? middleware(respond(httpApp)) : respond(httpApp)
+        return Effect.flatMap(Effect.runtime(), (runtime) => {
+          const runFork = Runtime.runFork(runtime as Runtime.Runtime<unknown>)
+          function handler(nodeRequest: Http.IncomingMessage, nodeResponse: Http.ServerResponse) {
+            runFork(
+              Effect.provideService(
+                handledApp,
+                ServerRequest.ServerRequest,
+                new ServerRequestImpl(nodeRequest, nodeResponse)
+              )
+            )
+          }
+          return Effect.all([
+            Effect.acquireRelease(
+              Effect.sync(() => server.on("request", handler)),
+              () => Effect.sync(() => server.off("request", handler))
+            ),
+            Fiber.join(serverFiber)
+          ], { discard: true, concurrency: "unbounded" }) as Effect.Effect<never, Error.ServeError, never>
+        })
+      }
+    })
+  }).pipe(
+    Effect.locally(
+      IncomingMessage.maxBodySize,
+      Option.some(FileSystem.Size(1024 * 1024 * 10))
+    )
+  )
+
+const respond = Middleware.make((httpApp) =>
+  Effect.flatMap(ServerRequest.ServerRequest, (request) =>
+    Effect.tapErrorCause(
+      Effect.tap(
+        Effect.flatMap(httpApp, ServerResponse.toNonEffectBody),
+        (response) => handleResponse(request, response)
+      ),
+      (_cause) =>
+        Effect.sync(() => {
+          const nodeResponse = (request as ServerRequestImpl).response
+          if (!nodeResponse.headersSent) {
+            nodeResponse.writeHead(500)
+          }
+          if (!nodeResponse.writableEnded) {
+            nodeResponse.end()
+          }
+        })
+    ))
+)
+
+class ServerRequestImpl extends IncomingMessageImpl<Error.RequestError> implements ServerRequest.ServerRequest {
+  readonly [ServerRequest.TypeId]: ServerRequest.TypeId
+
+  constructor(
+    readonly source: Http.IncomingMessage,
+    readonly response: Http.ServerResponse,
+    readonly url = source.url!,
+    private headersOverride?: Headers.Headers
+  ) {
+    super(source, (_) =>
+      Error.RequestError({
+        request: this,
+        reason: "Decode",
+        error: _
+      }))
+    this[ServerRequest.TypeId] = ServerRequest.TypeId
+  }
+
+  get originalUrl(): string {
+    return this.source.url!
+  }
+
+  get method(): Method {
+    return this.source.method as Method
+  }
+
+  get headers(): Headers.Headers {
+    this.headersOverride ??= Headers.fromInput(this.source.headers as any)
+    return this.headersOverride
+  }
+
+  private formDataEffect:
+    | Effect.Effect<
+      Scope.Scope | FileSystem.FileSystem | Path.Path,
+      FormData.FormDataError,
+      globalThis.FormData
+    >
+    | undefined
+  get formData(): Effect.Effect<
+    Scope.Scope | FileSystem.FileSystem | Path.Path,
+    FormData.FormDataError,
+    globalThis.FormData
+  > {
+    if (this.formDataEffect) {
+      return this.formDataEffect
+    }
+    this.formDataEffect = Effect.runSync(Effect.cached(
+      internalFormData.formData(this.source)
+    ))
+    return this.formDataEffect
+  }
+
+  get formDataStream(): Stream.Stream<never, FormData.FormDataError, FormData.Part> {
+    return internalFormData.fromRequest(this.source)
+  }
+
+  setUrl(url: string): ServerRequest.ServerRequest {
+    return new ServerRequestImpl(
+      this.source,
+      this.response,
+      url,
+      this.headersOverride
+    )
+  }
+
+  replaceHeaders(headers: Headers.Headers): ServerRequest.ServerRequest {
+    return new ServerRequestImpl(
+      this.source,
+      this.response,
+      this.url,
+      headers
+    )
+  }
+
+  toString(): string {
+    return `ServerRequest(${this.method} ${this.url})`
+  }
+
+  toJSON(): unknown {
+    return {
+      _tag: "ServerRequest",
+      method: this.method,
+      url: this.url,
+      originalUrl: this.originalUrl,
+      headers: Object.fromEntries(this.headers)
+    }
+  }
+}
+
+/** @internal */
+export const layer = (
+  evaluate: LazyArg<Http.Server>,
+  options: Net.ListenOptions
+) => Layer.scoped(Server.Server, make(evaluate, options))
+
+/** @internal */
+export const layerConfig = (
+  evaluate: LazyArg<Http.Server>,
+  options: Config.Config.Wrap<Net.ListenOptions>
+) =>
+  Layer.scoped(
+    Server.Server,
+    Effect.flatMap(
+      Effect.config(Config.unwrap(options)),
+      (options) => make(evaluate, options)
+    )
+  )
+
+const handleResponse = (
+  request: ServerRequest.ServerRequest,
+  response: ServerResponse.ServerResponse.NonEffectBody
+) =>
+  Effect.suspend((): Effect.Effect<never, Error.ResponseError, void> => {
+    const nodeResponse = (request as ServerRequestImpl).response
+    switch (response.body._tag) {
+      case "Empty": {
+        nodeResponse.writeHead(
+          response.status,
+          response.headers === Headers.empty ? undefined : Object.fromEntries(response.headers)
+        )
+        nodeResponse.end()
+        return Effect.unit
+      }
+      case "Raw": {
+        const headers = response.headers === Headers.empty ? {} : Object.fromEntries(response.headers)
+        if (response.body.contentType) {
+          headers["content-type"] = response.body.contentType
+        }
+        if (response.body.contentLength) {
+          headers["content-length"] = response.body.contentLength.toString()
+        }
+        nodeResponse.writeHead(response.status, headers)
+        nodeResponse.end(response.body.body)
+        return Effect.unit
+      }
+      case "Uint8Array": {
+        const headers = response.headers === Headers.empty ? {} : Object.fromEntries(response.headers)
+        headers["content-type"] = response.body.contentType
+        headers["content-length"] = response.body.contentLength.toString()
+        nodeResponse.writeHead(response.status, headers)
+        nodeResponse.end(response.body.body)
+        return Effect.unit
+      }
+      case "FormData": {
+        const body = response.body
+        return Effect.async<never, Error.ResponseError, void>((resume) => {
+          const r = new Response(body.formData)
+          const headers = response.headers
+            ? Object.fromEntries(response.headers)
+            : {}
+          headers["content-type"] = r.headers.get("content-type")!
+          nodeResponse.writeHead(response.status, headers)
+          Readable.fromWeb(r.body as any)
+            .pipe(nodeResponse)
+            .on("error", (error) => {
+              resume(Effect.fail(Error.ResponseError({
+                request,
+                response,
+                reason: "Decode",
+                error
+              })))
+            })
+            .once("finish", () => {
+              resume(Effect.unit)
+            })
+        })
+      }
+      case "Stream": {
+        const headers = response.headers === Headers.empty ? {} : Object.fromEntries(response.headers)
+        headers["content-type"] = response.body.contentType
+        if (response.body.contentLength) {
+          headers["content-length"] = response.body.contentLength.toString()
+        }
+        nodeResponse.writeHead(response.status, headers)
+        return Stream.run(
+          Stream.mapError(
+            response.body.stream,
+            (error) =>
+              Error.ResponseError({
+                request,
+                response,
+                reason: "Decode",
+                error
+              })
+          ),
+          NodeSink.fromWritable(() => nodeResponse, (error) =>
+            Error.ResponseError({
+              request,
+              response,
+              reason: "Decode",
+              error
+            }))
+        )
+      }
+    }
+  })

package/src/internal/stream.ts

@@ -3,7 +3,7 @@ import { pipe } from "@effect/data/Function"
 import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import type { FromReadableOptions } from "@effect/platform-node/Stream"
-import type { Size } from "@effect/platform/FileSystem"
+import type { SizeInput } from "@effect/platform/FileSystem"
 import * as Stream from "@effect/stream/Stream"
 import type { Readable } from "node:stream"
 
@@ -11,7 +11,7 @@ import type { Readable } from "node:stream"
 export const fromReadable = <E, A>(
   evaluate: LazyArg<Readable>,
   onError: (error: unknown) => E,
-  { chunkSize = Option.none() }: FromReadableOptions = {}
+  { chunkSize }: FromReadableOptions = {}
 ): Stream.Stream<never, E, A> =>
   pipe(
     Effect.acquireRelease(Effect.sync(evaluate), (stream) =>
@@ -52,57 +52,92 @@ export const fromReadable = <E, A>(
 
 const readChunk = <A>(
   stream: Readable,
-  size: Option.Option<Size>
+  size: SizeInput | undefined
 ): Effect.Effect<never, Option.Option<never>, A> =>
   pipe(
-    Effect.sync(() => (size._tag === "Some" ? stream.read(Number(size)) : stream.read()) as A | null),
+    Effect.sync(() => (size ? stream.read(Number(size)) : stream.read()) as A | null),
     Effect.flatMap((_) => (_ ? Effect.succeed(_) : Effect.fail(Option.none())))
   )
 
 /** @internal */
 export const toString = <E>(
-  evaluate: LazyArg<Readable>,
-  onError: (error: unknown) => E,
-  encoding: BufferEncoding = "utf-8"
-): Effect.Effect<never, E, string> =>
-  Effect.async<never, E, string>((resume) => {
-    const stream = evaluate()
-    let string = ""
-    stream.setEncoding(encoding)
-    stream.once("error", (err) => {
-      resume(Effect.fail(onError(err)))
-    })
-    stream.once("end", () => {
-      resume(Effect.succeed(string))
-    })
-    stream.on("data", (chunk) => {
-      string += chunk
-    })
-    return Effect.sync(() => {
-      stream.removeAllListeners()
-      stream.destroy()
-    })
-  })
+  options: {
+    readable: LazyArg<Readable>
+    onFailure: (error: unknown) => E
+    encoding?: BufferEncoding
+    maxBytes?: SizeInput
+  }
+): Effect.Effect<never, E, string> => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined
+  return Effect.acquireUseRelease(
+    Effect.sync(() => {
+      const stream = options.readable()
+      stream.setEncoding(options.encoding ?? "utf8")
+      return stream
+    }),
+    (stream) =>
+      Effect.async((resume) => {
+        let string = ""
+        let bytes = 0
+        stream.once("error", (err) => {
+          resume(Effect.fail(options.onFailure(err)))
+        })
+        stream.once("end", () => {
+          resume(Effect.succeed(string))
+        })
+        stream.on("data", (chunk) => {
+          string += chunk
+          bytes += Buffer.byteLength(chunk)
+          if (maxBytesNumber && bytes > maxBytesNumber) {
+            resume(Effect.fail(options.onFailure(new Error("maxBytes exceeded"))))
+          }
+        })
+      }),
+    (stream) =>
+      Effect.sync(() => {
+        stream.removeAllListeners()
+        if (!stream.closed) {
+          stream.destroy()
+        }
+      })
+  )
+}
 
 /** @internal */
 export const toUint8Array = <E>(
-  evaluate: LazyArg<Readable>,
-  onError: (error: unknown) => E
-): Effect.Effect<never, E, Uint8Array> =>
-  Effect.async<never, E, Uint8Array>((resume) => {
-    const stream = evaluate()
-    let buffer = Buffer.alloc(0)
-    stream.once("error", (err) => {
-      resume(Effect.fail(onError(err)))
-    })
-    stream.once("end", () => {
-      resume(Effect.succeed(buffer))
-    })
-    stream.on("data", (chunk) => {
-      buffer = Buffer.concat([buffer, chunk])
-    })
-    return Effect.sync(() => {
-      stream.removeAllListeners()
-      stream.destroy()
-    })
-  })
+  options: {
+    readable: LazyArg<Readable>
+    onFailure: (error: unknown) => E
+    maxBytes?: SizeInput
+  }
+): Effect.Effect<never, E, Uint8Array> => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined
+  return Effect.acquireUseRelease(
+    Effect.sync(options.readable),
+    (stream) =>
+      Effect.async((resume) => {
+        let buffer = Buffer.alloc(0)
+        let bytes = 0
+        stream.once("error", (err) => {
+          resume(Effect.fail(options.onFailure(err)))
+        })
+        stream.once("end", () => {
+          resume(Effect.succeed(buffer))
+        })
+        stream.on("data", (chunk) => {
+          buffer = Buffer.concat([buffer, chunk])
+          bytes += chunk.length
+          if (maxBytesNumber && bytes > maxBytesNumber) {
+            resume(Effect.fail(options.onFailure(new Error("maxBytes exceeded"))))
+          }
+        })
+      }),
+    (stream) =>
+      Effect.sync(() => {
+        stream.removeAllListeners()
+        if (!stream.closed) {
+          stream.destroy()
+        }
+      })
+  )
+}