@jsenv/server 15.0.2 → 15.0.4

package/src/service_controller.js

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

package/src/services/cors/jsenv_service_cors.js

@@ -1,4 +1,4 @@
-export const jsenvAccessControlAllowedHeaders = ["x-requested-with"]
+export const jsenvAccessControlAllowedHeaders = ["x-requested-with"];
 
 export const jsenvAccessControlAllowedMethods = [
   "GET",
@@ -6,7 +6,7 @@ export const jsenvAccessControlAllowedMethods = [
   "PUT",
   "DELETE",
   "OPTIONS",
-]
+];
 
 export const jsenvServiceCORS = ({
   accessControlAllowedOrigins = [],
@@ -24,10 +24,10 @@ export const jsenvServiceCORS = ({
   // TODO: we should check access control params to throw or warn if we find strange values
 
   const corsEnabled =
-    accessControlAllowRequestOrigin || accessControlAllowedOrigins.length
+    accessControlAllowRequestOrigin || accessControlAllowedOrigins.length;
 
   if (!corsEnabled) {
-    return []
+    return [];
   }
 
   return {
@@ -42,9 +42,9 @@ export const jsenvServiceCORS = ({
           headers: {
             "content-length": 0,
           },
-        }
+        };
       }
-      return null
+      return null;
     },
 
     injectResponseHeaders: (response, { request }) => {
@@ -59,11 +59,11 @@ export const jsenvServiceCORS = ({
         accessControlAllowCredentials,
         accessControlMaxAge,
         timingAllowOrigin,
-      })
-      return accessControlHeaders
+      });
+      return accessControlHeaders;
     },
-  }
-}
+  };
+};
 
 // https://www.w3.org/TR/cors/
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
@@ -81,49 +81,49 @@ const generateAccessControlHeaders = ({
   accessControlMaxAge = 600,
   timingAllowOrigin,
 } = {}) => {
-  const vary = []
+  const vary = [];
 
-  const allowedOriginArray = [...accessControlAllowedOrigins]
+  const allowedOriginArray = [...accessControlAllowedOrigins];
   if (accessControlAllowRequestOrigin) {
     if ("origin" in headers && headers.origin !== "null") {
-      allowedOriginArray.push(headers.origin)
-      vary.push("origin")
+      allowedOriginArray.push(headers.origin);
+      vary.push("origin");
     } else if ("referer" in headers) {
-      allowedOriginArray.push(new URL(headers.referer).origin)
-      vary.push("referer")
+      allowedOriginArray.push(new URL(headers.referer).origin);
+      vary.push("referer");
     } else {
-      allowedOriginArray.push("*")
+      allowedOriginArray.push("*");
     }
   }
 
-  const allowedMethodArray = [...accessControlAllowedMethods]
+  const allowedMethodArray = [...accessControlAllowedMethods];
   if (
     accessControlAllowRequestMethod &&
     "access-control-request-method" in headers
   ) {
-    const requestMethodName = headers["access-control-request-method"]
+    const requestMethodName = headers["access-control-request-method"];
     if (!allowedMethodArray.includes(requestMethodName)) {
-      allowedMethodArray.push(requestMethodName)
-      vary.push("access-control-request-method")
+      allowedMethodArray.push(requestMethodName);
+      vary.push("access-control-request-method");
     }
   }
 
-  const allowedHeaderArray = [...accessControlAllowedHeaders]
+  const allowedHeaderArray = [...accessControlAllowedHeaders];
   if (
     accessControlAllowRequestHeaders &&
     "access-control-request-headers" in headers
   ) {
     const requestHeaderNameArray =
-      headers["access-control-request-headers"].split(", ")
+      headers["access-control-request-headers"].split(", ");
     requestHeaderNameArray.forEach((headerName) => {
-      const headerNameLowerCase = headerName.toLowerCase()
+      const headerNameLowerCase = headerName.toLowerCase();
       if (!allowedHeaderArray.includes(headerNameLowerCase)) {
-        allowedHeaderArray.push(headerNameLowerCase)
+        allowedHeaderArray.push(headerNameLowerCase);
         if (!vary.includes("access-control-request-headers")) {
-          vary.push("access-control-request-headers")
+          vary.push("access-control-request-headers");
         }
       }
-    })
+    });
   }
 
   return {
@@ -138,5 +138,5 @@ const generateAccessControlHeaders = ({
       ? { "timing-allow-origin": allowedOriginArray.join(", ") }
       : {}),
     ...(vary.length ? { vary: vary.join(", ") } : {}),
-  }
-}
+  };
+};

