@jsenv/server 10.0.0 → 10.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "10.0.0",
+  "version": "10.0.4",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -46,7 +46,7 @@
     "postpublish": "node ./script/publish/restore_postinstall.mjs"
   },
   "dependencies": {
-    "@jsenv/abort": "3.1.2",
+    "@jsenv/abort": "4.1.1",
     "@jsenv/logger": "4.0.1",
     "node-fetch": "2.6.2"
   },
@@ -55,15 +55,15 @@
     "@babel/eslint-parser": "7.16.0",
     "@jsenv/assert": "2.3.2",
     "@jsenv/codecov-upload": "3.5.0",
-    "@jsenv/core": "23.2.1",
+    "@jsenv/core": "23.4.2",
     "@jsenv/eslint-config": "16.0.8",
-    "@jsenv/filesystem": "2.3.1",
+    "@jsenv/filesystem": "2.5.1",
     "@jsenv/github-release-package": "1.2.3",
     "@jsenv/https-local": "1.0.2",
     "@jsenv/importmap-eslint-resolver": "5.1.2",
     "@jsenv/importmap-node-module": "2.4.1",
     "@jsenv/package-publish": "1.6.2",
-    "@jsenv/performance-impact": "2.2.0",
+    "@jsenv/performance-impact": "2.2.1",
     "@jsenv/prettier-check-project": "5.6.1",
     "eslint": "7.32.0",
     "eslint-plugin-import": "2.25.2",

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,21 +6,7 @@ import { createObservable } from "./observable.js"
 const readableStreamLifetimeInSeconds = 120
 
 export const nodeStreamToObservable = (nodeStream) => {
-  if (nodeStream instanceof Readable) {
-    // safe measure, ensure the readable stream gets
-    // used in the next ${readableStreamLifetimeInSeconds} otherwise destroys it
-    const timeout = setTimeout(() => {
-      console.warn(
-        `readable stream still unused after ${readableStreamLifetimeInSeconds} seconds -> destroying it to release file handle`,
-      )
-      nodeStream.destroy()
-    }, readableStreamLifetimeInSeconds * 1000)
-    onceReadableStreamUsedOrClosed(nodeStream, () => {
-      clearTimeout(timeout)
-    })
-  }
-
-  return createObservable(({ next, error, complete }) => {
+  const observable = createObservable(({ next, error, complete }) => {
     const cleanup = () => {
       nodeStream.removeListener("data", next)
       nodeStream.removeListener("error", error)
@@ -37,6 +23,28 @@ export const nodeStreamToObservable = (nodeStream) => {
 
     return cleanup
   })
+
+  if (nodeStream instanceof Readable) {
+    // safe measure, ensure the readable stream gets
+    // used in the next ${readableStreamLifetimeInSeconds} otherwise destroys it
+    const timeout = setTimeout(() => {
+      process.emitWarning(
+        `Readable stream not used after ${readableStreamLifetimeInSeconds} seconds. It will be destroyed to release ressources`,
+        {
+          CODE: "READABLE_STREAM_TIMEOUT",
+          // url is for http client request
+          detail: `path: ${nodeStream.path}, fd: ${nodeStream.fd}, url: ${nodeStream.url}`,
+        },
+      )
+      nodeStream.destroy()
+    }, readableStreamLifetimeInSeconds * 1000)
+    observable.timeout = timeout
+    onceReadableStreamUsedOrClosed(nodeStream, () => {
+      clearTimeout(timeout)
+    })
+  }
+
+  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

@@ -5,7 +5,7 @@ import { createDetailedMessage, createLogger } from "@jsenv/logger"
 import {
   Abort,
   raceProcessTeardownEvents,
-  createCallbackListCalledOnce,
+  createCallbackListNotifiedOnce,
 } from "@jsenv/abort"
 
 import { createPolyglotServer } from "./internal/server-polyglot.js"
@@ -164,7 +164,7 @@ export const startServer = async ({
   // we can proceed to create a stop function to stop it gacefully
   // and add a request handler
 
-  const stopCallbackList = createCallbackListCalledOnce()
+  const stopCallbackList = createCallbackListNotifiedOnce()
   stopCallbackList.add(({ reason }) => {
     logger.info(`${serverName} stopping server (reason: ${reason})`)
   })
@@ -178,7 +178,7 @@ export const startServer = async ({
   })
   const stop = memoize(async (reason = STOP_REASON_NOT_SPECIFIED) => {
     status = "stopping"
-    await Promise.all(stopCallbackList.call({ reason }))
+    await Promise.all(stopCallbackList.notify({ reason }))
     status = "stopped"
     stoppedResolve(reason)
   })
@@ -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,