@jsenv/server 12.8.0 → 14.0.0

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/internal/getServerOrigins.js

@@ -1,63 +0,0 @@
-import { networkInterfaces } from "node:os"
-import { lookup } from "node:dns"
-
-export const getServerOrigins = async ({ protocol, ip, port }) => {
-  const isInternalIp = ip === "127.0.0.1"
-  const localhostDnsResolution = await applyDnsResolution("localhost")
-  const internalOrigin = createServerOrigin({
-    protocol,
-    hostname:
-      localhostDnsResolution.address === "127.0.0.1"
-        ? "localhost"
-        : "127.0.0.1",
-    port,
-  })
-  if (isInternalIp) {
-    return { internal: internalOrigin }
-  }
-  const isAnyIp = !ip || ip === "::" || ip === "0.0.0.0"
-  return {
-    internal: internalOrigin,
-    external: createServerOrigin({
-      protocol,
-      hostname: isAnyIp ? getExternalIp(ip) : ip,
-      port,
-    }),
-  }
-}
-
-const applyDnsResolution = async (hostname) => {
-  const dnsResolution = await new Promise((resolve, reject) => {
-    lookup(hostname, (error, address, family) => {
-      if (error) {
-        reject(error)
-      } else {
-        resolve({ address, family })
-      }
-    })
-  })
-  return dnsResolution
-}
-
-const createServerOrigin = ({ protocol, hostname, port }) => {
-  const url = new URL("https://127.0.0.1:80")
-  url.protocol = protocol
-  url.hostname = hostname
-  url.port = port
-  return url.origin
-}
-
-const getExternalIp = () => {
-  const networkInterfaceMap = networkInterfaces()
-  let internalIPV4NetworkAddress
-  Object.keys(networkInterfaceMap).find((key) => {
-    const networkAddressArray = networkInterfaceMap[key]
-    return networkAddressArray.find((networkAddress) => {
-      if (networkAddress.internal) return false
-      if (networkAddress.family !== "IPv4") return false
-      internalIPV4NetworkAddress = networkAddress
-      return true
-    })
-  })
-  return internalIPV4NetworkAddress ? internalIPV4NetworkAddress.address : null
-}

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)
-  })
-}