@jsenv/server 12.8.0 → 13.0.0

package/src/{cors/plugin_cors.js → services/cors/jsenv_service_cors.js}

@@ -8,7 +8,7 @@ export const jsenvAccessControlAllowedMethods = [
   "OPTIONS",
 ]
 
-export const pluginCORS = ({
+export const jsenvServiceCORS = ({
   accessControlAllowedOrigins = [],
   accessControlAllowedMethods = jsenvAccessControlAllowedMethods,
   accessControlAllowedHeaders = jsenvAccessControlAllowedHeaders,
@@ -19,7 +19,7 @@ export const pluginCORS = ({
   // 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,
-  timingAllowOrigin,
+  timingAllowOrigin = false,
 } = {}) => {
   // TODO: we should check access control params to throw or warn if we find strange values
 
@@ -27,56 +27,40 @@ export const pluginCORS = ({
     accessControlAllowRequestOrigin || accessControlAllowedOrigins.length
 
   if (!corsEnabled) {
-    return {
-      cors: {},
-    }
+    return []
   }
 
   return {
-    cors: {
-      onServerParams: ({ plugins }) => {
-        if (timingAllowOrigin === undefined && plugins.server_timings) {
-          timingAllowOrigin = true
-        }
-      },
-
-      onRequest: (request, { shortcircuitResponse }) => {
-        if (request.method === "OPTIONS") {
-          // when request method is "OPTIONS" we must return a 200 without body
-          // So we bypass "requestToResponse" in that scenario using shortcircuitResponse
-          shortcircuitResponse({
-            status: 200,
-            headers: {
-              "content-length": 0,
-            },
-          })
-        }
-
-        if (request.parent) {
-          return null
-        }
+    name: "jsenv:cors",
 
+    handleRequest: (request) => {
+      // when request method is "OPTIONS" we must return a 200 without body
+      // So we bypass "requestToResponse" in that scenario using shortcircuitResponse
+      if (request.method === "OPTIONS") {
         return {
-          onResponse: () => {
-            const accessControlHeaders = generateAccessControlHeaders({
-              request,
-              accessControlAllowedOrigins,
-              accessControlAllowRequestOrigin,
-              accessControlAllowedMethods,
-              accessControlAllowRequestMethod,
-              accessControlAllowedHeaders,
-              accessControlAllowRequestHeaders,
-              accessControlAllowCredentials,
-              accessControlMaxAge,
-              timingAllowOrigin,
-            })
-
-            return {
-              headers: accessControlHeaders,
-            }
+          status: 200,
+          headers: {
+            "content-length": 0,
           },
         }
-      },
+      }
+      return null
+    },
+
+    injectResponseHeaders: (response, { request }) => {
+      const accessControlHeaders = generateAccessControlHeaders({
+        request,
+        accessControlAllowedOrigins,
+        accessControlAllowRequestOrigin,
+        accessControlAllowedMethods,
+        accessControlAllowRequestMethod,
+        accessControlAllowedHeaders,
+        accessControlAllowRequestHeaders,
+        accessControlAllowCredentials,
+        accessControlMaxAge,
+        timingAllowOrigin,
+      })
+      return accessControlHeaders
     },
   }
 }

package/src/services/error_handler/jsenv_service_error_handler.js

@@ -0,0 +1,98 @@
+import { pickContentType } from "../../content_negotiation/pick_content_type.js"
+
+export const jsenvServiceErrorHandler = ({ sendErrorDetails = false } = {}) => {
+  return {
+    name: "jsenv:error_handler",
+    handleError: (serverInternalError, { request }) => {
+      const serverInternalErrorIsAPrimitive =
+        serverInternalError === null ||
+        (typeof serverInternalError !== "object" &&
+          typeof serverInternalError !== "function")
+      if (!serverInternalErrorIsAPrimitive && serverInternalError.asResponse) {
+        return serverInternalError.asResponse()
+      }
+      const dataToSend = serverInternalErrorIsAPrimitive
+        ? {
+            code: "VALUE_THROWED",
+            value: serverInternalError,
+          }
+        : {
+            code: serverInternalError.code || "UNKNOWN_ERROR",
+            ...(sendErrorDetails
+              ? {
+                  stack: serverInternalError.stack,
+                  ...serverInternalError,
+                }
+              : {}),
+          }
+
+      const availableContentTypes = {
+        "text/html": () => {
+          const renderHtmlForErrorWithoutDetails = () => {
+            return `<p>Details not available: to enable them use jsenvServiceErrorHandler({ sendErrorDetails: true }).</p>`
+          }
+
+          const renderHtmlForErrorWithDetails = () => {
+            if (serverInternalErrorIsAPrimitive) {
+              return `<pre>${JSON.stringify(
+                serverInternalError,
+                null,
+                "  ",
+              )}</pre>`
+            }
+            return `<pre>${serverInternalError.stack}</pre>`
+          }
+
+          const body = `<!DOCTYPE html>
+<html>
+  <head>
+    <title>Internal server error</title>
+    <meta charset="utf-8" />
+    <link rel="icon" href="data:," />
+  </head>
+
+  <body>
+    <h1>Internal server error</h1>
+    <p>${
+      serverInternalErrorIsAPrimitive
+        ? `Code inside server has thrown a literal.`
+        : `Code inside server has thrown an error.`
+    }</p>
+    <details>
+      <summary>See internal error details</summary>
+      ${
+        sendErrorDetails
+          ? renderHtmlForErrorWithDetails()
+          : renderHtmlForErrorWithoutDetails()
+      }
+    </details>
+  </body>
+</html>`
+
+          return {
+            headers: {
+              "content-type": "text/html",
+              "content-length": Buffer.byteLength(body),
+            },
+            body,
+          }
+        },
+        "application/json": () => {
+          const body = JSON.stringify(dataToSend)
+          return {
+            headers: {
+              "content-type": "application/json",
+              "content-length": Buffer.byteLength(body),
+            },
+            body,
+          }
+        },
+      }
+      const bestContentType = pickContentType(
+        request,
+        Object.keys(availableContentTypes),
+      )
+      return availableContentTypes[bestContentType || "application/json"]()
+    },
+  }
+}

package/src/{content_negotiation/checkContentNegotiation.js → services/response_acceptance_check/jsenv_service_response_acceptance_check.js}

@@ -1,14 +1,23 @@
-import { negotiateContentType } from "./negotiateContentType.js"
-import { negotiateContentLanguage } from "./negotiateContentLanguage.js"
-import { negotiateContentEncoding } from "./negotiateContentEncoding.js"
+import { pickContentType } from "@jsenv/server/src/content_negotiation/pick_content_type.js"
+import { pickContentLanguage } from "@jsenv/server/src/content_negotiation/pick_content_language.js"
+import { pickContentEncoding } from "@jsenv/server/src/content_negotiation/pick_content_encoding.js"
 
-export const checkContentNegotiation = (request, response, { warn }) => {
+export const jsenvServiceResponseAcceptanceCheck = () => {
+  return {
+    name: "jsenv:response_acceptance_check",
+    inspectResponse: (request, { response, warn }) => {
+      checkResponseAcceptance(request, response, { warn })
+    },
+  }
+}
+
+const checkResponseAcceptance = (request, response, { warn }) => {
   const requestAcceptHeader = request.headers.accept
   const responseContentTypeHeader = response.headers["content-type"]
   if (
     requestAcceptHeader &&
     responseContentTypeHeader &&
-    !negotiateContentType(request, [responseContentTypeHeader])
+    !pickContentType(request, [responseContentTypeHeader])
   ) {
     warn(`response content type is not in the request accepted content types.
 --- response content-type header ---
@@ -22,7 +31,7 @@ ${requestAcceptHeader}`)
   if (
     requestAcceptLanguageHeader &&
     responseContentLanguageHeader &&
-    !negotiateContentLanguage(request, [responseContentLanguageHeader])
+    !pickContentLanguage(request, [responseContentLanguageHeader])
   ) {
     warn(`response language is not in the request accepted language.
 --- response content-language header ---
@@ -36,7 +45,7 @@ ${requestAcceptLanguageHeader}`)
   if (
     requestAcceptLanguageHeader &&
     responseContentLanguageHeader &&
-    !negotiateContentEncoding(request, [responseContentLanguageHeader])
+    !pickContentEncoding(request, [responseContentLanguageHeader])
   ) {
     warn(`response encoding is not in the request accepted encoding.
 --- response content-encoding header ---

package/src/services/ressource_aliases/jsenv_service_ressource_aliases.js

@@ -0,0 +1,40 @@
+import { URL_META } from "@jsenv/url-meta"
+
+export const jsenvServiceRessourceAliases = (ressourceAliases) => {
+  const aliases = {}
+  Object.keys(ressourceAliases).forEach((key) => {
+    aliases[asFileUrl(key)] = asFileUrl(ressourceAliases[key])
+  })
+  return {
+    name: "jsenv:ressource_aliases",
+    redirectRequest: (request) => {
+      const ressourceBeforeAlias = request.ressource
+      const urlAfterAliasing = URL_META.applyAliases({
+        url: asFileUrl(request.pathname),
+        aliases,
+      })
+      const ressourceAfterAlias = urlAfterAliasing.slice("file://".length)
+      if (ressourceBeforeAlias === ressourceAfterAlias) {
+        return null
+      }
+      const ressource = replaceRessource(
+        ressourceBeforeAlias,
+        ressourceAfterAlias,
+      )
+      return { ressource }
+    },
+  }
+}
+
+const asFileUrl = (specifier) => new URL(specifier, "file:///").href
+
+const replaceRessource = (ressourceBeforeAlias, newValue) => {
+  const urlObject = new URL(ressourceBeforeAlias, "file://")
+  const searchSeparatorIndex = newValue.indexOf("?")
+  if (searchSeparatorIndex > -1) {
+    return newValue // let new value override search params
+  }
+  urlObject.pathname = newValue
+  const ressource = `${urlObject.pathname}${urlObject.search}`
+  return ressource
+}

package/src/sse/{createSSERoom.js → sse_room.js}

@@ -57,6 +57,7 @@ export const createSSERoom = ({
       const client = {
         next,
         complete,
+        request,
       }
       if (clients.size === 0) {
         const effectReturnValue = effect()
@@ -94,7 +95,9 @@ export const createSSERoom = ({
 
         // send to everyone
         if (welcomeEventPublic) {
-          write(stringifySourceEvent(welcomeEvent))
+          sendEventToAllClients(welcomeEvent, {
+            history: false,
+          })
         }
         // send only to this client
         else {
@@ -148,14 +151,17 @@ export const createSSERoom = ({
     eventHistory.add(event)
   }
 
-  const sendEvent = (event) => {
-    if (event.type !== "comment") {
+  const sendEventToAllClients = (event, { history = true } = {}) => {
+    if (history) {
       addEventToHistory(event)
     }
     logger.debug(
       `send "${event.type}" event to ${clients.size} client in the room`,
     )
-    write(stringifySourceEvent(event))
+    const eventString = stringifySourceEvent(event)
+    clients.forEach((client) => {
+      client.next(eventString)
+    })
   }
 
   const getAllEventSince = (id) => {
@@ -166,21 +172,18 @@ export const createSSERoom = ({
     return events
   }
 
-  const write = (data) => {
-    clients.forEach((client) => {
-      client.next(data)
-    })
-  }
-
   const keepAlive = () => {
     // maybe that, when an event occurs, we can delay the keep alive event
     logger.debug(
       `send keep alive event, number of client listening event source: ${clients.size}`,
     )
-    sendEvent({
-      type: "comment",
-      data: new Date().toLocaleTimeString(),
-    })
+    sendEventToAllClients(
+      {
+        type: "comment",
+        data: new Date().toLocaleTimeString(),
+      },
+      { history: false },
+    )
   }
 
   const open = () => {
@@ -209,7 +212,7 @@ export const createSSERoom = ({
     // - ability to sendEvent to clients in the room
     // - ability to join the room
     // - ability to leave the room
-    sendEvent,
+    sendEventToAllClients,
     join,
     leave,
 
@@ -256,7 +259,6 @@ const disconnectRequestFromRoom = (request, room) => {
   if (!requestInfo) {
     return
   }
-
   const { sseProducer, roomObservableMap } = requestInfo
   const roomObservable = roomObservableMap.get(room)
   roomObservableMap.delete(room)

package/src/content_negotiation/plugin_content_negotiation_check.js

@@ -1,15 +0,0 @@
-import { checkContentNegotiation } from "./checkContentNegotiation.js"
-
-export const pluginContentNegotiationCheck = () => {
-  return {
-    content_negotiation_check: {
-      onRequest: (request, { warn }) => {
-        return {
-          onResponse: (response) => {
-            checkContentNegotiation(request, response, { warn })
-          },
-        }
-      },
-    },
-  }
-}

package/src/error_to_response_default.js

@@ -1,94 +0,0 @@
-import { negotiateContentType } from "./content_negotiation/negotiateContentType.js"
-
-export const applyDefaultErrorToResponse = (
-  serverInternalError,
-  { request, sendErrorDetails = false },
-) => {
-  const serverInternalErrorIsAPrimitive =
-    serverInternalError === null ||
-    (typeof serverInternalError !== "object" &&
-      typeof serverInternalError !== "function")
-
-  if (!serverInternalErrorIsAPrimitive && serverInternalError.asResponse) {
-    return serverInternalError.asResponse()
-  }
-
-  const dataToSend = serverInternalErrorIsAPrimitive
-    ? {
-        code: "VALUE_THROWED",
-        value: serverInternalError,
-      }
-    : {
-        code: serverInternalError.code || "UNKNOWN_ERROR",
-        ...(sendErrorDetails
-          ? {
-              stack: serverInternalError.stack,
-              ...serverInternalError,
-            }
-          : {}),
-      }
-
-  const availableContentTypes = {
-    "text/html": () => {
-      const renderHtmlForErrorWithoutDetails = () => {
-        return `<p>Details not available: to enable them server must be started with sendErrorDetails: true.</p>`
-      }
-
-      const renderHtmlForErrorWithDetails = () => {
-        if (serverInternalErrorIsAPrimitive) {
-          return `<pre>${JSON.stringify(serverInternalError, null, "  ")}</pre>`
-        }
-        return `<pre>${serverInternalError.stack}</pre>`
-      }
-
-      const body = `<!DOCTYPE html>
-<html>
-  <head>
-    <title>Internal server error</title>
-    <meta charset="utf-8" />
-    <link rel="icon" href="data:," />
-  </head>
-
-  <body>
-    <h1>Internal server error</h1>
-    <p>${
-      serverInternalErrorIsAPrimitive
-        ? `Code inside server has thrown a literal.`
-        : `Code inside server has thrown an error.`
-    }</p>
-    <details>
-      <summary>See internal error details</summary>
-      ${
-        sendErrorDetails
-          ? renderHtmlForErrorWithDetails()
-          : renderHtmlForErrorWithoutDetails()
-      }
-    </details>
-  </body>
-</html>`
-
-      return {
-        headers: {
-          "content-type": "text/html",
-          "content-length": Buffer.byteLength(body),
-        },
-        body,
-      }
-    },
-    "application/json": () => {
-      const body = JSON.stringify(dataToSend)
-      return {
-        headers: {
-          "content-type": "application/json",
-          "content-length": Buffer.byteLength(body),
-        },
-        body,
-      }
-    },
-  }
-  const bestContentType = negotiateContentType(
-    request,
-    Object.keys(availableContentTypes),
-  )
-  return availableContentTypes[bestContentType || "application/json"]()
-}

package/src/plugin_request_waiting_check.js

@@ -1,32 +0,0 @@
-import { createDetailedMessage } from "@jsenv/log"
-
-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: {
-      onRequest: (request, { logger }) => {
-        const timeout = setTimeout(
-          () => requestWaitingCallback({ request, logger, requestWaitingMs }),
-          requestWaitingMs,
-        )
-        return {
-          onResponse: () => {
-            clearTimeout(timeout)
-          },
-        }
-      },
-    },
-  }
-}

package/src/ressource_aliases/plugin_ressource_aliases.js

@@ -1,44 +0,0 @@
-import { URL_META } from "@jsenv/url-meta"
-
-export const pluginRessourceAliases = (ressourceAliases) => {
-  const aliases = {}
-  Object.keys(ressourceAliases).forEach((key) => {
-    aliases[asFileUrl(key)] = asFileUrl(ressourceAliases[key])
-  })
-  return {
-    ressource_aliases: {
-      onRequest: (request, { redirectRequest }) => {
-        const ressourceBeforeAlias = request.ressource
-        const urlAfterAliasing = URL_META.applyAliases({
-          url: asFileUrl(request.pathname),
-          aliases,
-        })
-        const ressourceAfterAlias = urlAfterAliasing.slice("file://".length)
-        if (ressourceBeforeAlias === ressourceAfterAlias) {
-          return
-        }
-        const ressource = replaceRessource(
-          ressourceBeforeAlias,
-          ressourceAfterAlias,
-        )
-        redirectRequest({
-          ressourceBeforeAlias,
-          ressource,
-        })
-      },
-    },
-  }
-}
-
-const asFileUrl = (specifier) => new URL(specifier, "file:///").href
-
-const replaceRessource = (ressourceBeforeAlias, newValue) => {
-  const urlObject = new URL(ressourceBeforeAlias, "file://")
-  const searchSeparatorIndex = newValue.indexOf("?")
-  if (searchSeparatorIndex > -1) {
-    return newValue // let new value override search params
-  }
-  urlObject.pathname = newValue
-  const ressource = `${urlObject.pathname}${urlObject.search}`
-  return ressource
-}

package/src/server_timing/plugin_server_timing.js

@@ -1,28 +0,0 @@
-// 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),
-            }
-          },
-        }
-      },
-    },
-  }
-}

package/src/service_composition/service_composition.js

@@ -1,55 +0,0 @@
-import { timeFunction } from "../server_timing/timing_measure.js"
-import { composeTwoResponses } from "../internal/response_composition.js"
-import { applyRedirectionToRequest } from "../internal/request_factory.js"
-
-export const composeServices = (namedServices) => {
-  return async (request, { pushResponse }) => {
-    const redirectRequest = (requestRedirection) => {
-      request = applyRedirectionToRequest(request, requestRedirection)
-    }
-
-    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, { pushResponse, redirectRequest }),
-        )
-        Object.assign(servicesTiming, serviceTiming)
-        return value
-      },
-      predicate: (returnValue) => {
-        if (returnValue === null || typeof returnValue !== "object") {
-          return false
-        }
-        return true
-      },
-    })
-    if (response) {
-      return composeTwoResponses({ timing: servicesTiming }, response)
-    }
-    return null
-  }
-}
-
-const firstOperationMatching = ({ array, start, predicate }) => {
-  return new Promise((resolve, reject) => {
-    const visit = (index) => {
-      if (index >= array.length) {
-        return resolve()
-      }
-      const input = array[index]
-      const returnValue = start(input)
-      return Promise.resolve(returnValue).then((output) => {
-        if (predicate(output)) {
-          return resolve(output)
-        }
-        return visit(index + 1)
-      }, reject)
-    }
-
-    visit(0)
-  })
-}