package/src/services/error_handler/jsenv_service_error_handler.js

@@ -1,4 +1,4 @@
-import { pickContentType } from "../../content_negotiation/pick_content_type.js"
+import { pickContentType } from "../../content_negotiation/pick_content_type.js";
 
 export const jsenvServiceErrorHandler = ({ sendErrorDetails = false } = {}) => {
   return {
@@ -7,9 +7,9 @@ export const jsenvServiceErrorHandler = ({ sendErrorDetails = false } = {}) => {
       const serverInternalErrorIsAPrimitive =
         serverInternalError === null ||
         (typeof serverInternalError !== "object" &&
-          typeof serverInternalError !== "function")
+          typeof serverInternalError !== "function");
       if (!serverInternalErrorIsAPrimitive && serverInternalError.asResponse) {
-        return serverInternalError.asResponse()
+        return serverInternalError.asResponse();
       }
       const dataToSend = serverInternalErrorIsAPrimitive
         ? {
@@ -24,13 +24,13 @@ export const jsenvServiceErrorHandler = ({ sendErrorDetails = false } = {}) => {
                   ...serverInternalError,
                 }
               : {}),
-          }
+          };
 
       const availableContentTypes = {
         "text/html": () => {
           const renderHtmlForErrorWithoutDetails = () => {
-            return `<p>Details not available: to enable them use jsenvServiceErrorHandler({ sendErrorDetails: true }).</p>`
-          }
+            return `<p>Details not available: to enable them use jsenvServiceErrorHandler({ sendErrorDetails: true }).</p>`;
+          };
 
           const renderHtmlForErrorWithDetails = () => {
             if (serverInternalErrorIsAPrimitive) {
@@ -38,10 +38,10 @@ export const jsenvServiceErrorHandler = ({ sendErrorDetails = false } = {}) => {
                 serverInternalError,
                 null,
                 "  ",
-              )}</pre>`
+              )}</pre>`;
             }
-            return `<pre>${serverInternalError.stack}</pre>`
-          }
+            return `<pre>${serverInternalError.stack}</pre>`;
+          };
 
           const body = `<!DOCTYPE html>
 <html>
@@ -67,7 +67,7 @@ export const jsenvServiceErrorHandler = ({ sendErrorDetails = false } = {}) => {
       }
     </details>
   </body>
-</html>`
+</html>`;
 
           return {
             headers: {
@@ -75,24 +75,24 @@ export const jsenvServiceErrorHandler = ({ sendErrorDetails = false } = {}) => {
               "content-length": Buffer.byteLength(body),
             },
             body,
-          }
+          };
         },
         "application/json": () => {
-          const body = JSON.stringify(dataToSend)
+          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"]()
+      );
+      return availableContentTypes[bestContentType || "application/json"]();
     },
-  }
-}
+  };
+};

package/src/services/request_aliases/jsenv_service_request_aliases.js

@@ -1,37 +1,37 @@
-import { URL_META } from "@jsenv/url-meta"
+import { URL_META } from "@jsenv/url-meta";
 
 export const jsenvServiceRequestAliases = (resourceAliases) => {
-  const aliases = {}
+  const aliases = {};
   Object.keys(resourceAliases).forEach((key) => {
-    aliases[asFileUrl(key)] = asFileUrl(resourceAliases[key])
-  })
+    aliases[asFileUrl(key)] = asFileUrl(resourceAliases[key]);
+  });
   return {
     name: "jsenv:request_aliases",
     redirectRequest: (request) => {
-      const resourceBeforeAlias = request.resource
+      const resourceBeforeAlias = request.resource;
       const urlAfterAliasing = URL_META.applyAliases({
         url: asFileUrl(request.pathname),
         aliases,
-      })
-      const resourceAfterAlias = urlAfterAliasing.slice("file://".length)
+      });
+      const resourceAfterAlias = urlAfterAliasing.slice("file://".length);
       if (resourceBeforeAlias === resourceAfterAlias) {
-        return null
+        return null;
       }
-      const resource = replaceResource(resourceBeforeAlias, resourceAfterAlias)
-      return { resource }
+      const resource = replaceResource(resourceBeforeAlias, resourceAfterAlias);
+      return { resource };
     },
-  }
-}
+  };
+};
 
-const asFileUrl = (specifier) => new URL(specifier, "file:///").href
+const asFileUrl = (specifier) => new URL(specifier, "file:///").href;
 
 const replaceResource = (resourceBeforeAlias, newValue) => {
-  const urlObject = new URL(resourceBeforeAlias, "file://")
-  const searchSeparatorIndex = newValue.indexOf("?")
+  const urlObject = new URL(resourceBeforeAlias, "file://");
+  const searchSeparatorIndex = newValue.indexOf("?");
   if (searchSeparatorIndex > -1) {
-    return newValue // let new value override search params
+    return newValue; // let new value override search params
   }
-  urlObject.pathname = newValue
-  const resource = `${urlObject.pathname}${urlObject.search}`
-  return resource
-}
+  urlObject.pathname = newValue;
+  const resource = `${urlObject.pathname}${urlObject.search}`;
+  return resource;
+};

package/src/services/response_acceptance_check/jsenv_service_response_acceptance_check.js

@@ -1,19 +1,19 @@
-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"
+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 jsenvServiceResponseAcceptanceCheck = () => {
   return {
     name: "jsenv:response_acceptance_check",
     inspectResponse: (request, { response, warn }) => {
-      checkResponseAcceptance(request, response, { warn })
+      checkResponseAcceptance(request, response, { warn });
     },
-  }
-}
+  };
+};
 
 const checkResponseAcceptance = (request, response, { warn }) => {
-  const requestAcceptHeader = request.headers.accept
-  const responseContentTypeHeader = response.headers["content-type"]
+  const requestAcceptHeader = request.headers.accept;
+  const responseContentTypeHeader = response.headers["content-type"];
   if (
     requestAcceptHeader &&
     responseContentTypeHeader &&
@@ -23,11 +23,11 @@ const checkResponseAcceptance = (request, response, { warn }) => {
 --- response content-type header ---
 ${responseContentTypeHeader}
 --- request accept header ---
-${requestAcceptHeader}`)
+${requestAcceptHeader}`);
   }
 
-  const requestAcceptLanguageHeader = request.headers["accept-language"]
-  const responseContentLanguageHeader = response.headers["content-language"]
+  const requestAcceptLanguageHeader = request.headers["accept-language"];
+  const responseContentLanguageHeader = response.headers["content-language"];
   if (
     requestAcceptLanguageHeader &&
     responseContentLanguageHeader &&
@@ -37,11 +37,11 @@ ${requestAcceptHeader}`)
 --- response content-language header ---
 ${responseContentLanguageHeader}
 --- request accept-language header ---
-${requestAcceptLanguageHeader}`)
+${requestAcceptLanguageHeader}`);
   }
 
-  const requestAcceptEncodingHeader = request.headers["accept-encoding"]
-  const responseContentEncodingHeader = response.headers["content-encoding"]
+  const requestAcceptEncodingHeader = request.headers["accept-encoding"];
+  const responseContentEncodingHeader = response.headers["content-encoding"];
   if (
     requestAcceptLanguageHeader &&
     responseContentLanguageHeader &&
@@ -51,6 +51,6 @@ ${requestAcceptLanguageHeader}`)
 --- response content-encoding header ---
 ${responseContentEncodingHeader}
 --- request accept-encoding header ---
-${requestAcceptEncodingHeader}`)
+${requestAcceptEncodingHeader}`);
   }
-}
+};