@effect/platform-node 0.11.4 → 0.12.0

package/src/Http/Server.ts

@@ -0,0 +1,45 @@
+/**
+ * @since 1.0.0
+ */
+import type { LazyArg } from "@effect/data/Function"
+import type * as Config from "@effect/io/Config"
+import type * as ConfigError from "@effect/io/Config/Error"
+import type * as Effect from "@effect/io/Effect"
+import type * as Layer from "@effect/io/Layer"
+import type * as Scope from "@effect/io/Scope"
+import * as internal from "@effect/platform-node/internal/http/server"
+import type * as Server from "@effect/platform/Http/Server"
+import type * as Http from "node:http"
+import type * as Net from "node:net"
+
+/**
+ * @since 1.0.0
+ */
+export * from "@effect/platform/Http/Server"
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: (
+  evaluate: LazyArg<Http.Server>,
+  options: Net.ListenOptions
+) => Effect.Effect<Scope.Scope, never, Server.Server> = internal.make
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: (
+  evaluate: LazyArg<Http.Server>,
+  options: Net.ListenOptions
+) => Layer.Layer<never, never, Server.Server> = internal.layer
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerConfig: (
+  evaluate: LazyArg<Http.Server>,
+  options: Config.Config.Wrap<Net.ListenOptions>
+) => Layer.Layer<never, ConfigError.ConfigError, Server.Server> = internal.layerConfig

package/src/HttpServer.ts

@@ -0,0 +1,10 @@
+/**
+ * @since 1.0.0
+ */
+
+export * from "@effect/platform/HttpServer"
+
+/**
+ * @since 1.0.0
+ */
+export * as server from "@effect/platform-node/Http/Server"

package/src/Stream.ts

@@ -2,10 +2,9 @@
  * @since 1.0.0
  */
 import type { LazyArg } from "@effect/data/Function"
-import type { Option } from "@effect/data/Option"
 import type { Effect } from "@effect/io/Effect"
 import * as internal from "@effect/platform-node/internal/stream"
-import type { Size } from "@effect/platform/FileSystem"
+import type { SizeInput } from "@effect/platform/FileSystem"
 import type { Stream } from "@effect/stream/Stream"
 import type { Readable } from "stream"
 
@@ -14,8 +13,8 @@ import type { Readable } from "stream"
  * @since 1.0.0
  */
 export interface FromReadableOptions {
-  /** Defaults to None, which lets Node.js decide the chunk size */
-  readonly chunkSize?: Option<Size>
+  /** Defaults to undefined, which lets Node.js decide the chunk size */
+  readonly chunkSize?: SizeInput
 }
 
 /**
@@ -33,9 +32,12 @@ export const fromReadable: <E, A>(
  * @category conversions
  */
 export const toString: <E>(
-  evaluate: LazyArg<Readable>,
-  onError: (error: unknown) => E,
-  encoding?: BufferEncoding
+  options: {
+    readable: LazyArg<Readable>
+    onFailure: (error: unknown) => E
+    encoding?: BufferEncoding
+    maxBytes?: SizeInput
+  }
 ) => Effect<never, E, string> = internal.toString
 
 /**
@@ -43,6 +45,9 @@ export const toString: <E>(
  * @category conversions
  */
 export const toUint8Array: <E>(
-  evaluate: LazyArg<Readable>,
-  onError: (error: unknown) => E
+  options: {
+    readable: LazyArg<Readable>
+    onFailure: (error: unknown) => E
+    maxBytes?: SizeInput
+  }
 ) => Effect<never, E, Uint8Array> = internal.toUint8Array

package/src/internal/fileSystem.ts

@@ -1,4 +1,4 @@
-import { identity, pipe } from "@effect/data/Function"
+import { pipe } from "@effect/data/Function"
 import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
