@jsenv/server 14.1.4 → 14.1.5

package/package.json

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

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

@@ -2,7 +2,7 @@ import { Stream, Writable, Readable } from "node:stream"
 import { createReadStream } from "node:fs"
 
 import { isObservable, observableFromValue } from "./observable.js"
-import { nodeStreamToObservable } from "./nodeStreamToObservable.js"
+import { observableFromNodeStream } from "./observable_from_node_stream.js"
 
 export const normalizeBodyMethods = (body) => {
   if (isObservable(body)) {
@@ -23,7 +23,7 @@ export const normalizeBodyMethods = (body) => {
 
   if (isNodeStream(body)) {
     return {
-      asObservable: () => nodeStreamToObservable(body),
+      asObservable: () => observableFromNodeStream(body),
       destroy: () => {
         body.destroy()
       },
@@ -61,7 +61,7 @@ export const fileHandleToReadableStream = (fileHandle) => {
 }
 
 const fileHandleToObservable = (fileHandle) => {
-  return nodeStreamToObservable(fileHandleToReadableStream(fileHandle))
+  return observableFromNodeStream(fileHandleToReadableStream(fileHandle))
 }
 
 const isNodeStream = (value) => {

package/src/{internal/nodeStreamToObservable.js → interfacing_with_node/observable_from_node_stream.js}

@@ -2,9 +2,12 @@
 import { Readable } from "node:stream"
 import { createObservable } from "./observable.js"
 
-const readableStreamLifetimeInSeconds = 120
-
-export const nodeStreamToObservable = (nodeStream) => {
+export const observableFromNodeStream = (
+  nodeStream,
+  {
+    readableStreamLifetime = 120_000, // 2s
+  } = {},
+) => {
   const observable = createObservable(({ next, error, complete }) => {
     if (nodeStream.isPaused()) {
       nodeStream.resume()
@@ -38,7 +41,9 @@ export const nodeStreamToObservable = (nodeStream) => {
     // 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 resources`,
+        `Readable stream not used after ${
+          readableStreamLifetime / 1000
+        } seconds. It will be destroyed to release resources`,
         {
           CODE: "READABLE_STREAM_TIMEOUT",
           // url is for http client request
@@ -46,7 +51,7 @@ export const nodeStreamToObservable = (nodeStream) => {
         },
       )
       nodeStream.destroy()
-    }, readableStreamLifetimeInSeconds * 1000)
+    }, readableStreamLifetime)
     observable.timeout = timeout
     onceReadableStreamUsedOrClosed(nodeStream, () => {
       clearTimeout(timeout)

package/src/{internal → interfacing_with_node}/request_factory.js

@@ -1,9 +1,14 @@
-import { nodeStreamToObservable } from "./nodeStreamToObservable.js"
-import { headersFromObject } from "./headersFromObject.js"
+import { observableFromNodeStream } from "./observable_from_node_stream.js"
+import { headersFromObject } from "../internal/headersFromObject.js"
 
-export const fromNodeRequest = (nodeRequest, { serverOrigin, signal }) => {
+export const fromNodeRequest = (
+  nodeRequest,
+  { serverOrigin, signal, requestBodyLifetime },
+) => {
   const headers = headersFromObject(nodeRequest.headers)
-  const body = nodeStreamToObservable(nodeRequest)
+  const body = observableFromNodeStream(nodeRequest, {
+    readableStreamLifetime: requestBodyLifetime,
+  })
 
   let requestOrigin
   if (nodeRequest.upgrade) {

package/src/{internal/populateNodeResponse.js → interfacing_with_node/write_node_response.js}

@@ -4,7 +4,7 @@ import { raceCallbacks } from "@jsenv/abort"
 
 import { normalizeBodyMethods } from "./body.js"
 
-export const populateNodeResponse = async (
+export const writeNodeResponse = async (
   responseStream,
   { status, statusText, headers, body, bodyEncoding },
   { signal, ignoreBody, onAbort, onError, onHeadersSent, onEnd } = {},

package/src/sse/sse_room.js

@@ -3,7 +3,7 @@ import { createLogger } from "@jsenv/log"
 import {
   createObservable,
   createCompositeProducer,
-} from "@jsenv/server/src/internal/observable.js"
+} from "@jsenv/server/src/interfacing_with_node/observable.js"
 
 // https://www.html5rocks.com/en/tutorials/eventsource/basics/
 export const createSSERoom = ({

package/src/start_server.js

@@ -18,8 +18,8 @@ import {
   fromNodeRequest,
   createPushRequest,
   applyRedirectionToRequest,
-} from "./internal/request_factory.js"
-import { populateNodeResponse } from "./internal/populateNodeResponse.js"
+} from "./interfacing_with_node/request_factory.js"
+import { writeNodeResponse } from "./interfacing_with_node/write_node_response.js"
 import {
   statusToType,
   colorizeResponseStatus,
@@ -87,6 +87,13 @@ export const startServer = async ({
       ),
     )
   },
+  // timeAllocated to start responding to a request
+  // after this delay the server will respond with 504
+  responseTimeout = 60_000 * 10, // 10s
+  // time allocated to server code to start reading the request body
+  // after this delay the underlying stream is destroyed, attempting to read it would throw
+  // if used the stream stays opened, it's only if the stream is not read at all that it gets destroyed
+  requestBodyLifetime = 60_000 * 2, // 2s
 } = {}) => {
   const logger = createLogger({ logLevel })
 
@@ -535,7 +542,8 @@ export const startServer = async ({
                 abortController.abort()
               } else if (!http2Stream.pushAllowed) {
                 abortController.abort()
-              } else if (responseProperties !== ABORTED_RESPONSE_PROPERTIES) {
+              } else if (responseProperties.requestAborted) {
+              } else {
                 const responseLength =
                   responseProperties.headers["content-length"] || 0
                 const { effectiveRecvDataLength, remoteWindowSize } =
@@ -609,75 +617,95 @@ export const startServer = async ({
         let handleRequestReturnValue
         let errorWhileHandlingRequest = null
         let handleRequestTimings = serverTiming ? {} : null
-        try {
-          handleRequestReturnValue =
-            await serviceController.callAsyncHooksUntil(
-              "handleRequest",
-              request,
-              {
-                timing: handleRequestTimings,
-                warn,
-                pushResponse: async ({ path, method }) => {
-                  if (typeof path !== "string" || path[0] !== "/") {
-                    addRequestLog(requestNode, {
-                      type: "warn",
-                      value: `response push ignored because path is invalid (must be a string starting with "/", found ${path})`,
-                    })
-                    return
-                  }
-                  if (!request.http2) {
-                    addRequestLog(requestNode, {
-                      type: "warn",
-                      value: `response push ignored because request is not http2`,
-                    })
-                    return
-                  }
-                  const canPushStream = testCanPushStream(nodeResponse.stream)
-                  if (!canPushStream.can) {
-                    addRequestLog(requestNode, {
-                      type: "debug",
-                      value: `response push ignored because ${canPushStream.reason}`,
-                    })
-                    return
-                  }
-
-                  let preventedByService = null
-                  const prevent = () => {
-                    preventedByService = serviceController.getCurrentService()
-                  }
-                  serviceController.callHooksUntil(
-                    "onResponsePush",
-                    { path, method },
-                    {
-                      request,
-                      warn,
-                      prevent,
-                    },
-                    () => preventedByService,
-                  )
-                  if (preventedByService) {
-                    addRequestLog(requestNode, {
-                      type: "debug",
-                      value: `response push prevented by "${preventedByService.name}" service`,
-                    })
-                    return
-                  }
-
-                  const requestChildNode = { logs: [], children: [] }
-                  requestNode.children.push(requestChildNode)
-                  await pushResponse(
-                    { path, method },
-                    {
-                      requestNode: requestChildNode,
-                      parentHttp2Stream: nodeResponse.stream,
-                    },
-                  )
+
+        let timeout
+        const timeoutPromise = new Promise((resolve) => {
+          timeout = setTimeout(() => {
+            resolve({
+              // the correct status code should be 500 because it's
+              // we don't really know what takes time
+              // in practice it's often because server is trying to reach an other server
+              // that is not responding so 504 is more correct
+              status: 504,
+              statusText: `server timeout after ${
+                responseTimeout / 1000
+              }s waiting to handle request`,
+            })
+          }, responseTimeout)
+        })
+        const handleRequestPromise = serviceController.callAsyncHooksUntil(
+          "handleRequest",
+          request,
+          {
+            timing: handleRequestTimings,
+            warn,
+            pushResponse: async ({ path, method }) => {
+              if (typeof path !== "string" || path[0] !== "/") {
+                addRequestLog(requestNode, {
+                  type: "warn",
+                  value: `response push ignored because path is invalid (must be a string starting with "/", found ${path})`,
+                })
+                return
+              }
+              if (!request.http2) {
+                addRequestLog(requestNode, {
+                  type: "warn",
+                  value: `response push ignored because request is not http2`,
+                })
+                return
+              }
+              const canPushStream = testCanPushStream(nodeResponse.stream)
+              if (!canPushStream.can) {
+                addRequestLog(requestNode, {
+                  type: "debug",
+                  value: `response push ignored because ${canPushStream.reason}`,
+                })
+                return
+              }
+
+              let preventedByService = null
+              const prevent = () => {
+                preventedByService = serviceController.getCurrentService()
+              }
+              serviceController.callHooksUntil(
+                "onResponsePush",
+                { path, method },
+                {
+                  request,
+                  warn,
+                  prevent,
                 },
-              },
-            )
-        } catch (error) {
-          errorWhileHandlingRequest = error
+                () => preventedByService,
+              )
+              if (preventedByService) {
+                addRequestLog(requestNode, {
+                  type: "debug",
+                  value: `response push prevented by "${preventedByService.name}" service`,
+                })
+                return
+              }
+
+              const requestChildNode = { logs: [], children: [] }
+              requestNode.children.push(requestChildNode)
+              await pushResponse(
+                { path, method },
+                {
+                  requestNode: requestChildNode,
+                  parentHttp2Stream: nodeResponse.stream,
+                },
+              )
+            },
+          },
+        )
+        try {
+          handleRequestReturnValue = await Promise.race([
+            timeoutPromise,
+            handleRequestPromise,
+          ])
+        } catch (e) {
+          errorWhileHandlingRequest = e
         }
+        clearTimeout(timeout)
 
         let responseProperties
         if (errorWhileHandlingRequest) {
@@ -685,7 +713,7 @@ export const startServer = async ({
             errorWhileHandlingRequest.name === "AbortError" &&
             request.signal.aborted
           ) {
-            responseProperties = ABORTED_RESPONSE_PROPERTIES
+            responseProperties = { requestAborted: true }
           } else {
             // internal error, create 500 response
             if (
@@ -818,7 +846,7 @@ export const startServer = async ({
           await new Promise((resolve) => setTimeout(resolve))
         }
 
-        await populateNodeResponse(responseStream, responseProperties, {
+        await writeNodeResponse(responseStream, responseProperties, {
           signal,
           ignoreBody,
           onAbort: () => {
@@ -927,6 +955,7 @@ export const startServer = async ({
             const request = fromNodeRequest(nodeRequest, {
               serverOrigin: websocketOrigin,
               signal: new AbortController().signal,
+              requestBodyLifetime,
             })
             serviceController.callAsyncHooksUntil(
               "handleWebsocket",
@@ -1039,8 +1068,6 @@ const testCanPushStream = (http2Stream) => {
   }
 }
 
-const ABORTED_RESPONSE_PROPERTIES = {}
-
 const PROCESS_TEARDOWN_EVENTS_MAP = {
   SIGHUP: STOP_REASON_PROCESS_SIGHUP,
   SIGTERM: STOP_REASON_PROCESS_SIGTERM,