@effect/platform-node 4.0.0-beta.99 → 4.0.0-rc.108

package/src/NodeMultipartParser.ts

@@ -0,0 +1,184 @@
+/**
+ * Node.js streams adapter for the low-level multipart parser.
+ *
+ * @since 4.0.0
+ */
+// oxlint-disable typescript/no-unsafe-declaration-merging
+/// <reference types="node" />
+import type { BaseConfig, MultipartError, Parser, PartInfo } from "effect/unstable/http/MultipartParser"
+import { make as makeParser } from "effect/unstable/http/MultipartParser"
+import type { IncomingHttpHeaders } from "node:http"
+import { Duplex, Readable } from "node:stream"
+
+/**
+ * A part emitted by the Node.js multipart parser.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type Part = Field | FileStream
+
+/**
+ * A parsed multipart field.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Field {
+  readonly _tag: "Field"
+  readonly info: PartInfo
+  readonly value: Uint8Array
+}
+
+/**
+ * A Node.js duplex stream that emits parsed multipart parts.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface MultipartStream extends Duplex {
+  [Symbol.asyncIterator](): NodeJS.AsyncIterator<Part>
+
+  on(event: "field", listener: (field: Field) => void): this
+  on(event: "file", listener: (file: FileStream) => void): this
+  on(event: "close", listener: () => void): this
+  on(event: "data", listener: (part: Part) => void): this
+  on(event: "drain", listener: () => void): this
+  on(event: "end", listener: () => void): this
+  on(event: "error", listener: (err: MultipartError) => void): this
+  on(event: "finish", listener: () => void): this
+  on(event: "pause", listener: () => void): this
+  on(event: "pipe", listener: (src: Readable) => void): this
+  on(event: "readable", listener: () => void): this
+  on(event: "resume", listener: () => void): this
+  on(event: "unpipe", listener: (src: Readable) => void): this
+  on(event: string | symbol, listener: (...args: Array<any>) => void): this
+
+  read(size?: number): Part | null
+}
+
+/**
+ * Configuration for the Node.js multipart parser.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type NodeConfig = Omit<BaseConfig, "headers"> & {
+  readonly headers: IncomingHttpHeaders
+}
+
+/**
+ * A Node.js duplex stream that parses multipart input.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export class MultipartStream extends Duplex {
+  private _parser: Parser
+  _canWrite = true
+  private _writeCallback: (() => void) | undefined
+
+  constructor(config: NodeConfig) {
+    super({ readableObjectMode: true })
+    let currentError: MultipartError | undefined
+    let currentFile: FileStream | undefined
+    this._parser = makeParser({
+      ...(config as any),
+      onField: (info, value) => {
+        if (currentError !== undefined) return
+        const field: Field = { _tag: "Field", info, value }
+        this.push(field)
+        this.emit("field", field)
+      },
+      onFile: (info) => {
+        if (currentError !== undefined) return (_) => {}
+        const file = new FileStream(info, this)
+        currentFile = file
+        this.push(file)
+        this.emit("file", file)
+        return (chunk) => {
+          if (currentError !== undefined) return
+          this._canWrite = file.push(chunk)
+          if (chunk === null && !this._canWrite) {
+            currentFile = undefined
+            this._resume()
+          }
+        }
+      },
+      onError: (error) => {
+        this.emit("error", error)
+        currentFile?.emit("error", error)
+        currentError = error
+      },
+      onDone: () => {
+        this.push(null)
+      }
+    })
+  }
+
+  _resume() {
+    this._canWrite = true
+    if (this._writeCallback !== undefined) {
+      const callback = this._writeCallback
+      this._writeCallback = undefined
+      callback()
+    }
+  }
+
+  override _read(_size: number) {}
+
+  override _write(
+    chunk: any,
+    encoding: BufferEncoding,
+    callback: (error?: Error | null | undefined) => void
+  ): void {
+    this._parser.write(
+      chunk instanceof Uint8Array ? chunk : Buffer.from(chunk, encoding)
+    )
+    if (this._canWrite) {
+      callback()
+    } else {
+      this._writeCallback = callback
+    }
+  }
+
+  override _final(callback: (error?: Error | null | undefined) => void): void {
+    this._parser.end()
+    callback()
+  }
+}
+
+/**
+ * Creates a Node.js multipart parser stream.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = (config: NodeConfig): MultipartStream => new MultipartStream(config)
+
+/**
+ * A readable stream containing a parsed multipart file.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export class FileStream extends Readable {
+  readonly _tag = "File"
+  readonly filename: string | undefined
+  readonly info: PartInfo
+  private _parent: MultipartStream
+  constructor(
+    info: PartInfo,
+    parent: MultipartStream
+  ) {
+    super()
+    this.info = info
+    this._parent = parent
+    this.filename = info.filename
+  }
+  override _read(_size: number) {
+    if (this._parent._canWrite === false) {
+      this._parent._resume()
+    }
+  }
+}

package/src/NodeWorkerRunner.ts

@@ -16,6 +16,7 @@ import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
 import * as Fiber from "effect/Fiber"
 import * as Layer from "effect/Layer"
+import * as Scope from "effect/Scope"
 import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/unstable/workers/WorkerError"
 import * as WorkerRunner from "effect/unstable/workers/WorkerRunner"
 import * as WorkerThreads from "node:worker_threads"
@@ -56,7 +57,8 @@ export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succe
               runFork(Effect.logError("unhandled error in worker", exit.cause))
             }
           }
-          ;(WorkerThreads.parentPort ?? process).on("message", (message: WorkerRunner.PlatformMessage<I>) => {
+          const port = WorkerThreads.parentPort ?? process
+          function onMessage(message: WorkerRunner.PlatformMessage<I>) {
             if (message[0] === 0) {
               const result = handler(0, message[1])
               if (Effect.isEffect(result)) {
@@ -72,32 +74,46 @@ export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succe
               }
               Deferred.doneUnsafe(closeLatch, Exit.void)
             }
-          })
+          }
+          port.on("message", onMessage)
 
-          if (WorkerThreads.parentPort) {
-            WorkerThreads.parentPort.on("messageerror", (cause) => {
-              Deferred.doneUnsafe(
-                closeLatch,
-                new WorkerError({
-                  reason: new WorkerReceiveError({
-                    message: "received messageerror event",
-                    cause
-                  })
+          function onMessageError(cause: unknown) {
+            Deferred.doneUnsafe(
+              closeLatch,
+              new WorkerError({
+                reason: new WorkerReceiveError({
+                  message: "received messageerror event",
+                  cause
                 })
-              )
-            })
-            WorkerThreads.parentPort.on("error", (cause) => {
-              Deferred.doneUnsafe(
-                closeLatch,
-                new WorkerError({
-                  reason: new WorkerReceiveError({
-                    message: "received messageerror event",
-                    cause
-                  })
+              })
+            )
+          }
+          function onError(cause: unknown) {
+            Deferred.doneUnsafe(
+              closeLatch,
+              new WorkerError({
+                reason: new WorkerReceiveError({
+                  message: "received error event",
+                  cause
                 })
-              )
-            })
+              })
+            )
           }
+          if (WorkerThreads.parentPort) {
+            WorkerThreads.parentPort.on("messageerror", onMessageError)
+            WorkerThreads.parentPort.on("error", onError)
+          }
+
+          yield* Scope.addFinalizer(
+            scope,
+            Effect.sync(() => {
+              port.off("message", onMessage)
+              if (WorkerThreads.parentPort) {
+                WorkerThreads.parentPort.off("messageerror", onMessageError)
+                WorkerThreads.parentPort.off("error", onError)
+              }
+            })
+          )
 
           sendUnsafe(0, [0])
 

package/src/Undici.ts

@@ -17,13 +17,13 @@
 import Undici from "undici"
 
 /**
- * @category Undici
+ * @category re-exports
  * @since 4.0.0
  */
 export * from "undici"
 
 /**
- * @category Undici
+ * @category re-exports
  * @since 4.0.0
  */
 export default Undici

package/src/index.ts

@@ -64,6 +64,11 @@ export * as NodeHttpServerRequest from "./NodeHttpServerRequest.ts"
  */
 export * as NodeMultipart from "./NodeMultipart.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as NodeMultipartParser from "./NodeMultipartParser.ts"
+
 /**
  * @since 4.0.0
  */