@effect/platform-node-shared 4.0.0-beta.102 → 4.0.0-beta.104

package/src/NodeHttpCompression.ts

@@ -0,0 +1,153 @@
+/**
+ * HTTP response compression backed by `node:zlib`, shared by the Node.js, Bun,
+ * and Deno platforms.
+ *
+ * Byte-array bodies are compressed in one shot with the asynchronous
+ * `node:zlib` APIs, preserving an exact `Content-Length`. Streaming bodies go
+ * through `node:zlib` transform streams that flush each input chunk.
+ *
+ * @since 4.0.0
+ */
+import * as Effect from "effect/Effect"
+import * as HttpBody from "effect/unstable/http/HttpBody"
+import type * as Platform from "effect/unstable/http/HttpPlatform"
+import * as Response from "effect/unstable/http/HttpServerResponse"
+import type { Duplex } from "node:stream"
+import { Readable } from "node:stream"
+import * as Zlib from "node:zlib"
+
+/**
+ * The compression algorithms supported by the runtime's `node:zlib`. `zstd`
+ * requires Node.js 22.15 or newer.
+ *
+ * @category constants
+ * @since 4.0.0
+ */
+export const algorithms: ReadonlySet<Platform.CompressionAlgorithm> = new Set(
+  typeof Zlib.zstdCompress === "function"
+    ? ["gzip", "deflate", "br", "zstd"]
+    : ["gzip", "deflate", "br"]
+)
+
+const brotliParams = (level: number | undefined, sizeHint?: number): Zlib.BrotliOptions => {
+  const params: Record<number, number> = {}
+  if (level !== undefined) {
+    params[Zlib.constants.BROTLI_PARAM_QUALITY] = level
+  }
+  if (sizeHint !== undefined) {
+    params[Zlib.constants.BROTLI_PARAM_SIZE_HINT] = sizeHint
+  }
+  return { params }
+}
+
+const zstdParams = (level: number | undefined): Zlib.ZstdOptions | undefined =>
+  level === undefined || level === 3 ? undefined : { params: { [Zlib.constants.ZSTD_c_compressionLevel]: level } }
+
+const compress = (
+  data: Uint8Array,
+  algorithm: Platform.CompressionAlgorithm,
+  options?: Platform.CompressionOptions | undefined
+): Effect.Effect<Uint8Array> =>
+  Effect.callback((resume) => {
+    const complete = (error: Error | null, result: Uint8Array) =>
+      resume(error === null ? Effect.succeed(result) : Effect.die(error))
+    switch (algorithm) {
+      case "gzip": {
+        Zlib.gzip(data, { level: options?.level }, complete)
+        break
+      }
+      case "deflate": {
+        Zlib.deflate(data, { level: options?.level }, complete)
+        break
+      }
+      case "br": {
+        Zlib.brotliCompress(data, brotliParams(options?.level, data.byteLength), complete)
+        break
+      }
+      case "zstd": {
+        const params = zstdParams(options?.level)
+        if (params === undefined) {
+          Zlib.zstdCompress(data, complete)
+        } else {
+          Zlib.zstdCompress(data, params, complete)
+        }
+        break
+      }
+    }
+  })
+
+/**
+ * Creates a `Compression` that compresses byte-array bodies in one shot with
+ * the asynchronous `node:zlib` APIs, setting the exact `Content-Length` of the
+ * compressed body. All other bodies are delegated to `fallback`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = (fallback: Platform.Compression): Platform.Compression => ({
+  algorithms: fallback.algorithms,
+  compressResponse(response, algorithm, options) {
+    const body = response.body
+    if (body._tag !== "Uint8Array") {
+      return fallback.compressResponse(response, algorithm, options)
+    }
+    return Effect.map(compress(body.body, algorithm, options), (result) =>
+      Response.setHeader(
+        Response.setBody(response, HttpBody.uint8Array(result, body.contentType)),
+        "content-length",
+        result.byteLength.toString()
+      ))
+  }
+})
+
+/**
+ * Creates a `node:zlib` compression transform stream that flushes each input
+ * chunk, for streaming response bodies.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const compressTransform = (
+  algorithm: Platform.CompressionAlgorithm,
+  options?: Platform.CompressionOptions | undefined
+): Duplex => {
+  switch (algorithm) {
+    case "gzip": {
+      return Zlib.createGzip({ level: options?.level, flush: Zlib.constants.Z_SYNC_FLUSH })
+    }
+    case "deflate": {
+      return Zlib.createDeflate({ level: options?.level, flush: Zlib.constants.Z_SYNC_FLUSH })
+    }
+    case "br": {
+      return Zlib.createBrotliCompress({
+        ...brotliParams(options?.level),
+        flush: Zlib.constants.BROTLI_OPERATION_FLUSH
+      })
+    }
+    case "zstd": {
+      return Zlib.createZstdCompress({
+        ...zstdParams(options?.level),
+        flush: Zlib.constants.ZSTD_e_flush
+      })
+    }
+  }
+}
+
+/**
+ * A Web `ReadableStream` version of `compressTransform`, for platforms that
+ * stream response bodies as Web streams.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const compressTransformWeb = (
+  algorithm: Platform.CompressionAlgorithm,
+  options?: Platform.CompressionOptions | undefined
+) =>
+(stream: ReadableStream<Uint8Array>): ReadableStream<Uint8Array> => {
+  const transform = compressTransform(algorithm, options)
+  const source = Readable.fromWeb(stream as any)
+  source.on("error", (cause) => transform.destroy(cause))
+  transform.on("close", () => source.destroy())
+  return Readable.toWeb(source.pipe(transform)) as unknown as ReadableStream<Uint8Array>
+}

package/src/NodePath.ts

@@ -15,27 +15,28 @@ import { BadArgument } from "effect/PlatformError"
 import * as NodePath from "node:path"
 import * as NodeUrl from "node:url"
 
-const fromFileUrl = (url: URL): Effect.Effect<string, BadArgument> =>
-  Effect.try({
-    try: () => NodeUrl.fileURLToPath(url),
-    catch: (cause) =>
-      new BadArgument({
-        module: "Path",
-        method: "fromFileUrl",
-        cause
-      })
-  })
-
-const toFileUrl = (path: string): Effect.Effect<URL, BadArgument> =>
-  Effect.try({
-    try: () => NodeUrl.pathToFileURL(path),
-    catch: (cause) =>
-      new BadArgument({
-        module: "Path",
-        method: "toFileUrl",
-        cause
-      })
-  })
+const fileUrlOps = (windows: boolean | undefined) => ({
+  fromFileUrl: (url: URL): Effect.Effect<string, BadArgument> =>
+    Effect.try({
+      try: () => NodeUrl.fileURLToPath(url, { windows }),
+      catch: (cause) =>
+        new BadArgument({
+          module: "Path",
+          method: "fromFileUrl",
+          cause
+        })
+    }),
+  toFileUrl: (path: string): Effect.Effect<URL, BadArgument> =>
+    Effect.try({
+      try: () => NodeUrl.pathToFileURL(path, { windows }),
+      catch: (cause) =>
+        new BadArgument({
+          module: "Path",
+          method: "toFileUrl",
+          cause
+        })
+    })
+})
 
 /**
  * Provides the `Path` service using Node's POSIX path implementation plus
@@ -47,8 +48,7 @@ const toFileUrl = (path: string): Effect.Effect<URL, BadArgument> =>
 export const layerPosix: Layer.Layer<Path> = Layer.succeed(Path)({
   [TypeId]: TypeId,
   ...NodePath.posix,
-  fromFileUrl,
-  toFileUrl
+  ...fileUrlOps(false)
 })
 
 /**
@@ -61,8 +61,7 @@ export const layerPosix: Layer.Layer<Path> = Layer.succeed(Path)({
 export const layerWin32: Layer.Layer<Path> = Layer.succeed(Path)({
   [TypeId]: TypeId,
   ...NodePath.win32,
-  fromFileUrl,
-  toFileUrl
+  ...fileUrlOps(true)
 })
 
 /**
@@ -75,6 +74,5 @@ export const layerWin32: Layer.Layer<Path> = Layer.succeed(Path)({
 export const layer: Layer.Layer<Path> = Layer.succeed(Path)({
   [TypeId]: TypeId,
   ...NodePath,
-  fromFileUrl,
-  toFileUrl
+  ...fileUrlOps(undefined)
 })

package/src/NodeSocketServer.ts

@@ -52,12 +52,14 @@ export const make = Effect.fnUntraced(function*(
   options: Net.ServerOpts & Net.ListenOptions
 ) {
   const errorDeferred = Deferred.makeUnsafe<never, Error>()
-  const pending = new Set<Net.Socket>()
+  const pending = new Map<Net.Socket, () => void>()
   function defaultOnConnection(conn: Net.Socket) {
-    pending.add(conn)
     const remove = () => {
       pending.delete(conn)
+      conn.off("close", remove)
+      conn.off("error", remove)
     }
+    pending.set(conn, remove)
     conn.on("close", remove)
     conn.on("error", remove)
   }
@@ -66,6 +68,10 @@ export const make = Effect.fnUntraced(function*(
   let server: Net.Server | undefined
   yield* Effect.addFinalizer(() =>
     Effect.callback<void>((resume) => {
+      pending.forEach((remove, conn) => {
+        remove()
+        conn.destroy()
+      })
       server?.close(() => resume(Effect.void))
     })
   )
@@ -129,12 +135,10 @@ export const make = Effect.fnUntraced(function*(
         trackFiber
       )
     }
-    pending.forEach((conn) => {
-      conn.removeAllListeners("error")
-      conn.removeAllListeners("close")
+    pending.forEach((remove, conn) => {
+      remove()
       onConnection(conn)
     })
-    pending.clear()
     return yield* Effect.callback<never>((_resume) => {
       return Effect.suspend(() => {
         onConnection = prevOnConnection
@@ -190,20 +194,29 @@ export const makeWebSocket: (
 > = Effect.fnUntraced(function*(
   options: NodeWS.ServerOptions
 ) {
+  const pendingConnections = new Map<
+    globalThis.WebSocket,
+    readonly [request: Http.IncomingMessage, remove: () => void]
+  >()
   const server = yield* Effect.acquireRelease(
     Effect.sync(() => new NodeWS.WebSocketServer(options)),
     (server) =>
       Effect.callback<void>((resume) => {
+        pendingConnections.forEach(([, remove], conn) => {
+          remove()
+          const socket = conn as unknown as NodeWS.WebSocket
+          socket.terminate()
+        })
         server.close(() => resume(Effect.void))
       })
   )
-  const pendingConnections = new Set<readonly [globalThis.WebSocket, Http.IncomingMessage]>()
   function defaultHandler(conn: globalThis.WebSocket, req: Http.IncomingMessage) {
-    const entry = [conn, req] as const
-    pendingConnections.add(entry)
-    conn.addEventListener("close", () => {
-      pendingConnections.delete(entry)
-    })
+    const remove = () => {
+      pendingConnections.delete(conn)
+      conn.removeEventListener("close", remove)
+    }
+    pendingConnections.set(conn, [req, remove])
+    conn.addEventListener("close", remove)
   }
   let onConnection = defaultHandler
   server.on("connection", (conn, req) => onConnection(conn as any, req))
@@ -248,10 +261,10 @@ export const makeWebSocket: (
         trackFiber
       )
     }
-    for (const [conn, req] of pendingConnections) {
+    pendingConnections.forEach(([req, remove], conn) => {
+      remove()
       onConnection(conn, req)
-    }
-    pendingConnections.clear()
+    })
     return yield* Effect.callback<never>((_resume) => {
       return Effect.sync(() => {
         onConnection = prevOnConnection

package/src/NodeTerminal.ts

@@ -35,25 +35,52 @@ export const make: (
   function*(shouldQuit: (input: Terminal.UserInput) => boolean = defaultShouldQuit) {
     const stdin = process.stdin
     const stdout = process.stdout
+    const lines = yield* Queue.make<string, Cause.Done>()
+
+    // stdin "end" fires once per process, so remember end-of-input for readers
+    // created after the event (Bun never sets `readableEnded`).
+    let inputEnded = stdin.readableEnded
+    let readlineActive = false
+    const onStdinEnd = () => {
+      inputEnded = true
+      if (!readlineActive) {
+        Queue.endUnsafe(lines)
+      }
+    }
+    stdin.once("end", onStdinEnd)
+    yield* Effect.addFinalizer(() => Effect.sync(() => stdin.off("end", onStdinEnd)))
 
-    // Acquire readline interface with TTY setup/cleanup inside the scope
     const rlRef = yield* RcRef.make({
       acquire: Effect.acquireRelease(
         Effect.sync(() => {
           const rl = readline.createInterface({ input: stdin, escapeCodeTimeout: 50 })
+          const onLine = (line: string) => Queue.offerUnsafe(lines, line)
+          const onClose = () => {
+            readlineActive = false
+            Queue.endUnsafe(lines)
+          }
+          readlineActive = true
           readline.emitKeypressEvents(stdin, rl)
+          rl.on("line", onLine)
+          rl.once("close", onClose)
 
           if (stdin.isTTY) {
             stdin.setRawMode(true)
           }
-          return rl
+          return { rl, onClose, onLine }
         }),
-        (rl) =>
+        ({ rl, onClose, onLine }) =>
           Effect.sync(() => {
+            readlineActive = false
+            rl.off("line", onLine)
+            rl.off("close", onClose)
             if (stdin.isTTY) {
               stdin.setRawMode(false)
             }
             rl.close()
+            if (inputEnded) {
+              Queue.endUnsafe(lines)
+            }
           })
       )
     })
@@ -62,7 +89,6 @@ export const make: (
     const rows = Effect.sync(() => stdout.rows ?? 0)
 
     const readInput = Effect.gen(function*() {
-      yield* RcRef.get(rlRef)
       const queue = yield* Queue.make<Terminal.UserInput, Cause.Done>()
       const handleKeypress = (s: string | undefined, k: readline.Key) => {
         const userInput = {
@@ -74,18 +100,40 @@ export const make: (
           Queue.endUnsafe(queue)
         }
       }
-      yield* Effect.addFinalizer(() => Effect.sync(() => stdin.off("keypress", handleKeypress)))
+      // Deno's `process.stdin` shim does not keep the event loop alive, so a
+      // program blocked on input can exit before `end` is ever delivered. A
+      // timer holds the loop open for as long as this reader is active.
+      const keepAlive = setInterval(() => {}, 2147483647)
+      // Without this, consumers (e.g. `Prompt.run`) hang forever on closed stdin.
+      const handleEnd = () => {
+        clearInterval(keepAlive)
+        Queue.endUnsafe(queue)
+      }
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          clearInterval(keepAlive)
+          stdin.off("keypress", handleKeypress)
+          stdin.off("end", handleEnd)
+        })
+      )
       stdin.on("keypress", handleKeypress)
+      if (inputEnded) {
+        handleEnd()
+      } else {
+        yield* RcRef.get(rlRef)
+        stdin.once("end", handleEnd)
+      }
       return queue as Queue.Dequeue<Terminal.UserInput, Cause.Done>
     })
 
-    const readLine = Effect.scoped(
-      Effect.flatMap(RcRef.get(rlRef), (readlineInterface) =>
-        Effect.callback<string, Terminal.QuitError>((resume) => {
-          const onLine = (line: string) => resume(Effect.succeed(line))
-          readlineInterface.once("line", onLine)
-          return Effect.sync(() => readlineInterface.off("line", onLine))
-        }))
+    const readLine = Effect.suspend(() =>
+      Queue.poll(lines).pipe(
+        Effect.flatMap(Option.match({
+          onNone: () => Effect.scoped(Effect.andThen(RcRef.get(rlRef), Queue.take(lines))),
+          onSome: Effect.succeed
+        })),
+        Effect.mapError(() => new Terminal.QuitError({}))
+      )
     )
 
     const display = (prompt: string) =>

package/src/index.ts

@@ -24,6 +24,11 @@ export * as NodeCrypto from "./NodeCrypto.ts"
  */
 export * as NodeFileSystem from "./NodeFileSystem.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as NodeHttpCompression from "./NodeHttpCompression.ts"
+
 /**
  * @since 4.0.0
  */

package/src/internal/utils.ts

@@ -6,7 +6,7 @@ import type { PathLike } from "node:fs"
 export const handleErrnoException = (module: SystemError["module"], method: string) =>
 (
   err: NodeJS.ErrnoException,
-  [path]: [path: PathLike | number | string | readonly string[], ...args: Array<any>]
+  [path]: [path: PathLike | number | string | ReadonlyArray<string>, ...args: Array<any>]
 ): PlatformError.PlatformError => {
   let reason: SystemErrorTag = "Unknown"