@@ -218,7 +218,7 @@ const makeFile = (() => {
   const nodeWriteAll = nodeWriteFactory("writeAll")
 
   class FileImpl implements FileSystem.File {
-    readonly [FileSystem.FileTypeId] = identity
+    readonly [FileSystem.FileTypeId]: FileSystem.FileTypeId
 
     private readonly semaphore = Effect.unsafeMakeSemaphore(1)
     private position: bigint = 0n
@@ -226,19 +226,22 @@ const makeFile = (() => {
     constructor(
       readonly fd: FileSystem.File.Descriptor,
       private readonly append: boolean
-    ) {}
+    ) {
+      this[FileSystem.FileTypeId] = FileSystem.FileTypeId
+    }
 
     get stat() {
       return Effect.map(nodeStat(this.fd), makeFileInfo)
     }
 
-    seek(offset: FileSystem.Size, from: FileSystem.SeekMode) {
+    seek(offset: FileSystem.SizeInput, from: FileSystem.SeekMode) {
+      const offsetSize = FileSystem.Size(offset)
       return this.semaphore.withPermits(1)(
         Effect.sync(() => {
           if (from === "start") {
-            this.position = offset
+            this.position = offsetSize
           } else if (from === "current") {
-            this.position = this.position + offset
+            this.position = this.position + offsetSize
           }
 
           return this.position
@@ -264,9 +267,10 @@ const makeFile = (() => {
       )
     }
 
-    readAlloc(size: FileSystem.Size) {
+    readAlloc(size: FileSystem.SizeInput) {
+      const sizeNumber = Number(size)
       return this.semaphore.withPermits(1)(Effect.flatMap(
-        Effect.sync(() => Buffer.allocUnsafeSlow(Number(size))),
+        Effect.sync(() => Buffer.allocUnsafeSlow(sizeNumber)),
         (buffer) =>
           Effect.map(
             nodeReadAlloc(this.fd, {
@@ -279,7 +283,7 @@ const makeFile = (() => {
               }
 
               this.position = this.position + BigInt(bytesRead)
-              if (bytesRead === Number(size)) {
+              if (bytesRead === sizeNumber) {
                 return Option.some(buffer)
               }
 
@@ -291,7 +295,7 @@ const makeFile = (() => {
       ))
     }
 
-    truncate(length?: FileSystem.Size) {
+    truncate(length?: FileSystem.SizeInput) {
       return this.semaphore.withPermits(1)(
         Effect.map(nodeTruncate(this.fd, length ? Number(length) : undefined), () => {
           if (!this.append) {
@@ -505,7 +509,8 @@ const truncate = (() => {
     handleErrnoException("FileSystem", "truncate"),
     handleBadArgument("truncate")
   )
-  return (path: string, length?: FileSystem.Size) => nodeTruncate(path, length ? Number(length) : undefined)
+  return (path: string, length?: FileSystem.SizeInput) =>
+    nodeTruncate(path, length !== undefined ? Number(length) : undefined)
 })()
 
 // == utimes

package/src/internal/http/formData.ts

@@ -0,0 +1,158 @@
+import * as Chunk from "@effect/data/Chunk"
+import { pipe } from "@effect/data/Function"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as FiberRef from "@effect/io/FiberRef"
+import * as NodeStream from "@effect/platform-node/Stream"
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as FormData from "@effect/platform/Http/FormData"
+import * as Path from "@effect/platform/Path"
+import * as Stream from "@effect/stream/Stream"
+import Busboy from "busboy"
+import * as NodeFs from "node:fs"
+import type * as Http from "node:http"
+import type { Readable } from "node:stream"
+import * as NodeStreamP from "node:stream/promises"
+
+export const fromRequest = (
+  source: Http.IncomingMessage
+): Stream.Stream<never, FormData.FormDataError, FormData.Part> =>
+  pipe(
+    Effect.Do,
+    Effect.bind("fieldMimeTypes", () => FiberRef.get(FormData.fieldMimeTypes)),
+    Effect.bind("maxFieldSize", () => FiberRef.get(FormData.maxFieldSize)),
+    Effect.bind("maxFileSize", () => FiberRef.get(FormData.maxFileSize)),
+    Effect.bind("busboy", ({ maxFieldSize, maxFileSize }) =>
+      Effect.acquireRelease(
+        Effect.sync(
+          () =>
+            Busboy({
+              headers: source.headers,
+              limits: {
+                fieldSize: Number(maxFieldSize),
+                fileSize: Option.getOrUndefined(Option.map(maxFileSize, Number))
+              }
+            })
+        ),
+        (busboy) =>
+          Effect.sync(() => {
+            busboy.removeAllListeners()
+            if (!busboy.closed) {
+              busboy.destroy()
+            }
+          })
+      )),
+    Effect.map(({ busboy, fieldMimeTypes }) =>
+      Stream.mapEffect(
+        Stream.async<never, FormData.FormDataError, FieldImpl | FileImpl>((emit) => {
+          busboy.on("field", (name, value, info) => {
+            if (info.valueTruncated) {
+              emit.fail(FormData.FormDataError("FieldTooLarge", new Error("maxFieldSize exceeded")))
+            } else {
+              emit.single(new FieldImpl(name, info.mimeType, value))
+            }
+          })
+
+          busboy.on("file", (name, stream, info) => {
+            stream.once("limit", () => {
+              emit.fail(FormData.FormDataError("FileTooLarge", new Error("maxFileSize exceeded")))
+            })
+            emit.single(
+              new FileImpl(
+                name,
+                info.filename,
+                info.mimeType,
+                NodeStream.fromReadable(() => stream, (error) => FormData.FormDataError("InternalError", error)),
+                stream
+              )
+            )
+          })
+
+          busboy.on("error", (_) => {
+            emit.fail(FormData.FormDataError("InternalError", _))
+          })
+
+          busboy.on("finish", () => {
+            emit.end()
+          })
+
+          source.pipe(busboy)
+        }),
+        (part) =>
+          part._tag === "File" && Chunk.some(fieldMimeTypes, (_) => part.contentType.includes(_)) ?
+            Effect.map(
+              NodeStream.toString({
+                readable: () => part.source,
+                onFailure: (error) => FormData.FormDataError("InternalError", error)
+              }),
+              (content) => new FieldImpl(part.key, part.contentType, content)
+            )
+            : Effect.succeed(part)
+      )
+    ),
+    Stream.unwrapScoped
+  )
+
+class FieldImpl implements FormData.Field {
+  readonly [FormData.TypeId]: FormData.TypeId
+  readonly _tag = "Field"
+  constructor(
+    readonly key: string,
+    readonly contentType: string,
+    readonly value: string
+  ) {
+    this[FormData.TypeId] = FormData.TypeId
+  }
+}
+
+class FileImpl implements FormData.File {
+  readonly [FormData.TypeId]: FormData.TypeId
+  readonly _tag = "File"
+  constructor(
+    readonly key: string,
+    readonly name: string,
+    readonly contentType: string,
+    readonly content: Stream.Stream<never, FormData.FormDataError, Uint8Array>,
+    readonly source: Readable
+  ) {
+    this[FormData.TypeId] = FormData.TypeId
+  }
+}
+
+/** @internal */
+export const formData = (
+  source: Http.IncomingMessage
+) =>
+  Effect.flatMap(
+    Effect.all([
+      Effect.mapError(
+        Effect.flatMap(FileSystem.FileSystem, (_) => _.makeTempDirectoryScoped()),
+        (error) => FormData.FormDataError("InternalError", error)
+      ),
+      Path.Path
+    ]),
+    ([dir, path_]) =>
+      Stream.runFoldEffect(
+        fromRequest(source),
+        new globalThis.FormData(),
+        (formData, part) => {
+          if (part._tag === "Field") {
+            formData.append(part.key, part.value)
+            return Effect.succeed(formData)
+          }
+          const file = part as FileImpl
+          const path = path_.join(dir, file.name)
+          formData.append(part.key, new Blob([], { type: file.contentType }), path)
+          return Effect.as(
+            Effect.tryPromise({
+              try: (signal) =>
+                NodeStreamP.pipeline(file.source, NodeFs.createWriteStream(path), {
+                  signal
+                }),
+              catch: (error) => FormData.FormDataError("InternalError", error)
+            }),
+            formData
+          )
+        }
+      )
+  )

package/src/internal/http/incomingMessage.ts

@@ -0,0 +1,78 @@
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as FiberRef from "@effect/io/FiberRef"
+import * as NodeStream from "@effect/platform-node/Stream"
+import * as Headers from "@effect/platform/Http/Headers"
+import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
+import * as UrlParams from "@effect/platform/Http/UrlParams"
+import type * as Stream from "@effect/stream/Stream"
+import type * as Http from "node:http"
+
+/** @internal */
+export class IncomingMessageImpl<E> implements IncomingMessage.IncomingMessage<E> {
+  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId
+
+  constructor(
+    readonly source: Http.IncomingMessage,
+    readonly onError: (error: unknown) => E
+  ) {
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId
+  }
+
+  get headers() {
+    return Headers.fromInput(this.source.headers as any)
+  }
+
+  private textEffect: Effect.Effect<never, E, string> | undefined
+  get text(): Effect.Effect<never, E, string> {
+    if (this.textEffect) {
+      return this.textEffect
+    }
+    this.textEffect = Effect.runSync(Effect.cached(
+      Effect.flatMap(
+        FiberRef.get(IncomingMessage.maxBodySize),
+        (maxBodySize) =>
+          NodeStream.toString({
+            readable: () => this.source,
+            onFailure: this.onError,
+            maxBytes: Option.getOrUndefined(maxBodySize)
+          })
+      )
+    ))
+    return this.textEffect
+  }
+
+  get json(): Effect.Effect<never, E, unknown> {
+    return Effect.tryMap(this.text, {
+      try: (_) => JSON.parse(_) as unknown,
+      catch: this.onError
+    })
+  }
+
+  get urlParams(): Effect.Effect<never, E, UrlParams.UrlParams> {
+    return Effect.flatMap(this.text, (_) =>
+      Effect.try({
+        try: () => UrlParams.fromInput(new URLSearchParams(_)),
+        catch: this.onError
+      }))
+  }
+
+  get stream(): Stream.Stream<never, E, Uint8Array> {
+    return NodeStream.fromReadable<E, Uint8Array>(
+      () => this.source,
+      this.onError
+    )
+  }
+
+  get arrayBuffer(): Effect.Effect<never, E, ArrayBuffer> {
+    return Effect.flatMap(
+      FiberRef.get(IncomingMessage.maxBodySize),
+      (maxBodySize) =>
+        NodeStream.toUint8Array({
+          readable: () => this.source,
+          onFailure: this.onError,
+          maxBytes: Option.getOrUndefined(maxBodySize)
+        })
+    )
+  }
+}

package/src/internal/http/nodeClient.ts

@@ -4,15 +4,13 @@ import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
 import type * as Scope from "@effect/io/Scope"
 import type * as NodeClient from "@effect/platform-node/Http/NodeClient"
+import { IncomingMessageImpl } from "@effect/platform-node/internal/http/incomingMessage"
 import * as NodeSink from "@effect/platform-node/Sink"
-import * as NodeStream from "@effect/platform-node/Stream"
 import type * as Body from "@effect/platform/Http/Body"
 import * as Client from "@effect/platform/Http/Client"
 import * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
 import * as ClientResponse from "@effect/platform/Http/ClientResponse"
-import * as Headers from "@effect/platform/Http/Headers"
-import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as Stream from "@effect/stream/Stream"
 import * as Http from "node:http"
@@ -49,46 +47,52 @@ export const makeAgent = (options?: Https.AgentOptions): Effect.Effect<Scope.Sco
   )
 
 /** @internal */
-export const agentLayer = Layer.scoped(HttpAgent, makeAgent())
+export const makeAgentLayer = (options?: Https.AgentOptions): Layer.Layer<never, never, NodeClient.HttpAgent> =>
+  Layer.scoped(HttpAgent, makeAgent(options))
 
-const fromAgent = (agent: NodeClient.HttpAgent): Client.Client.Default => (request) =>
-  Effect.flatMap(
-    UrlParams.makeUrl(request.url, request.urlParams, (_) =>
-      Error.RequestError({
-        request,
-        reason: "InvalidUrl",
-        error: _
-      })),
-    (url) =>
-      Effect.suspend(() => {
-        const controller = new AbortController()
-        const nodeRequest = url.protocol === "https:" ?
-          Https.request(url, {
-            agent: agent.https,
-            method: request.method,
-            headers: Object.fromEntries(request.headers),
-            signal: controller.signal
-          }) :
-          Http.request(url, {
-            agent: agent.http,
-            method: request.method,
-            headers: Object.fromEntries(request.headers),
-            signal: controller.signal
-          })
-        return pipe(
-          Effect.zipRight(sendBody(nodeRequest, request, request.body), waitForResponse(nodeRequest), {
-            concurrent: true
-          }),
-          Effect.onInterrupt(() => Effect.sync(() => controller.abort())),
-          Effect.map((_) => new ClientResponseImpl(request, _))
-        )
-      })
+/** @internal */
+export const agentLayer = makeAgentLayer()
+
+const fromAgent = (agent: NodeClient.HttpAgent): Client.Client.Default =>
+  Client.make((request) =>
+    Effect.flatMap(
+      UrlParams.makeUrl(request.url, request.urlParams, (_) =>
+        Error.RequestError({
+          request,
+          reason: "InvalidUrl",
+          error: _
+        })),
+      (url) =>
+        Effect.suspend(() => {
+          const controller = new AbortController()
+          const nodeRequest = url.protocol === "https:" ?
+            Https.request(url, {
+              agent: agent.https,
+              method: request.method,
+              headers: Object.fromEntries(request.headers),
+              signal: controller.signal
+            }) :
+            Http.request(url, {
+              agent: agent.http,
+              method: request.method,
+              headers: Object.fromEntries(request.headers),
+              signal: controller.signal
+            })
+          return pipe(
+            Effect.zipRight(sendBody(nodeRequest, request, request.body), waitForResponse(nodeRequest), {
+              concurrent: true
+            }),
+            Effect.onInterrupt(() => Effect.sync(() => controller.abort())),
+            Effect.map((_) => new ClientResponseImpl(request, _))
+          )
+        })
+    )
   )
 
 const sendBody = (
   nodeRequest: Http.ClientRequest,
   request: ClientRequest.ClientRequest,
-  body: Body.Body
+  body: Body.NonEffect
 ): Effect.Effect<never, Error.RequestError, void> =>
   Effect.suspend((): Effect.Effect<never, Error.RequestError, void> => {
     switch (body._tag) {
@@ -96,7 +100,7 @@ const sendBody = (
         nodeRequest.end()
         return waitForFinish(nodeRequest, request)
       }
-      case "Bytes":
+      case "Uint8Array":
       case "Raw": {
         nodeRequest.end(body.body)
         return waitForFinish(nodeRequest, request)
@@ -118,20 +122,6 @@ const sendBody = (
             })
         })
       }
-      case "BytesEffect": {
-        return Effect.flatMap(
-          Effect.mapError(body.body, (_) =>
-            Error.RequestError({
-              request,
-              reason: "Encode",
-              error: _
-            })),
-          (bytes) => {
-            nodeRequest.end(bytes)
-            return waitForFinish(nodeRequest, request)
-          }
-        )
-      }
       case "Stream": {
         return Stream.run(
           Stream.mapError(body.stream, (_) =>
@@ -181,44 +171,25 @@ const waitForFinish = (nodeRequest: Http.ClientRequest, request: ClientRequest.C
     })
   })
 
-class ClientResponseImpl implements ClientResponse.ClientResponse {
-  readonly [IncomingMessage.TypeId]: IncomingMessage.TypeId = IncomingMessage.TypeId
-  readonly [ClientResponse.TypeId]: ClientResponse.TypeId = ClientResponse.TypeId
+class ClientResponseImpl extends IncomingMessageImpl<Error.ResponseError> implements ClientResponse.ClientResponse {
+  readonly [ClientResponse.TypeId]: ClientResponse.TypeId
 
   constructor(
     readonly request: ClientRequest.ClientRequest,
-    readonly source: Http.IncomingMessage
-  ) {}
-
-  get status() {
-    return this.source.statusCode!
-  }
-
-  get headers() {
-    return Headers.fromInput(this.source.headers as any)
-  }
-
-  get text(): Effect.Effect<never, Error.ResponseError, string> {
-    return NodeStream.toString(() => this.source, (_) =>
+    source: Http.IncomingMessage
+  ) {
+    super(source, (_) =>
       Error.ResponseError({
-        request: this.request,
+        request,
         response: this,
         reason: "Decode",
         error: _
       }))
+    this[ClientResponse.TypeId] = ClientResponse.TypeId
   }
 
-  get json(): Effect.Effect<never, Error.ResponseError, unknown> {
-    return Effect.tryMap(this.text, {
-      try: (_) => JSON.parse(_) as unknown,
-      catch: (_) =>
-        Error.ResponseError({
-          request: this.request,
-          response: this,
-          reason: "Decode",
-          error: _
-        })
-    })
+  get status() {
+    return this.source.statusCode!
   }
 
   get formData(): Effect.Effect<never, Error.ResponseError, FormData> {
@@ -229,37 +200,20 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
           status: this.source.statusCode,
           statusText: this.source.statusMessage
         }).formData(),
-      catch: (_) =>
-        Error.ResponseError({
-          request: this.request,
-          response: this,
-          reason: "Decode",
-          error: _
-        })
+      catch: this.onError
     })
   }
 
-  get stream(): Stream.Stream<never, Error.ResponseError, Uint8Array> {
-    return NodeStream.fromReadable<Error.ResponseError, Uint8Array>(
-      () => this.source,
-      (_) =>
-        Error.ResponseError({
-          request: this.request,
-          response: this,
-          reason: "Decode",
-          error: _
-        })
-    )
+  toString(): string {
+    return `ClientResponse(${this.status})`
   }
 
-  get arrayBuffer(): Effect.Effect<never, Error.ResponseError, ArrayBuffer> {
-    return NodeStream.toUint8Array(() => this.source, (_) =>
-      Error.ResponseError({
-        request: this.request,
-        response: this,
-        reason: "Decode",
-        error: _
-      }))
+  toJSON(): unknown {
+    return {
+      _tag: "ClientResponse",
+      status: this.status,
+      headers: Object.fromEntries(this.headers)
+    }
   }
 }
 
@@ -267,7 +221,7 @@ class ClientResponseImpl implements ClientResponse.ClientResponse {
 export const make = Effect.map(HttpAgent, fromAgent)
 
 /** @internal */
-export const layer = Layer.provide(
-  agentLayer,
-  Layer.effect(Client.Client, make)
-)
+export const layerWithoutAgent = Layer.effect(Client.Client, make)
+
+/** @internal */
+export const layer = Layer.provide(agentLayer, layerWithoutAgent)