@jsenv/server 12.7.5 → 13.1.0

package/src/service_controller.js

@@ -0,0 +1,174 @@
+import { timeStart } from "./server_timing/timing_measure.js"
+
+const HOOK_NAMES = [
+  "serverListening",
+  "redirectRequest",
+  "handleRequest",
+  "handleWebsocket",
+  "handleError",
+  "onResponsePush",
+  "injectResponseHeaders",
+  "responseReady",
+  "serverStopped",
+]
+
+export const createServiceController = (services) => {
+  const flatServices = flattenAndFilterServices(services)
+  const hookGroups = {}
+
+  const addService = (service) => {
+    Object.keys(service).forEach((key) => {
+      if (key === "name") return
+      const isHook = HOOK_NAMES.includes(key)
+      if (!isHook) {
+        console.warn(
+          `Unexpected "${key}" property on "${service.name}" service`,
+        )
+      }
+      const hookName = key
+      const hookValue = service[hookName]
+      if (hookValue) {
+        const group = hookGroups[hookName] || (hookGroups[hookName] = [])
+        group.push({
+          service,
+          name: hookName,
+          value: hookValue,
+        })
+      }
+    })
+  }
+  flatServices.forEach((service) => {
+    addService(service)
+  })
+
+  let currentService = null
+  let currentHookName = null
+  const callHook = (hook, info, context) => {
+    const hookFn = hook.value
+    if (!hookFn) {
+      return null
+    }
+    currentService = hook.service
+    currentHookName = hook.name
+    let timeEnd
+    if (context && context.timing) {
+      timeEnd = timeStart(
+        `${currentService.name.replace("jsenv:", "")}.${currentHookName}`,
+      )
+    }
+    let valueReturned = hookFn(info, context)
+    if (context && context.timing) {
+      Object.assign(context.timing, timeEnd())
+    }
+    currentService = null
+    currentHookName = null
+    return valueReturned
+  }
+  const callAsyncHook = async (hook, info, context) => {
+    const hookFn = hook.value
+    if (!hookFn) {
+      return null
+    }
+    currentService = hook.service
+    currentHookName = hook.name
+    let timeEnd
+    if (context && context.timing) {
+      timeEnd = timeStart(
+        `${currentService.name.replace("jsenv:", "")}.${currentHookName}`,
+      )
+    }
+    let valueReturned = await hookFn(info, context)
+    if (context && context.timing) {
+      Object.assign(context.timing, timeEnd())
+    }
+    currentService = null
+    currentHookName = null
+    return valueReturned
+  }
+
+  const callHooks = (hookName, info, context, callback = () => {}) => {
+    const hooks = hookGroups[hookName]
+    if (hooks) {
+      for (const hook of hooks) {
+        const returnValue = callHook(hook, info, context)
+        if (returnValue) {
+          callback(returnValue)
+        }
+      }
+    }
+  }
+  const callHooksUntil = (
+    hookName,
+    info,
+    context,
+    until = (returnValue) => returnValue,
+  ) => {
+    const hooks = hookGroups[hookName]
+    if (hooks) {
+      for (const hook of hooks) {
+        const returnValue = callHook(hook, info, context)
+        const untilReturnValue = until(returnValue)
+        if (untilReturnValue) {
+          return untilReturnValue
+        }
+      }
+    }
+    return null
+  }
+  const callAsyncHooksUntil = (hookName, info, context) => {
+    const hooks = hookGroups[hookName]
+    if (!hooks) {
+      return null
+    }
+    if (hooks.length === 0) {
+      return null
+    }
+    return new Promise((resolve, reject) => {
+      const visit = (index) => {
+        if (index >= hooks.length) {
+          return resolve()
+        }
+        const hook = hooks[index]
+        const returnValue = callAsyncHook(hook, info, context)
+        return Promise.resolve(returnValue).then((output) => {
+          if (output) {
+            return resolve(output)
+          }
+          return visit(index + 1)
+        }, reject)
+      }
+      visit(0)
+    })
+  }
+
+  return {
+    services: flatServices,
+
+    callHooks,
+    callHooksUntil,
+    callAsyncHooksUntil,
+
+    getCurrentService: () => currentService,
+    getCurrentHookName: () => currentHookName,
+  }
+}
+
+const flattenAndFilterServices = (services) => {
+  const flatServices = []
+  const visitServiceEntry = (serviceEntry) => {
+    if (Array.isArray(serviceEntry)) {
+      serviceEntry.forEach((value) => visitServiceEntry(value))
+      return
+    }
+    if (typeof serviceEntry === "object" && serviceEntry !== null) {
+      if (!serviceEntry.name) {
+        serviceEntry.name = "anonymous"
+      }
+      flatServices.push(serviceEntry)
+      return
+    }
+    throw new Error(`services must be objects, got ${serviceEntry}`)
+  }
+  services.forEach((serviceEntry) => visitServiceEntry(serviceEntry))
+  return flatServices
+}

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)