@jsenv/server 7.1.0 → 8.0.0

package/src/startServer.js

@@ -1,5 +1,3 @@
-/* eslint-disable import/max-dependencies */
-
 import http from "node:http"
 import {
   createCancellationToken,
@@ -9,21 +7,27 @@ import {
   isCancelError,
   executeAsyncFunction,
 } from "@jsenv/cancellation"
-import { SIGINTSignal, unadvisedCrashSignal, teardownSignal } from "@jsenv/node-signals"
-import { memoize, urlToOrigin } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/logger"
+import {
+  SIGINTSignal,
+  unadvisedCrashSignal,
+  teardownSignal,
+} from "@jsenv/node-signals"
+import { memoize } from "@jsenv/filesystem"
+import { createDetailedMessage, createLogger } from "@jsenv/logger"
 
 import { createTracker } from "./internal/createTracker.js"
 import { createPolyglotServer } from "./internal/server-polyglot.js"
 import { trackServerPendingConnections } from "./internal/trackServerPendingConnections.js"
 import { trackServerPendingRequests } from "./internal/trackServerPendingRequests.js"
 import { nodeRequestToRequest } from "./internal/nodeRequestToRequest.js"
-import { composeResponseHeaders } from "./internal/composeResponseHeaders.js"
 import { populateNodeResponse } from "./internal/populateNodeResponse.js"
 import { colorizeResponseStatus } from "./internal/colorizeResponseStatus.js"
 import { getServerOrigins } from "./internal/getServerOrigins.js"
 import { listen, stopListening } from "./internal/listen.js"
-import { composeResponse } from "./composeResponse.js"
+import { composeResponse } from "./internal/composeResponse.js"
+import { listenRequest } from "./internal/listenRequest.js"
+import { listenServerConnectionError } from "./internal/listenServerConnectionError.js"
+import { jsenvServerInternalErrorToResponse } from "./jsenvServerInternalErrorToResponse.js"
 import {
   STOP_REASON_INTERNAL_ERROR,
   STOP_REASON_PROCESS_SIGHUP,
@@ -33,13 +37,6 @@ import {
   STOP_REASON_PROCESS_EXIT,
   STOP_REASON_NOT_SPECIFIED,
 } from "./stopReasons.js"
-import { jsenvAccessControlAllowedHeaders } from "./jsenvAccessControlAllowedHeaders.js"
-import { jsenvAccessControlAllowedMethods } from "./jsenvAccessControlAllowedMethods.js"
-import { listenRequest } from "./internal/listenRequest.js"
-import { timeFunction, timingToServerTimingResponseHeaders } from "./serverTiming.js"
-import { jsenvServerInternalErrorToResponse } from "./jsenvServerInternalErrorToResponse.js"
-import { checkContentNegotiation } from "./internal/checkContentNegotiation.js"
-import { listenServerConnectionError } from "./internal/listenServerConnectionError.js"
 
 export const startServer = async ({
   cancellationToken = createCancellationToken(),
@@ -66,36 +63,11 @@ export const startServer = async ({
   stopOnCrash = false,
   keepProcessAlive = true,
   requestToResponse = () => null,
+  plugins = {},
 
-  accessControlAllowedOrigins = [],
-  accessControlAllowedMethods = jsenvAccessControlAllowedMethods,
-  accessControlAllowedHeaders = jsenvAccessControlAllowedHeaders,
-  accessControlAllowRequestOrigin = false,
-  accessControlAllowRequestMethod = false,
-  accessControlAllowRequestHeaders = false,
-  accessControlAllowCredentials = false,
-  // by default OPTIONS request can be cache for a long time, it's not going to change soon ?
-  // we could put a lot here, see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age
-  accessControlMaxAge = 600,
-
-  // https://www.w3.org/TR/server-timing/
-  sendServerTiming = false,
   sendServerInternalErrorDetails = false,
   serverInternalErrorToResponse = jsenvServerInternalErrorToResponse,
 
-  requestWaitingMs = 20000,
-  requestWaitingCallback = (request, { logger }) => {
-    logger.warn(
-      `still no response found for request after ${requestWaitingMs} ms
---- request url ---
-${request.origin}${request.ressource}
---- request headers ---
-${JSON.stringify(request.headers, null, "  ")}
-`,
-    )
-  },
-  contentNegotiationWarnings = true,
-
   startedCallback = () => {},
   stoppedCallback = () => {},
   errorIsCancellation = () => false,
@@ -118,7 +90,11 @@ ${JSON.stringify(request.headers, null, "  ")}
     }
 
     const logger = createLogger({ logLevel })
-    if (redirectHttpToHttps === undefined && protocol === "https" && !allowHttpRequestOnHttps) {
+    if (
+      redirectHttpToHttps === undefined &&
+      protocol === "https" &&
+      !allowHttpRequestOnHttps
+    ) {
       redirectHttpToHttps = true
     }
     if (redirectHttpToHttps && protocol === "http") {
@@ -126,7 +102,9 @@ ${JSON.stringify(request.headers, null, "  ")}
       redirectHttpToHttps = false
     }
     if (allowHttpRequestOnHttps && redirectHttpToHttps) {
-      logger.warn(`redirectHttpToHttps ignored because allowHttpRequestOnHttps is enabled`)
+      logger.warn(
+        `redirectHttpToHttps ignored because allowHttpRequestOnHttps is enabled`,
+      )
       redirectHttpToHttps = false
     }
 
@@ -208,7 +186,10 @@ ${JSON.stringify(request.headers, null, "  ")}
     const stop = memoize(async (reason = STOP_REASON_NOT_SPECIFIED) => {
       status = "stopping"
 
-      errorIsCancellation = composePredicate(errorIsCancellation, (error) => error === reason)
+      errorIsCancellation = composePredicate(
+        errorIsCancellation,
+        (error) => error === reason,
+      )
       errorIsCancellation = composePredicate(
         errorIsCancellation,
         (error) => error && error.code === "ECONNRESET",
@@ -241,7 +222,10 @@ ${JSON.stringify(request.headers, null, "  ")}
     const serverOrigins = getServerOrigins({ protocol, ip, port })
     const serverOrigin = serverOrigins.main
 
-    const removeConnectionErrorListener = listenServerConnectionError(nodeServer, onError)
+    const removeConnectionErrorListener = listenServerConnectionError(
+      nodeServer,
+      onError,
+    )
     registerCleanupCallback(removeConnectionErrorListener)
 
     const connectionsTracker = trackServerPendingConnections(nodeServer, {
@@ -250,7 +234,9 @@ ${JSON.stringify(request.headers, null, "  ")}
     // opened connection must be shutdown before the close event is emitted
     registerCleanupCallback(connectionsTracker.stop)
 
-    const pendingRequestsTracker = trackServerPendingRequests(nodeServer, { http2 })
+    const pendingRequestsTracker = trackServerPendingRequests(nodeServer, {
+      http2,
+    })
     // ensure pending requests got a response from the server
     registerCleanupCallback((reason) => {
       pendingRequestsTracker.stop({
@@ -271,74 +257,173 @@ ${JSON.stringify(request.headers, null, "  ")}
         return
       }
 
-      const request = nodeRequestToRequest(nodeRequest, { serverCancellationToken, serverOrigin })
-      nodeRequest.on("error", (error) => {
-        logger[error.message === "aborted" ? "debug" : "error"](`error on request.
---- request ressource ---
-${request.ressource}
---- error stack ---
-${error.stack}`)
+      const request = nodeRequestToRequest(nodeRequest, {
+        serverCancellationToken,
+        serverOrigin,
       })
 
-      const [startRespondingTiming, { response, error }] = await timeFunction(
-        "time to start responding",
-        () => generateResponseDescription(request),
-      )
-      if (sendServerTiming) {
-        const serverTiming = {
-          ...response.timing,
-          ...startRespondingTiming,
-        }
-        response.headers = composeResponseHeaders(
-          timingToServerTimingResponseHeaders(serverTiming),
-          response.headers,
-        )
-
-        if (contentNegotiationWarnings) {
-          checkContentNegotiation(request, response, { warn: logger.warn })
-        }
+      // Handling request is asynchronous, we buffer logs for that request
+      // until we know what happens with that request
+      // It delays logs until we know of the request will be handled
+      // but it's mandatory to make logs readable.
+      let requestLogs = []
+      const releaseRequestLogs = () => {
+        requestLogs.forEach(({ type, value }) => {
+          logger[type](value)
+        })
+        requestLogs.length = 0
       }
+      const warn = (value) => {
+        requestLogs.push({
+          type: "warn",
+          value,
+        })
+      }
+      requestLogs.push({
+        type: "info",
+        value: `${request.method} ${request.origin}${request.ressource}`,
+      })
 
-      logger.info(`${request.method} ${request.origin}${request.ressource}`)
+      nodeRequest.on("error", (error) => {
+        if (error.message === "aborted") {
+          requestLogs.push({
+            type: "debug",
+            value: createDetailedMessage(`request aborted by client`, {
+              "error message": error.message,
+            }),
+          })
+        } else {
+          requestLogs.push({
+            type: "error",
+            value: createDetailedMessage(`"error" event emitted on request`, {
+              "error stack": error.stack,
+            }),
+          })
+        }
+      })
 
-      if (error && isCancelError(error) && internalCancellationToken.cancellationRequested) {
-        logger.info("ignored because server closing")
-        nodeResponse.destroy()
-        return
+      const requestPlugins = []
+      let responseFromShortcircuit
+      const shortcircuitResponse = (value) => {
+        responseFromShortcircuit = value
       }
+      Object.keys(plugins).forEach((pluginName) => {
+        const { onRequest } = plugins[pluginName]
+        if (onRequest) {
+          const returnValue = onRequest(request, { warn, shortcircuitResponse })
+          if (returnValue) {
+            requestPlugins.push(returnValue)
+          }
+        }
+      })
+      let { error, responseProperties } = responseFromShortcircuit
+        ? { responseProperties: responseFromShortcircuit }
+        : await generateResponseDescription({
+            requestToResponse,
+            request,
+          })
 
-      if (error && isCancelError(error) && request.cancellationToken.cancellationRequested) {
-        logger.info("ignored because request canceled")
-        nodeResponse.destroy()
-        return
+      if (error && isCancelError(error)) {
+        if (internalCancellationToken.cancellationRequested) {
+          requestLogs.push({
+            type: "info",
+            value: `aborted because server closing`,
+          })
+          releaseRequestLogs()
+          nodeResponse.destroy()
+          return
+        }
+        if (request.cancellationToken.cancellationRequested) {
+          requestLogs.push({
+            type: "info",
+            value: `aborted because request aborted by client`,
+          })
+          releaseRequestLogs()
+          nodeResponse.destroy()
+          return
+        }
+        // unknown cancel error, never supposed to happen
       }
 
-      if (request.aborted) {
-        logger.info(`request aborted by client`)
-        nodeResponse.destroy()
-        return
+      // internal error, create 500 response
+      if (error) {
+        const propertiesFromError = await serverInternalErrorToResponse(error, {
+          request,
+          sendServerInternalErrorDetails,
+        })
+        responseProperties = composeResponse(
+          {
+            status: 500,
+            statusText: statusToStatusText(500),
+            headers: {
+              // ensure error are not cached
+              "cache-control": "no-store",
+              "content-type": "text/plain",
+            },
+            body: "",
+          },
+          propertiesFromError,
+        )
+        requestLogs.push({
+          type: "error",
+          value: createDetailedMessage(
+            `internal error while handling request`,
+            {
+              "error stack": error.stack,
+            },
+          ),
+        })
+      } else {
+        const {
+          status = 501,
+          statusText = statusToStatusText(status),
+          headers = {},
+          body = "",
+          ...rest
+        } = responseProperties || {}
+        responseProperties = {
+          status,
+          statusText,
+          headers,
+          body,
+          ...rest,
+        }
       }
 
+      // call every plugin "onResponse" hook
+      requestPlugins.forEach((requestPlugin) => {
+        const { onResponse } = requestPlugin
+        if (onResponse) {
+          const returnValue = onResponse(responseProperties)
+          if (returnValue) {
+            responseProperties = composeResponse(
+              responseProperties,
+              returnValue,
+            )
+          }
+        }
+      })
+
       if (
         request.method !== "HEAD" &&
-        response.headers["content-length"] > 0 &&
-        response.body === ""
+        responseProperties.headers["content-length"] > 0 &&
+        responseProperties.body === ""
       ) {
-        logger.warn(
-          `content-length header is ${response.headers["content-length"]} but body is empty`,
-        )
+        requestLogs.push({
+          type: "warn",
+          value: `content-length header is ${responseProperties.headers["content-length"]} but body is empty`,
+        })
       }
 
-      if (error) {
-        logger.error(`internal error while handling request.
---- error stack ---
-${error.stack}
---- request ---
-${request.method} ${request.origin}${request.ressource}`)
-      }
-      logger.info(`${colorizeResponseStatus(response.status)} ${response.statusText}`)
+      requestLogs.push({
+        type: "info",
+        value: `${colorizeResponseStatus(responseProperties.status)} ${
+          responseProperties.statusText
+        }`,
+      })
+      releaseRequestLogs()
 
-      populateNodeResponse(nodeResponse, response, {
+      populateNodeResponse(nodeResponse, responseProperties, {
         cancellationToken: request.cancellationToken,
         ignoreBody: request.method === "HEAD",
         // https://github.com/nodejs/node/blob/79296dc2d02c0b9872bbfcbb89148ea036a546d0/lib/internal/http2/compat.js#L97
@@ -348,12 +433,12 @@ ${request.method} ${request.origin}${request.ressource}`)
       })
 
       if (
-        stopOnInternalError &&
+        error &&
         // stopOnInternalError stops server only if requestToResponse generated
         // a non controlled error (internal error).
         // if requestToResponse gracefully produced a 500 response (it did not throw)
         // then we can assume we are still in control of what we are doing
-        error
+        stopOnInternalError
       ) {
         // il faudrais pouvoir stop que les autres response ?
         stop(STOP_REASON_INTERNAL_ERROR)
@@ -364,100 +449,11 @@ ${request.method} ${request.origin}${request.ressource}`)
     // ensure we don't try to handle new requests while server is stopping
     registerCleanupCallback(removeRequestListener)
 
-    logger.info(`${serverName} started at ${serverOrigin} (${serverOrigins.external})`)
+    logger.info(
+      `${serverName} started at ${serverOrigin} (${serverOrigins.external})`,
+    )
     startedCallback({ origin: serverOrigin })
 
-    const corsEnabled = accessControlAllowRequestOrigin || accessControlAllowedOrigins.length
-    // here we check access control options to throw or warn if we find strange values
-
-    const generateResponseDescription = async (request) => {
-      const responsePropertiesToResponse = ({
-        status = 501,
-        statusText = statusToStatusText(status),
-        headers = {},
-        body = "",
-        bodyEncoding,
-        timing,
-      }) => {
-        if (corsEnabled) {
-          const accessControlHeaders = generateAccessControlHeaders({
-            request,
-            accessControlAllowedOrigins,
-            accessControlAllowRequestOrigin,
-            accessControlAllowedMethods,
-            accessControlAllowRequestMethod,
-            accessControlAllowedHeaders,
-            accessControlAllowRequestHeaders,
-            accessControlAllowCredentials,
-            accessControlMaxAge,
-            sendServerTiming,
-          })
-
-          return {
-            status,
-            statusText,
-            headers: composeResponseHeaders(headers, accessControlHeaders),
-            body,
-            bodyEncoding,
-            timing,
-          }
-        }
-
-        return {
-          status,
-          statusText,
-          headers,
-          body,
-          bodyEncoding,
-          timing,
-        }
-      }
-
-      let timeout
-      try {
-        if (corsEnabled && request.method === "OPTIONS") {
-          return {
-            response: responsePropertiesToResponse({
-              status: 200,
-              headers: {
-                "content-length": 0,
-              },
-            }),
-          }
-        }
-
-        timeout = setTimeout(
-          () => requestWaitingCallback(request, { logger, requestWaitingMs }),
-          requestWaitingMs,
-        )
-
-        const responseProperties = await requestToResponse(request)
-        clearTimeout(timeout)
-        return {
-          response: responsePropertiesToResponse(responseProperties || {}),
-        }
-      } catch (error) {
-        clearTimeout(timeout)
-        return {
-          response: composeResponse(
-            responsePropertiesToResponse({
-              status: 500,
-              headers: {
-                // ensure error are not cached
-                "cache-control": "no-store",
-                "content-type": "text/plain",
-              },
-            }),
-            await serverInternalErrorToResponse(error, {
-              request,
-              sendServerInternalErrorDetails,
-            }),
-          ),
-          error,
-        }
-      }
-    }
-
     return {
       getStatus: () => status,
       origin: serverOrigin,
@@ -497,73 +493,22 @@ const createNodeServer = async ({
   })
 }
 
-const statusToStatusText = (status) => http.STATUS_CODES[status] || "not specified"
-
-// https://www.w3.org/TR/cors/
-// https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
-const generateAccessControlHeaders = ({
-  request: { headers },
-  accessControlAllowedOrigins,
-  accessControlAllowRequestOrigin,
-  accessControlAllowedMethods,
-  accessControlAllowRequestMethod,
-  accessControlAllowedHeaders,
-  accessControlAllowRequestHeaders,
-  accessControlAllowCredentials,
-  // by default OPTIONS request can be cache for a long time, it's not going to change soon ?
-  // we could put a lot here, see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age
-  accessControlMaxAge = 600,
-  sendServerTiming,
-} = {}) => {
-  const vary = []
-
-  const allowedOriginArray = [...accessControlAllowedOrigins]
-  if (accessControlAllowRequestOrigin) {
-    if ("origin" in headers && headers.origin !== "null") {
-      allowedOriginArray.push(headers.origin)
-      vary.push("origin")
-    } else if ("referer" in headers) {
-      allowedOriginArray.push(urlToOrigin(headers.referer))
-      vary.push("referer")
-    } else {
-      allowedOriginArray.push("*")
+const generateResponseDescription = async ({ requestToResponse, request }) => {
+  try {
+    const returnValue = await requestToResponse(request)
+    return {
+      responseProperties: returnValue,
     }
-  }
-
-  const allowedMethodArray = [...accessControlAllowedMethods]
-  if (accessControlAllowRequestMethod && "access-control-request-method" in headers) {
-    const requestMethodName = headers["access-control-request-method"]
-    if (!allowedMethodArray.includes(requestMethodName)) {
-      allowedMethodArray.push(requestMethodName)
-      vary.push("access-control-request-method")
+  } catch (error) {
+    return {
+      error,
     }
   }
-
-  const allowedHeaderArray = [...accessControlAllowedHeaders]
-  if (accessControlAllowRequestHeaders && "access-control-request-headers" in headers) {
-    const requestHeaderNameArray = headers["access-control-request-headers"].split(", ")
-    requestHeaderNameArray.forEach((headerName) => {
-      const headerNameLowerCase = headerName.toLowerCase()
-      if (!allowedHeaderArray.includes(headerNameLowerCase)) {
-        allowedHeaderArray.push(headerNameLowerCase)
-        if (!vary.includes("access-control-request-headers")) {
-          vary.push("access-control-request-headers")
-        }
-      }
-    })
-  }
-
-  return {
-    "access-control-allow-origin": allowedOriginArray.join(", "),
-    "access-control-allow-methods": allowedMethodArray.join(", "),
-    "access-control-allow-headers": allowedHeaderArray.join(", "),
-    ...(accessControlAllowCredentials ? { "access-control-allow-credentials": true } : {}),
-    "access-control-max-age": accessControlMaxAge,
-    ...(sendServerTiming ? { "timing-allow-origin": allowedOriginArray.join(", ") } : {}),
-    ...(vary.length ? { vary: vary.join(", ") } : {}),
-  }
 }
 
+const statusToStatusText = (status) =>
+  http.STATUS_CODES[status] || "not specified"
+
 const composePredicate = (previousPredicate, predicate) => {
   return (value) => {
     return previousPredicate(value) || predicate(value)

package/src/stopReasons.js

@@ -8,6 +8,8 @@ export const STOP_REASON_INTERNAL_ERROR = createReason("Internal error")
 export const STOP_REASON_PROCESS_SIGHUP = createReason("process SIGHUP")
 export const STOP_REASON_PROCESS_SIGTERM = createReason("process SIGTERM")
 export const STOP_REASON_PROCESS_SIGINT = createReason("process SIGINT")
-export const STOP_REASON_PROCESS_BEFORE_EXIT = createReason("process before exit")
+export const STOP_REASON_PROCESS_BEFORE_EXIT = createReason(
+  "process before exit",
+)
 export const STOP_REASON_PROCESS_EXIT = createReason("process exit")
 export const STOP_REASON_NOT_SPECIFIED = createReason("not specified")

package/src/urlToContentType.js

@@ -1,6 +1,7 @@
 // https://github.com/jshttp/mime-db/blob/master/src/apache-types.json
 
-import { extname } from "path"
+import { extname } from "node:path"
+
 import { jsenvContentTypeMap } from "./jsenvContentTypeMap.js"
 
 export const urlToContentType = (
@@ -9,7 +10,9 @@ export const urlToContentType = (
   contentTypeDefault = "application/octet-stream",
 ) => {
   if (typeof contentTypeMap !== "object") {
-    throw new TypeError(`contentTypeMap must be an object, got ${contentTypeMap}`)
+    throw new TypeError(
+      `contentTypeMap must be an object, got ${contentTypeMap}`,
+    )
   }
   const pathname = new URL(url).pathname
 
@@ -21,9 +24,13 @@ export const urlToContentType = (
 
   const extension = extensionWithDot.slice(1)
   const availableContentTypes = Object.keys(contentTypeMap)
-  const contentTypeForExtension = availableContentTypes.find((contentTypeName) => {
-    const contentType = contentTypeMap[contentTypeName]
-    return contentType.extensions && contentType.extensions.indexOf(extension) > -1
-  })
+  const contentTypeForExtension = availableContentTypes.find(
+    (contentTypeName) => {
+      const contentType = contentTypeMap[contentTypeName]
+      return (
+        contentType.extensions && contentType.extensions.indexOf(extension) > -1
+      )
+    },
+  )
   return contentTypeForExtension || contentTypeDefault
 }

package/src/jsenvAccessControlAllowedHeaders.js

@@ -1 +0,0 @@
-export const jsenvAccessControlAllowedHeaders = ["x-requested-with"]

package/src/jsenvAccessControlAllowedMethods.js

@@ -1 +0,0 @@
-export const jsenvAccessControlAllowedMethods = ["GET", "POST", "PUT", "DELETE", "OPTIONS"]

package/src/service-composition.js

@@ -1,41 +0,0 @@
-import { firstOperationMatching } from "@jsenv/cancellation"
-import { timeFunction } from "./serverTiming.js"
-import { composeResponse } from "./composeResponse.js"
-
-export const composeServices = (...callbacks) => {
-  return (request) => {
-    return firstOperationMatching({
-      array: callbacks,
-      start: (callback) => callback(request),
-      predicate: serviceGeneratedResponsePredicate,
-    })
-  }
-}
-
-export const composeServicesWithTiming = (namedServices) => {
-  return async (request) => {
-    const servicesTiming = {}
-    const response = await firstOperationMatching({
-      array: Object.keys(namedServices).map((serviceName) => {
-        return { serviceName, serviceFn: namedServices[serviceName] }
-      }),
-      start: async ({ serviceName, serviceFn }) => {
-        const [serviceTiming, value] = await timeFunction(serviceName, () => serviceFn(request))
-        Object.assign(servicesTiming, serviceTiming)
-        return value
-      },
-      predicate: serviceGeneratedResponsePredicate,
-    })
-    if (response) {
-      return composeResponse({ timing: servicesTiming }, response)
-    }
-    return null
-  }
-}
-
-const serviceGeneratedResponsePredicate = (value) => {
-  if (value === null) {
-    return false
-  }
-  return typeof value === "object"
-}

package/src/urlToSearchParamValue.js

@@ -1,3 +0,0 @@
-export const urlToSearchParamValue = (url, searchParamName) => {
-  return new URL(url).searchParams.get(searchParamName)
-}