@jsenv/server 7.1.0 → 8.0.0

package/src/internal/getServerOrigins.js

@@ -20,7 +20,11 @@ const createServerOrigin = ({ protocol, ip, port }) => {
 
 const ipToHostname = (
   ip,
-  { preferLocalhost = true, preferLocalIp = false, preferExternalIp = false } = {},
+  {
+    preferLocalhost = true,
+    preferLocalIp = false,
+    preferExternalIp = false,
+  } = {},
 ) => {
   if (ip === "0.0.0.0" || !ip) {
     if (preferLocalhost) return "localhost"

package/src/internal/headersFromObject.js

@@ -14,7 +14,9 @@ export const headersFromObject = (headersObject) => {
       // exclude http2 headers
       return
     }
-    headers[normalizeHeaderName(headerName)] = normalizeHeaderValue(headersObject[headerName])
+    headers[normalizeHeaderName(headerName)] = normalizeHeaderValue(
+      headersObject[headerName],
+    )
   })
 
   return headers

package/src/internal/listenClientError.js

@@ -2,7 +2,11 @@ import { listenEvent } from "./listenEvent.js"
 
 export const listenClientError = (nodeServer, clientErrorCallback) => {
   if (nodeServer._httpServer) {
-    const removeNetClientError = listenEvent(nodeServer, "clientError", clientErrorCallback)
+    const removeNetClientError = listenEvent(
+      nodeServer,
+      "clientError",
+      clientErrorCallback,
+    )
     const removeHttpClientError = listenEvent(
       nodeServer._httpServer,
       "clientError",

package/src/internal/listenEvent.js

@@ -1,4 +1,9 @@
-export const listenEvent = (objectWithEventEmitter, eventName, callback, { once = false } = {}) => {
+export const listenEvent = (
+  objectWithEventEmitter,
+  eventName,
+  callback,
+  { once = false } = {},
+) => {
   if (once) {
     objectWithEventEmitter.once(eventName, callback)
   } else {

package/src/internal/listenRequest.js

@@ -7,7 +7,11 @@ export const listenRequest = (nodeServer, requestCallback) => {
       "request",
       requestCallback,
     )
-    const removeTlsRequestListener = listenEvent(nodeServer._tlsServer, "request", requestCallback)
+    const removeTlsRequestListener = listenEvent(
+      nodeServer._tlsServer,
+      "request",
+      requestCallback,
+    )
     return () => {
       removeHttpRequestListener()
       removeTlsRequestListener()

package/src/internal/listenServerConnectionError.js

@@ -7,30 +7,38 @@ export const listenServerConnectionError = (
 ) => {
   const cleanupSet = new Set()
 
-  const removeConnectionListener = listenEvent(nodeServer, "connection", (socket) => {
-    const removeSocketErrorListener = listenEvent(socket, "error", (error) => {
-      if (ignoreErrorAfterConnectionIsDestroyed && socket.destroyed) {
-        return
-      }
-      connectionErrorCallback(error, socket)
-    })
-    const removeOnceSocketCloseListener = listenEvent(
-      socket,
-      "close",
-      () => {
+  const removeConnectionListener = listenEvent(
+    nodeServer,
+    "connection",
+    (socket) => {
+      const removeSocketErrorListener = listenEvent(
+        socket,
+        "error",
+        (error) => {
+          if (ignoreErrorAfterConnectionIsDestroyed && socket.destroyed) {
+            return
+          }
+          connectionErrorCallback(error, socket)
+        },
+      )
+      const removeOnceSocketCloseListener = listenEvent(
+        socket,
+        "close",
+        () => {
+          removeSocketErrorListener()
+          cleanupSet.delete(cleanup)
+        },
+        {
+          once: true,
+        },
+      )
+      const cleanup = () => {
         removeSocketErrorListener()
-        cleanupSet.delete(cleanup)
-      },
-      {
-        once: true,
-      },
-    )
-    const cleanup = () => {
-      removeSocketErrorListener()
-      removeOnceSocketCloseListener()
-    }
-    cleanupSet.add(cleanup)
-  })
+        removeOnceSocketCloseListener()
+      }
+      cleanupSet.add(cleanup)
+    },
+  )
   return () => {
     removeConnectionListener()
     cleanupSet.forEach((cleanup) => {

package/src/internal/multiple-header.js

@@ -26,7 +26,9 @@ export const parseMultipleHeader = (
       return
     }
 
-    const properties = parseHeaderProperties(valueParts.slice(1), { validateProperty })
+    const properties = parseHeaderProperties(valueParts.slice(1), {
+      validateProperty,
+    })
     multipleHeader[name] = properties
   })
   return multipleHeader
@@ -51,7 +53,8 @@ const parseHeaderProperties = (headerProperties, { validateProperty }) => {
 
 const parseHeaderPropertyValue = (headerPropertyValueString) => {
   const firstChar = headerPropertyValueString[0]
-  const lastChar = headerPropertyValueString[headerPropertyValueString.length - 1]
+  const lastChar =
+    headerPropertyValueString[headerPropertyValueString.length - 1]
   if (firstChar === '"' && lastChar === '"') {
     return headerPropertyValueString.slice(1, -1)
   }
@@ -82,9 +85,12 @@ export const stringifyMultipleHeader = (
     })
     .map((name) => {
       const headerProperties = multipleHeader[name]
-      const headerPropertiesString = stringifyHeaderProperties(headerProperties, {
-        validateProperty,
-      })
+      const headerPropertiesString = stringifyHeaderProperties(
+        headerProperties,
+        {
+          validateProperty,
+        },
+      )
       if (headerPropertiesString.length) {
         return `${name};${headerPropertiesString}`
       }

package/src/internal/nodeRequestToRequest.js

@@ -1,15 +1,18 @@
-import { composeCancellationToken, createCancellationSource } from "@jsenv/cancellation"
+import {
+  composeCancellationToken,
+  createCancellationSource,
+} from "@jsenv/cancellation"
 import { nodeStreamToObservable } from "./nodeStreamToObservable.js"
 import { headersFromObject } from "./headersFromObject.js"
 
-export const nodeRequestToRequest = (nodeRequest, { serverCancellationToken, serverOrigin }) => {
+export const nodeRequestToRequest = (
+  nodeRequest,
+  { serverCancellationToken, serverOrigin },
+) => {
   const { method } = nodeRequest
   const { url: ressource } = nodeRequest
   const headers = headersFromObject(nodeRequest.headers)
-  const body =
-    method === "POST" || method === "PUT" || method === "PATCH"
-      ? nodeStreamToObservable(nodeRequest)
-      : undefined
+  const body = nodeStreamToObservable(nodeRequest)
 
   let requestOrigin
   if (nodeRequest.authority) {
@@ -44,7 +47,7 @@ export const nodeRequestToRequest = (nodeRequest, { serverCancellationToken, ser
 const nodeRequestToCancellationToken = (nodeRequest) => {
   const { cancel, token } = createCancellationSource()
   nodeRequest.on("abort", () => {
-    cancel("request aborted")
+    cancel("request aborted by client")
   })
   nodeRequest.on("close", () => {
     cancel("request closed")

package/src/internal/observable.js

@@ -105,7 +105,11 @@ export const createCompositeProducer = ({ cleanup = () => {} } = {}) => {
     return true
   }
 
-  const producer = ({ next = () => {}, complete = () => {}, error = () => {} }) => {
+  const producer = ({
+    next = () => {},
+    complete = () => {},
+    error = () => {},
+  }) => {
     let completeCount = 0
 
     const checkComplete = () => {

package/src/internal/populateNodeResponse.js

@@ -5,7 +5,12 @@ import { nodeStreamToObservable } from "./nodeStreamToObservable.js"
 export const populateNodeResponse = (
   nodeResponse,
   { status, statusText, headers, body, bodyEncoding },
-  { cancellationToken, ignoreBody, ignoreStatusText, ignoreConnectionHeader } = {},
+  {
+    cancellationToken,
+    ignoreBody,
+    ignoreStatusText,
+    ignoreConnectionHeader,
+  } = {},
 ) => {
   const nodeHeaders = headersToNodeHeaders(headers, { ignoreConnectionHeader })
   // nodejs strange signature for writeHead force this
@@ -101,7 +106,11 @@ const isNodeStream = (value) => {
     return false
   }
 
-  if (value instanceof Stream || value instanceof Writable || value instanceof Readable) {
+  if (
+    value instanceof Stream ||
+    value instanceof Writable ||
+    value instanceof Readable
+  ) {
     return true
   }
 

package/src/internal/server-polyglot.js

@@ -37,11 +37,20 @@ export const createPolyglotServer = async ({
         return
       }
 
-      const response = [`HTTP/1.1 400 Bad Request`, `Content-Length: 0`, "", ""].join("\r\n")
+      const response = [
+        `HTTP/1.1 400 Bad Request`,
+        `Content-Length: 0`,
+        "",
+        "",
+      ].join("\r\n")
       socket.write(response)
       socket.end()
       socket.destroy()
-      netServer.emit("clientError", new Error("protocol error, Neither http, nor tls"), socket)
+      netServer.emit(
+        "clientError",
+        new Error("protocol error, Neither http, nor tls"),
+        socket,
+      )
     })
   })
 

package/src/internal/trackServerPendingConnections.js

@@ -13,17 +13,21 @@ export const trackServerPendingConnections = (nodeServer, { http2 }) => {
 const trackHttp1ServerPendingConnections = (nodeServer) => {
   const pendingConnections = new Set()
 
-  const removeConnectionListener = listenEvent(nodeServer, "connection", (connection) => {
-    pendingConnections.add(connection)
-    listenEvent(
-      connection,
-      "close",
-      () => {
-        pendingConnections.delete(connection)
-      },
-      { once: true },
-    )
-  })
+  const removeConnectionListener = listenEvent(
+    nodeServer,
+    "connection",
+    (connection) => {
+      pendingConnections.add(connection)
+      listenEvent(
+        connection,
+        "close",
+        () => {
+          pendingConnections.delete(connection)
+        },
+        { once: true },
+      )
+    },
+  )
 
   const stop = async (reason) => {
     removeConnectionListener()

package/src/internal/trackServerPendingRequests.js

@@ -13,13 +13,16 @@ export const trackServerPendingRequests = (nodeServer, { http2 }) => {
 const trackHttp1ServerPendingRequests = (nodeServer) => {
   const pendingClients = new Set()
 
-  const removeRequestListener = listenRequest(nodeServer, (nodeRequest, nodeResponse) => {
-    const client = { nodeRequest, nodeResponse }
-    pendingClients.add(client)
-    nodeResponse.once("close", () => {
-      pendingClients.delete(client)
-    })
-  })
+  const removeRequestListener = listenRequest(
+    nodeServer,
+    (nodeRequest, nodeResponse) => {
+      const client = { nodeRequest, nodeResponse }
+      pendingClients.add(client)
+      nodeResponse.once("close", () => {
+        pendingClients.delete(client)
+      })
+    },
+  )
 
   const stop = async ({ status, reason }) => {
     removeRequestListener()

package/src/jsenvServerInternalErrorToResponse.js

@@ -1,4 +1,4 @@
-import { negotiateContentType } from "./negotiateContentType.js"
+import { negotiateContentType } from "./content_negotiation/negotiateContentType.js"
 
 export const jsenvServerInternalErrorToResponse = (
   serverInternalError,
@@ -6,7 +6,8 @@ export const jsenvServerInternalErrorToResponse = (
 ) => {
   const serverInternalErrorIsAPrimitive =
     serverInternalError === null ||
-    (typeof serverInternalError !== "object" && typeof serverInternalError !== "function")
+    (typeof serverInternalError !== "object" &&
+      typeof serverInternalError !== "function")
 
   const dataToSend = serverInternalErrorIsAPrimitive
     ? {
@@ -81,6 +82,9 @@ export const jsenvServerInternalErrorToResponse = (
       }
     },
   }
-  const bestContentType = negotiateContentType(request, Object.keys(availableContentTypes))
+  const bestContentType = negotiateContentType(
+    request,
+    Object.keys(availableContentTypes),
+  )
   return availableContentTypes[bestContentType || "application/json"]()
 }

package/src/plugin_request_waiting_check.js

@@ -0,0 +1,34 @@
+import { createDetailedMessage } from "@jsenv/logger"
+
+export const pluginRequestWaitingCheck = ({
+  requestWaitingMs = 20000,
+  requestWaitingCallback = ({ request, logger, requestWaitingMs }) => {
+    logger.warn(
+      createDetailedMessage(
+        `still no response found for request after ${requestWaitingMs} ms`,
+        {
+          "request url": `${request.origin}${request.ressource}`,
+          "request headers": JSON.stringify(request.headers, null, "  "),
+        },
+      ),
+    )
+  },
+} = {}) => {
+  return {
+    plugin_request_waiting_check: {
+      init: () => {},
+
+      onRequest: (request, { logger }) => {
+        const timeout = setTimeout(
+          () => requestWaitingCallback({ request, logger, requestWaitingMs }),
+          requestWaitingMs,
+        )
+        return {
+          onResponse: () => {
+            clearTimeout(timeout)
+          },
+        }
+      },
+    },
+  }
+}

package/src/serveFile.js

@@ -1,5 +1,4 @@
-/* eslint-disable import/max-dependencies */
-import { createReadStream, promises, statSync } from "node:fs"
+import { createReadStream, statSync } from "node:fs"
 import {
   assertAndNormalizeDirectoryUrl,
   resolveUrl,
@@ -8,21 +7,19 @@ import {
   readDirectory,
   urlToFileSystemPath,
   urlToRelativeUrl,
+  readFile,
 } from "@jsenv/filesystem"
 import { createOperation } from "@jsenv/cancellation"
 
-import { negotiateContentType } from "./negotiateContentType.js"
-import { timeFunction } from "./serverTiming.js"
-import { convertFileSystemErrorToResponseProperties } from "./convertFileSystemErrorToResponseProperties.js"
-import { urlToContentType } from "./urlToContentType.js"
+import { composeResponse } from "./internal/composeResponse.js"
+import { convertFileSystemErrorToResponseProperties } from "./internal/convertFileSystemErrorToResponseProperties.js"
 import { jsenvContentTypeMap } from "./jsenvContentTypeMap.js"
-import { composeResponse } from "./composeResponse.js"
-import { negotiateContentEncoding } from "./negotiateContentEncoding.js"
-
-const { readFile } = promises
+import { timeFunction } from "./server_timing/timing_measure.js"
+import { negotiateContentType } from "./content_negotiation/negotiateContentType.js"
+import { negotiateContentEncoding } from "./content_negotiation/negotiateContentEncoding.js"
+import { urlToContentType } from "./urlToContentType.js"
 
-const ETAG_CACHE = new Map()
-const ETAG_CACHE_MAX_SIZE = 500
+const ETAG_MEMORY_MAP = new Map()
 
 export const serveFile = async (
   request,
@@ -30,11 +27,14 @@ export const serveFile = async (
     rootDirectoryUrl,
     contentTypeMap = jsenvContentTypeMap,
     etagEnabled = false,
-    etagCacheDisabled = false,
+    etagMemory = true,
+    etagMemoryMaxSize = 1000,
     mtimeEnabled = false,
     compressionEnabled = false,
     compressionSizeThreshold = 1024,
-    cacheControl = etagEnabled || mtimeEnabled ? "private,max-age=0,must-revalidate" : "no-store",
+    cacheControl = etagEnabled || mtimeEnabled
+      ? "private,max-age=0,must-revalidate"
+      : "no-store",
     canReadDirectory = false,
     readableStreamLifetimeInSeconds = 120,
   } = {},
@@ -66,7 +66,9 @@ export const serveFile = async (
     }
   }
   if (etagEnabled && mtimeEnabled) {
-    console.warn(`cannot enable both etag and mtime, mtime disabled in favor of etag.`)
+    console.warn(
+      `cannot enable both etag and mtime, mtime disabled in favor of etag.`,
+    )
     mtimeEnabled = false
   }
 
@@ -81,8 +83,9 @@ export const serveFile = async (
   const sourceFileSystemPath = urlToFileSystemPath(sourceUrl)
 
   try {
-    const [readStatTiming, sourceStat] = await timeFunction("file service>read file stat", () =>
-      statSync(sourceFileSystemPath),
+    const [readStatTiming, sourceStat] = await timeFunction(
+      "file service>read file stat",
+      () => statSync(sourceFileSystemPath),
     )
 
     if (sourceStat.isDirectory()) {
@@ -135,7 +138,10 @@ export const serveFile = async (
     <ul>
       ${directoryContentArray.map((filename) => {
         const fileUrl = resolveUrl(filename, sourceUrl)
-        const fileUrlRelativeToServer = urlToRelativeUrl(fileUrl, rootDirectoryUrl)
+        const fileUrlRelativeToServer = urlToRelativeUrl(
+          fileUrl,
+          rootDirectoryUrl,
+        )
         return `<li>
         <a href="/${fileUrlRelativeToServer}">${fileUrlRelativeToServer}</a>
       </li>`
@@ -155,7 +161,10 @@ export const serveFile = async (
           }
         },
       }
-      const bestContentType = negotiateContentType(request, Object.keys(responseProducers))
+      const bestContentType = negotiateContentType(
+        request,
+        Object.keys(responseProducers),
+      )
       return responseProducers[bestContentType || "application/json"]()
     }
 
@@ -169,7 +178,8 @@ export const serveFile = async (
 
     const clientCacheResponse = await getClientCacheResponse(request, {
       etagEnabled,
-      etagCacheDisabled,
+      etagMemory,
+      etagMemoryMaxSize,
       mtimeEnabled,
       sourceStat,
       sourceUrl,
@@ -213,7 +223,10 @@ export const serveFile = async (
       // moreover it will prevent to unlink the file on windows.
       if (clientCacheResponse.body) {
         response.body.destroy()
-      } else if (readableStreamLifetimeInSeconds && readableStreamLifetimeInSeconds !== Infinity) {
+      } else if (
+        readableStreamLifetimeInSeconds &&
+        readableStreamLifetimeInSeconds !== Infinity
+      ) {
         // safe measure, ensure the readable stream gets used in the next ${readableStreamLifetimeInSeconds} otherwise destroys it
         const timeout = setTimeout(() => {
           console.warn(
@@ -250,7 +263,14 @@ export const serveFile = async (
 
 const getClientCacheResponse = async (
   request,
-  { etagEnabled, etagCacheDisabled, mtimeEnabled, sourceStat, sourceUrl },
+  {
+    etagEnabled,
+    etagMemory,
+    etagMemoryMaxSize,
+    mtimeEnabled,
+    sourceStat,
+    sourceUrl,
+  },
 ) => {
   // here you might be tempted to add || headers["cache-control"] === "no-cache"
   // but no-cache means ressource can be cache but must be revalidated (yeah naming is strange)
@@ -259,7 +279,7 @@ const getClientCacheResponse = async (
   const { headers = {} } = request
   if (
     headers["cache-control"] === "no-store" ||
-    // let's disable it on no-cache too (https://github.com/jsenv/server/issues/17)
+    // let's disable it on no-cache too
     headers["cache-control"] === "no-cache"
   ) {
     return { status: 200 }
@@ -267,7 +287,8 @@ const getClientCacheResponse = async (
 
   if (etagEnabled) {
     return getEtagResponse(request, {
-      etagCacheDisabled,
+      etagMemory,
+      etagMemoryMaxSize,
       sourceStat,
       sourceUrl,
     })
@@ -282,15 +303,27 @@ const getClientCacheResponse = async (
   return { status: 200 }
 }
 
-const getEtagResponse = async (request, { etagCacheDisabled, sourceUrl, sourceStat }) => {
+const getEtagResponse = async (
+  request,
+  { etagMemory, etagMemoryMaxSize, sourceUrl, sourceStat },
+) => {
   const [computeEtagTiming, fileContentEtag] = await timeFunction(
     "file service>generate file etag",
-    () => computeEtag(request, { etagCacheDisabled, sourceUrl, sourceStat }),
+    () =>
+      computeEtag(request, {
+        etagMemory,
+        etagMemoryMaxSize,
+        sourceUrl,
+        sourceStat,
+      }),
   )
 
   const { headers = {} } = request
   const requestHasIfNoneMatchHeader = "if-none-match" in headers
-  if (requestHasIfNoneMatchHeader && headers["if-none-match"] === fileContentEtag) {
+  if (
+    requestHasIfNoneMatchHeader &&
+    headers["if-none-match"] === fileContentEtag
+  ) {
     return {
       status: 304,
       timing: computeEtagTiming,
@@ -306,24 +339,30 @@ const getEtagResponse = async (request, { etagCacheDisabled, sourceUrl, sourceSt
   }
 }
 
-const computeEtag = async (request, { etagCacheDisabled, sourceUrl, sourceStat }) => {
-  if (!etagCacheDisabled) {
-    const etagCacheEntry = ETAG_CACHE.get(sourceUrl)
-    if (etagCacheEntry && fileStatAreTheSame(etagCacheEntry.sourceStat, sourceStat)) {
-      return etagCacheEntry.eTag
+const computeEtag = async (
+  request,
+  { etagMemory, etagMemoryMaxSize, sourceUrl, sourceStat },
+) => {
+  if (etagMemory) {
+    const etagMemoryEntry = ETAG_MEMORY_MAP.get(sourceUrl)
+    if (
+      etagMemoryEntry &&
+      fileStatAreTheSame(etagMemoryEntry.sourceStat, sourceStat)
+    ) {
+      return etagMemoryEntry.eTag
     }
   }
   const fileContentAsBuffer = await createOperation({
     cancellationToken: request.cancellationToken,
-    start: () => readFile(urlToFileSystemPath(sourceUrl)),
+    start: () => readFile(sourceUrl, { as: "buffer" }),
   })
   const eTag = bufferToEtag(fileContentAsBuffer)
-  if (!etagCacheDisabled) {
-    if (ETAG_CACHE.size >= ETAG_CACHE_MAX_SIZE) {
-      const firstKey = Array.from(ETAG_CACHE.keys())[0]
-      ETAG_CACHE.delete(firstKey)
+  if (etagMemory) {
+    if (ETAG_MEMORY_MAP.size >= etagMemoryMaxSize) {
+      const firstKey = Array.from(ETAG_MEMORY_MAP.keys())[0]
+      ETAG_MEMORY_MAP.delete(firstKey)
     }
-    ETAG_CACHE.set(sourceUrl, { sourceStat, eTag })
+    ETAG_MEMORY_MAP.set(sourceUrl, { sourceStat, eTag })
   }
   return eTag
 }
@@ -377,7 +416,10 @@ const getMtimeResponse = async (request, { sourceStat }) => {
   }
 }
 
-const getCompressedResponse = async (request, { sourceUrl, contentTypeMap }) => {
+const getCompressedResponse = async (
+  request,
+  { sourceUrl, contentTypeMap },
+) => {
   const acceptedCompressionFormat = negotiateContentEncoding(
     request,
     Object.keys(availableCompressionFormats),
@@ -387,7 +429,9 @@ const getCompressedResponse = async (request, { sourceUrl, contentTypeMap }) =>
   }
 
   const fileReadableStream = fileUrlToReadableStream(sourceUrl)
-  const body = await availableCompressionFormats[acceptedCompressionFormat](fileReadableStream)
+  const body = await availableCompressionFormats[acceptedCompressionFormat](
+    fileReadableStream,
+  )
 
   return {
     status: 200,
@@ -419,7 +463,10 @@ const availableCompressionFormats = {
   },
 }
 
-const getRawResponse = async (request, { sourceStat, sourceUrl, contentTypeMap }) => {
+const getRawResponse = async (
+  request,
+  { sourceStat, sourceUrl, contentTypeMap },
+) => {
   return {
     status: 200,
     headers: {

package/src/server_timing/plugin_server_timing.js

@@ -0,0 +1,28 @@
+// https://www.w3.org/TR/server-timing/
+
+import { performance } from "node:perf_hooks"
+
+import { timingToServerTimingResponseHeaders } from "./timing_header.js"
+
+export const pluginServerTiming = () => {
+  return {
+    server_timing: {
+      onRequest: () => {
+        const requestStartEvent = performance.now()
+        return {
+          onResponse: (response) => {
+            const responseEndEvent = performance.now()
+            const timeToCreateResponse = responseEndEvent - requestStartEvent
+            const serverTiming = {
+              ...response.timing,
+              "time to start responding": timeToCreateResponse,
+            }
+            return {
+              headers: timingToServerTimingResponseHeaders(serverTiming),
+            }
+          },
+        }
+      },
+    },
+  }
+}