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

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/NodeRedis.ts

@@ -1,11 +1,12 @@
 /**
- * Node.js Redis integration backed by `ioredis`.
+ * Node.js Redis integration backed by `redis` (node-redis).
  *
- * This module creates a scoped `ioredis` client and exposes it in two forms:
+ * This module creates a scoped `node-redis` client and exposes it in two forms:
  * the generic `Redis` service and the {@link NodeRedis} service for direct
- * access to the underlying client. `layer` accepts ioredis options directly,
- * while `layerConfig` reads them from Effect config. Both layers close the
- * client when the layer scope ends.
+ * access to the underlying client. `layer` accepts node-redis client options
+ * directly, while `layerConfig` reads them from Effect config. `node-redis`
+ * connects explicitly, so layer construction can fail with a `RedisError`.
+ * Both layers close the client when the layer scope ends.
  *
  * @since 4.0.0
  */
@@ -14,31 +15,68 @@ import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Fn from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as Scope from "effect/Scope"
 import * as Redis from "effect/unstable/persistence/Redis"
-import * as IoRedis from "ioredis"
+import { createClient, SocketTimeoutError } from "redis"
+
+type NodeRedisClient = ReturnType<typeof createClient>
+type NodeRedisClientOptions = NonNullable<Parameters<typeof createClient>[0]>
 
 /**
  * Service tag for the Node Redis integration, exposing the underlying
- * `ioredis` client and a `use` helper that maps client failures to
+ * `node-redis` client and a `use` helper that maps client failures to
  * `RedisError`.
  *
  * @category services
  * @since 4.0.0
  */
 export class NodeRedis extends Context.Service<NodeRedis, {
-  readonly client: IoRedis.Redis
-  readonly use: <A>(f: (client: IoRedis.Redis) => Promise<A>) => Effect.Effect<A, Redis.RedisError>
+  readonly client: NodeRedisClient
+  readonly use: <A>(f: (client: NodeRedisClient) => Promise<A>) => Effect.Effect<A, Redis.RedisError>
 }>()("@effect/platform-node/NodeRedis") {}
 
 const make = Effect.fnUntraced(function*(
-  options?: IoRedis.RedisOptions
+  options?: NodeRedisClientOptions
 ) {
-  const scope = yield* Effect.scope
-  yield* Scope.addFinalizer(scope, Effect.promise(() => client.quit()))
-  const client = new IoRedis.Redis(options ?? {})
+  let ready = false
+  const socket = options?.socket
+  const client = yield* Effect.acquireRelease(
+    Effect.sync((): NodeRedisClient =>
+      createClient({
+        ...options,
+        socket: socket?.reconnectStrategy === undefined
+          ? {
+            ...socket,
+            reconnectStrategy: (retries, cause) => {
+              if (!ready) return cause
+              if (cause instanceof SocketTimeoutError) return false
+              const jitter = Math.floor(Math.random() * 200)
+              const delay = Math.min(2 ** retries * 50, 2000)
+              return delay + jitter
+            }
+          }
+          : socket
+      })
+    ),
+    (client) => Effect.ignoreCause(Effect.promise(() => client.close()))
+  )
+  client.once("ready", () => {
+    ready = true
+  })
+
+  // node-redis rethrows `error` events that have no listener, which would crash
+  // the process on a transient socket failure. Command failures are still
+  // reported as `RedisError`.
+  const runSync = Effect.runSyncWith(yield* Effect.context<never>())
+  client.on("error", (cause) => {
+    runSync(Effect.logWarning("NodeRedis client error", cause))
+  })
+
+  yield* Effect.tryPromise({
+    try: () => client.connect(),
+    catch: (cause) => new Redis.RedisError({ cause })
+  })
 
-  const use = <A>(f: (client: IoRedis.Redis) => Promise<A>) =>
+  const use = <A>(f: (client: NodeRedisClient) => Promise<A>) =>
     Effect.tryPromise({
       try: () => f(client),
       catch: (cause) => new Redis.RedisError({ cause })
@@ -47,7 +85,7 @@ const make = Effect.fnUntraced(function*(
   const redis = yield* Redis.make({
     send: <A = unknown>(command: string, ...args: ReadonlyArray<string>) =>
       Effect.tryPromise({
-        try: () => client.call(command, ...args) as Promise<A>,
+        try: () => client.sendCommand([command, ...args]) as Promise<A>,
         catch: (cause) => new Redis.RedisError({ cause })
       })
   })
@@ -63,28 +101,50 @@ const make = Effect.fnUntraced(function*(
 })
 
 /**
- * Provides `Redis` and `NodeRedis` services backed by an `ioredis` client
- * created with the supplied options and closed when the layer scope ends.
+ * Provides `Redis` and `NodeRedis` services backed by a `node-redis` client
+ * created with the supplied options, connected when the layer is built and
+ * closed when the layer scope ends.
+ *
+ * **Details**
+ *
+ * By default, the initial connection fails on its first connection error. A
+ * caller-supplied `socket.reconnectStrategy` is used instead when present. Once
+ * the client has emitted `ready`, the default reconnect strategy uses
+ * node-redis' exponential backoff and stops on socket timeouts.
+ *
+ * Scope finalization calls `close()`, which waits for in-flight commands,
+ * including blocking commands, and can therefore delay scope closure.
  *
  * @category layers
  * @since 4.0.0
  */
 export const layer = (
-  options?: IoRedis.RedisOptions | undefined
-): Layer.Layer<Redis.Redis | NodeRedis> => Layer.effectContext(make(options))
+  options?: NodeRedisClientOptions | undefined
+): Layer.Layer<Redis.Redis | NodeRedis, Redis.RedisError> => Layer.effectContext(make(options))
 
 /**
- * Provides `Redis` and `NodeRedis` services from `Config`-backed ioredis
- * options, closing the client when the layer scope ends.
+ * Provides `Redis` and `NodeRedis` services from `Config`-backed node-redis
+ * client options, connecting the client when the layer is built and closing it
+ * when the layer scope ends.
+ *
+ * **Details**
+ *
+ * By default, the initial connection fails on its first connection error. A
+ * caller-supplied `socket.reconnectStrategy` is used instead when present. Once
+ * the client has emitted `ready`, the default reconnect strategy uses
+ * node-redis' exponential backoff and stops on socket timeouts.
+ *
+ * Scope finalization calls `close()`, which waits for in-flight commands,
+ * including blocking commands, and can therefore delay scope closure.
  *
  * @category layers
  * @since 4.0.0
  */
 export const layerConfig: (
-  options: Config.Wrap<IoRedis.RedisOptions>
-) => Layer.Layer<Redis.Redis | NodeRedis, Config.ConfigError> = (
-  options: Config.Wrap<IoRedis.RedisOptions>
-): Layer.Layer<Redis.Redis | NodeRedis, Config.ConfigError> =>
+  options: Config.Wrap<NodeRedisClientOptions>
+) => Layer.Layer<Redis.Redis | NodeRedis, Redis.RedisError | Config.ConfigError> = (
+  options: Config.Wrap<NodeRedisClientOptions>
+): Layer.Layer<Redis.Redis | NodeRedis, Redis.RedisError | Config.ConfigError> =>
   Layer.effectContext(
     Config.unwrap(options).pipe(
       Effect.flatMap(make)

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
  */