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

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))
@@ -229,9 +242,9 @@ export const makeWebSocket: (
     const trackFiber = Fiber.runIn(scope)
     const prevOnConnection = onConnection
     onConnection = function(conn: globalThis.WebSocket, req: Http.IncomingMessage) {
-      const map = new Map(services.mapUnsafe)
-      map.set(IncomingMessage.key, req)
-      map.set(Socket.WebSocket.key, conn as any)
+      let context = services
+      context = Context.add(context, IncomingMessage, req)
+      context = Context.add(context, Socket.WebSocket, conn as any)
       pipe(
         Socket.fromWebSocket(
           Effect.acquireRelease(
@@ -244,14 +257,14 @@ export const makeWebSocket: (
         ),
         Effect.flatMap(handler),
         Effect.catchCause(reportUnhandledError),
-        Effect.runForkWith(Context.makeUnsafe(map)),
+        Effect.runForkWith(context),
         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/NodeStdio.ts

@@ -28,6 +28,8 @@ export const layer: Layer.Layer<Stdio.Stdio> = Layer.succeed(
   Stdio.Stdio,
   Stdio.make({
     args: Effect.sync(() => process.argv.slice(2)),
+    stdinIsTerminal: Effect.sync(() => process.stdin.isTTY === true),
+    stdoutIsTerminal: Effect.sync(() => process.stdout.isTTY === true),
     stdout: (options) =>
       fromWritable({
         evaluate: () => process.stdout,

package/src/NodeStream.ts

@@ -245,7 +245,7 @@ export const toString = <E = Cause.UnknownError>(
     readonly maxBytes?: SizeInput | undefined
   }
 ): Effect.Effect<string, E> => {
-  const maxBytesNumber = options?.maxBytes ? Number(options.maxBytes) : undefined
+  const maxBytesNumber = options?.maxBytes !== undefined ? Number(options.maxBytes) : undefined
   const onError = options?.onError ?? defaultOnError
   const encoding = options?.encoding ?? "utf8"
   return Effect.callback((resume) => {
@@ -258,9 +258,6 @@ export const toString = <E = Cause.UnknownError>(
       }
       resume(Effect.fail(onError(err) as E))
     })
-    stream.once("error", (err) => {
-      resume(Effect.fail(onError(err) as E))
-    })
 
     let string = ""
     let bytes = 0
@@ -270,7 +267,10 @@ export const toString = <E = Cause.UnknownError>(
     stream.on("data", (chunk) => {
       string += chunk
       bytes += Buffer.byteLength(chunk)
-      if (maxBytesNumber && bytes > maxBytesNumber) {
+      if (maxBytesNumber !== undefined && bytes > maxBytesNumber) {
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy()
+        }
         resume(Effect.fail(onError(new Error("maxBytes exceeded")) as E))
       }
     })
@@ -297,7 +297,7 @@ export const toArrayBuffer = <E = Cause.UnknownError>(
     readonly maxBytes?: SizeInput | undefined
   }
 ): Effect.Effect<ArrayBuffer, E> => {
-  const maxBytesNumber = options?.maxBytes ? Number(options.maxBytes) : undefined
+  const maxBytesNumber = options?.maxBytes !== undefined ? Number(options.maxBytes) : undefined
   const onError = options?.onError ?? defaultOnError
   return Effect.callback((resume) => {
     const stream = readable() as Readable
@@ -321,7 +321,10 @@ export const toArrayBuffer = <E = Cause.UnknownError>(
     stream.on("data", (chunk) => {
       buffers.push(chunk)
       bytes += chunk.length
-      if (maxBytesNumber && bytes > maxBytesNumber) {
+      if (maxBytesNumber !== undefined && bytes > maxBytesNumber) {
+        if ("closed" in stream && !stream.closed) {
+          stream.destroy()
+        }
         resume(Effect.fail(onError(new Error("maxBytes exceeded")) as E))
       }
     })

package/src/NodeTerminal.ts

@@ -35,34 +35,61 @@ 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)
+            }
           })
-      )
+      ),
+      idleTimeToLive: "10 millis"
     })
 
     const columns = Effect.sync(() => stdout.columns ?? 0)
     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 +101,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/nodeChildProcessSpawner.ts

@@ -0,0 +1,16 @@
+import type * as ChildProcess from "effect/unstable/process/ChildProcess"
+import type * as NodeChildProcess from "node:child_process"
+
+export const buildSpawnOptions = (
+  options: ChildProcess.CommandOptions,
+  base: Pick<NodeChildProcess.SpawnOptions, "cwd" | "env" | "stdio">,
+  platform: NodeJS.Platform
+): NodeChildProcess.SpawnOptions => {
+  const detached = options.detached ?? platform !== "win32"
+  return {
+    ...base,
+    detached,
+    shell: options.shell,
+    windowsHide: options.windowsHide ?? !detached
+  }
+}

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"