@jsenv/server 10.0.3 → 10.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "10.0.3",
+  "version": "10.0.4",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {

package/src/fetch_url.js

@@ -4,10 +4,7 @@ import { Agent } from "node:https"
 import nodeFetch, { Response } from "node-fetch"
 
 import { fetchFileSystem } from "./fetch_filesystem.js"
-import {
-  isFileHandle,
-  fileHandleToReadableStream,
-} from "./internal/responseBody.js"
+import { isFileHandle, fileHandleToReadableStream } from "./internal/body.js"
 
 export const fetchUrl = async (
   url,

package/src/internal/{responseBody.js → body.js}

@@ -4,7 +4,7 @@ import { createReadStream } from "node:fs"
 import { isObservable, observableFromValue } from "./observable.js"
 import { nodeStreamToObservable } from "./nodeStreamToObservable.js"
 
-export const normalizeResponseBodyMethods = (body) => {
+export const normalizeBodyMethods = (body) => {
   if (isObservable(body)) {
     return {
       asObservable: () => body,

package/src/internal/nodeStreamToObservable.js

@@ -6,6 +6,24 @@ import { createObservable } from "./observable.js"
 const readableStreamLifetimeInSeconds = 120
 
 export const nodeStreamToObservable = (nodeStream) => {
+  const observable = createObservable(({ next, error, complete }) => {
+    const cleanup = () => {
+      nodeStream.removeListener("data", next)
+      nodeStream.removeListener("error", error)
+      nodeStream.removeListener("end", complete)
+      nodeStream.removeListener("close", cleanup)
+      nodeStream.destroy()
+    }
+
+    // should we do nodeStream.resume() in case the stream was paused ?
+    nodeStream.once("error", error)
+    nodeStream.on("data", next)
+    nodeStream.once("close", cleanup)
+    nodeStream.once("end", complete)
+
+    return cleanup
+  })
+
   if (nodeStream instanceof Readable) {
     // safe measure, ensure the readable stream gets
     // used in the next ${readableStreamLifetimeInSeconds} otherwise destroys it
@@ -20,28 +38,13 @@ export const nodeStreamToObservable = (nodeStream) => {
       )
       nodeStream.destroy()
     }, readableStreamLifetimeInSeconds * 1000)
+    observable.timeout = timeout
     onceReadableStreamUsedOrClosed(nodeStream, () => {
       clearTimeout(timeout)
     })
   }
 
-  return createObservable(({ next, error, complete }) => {
-    const cleanup = () => {
-      nodeStream.removeListener("data", next)
-      nodeStream.removeListener("error", error)
-      nodeStream.removeListener("end", complete)
-      nodeStream.removeListener("close", cleanup)
-      nodeStream.destroy()
-    }
-
-    // should we do nodeStream.resume() in case the stream was paused ?
-    nodeStream.once("error", error)
-    nodeStream.on("data", next)
-    nodeStream.once("close", cleanup)
-    nodeStream.once("end", complete)
-
-    return cleanup
-  })
+  return observable
 }
 
 const onceReadableStreamUsedOrClosed = (readableStream, callback) => {

package/src/internal/populateNodeResponse.js

@@ -1,7 +1,7 @@
 import { Http2ServerResponse } from "node:http2"
 import { raceCallbacks } from "@jsenv/abort"
 
-import { normalizeResponseBodyMethods } from "./responseBody.js"
+import { normalizeBodyMethods } from "./body.js"
 
 export const populateNodeResponse = async (
   responseStream,
@@ -9,7 +9,7 @@ export const populateNodeResponse = async (
   { signal, ignoreBody, onAbort, onError, onHeadersSent, onEnd } = {},
 ) => {
   body = await body
-  const bodyMethods = normalizeResponseBodyMethods(body)
+  const bodyMethods = normalizeBodyMethods(body)
 
   if (signal.aborted) {
     bodyMethods.destroy()

package/src/startServer.js

@@ -636,6 +636,14 @@ export const startServer = async ({
       if (receiveRequestOperation.signal.aborted) {
         return
       }
+
+      // the node request readable stream is never closed because
+      // the response headers contains "connection: keep-alive"
+      // In this scenario we want to disable READABLE_STREAM_TIMEOUT warning
+      if (responseProperties.headers.connection === "keep-alive") {
+        clearTimeout(request.body.timeout)
+      }
+
       await sendResponse({
         signal: sendResponseOperation.signal,
         request,