@jsenv/server 12.6.3 → 12.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "12.6.3",
+  "version": "12.7.2",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -10,61 +10,38 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsenv/server"
+    "url": "https://github.com/jsenv/jsenv-core",
+    "directory": "packages/server"
   },
   "engines": {
     "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
   },
   "type": "module",
   "exports": {
     ".": {
-      "import": "./main.js"
+      "import": "./src/main.js"
     },
     "./*": "./*"
   },
-  "main": "./main.js",
+  "main": "./src/main.js",
   "files": [
-    "/src/",
-    "/main.js"
+    "/src/"
   ],
   "scripts": {
-    "importmap": "node ./script/importmap/importmap.mjs",
-    "eslint": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
-    "performance": "node --expose-gc ./script/performance/performance.mjs --log",
-    "snapshot": "node ./test/internal_error/generate_html_snapshot_files.mjs",
-    "test": "node ./script/test/test.mjs",
-    "test-with-coverage": "npm run test -- --coverage",
-    "prettier": "prettier --write .",
-    "certificate-install": "node ./script/certificate/certificate_install.mjs",
-    "playwright-install": "npx playwright install-deps && npx playwright install"
+    "test": "node --conditions=development ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/abort": "4.1.2",
-    "@jsenv/logger": "4.1.1",
-    "@jsenv/url-meta": "6.2.0",
-    "node-fetch": "2.6.7",
-    "path-to-regexp": "6.2.0"
+    "@jsenv/abort": "4.2.3",
+    "@jsenv/log": "2.0.1",
+    "@jsenv/url-meta": "7.0.0",
+    "@jsenv/utils": "2.0.1"
   },
   "devDependencies": {
-    "@jsenv/assert": "2.5.2",
-    "@jsenv/core": "25.4.9",
-    "@jsenv/eslint-config": "16.0.9",
-    "@jsenv/filesystem": "2.7.1",
-    "@jsenv/github-release-package": "1.3.4",
-    "@jsenv/https-local": "1.0.7",
-    "@jsenv/importmap-eslint-resolver": "5.2.5",
-    "@jsenv/importmap-node-module": "5.1.3",
-    "@jsenv/package-publish": "1.7.2",
-    "@jsenv/performance-impact": "2.2.7",
-    "eslint": "8.7.0",
-    "eslint-plugin-import": "2.25.4",
-    "eventsource": "1.1.0",
-    "fastify": "3.27.0",
-    "fastify-static": "4.5.0",
-    "playwright": "1.18.1",
-    "prettier": "2.5.1"
+    "@jsenv/fetch": "../fetch/",
+    "eventsource": "2.0.2"
   }
-}
+}

package/src/fetch_filesystem.js

@@ -4,31 +4,23 @@
  * It is meant to be used inside "requestToResponse"
  */
 
-import { createReadStream, statSync, promises } from "node:fs"
-
-import {
-  isFileSystemPath,
-  urlToFileSystemPath,
-  fileSystemPathToUrl,
-} from "@jsenv/server/src/internal/filesystem.js"
-import { bufferToEtag } from "@jsenv/server/src/internal/etag.js"
+import { createReadStream, statSync, readFile } from "node:fs"
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+
+import { isFileSystemPath, fileSystemPathToUrl } from "./internal/filesystem.js"
+import { bufferToEtag } from "./internal/etag.js"
 import { composeTwoResponses } from "./internal/response_composition.js"
 import { convertFileSystemErrorToResponseProperties } from "./internal/convertFileSystemErrorToResponseProperties.js"
-import { jsenvContentTypeMap } from "./jsenvContentTypeMap.js"
 import { timeFunction } from "./server_timing/timing_measure.js"
 import { negotiateContentEncoding } from "./content_negotiation/negotiateContentEncoding.js"
-import { urlToContentType } from "./urlToContentType.js"
 import { serveDirectory } from "./serve_directory.js"
 
-const ETAG_MEMORY_MAP = new Map()
-
 export const fetchFileSystem = async (
   filesystemUrl,
   {
     // signal,
     method = "GET",
     headers = {},
-    contentTypeMap = jsenvContentTypeMap,
     etagEnabled = false,
     etagMemory = true,
     etagMemoryMaxSize = 1000,
@@ -97,13 +89,11 @@ export const fetchFileSystem = async (
     }
   }
 
-  let sourceUrl = `file://${new URL(urlString).pathname}`
-  const sourceFilesystemPath = urlToFileSystemPath(filesystemUrl)
-
+  const sourceUrl = `file://${new URL(urlString).pathname}`
   try {
     const [readStatTiming, sourceStat] = await timeFunction(
       "file service>read file stat",
-      () => statSync(sourceFilesystemPath),
+      () => statSync(new URL(sourceUrl)),
     )
     if (sourceStat.isDirectory()) {
       if (canReadDirectory) {
@@ -155,7 +145,6 @@ export const fetchFileSystem = async (
       const compressedResponse = await getCompressedResponse({
         headers,
         sourceUrl,
-        contentTypeMap,
       })
       if (compressedResponse) {
         response = compressedResponse
@@ -165,7 +154,6 @@ export const fetchFileSystem = async (
       response = await getRawResponse({
         sourceStat,
         sourceUrl,
-        contentTypeMap,
       })
     }
 
@@ -287,6 +275,7 @@ const getEtagResponse = async ({
   }
 }
 
+const ETAG_MEMORY_MAP = new Map()
 const computeEtag = async ({
   etagMemory,
   etagMemoryMaxSize,
@@ -302,9 +291,15 @@ const computeEtag = async ({
       return etagMemoryEntry.eTag
     }
   }
-  const fileContentAsBuffer = await promises.readFile(
-    urlToFileSystemPath(sourceUrl),
-  )
+  const fileContentAsBuffer = await new Promise((resolve, reject) => {
+    readFile(new URL(sourceUrl), (error, buffer) => {
+      if (error) {
+        reject(error)
+      } else {
+        resolve(buffer)
+      }
+    })
+  })
   const eTag = bufferToEtag(fileContentAsBuffer)
   if (etagMemory) {
     if (ETAG_MEMORY_MAP.size >= etagMemoryMaxSize) {
@@ -364,11 +359,7 @@ const getMtimeResponse = async ({ headers, sourceStat }) => {
   }
 }
 
-const getCompressedResponse = async ({
-  sourceUrl,
-  headers,
-  contentTypeMap,
-}) => {
+const getCompressedResponse = async ({ sourceUrl, headers }) => {
   const acceptedCompressionFormat = negotiateContentEncoding(
     { headers },
     Object.keys(availableCompressionFormats),
@@ -385,7 +376,7 @@ const getCompressedResponse = async ({
   return {
     status: 200,
     headers: {
-      "content-type": urlToContentType(sourceUrl, contentTypeMap),
+      "content-type": CONTENT_TYPE.fromUrlExtension(sourceUrl),
       "content-encoding": acceptedCompressionFormat,
       "vary": "accept-encoding",
     },
@@ -394,29 +385,32 @@ const getCompressedResponse = async ({
 }
 
 const fileUrlToReadableStream = (fileUrl) => {
-  return createReadStream(urlToFileSystemPath(fileUrl), { emitClose: true })
+  return createReadStream(new URL(fileUrl), {
+    emitClose: true,
+    autoClose: true,
+  })
 }
 
 const availableCompressionFormats = {
   br: async (fileReadableStream) => {
-    const { createBrotliCompress } = await import("zlib")
+    const { createBrotliCompress } = await import("node:zlib")
     return fileReadableStream.pipe(createBrotliCompress())
   },
   deflate: async (fileReadableStream) => {
-    const { createDeflate } = await import("zlib")
+    const { createDeflate } = await import("node:zlib")
     return fileReadableStream.pipe(createDeflate())
   },
   gzip: async (fileReadableStream) => {
-    const { createGzip } = await import("zlib")
+    const { createGzip } = await import("node:zlib")
     return fileReadableStream.pipe(createGzip())
   },
 }
 
-const getRawResponse = async ({ sourceUrl, sourceStat, contentTypeMap }) => {
+const getRawResponse = async ({ sourceUrl, sourceStat }) => {
   return {
     status: 200,
     headers: {
-      "content-type": urlToContentType(sourceUrl, contentTypeMap),
+      "content-type": CONTENT_TYPE.fromUrlExtension(sourceUrl),
       "content-length": sourceStat.size,
     },
     body: fileUrlToReadableStream(sourceUrl),

package/src/internal/getServerOrigins.js

@@ -1,5 +1,4 @@
-import { networkInterfaces } from "os"
-import { URL } from "url"
+import { networkInterfaces } from "node:os"
 
 export const getServerOrigins = ({ protocol, ip, port }) => {
   const isInternalIp = ip === "127.0.0.1"

package/src/internal/server-polyglot.js

@@ -4,8 +4,8 @@ https://stackoverflow.com/a/42019773/2634179
 
 */
 
-import http from "http"
-import net from "net"
+import http from "node:http"
+import net from "node:net"
 import { listenEvent } from "./listenEvent.js"
 
 export const createPolyglotServer = async ({
@@ -69,7 +69,7 @@ const createSecureServer = async ({
   http1Allowed,
 }) => {
   if (http2) {
-    const { createSecureServer } = await import("http2")
+    const { createSecureServer } = await import("node:http2")
     return createSecureServer({
       cert: certificate,
       key: privateKey,
@@ -77,7 +77,7 @@ const createSecureServer = async ({
     })
   }
 
-  const { createServer } = await import("https")
+  const { createServer } = await import("node:https")
   return createServer({
     cert: certificate,
     key: privateKey,

package/src/main.js

@@ -0,0 +1,48 @@
+/*
+ * This file is the first file executed by code using the package
+ * Its responsability is to export what is documented
+ * Ideally this file should be kept simple to help discovering codebase progressively.
+ */
+
+export { startServer } from "./startServer.js"
+export { composeServices } from "./service_composition/service_composition.js"
+export { setupRoutes } from "./service_composition/routing.js"
+export { readRequestBody } from "./readRequestBody.js"
+export { fetchFileSystem } from "./fetch_filesystem.js"
+export {
+  STOP_REASON_INTERNAL_ERROR,
+  STOP_REASON_PROCESS_SIGHUP,
+  STOP_REASON_PROCESS_SIGTERM,
+  STOP_REASON_PROCESS_SIGINT,
+  STOP_REASON_PROCESS_BEFORE_EXIT,
+  STOP_REASON_PROCESS_EXIT,
+  STOP_REASON_NOT_SPECIFIED,
+} from "./stopReasons.js"
+
+// CORS
+export {
+  pluginCORS,
+  jsenvAccessControlAllowedHeaders,
+  jsenvAccessControlAllowedMethods,
+} from "./cors/plugin_cors.js"
+
+// server timings
+export { pluginServerTiming } from "./server_timing/plugin_server_timing.js"
+export { timeFunction, timeStart } from "./server_timing/timing_measure.js"
+
+// SSE
+export { createSSERoom } from "./sse/createSSERoom.js"
+
+// content-negotiation
+export { negotiateContentType } from "./content_negotiation/negotiateContentType.js"
+export { negotiateContentEncoding } from "./content_negotiation/negotiateContentEncoding.js"
+export { negotiateContentLanguage } from "./content_negotiation/negotiateContentLanguage.js"
+export { pluginContentNegotiationCheck } from "./content_negotiation/plugin_content_negotiation_check.js"
+
+// others
+export { serveDirectory } from "./serve_directory.js"
+export { fromFetchResponse } from "./from_fetch_response.js"
+export { composeTwoResponses } from "./internal/response_composition.js"
+export { pluginRessourceAliases } from "./ressource_aliases/plugin_ressource_aliases.js"
+export { pluginRequestWaitingCheck } from "./plugin_request_waiting_check.js"
+export { findFreePort } from "./internal/listen.js"

package/src/plugin_request_waiting_check.js

@@ -1,4 +1,4 @@
-import { createDetailedMessage } from "@jsenv/logger"
+import { createDetailedMessage } from "@jsenv/log"
 
 export const pluginRequestWaitingCheck = ({
   requestWaitingMs = 20000,

package/src/ressource_aliases/plugin_ressource_aliases.js

@@ -1,4 +1,4 @@
-import { applyAliases } from "@jsenv/url-meta"
+import { URL_META } from "@jsenv/url-meta"
 
 export const pluginRessourceAliases = (ressourceAliases) => {
   const aliases = {}
@@ -9,7 +9,7 @@ export const pluginRessourceAliases = (ressourceAliases) => {
     ressource_aliases: {
       onRequest: (request, { redirectRequest }) => {
         const ressourceBeforeAlias = request.ressource
-        const urlAfterAliasing = applyAliases({
+        const urlAfterAliasing = URL_META.applyAliases({
           url: asFileUrl(request.pathname),
           aliases,
         })

package/src/server_timing/timing_measure.js

@@ -1,4 +1,4 @@
-import { performance } from "perf_hooks"
+import { performance } from "node:perf_hooks"
 
 export const timeStart = (name) => {
   // as specified in https://w3c.github.io/server-timing/#the-performanceservertiming-interface

package/src/service_composition/path_to_regexp.js

@@ -0,0 +1,431 @@
+// ESM version of "path-to-regexp@6.2.1"
+// https://github.com/pillarjs/path-to-regexp/blob/master/package.json
+
+/**
+ * Tokenize input string.
+ */
+function lexer(str) {
+  var tokens = []
+  var i = 0
+  while (i < str.length) {
+    var char = str[i]
+    if (char === "*" || char === "+" || char === "?") {
+      tokens.push({ type: "MODIFIER", index: i, value: str[i++] })
+      continue
+    }
+    if (char === "\\") {
+      tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] })
+      continue
+    }
+    if (char === "{") {
+      tokens.push({ type: "OPEN", index: i, value: str[i++] })
+      continue
+    }
+    if (char === "}") {
+      tokens.push({ type: "CLOSE", index: i, value: str[i++] })
+      continue
+    }
+    if (char === ":") {
+      var name = ""
+      let j = i + 1
+      while (j < str.length) {
+        var code = str.charCodeAt(j)
+        if (
+          // `0-9`
+          (code >= 48 && code <= 57) ||
+          // `A-Z`
+          (code >= 65 && code <= 90) ||
+          // `a-z`
+          (code >= 97 && code <= 122) ||
+          // `_`
+          code === 95
+        ) {
+          name += str[j++]
+          continue
+        }
+        break
+      }
+      if (!name) throw new TypeError("Missing parameter name at ".concat(i))
+      tokens.push({ type: "NAME", index: i, value: name })
+      i = j
+      continue
+    }
+    if (char === "(") {
+      var count = 1
+      var pattern = ""
+      var j = i + 1
+      if (str[j] === "?") {
+        throw new TypeError('Pattern cannot start with "?" at '.concat(j))
+      }
+      while (j < str.length) {
+        if (str[j] === "\\") {
+          pattern += str[j++] + str[j++]
+          continue
+        }
+        if (str[j] === ")") {
+          count--
+          if (count === 0) {
+            j++
+            break
+          }
+        } else if (str[j] === "(") {
+          count++
+          if (str[j + 1] !== "?") {
+            throw new TypeError(
+              "Capturing groups are not allowed at ".concat(j),
+            )
+          }
+        }
+        pattern += str[j++]
+      }
+      if (count) throw new TypeError("Unbalanced pattern at ".concat(i))
+      if (!pattern) throw new TypeError("Missing pattern at ".concat(i))
+      tokens.push({ type: "PATTERN", index: i, value: pattern })
+      i = j
+      continue
+    }
+    tokens.push({ type: "CHAR", index: i, value: str[i++] })
+  }
+  tokens.push({ type: "END", index: i, value: "" })
+  return tokens
+}
+/**
+ * Parse a string for the raw tokens.
+ */
+export function parse(str, { prefixes = "./", delimiter = "/#?" } = {}) {
+  var tokens = lexer(str)
+
+  var defaultPattern = "[^".concat(escapeString(delimiter), "]+?")
+  var result = []
+  var key = 0
+  var i = 0
+  var path = ""
+  var tryConsume = function (type) {
+    if (i < tokens.length && tokens[i].type === type) return tokens[i++].value
+    return undefined
+  }
+  var mustConsume = function (type) {
+    var value = tryConsume(type)
+    if (value !== undefined) return value
+    var _a = tokens[i]
+    var nextType = _a.type
+    var index = _a.inde
+    throw new TypeError(
+      "Unexpected "
+        .concat(nextType, " at ")
+        .concat(index, ", expected ")
+        .concat(type),
+    )
+  }
+  var consumeText = function () {
+    var result = ""
+    var value
+    while ((value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR"))) {
+      result += value
+    }
+    return result
+  }
+  while (i < tokens.length) {
+    var char = tryConsume("CHAR")
+    var name = tryConsume("NAME")
+    var pattern = tryConsume("PATTERN")
+    if (name || pattern) {
+      let prefix = char || ""
+      if (prefixes.indexOf(prefix) === -1) {
+        path += prefix
+        prefix = ""
+      }
+      if (path) {
+        result.push(path)
+        path = ""
+      }
+      result.push({
+        name: name || key++,
+        prefix,
+        suffix: "",
+        pattern: pattern || defaultPattern,
+        modifier: tryConsume("MODIFIER") || "",
+      })
+      continue
+    }
+    var value = char || tryConsume("ESCAPED_CHAR")
+    if (value) {
+      path += value
+      continue
+    }
+    if (path) {
+      result.push(path)
+      path = ""
+    }
+    var open = tryConsume("OPEN")
+    if (open) {
+      var prefix = consumeText()
+      var name_1 = tryConsume("NAME") || ""
+      var pattern_1 = tryConsume("PATTERN") || ""
+      var suffix = consumeText()
+      mustConsume("CLOSE")
+      result.push({
+        name: name_1 || (pattern_1 ? key++ : ""),
+        pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
+        prefix,
+        suffix,
+        modifier: tryConsume("MODIFIER") || "",
+      })
+      continue
+    }
+    mustConsume("END")
+  }
+  return result
+}
+/**
+ * Compile a string to a template function for the path.
+ */
+export function compile(str, options) {
+  return tokensToFunction(parse(str, options), options)
+}
+/**
+ * Expose a method for transforming tokens into the path function.
+ */
+export function tokensToFunction(
+  tokens,
+  { sensitive, encode = (x) => x, validate = true },
+) {
+  // Compile all the tokens into regexps.
+  var matches = tokens.map(function (token) {
+    if (typeof token === "object") {
+      return new RegExp(
+        "^(?:".concat(token.pattern, ")$"),
+        sensitive ? "" : "i",
+      )
+    }
+    return undefined
+  })
+  return function (data) {
+    var path = ""
+    for (var i = 0; i < tokens.length; i++) {
+      var token = tokens[i]
+      if (typeof token === "string") {
+        path += token
+        continue
+      }
+      var value = data ? data[token.name] : undefined
+      var optional = token.modifier === "?" || token.modifier === "*"
+      var repeat = token.modifier === "*" || token.modifier === "+"
+      if (Array.isArray(value)) {
+        if (!repeat) {
+          throw new TypeError(
+            'Expected "'.concat(
+              token.name,
+              '" to not repeat, but got an array',
+            ),
+          )
+        }
+        if (value.length === 0) {
+          if (optional) continue
+          throw new TypeError(
+            'Expected "'.concat(token.name, '" to not be empty'),
+          )
+        }
+        for (var j = 0; j < value.length; j++) {
+          let segment = encode(value[j], token)
+          if (validate && !matches[i].test(segment)) {
+            throw new TypeError(
+              'Expected all "'
+                .concat(token.name, '" to match "')
+                .concat(token.pattern, '", but got "')
+                .concat(segment, '"'),
+            )
+          }
+          path += token.prefix + segment + token.suffix
+        }
+        continue
+      }
+      if (typeof value === "string" || typeof value === "number") {
+        var segment = encode(String(value), token)
+        if (validate && !matches[i].test(segment)) {
+          throw new TypeError(
+            'Expected "'
+              .concat(token.name, '" to match "')
+              .concat(token.pattern, '", but got "')
+              .concat(segment, '"'),
+          )
+        }
+        path += token.prefix + segment + token.suffix
+        continue
+      }
+      if (optional) continue
+      var typeOfMessage = repeat ? "an array" : "a string"
+      throw new TypeError(
+        'Expected "'.concat(token.name, '" to be ').concat(typeOfMessage),
+      )
+    }
+    return path
+  }
+}
+/**
+ * Create path match function from `path-to-regexp` spec.
+ */
+export function match(str, options) {
+  var keys = []
+  var re = pathToRegexp(str, keys, options)
+  return regexpToFunction(re, keys, options)
+}
+/**
+ * Create a path match function from `path-to-regexp` output.
+ */
+export function regexpToFunction(re, keys, { decode = (x) => x }) {
+  return function (pathname) {
+    var m = re.exec(pathname)
+    if (!m) return false
+    var path = m[0]
+    var index = m.index
+    var params = Object.create(null)
+    var _loop_1 = function (i) {
+      if (m[i] === undefined) return "continue"
+      var key = keys[i - 1]
+      if (key.modifier === "*" || key.modifier === "+") {
+        params[key.name] = m[i]
+          .split(key.prefix + key.suffix)
+          .map(function (value) {
+            return decode(value, key)
+          })
+      } else {
+        params[key.name] = decode(m[i], key)
+      }
+      return undefined
+    }
+    for (var i = 1; i < m.length; i++) {
+      _loop_1(i)
+    }
+    return { path, index, params }
+  }
+}
+/**
+ * Escape a regular expression string.
+ */
+function escapeString(str) {
+  return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1")
+}
+/**
+ * Pull out keys from a regexp.
+ */
+function regexpToRegexp(path, keys) {
+  if (!keys) return path
+  var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g
+  var index = 0
+  var execResult = groupsRegex.exec(path.source)
+  while (execResult) {
+    keys.push({
+      // Use parenthesized substring match if available, index otherwise
+      name: execResult[1] || index++,
+      prefix: "",
+      suffix: "",
+      modifier: "",
+      pattern: "",
+    })
+    execResult = groupsRegex.exec(path.source)
+  }
+  return path
+}
+/**
+ * Transform an array into a regexp.
+ */
+function arrayToRegexp(paths, keys, { sensitive }) {
+  var parts = paths.map(function (path) {
+    return pathToRegexp(path, keys, { sensitive }).source
+  })
+  return new RegExp("(?:".concat(parts.join("|"), ")"), sensitive ? "" : "i")
+}
+/**
+ * Create a path regexp from string input.
+ */
+function stringToRegexp(path, keys, options) {
+  return tokensToRegexp(parse(path, options), keys, options)
+}
+/**
+ * Expose a function for taking tokens and returning a RegExp.
+ */
+export function tokensToRegexp(
+  tokens,
+  keys,
+  {
+    sensitive,
+    strict = false,
+    start = true,
+    end = true,
+    encode = (x) => x,
+    delimiter = "/#?",
+    endsWith = "",
+  } = {},
+) {
+  var endsWithRe = "[".concat(escapeString(endsWith), "]|$")
+  var delimiterRe = "[".concat(escapeString(delimiter), "]")
+  var route = start ? "^" : ""
+  // Iterate over the tokens and create our regexp string.
+  for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+    var token = tokens_1[_i]
+    if (typeof token === "string") {
+      route += escapeString(encode(token))
+    } else {
+      var prefix = escapeString(encode(token.prefix))
+      var suffix = escapeString(encode(token.suffix))
+      if (token.pattern) {
+        if (keys) keys.push(token)
+        if (prefix || suffix) {
+          if (token.modifier === "+" || token.modifier === "*") {
+            var mod = token.modifier === "*" ? "?" : ""
+            route += "(?:"
+              .concat(prefix, "((?:")
+              .concat(token.pattern, ")(?:")
+              .concat(suffix)
+              .concat(prefix, "(?:")
+              .concat(token.pattern, "))*)")
+              .concat(suffix, ")")
+              .concat(mod)
+          } else {
+            route += "(?:"
+              .concat(prefix, "(")
+              .concat(token.pattern, ")")
+              .concat(suffix, ")")
+              .concat(token.modifier)
+          }
+        } else if (token.modifier === "+" || token.modifier === "*") {
+          route += "((?:".concat(token.pattern, ")").concat(token.modifier, ")")
+        } else {
+          route += "(".concat(token.pattern, ")").concat(token.modifier)
+        }
+      } else {
+        route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier)
+      }
+    }
+  }
+  if (end) {
+    if (!strict) route += "".concat(delimiterRe, "?")
+    route += endsWith ? "(?=".concat(endsWithRe, ")") : "$"
+  } else {
+    var endToken = tokens[tokens.length - 1]
+    var isEndDelimited =
+      typeof endToken === "string"
+        ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1
+        : endToken === undefined
+    if (!strict) {
+      route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?")
+    }
+    if (!isEndDelimited) {
+      route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")")
+    }
+  }
+  return new RegExp(route, sensitive ? "" : "i")
+}
+/**
+ * Normalize the given path string, returning a regular expression.
+ *
+ * An empty array can be passed in for the keys, which will hold the
+ * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+ * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ */
+export function pathToRegexp(path, keys, options) {
+  if (path instanceof RegExp) return regexpToRegexp(path, keys)
+  if (Array.isArray(path)) return arrayToRegexp(path, keys, options)
+  return stringToRegexp(path, keys, options)
+}

package/src/service_composition/routing.js

@@ -1,10 +1,6 @@
-import { createRequire } from "node:module"
-
-const require = createRequire(import.meta.url)
+import { match } from "./path_to_regexp.js"
 
 export const setupRoutes = (routes) => {
-  const { match } = require("path-to-regexp")
-
   const candidates = Object.keys(routes).map((pathPattern) => {
     const applyPatternMatching = match(pathPattern, {
       decode: decodeURIComponent,

package/src/service_composition/service_composition.js

@@ -1,6 +1,6 @@
-import { timeFunction } from "@jsenv/server/src/server_timing/timing_measure.js"
-import { composeTwoResponses } from "@jsenv/server/src/internal/response_composition.js"
-import { applyRedirectionToRequest } from "@jsenv/server/src/internal/request_factory.js"
+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 }) => {

package/src/sse/createSSERoom.js

@@ -1,4 +1,4 @@
-import { createLogger } from "@jsenv/logger"
+import { createLogger } from "@jsenv/log"
 
 import {
   createObservable,

package/src/startServer.js

@@ -1,11 +1,12 @@
 import http from "node:http"
 import cluster from "node:cluster"
-import { createDetailedMessage, createLogger } from "@jsenv/logger"
+import { createDetailedMessage, createLogger } from "@jsenv/log"
 import {
   Abort,
   raceProcessTeardownEvents,
   createCallbackListNotifiedOnce,
 } from "@jsenv/abort"
+import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
 
 import { createPolyglotServer } from "./internal/server-polyglot.js"
 import { trackServerPendingConnections } from "./internal/trackServerPendingConnections.js"
@@ -25,7 +26,6 @@ import { listen, stopListening } from "./internal/listen.js"
 import { composeTwoResponses } from "./internal/response_composition.js"
 import { listenRequest } from "./internal/listenRequest.js"
 import { listenServerConnectionError } from "./internal/listenServerConnectionError.js"
-import { memoize } from "./internal/memoize.js"
 import { applyDefaultErrorToResponse } from "./error_to_response_default.js"
 import {
   STOP_REASON_INTERNAL_ERROR,
@@ -804,7 +804,7 @@ const createNodeServer = async ({
     })
   }
 
-  const { createServer } = await import("https")
+  const { createServer } = await import("node:https")
   return createServer({
     cert: certificate,
     key: privateKey,

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 jsenv
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/main.js

@@ -1,50 +0,0 @@
-/*
- * This file is the first file executed by code using the package
- * Its responsability is to export what is documented
- * Ideally this file should be kept simple to help discovering codebase progressively.
- */
-
-export { startServer } from "./src/startServer.js"
-export { composeServices } from "./src/service_composition/service_composition.js"
-export { setupRoutes } from "./src/service_composition/routing.js"
-export { readRequestBody } from "./src/readRequestBody.js"
-export { fetchFileSystem } from "./src/fetch_filesystem.js"
-export {
-  STOP_REASON_INTERNAL_ERROR,
-  STOP_REASON_PROCESS_SIGHUP,
-  STOP_REASON_PROCESS_SIGTERM,
-  STOP_REASON_PROCESS_SIGINT,
-  STOP_REASON_PROCESS_BEFORE_EXIT,
-  STOP_REASON_PROCESS_EXIT,
-  STOP_REASON_NOT_SPECIFIED,
-} from "./src/stopReasons.js"
-
-// CORS
-export {
-  pluginCORS,
-  jsenvAccessControlAllowedHeaders,
-  jsenvAccessControlAllowedMethods,
-} from "./src/cors/plugin_cors.js"
-
-// server timings
-export { pluginServerTiming } from "./src/server_timing/plugin_server_timing.js"
-export { timeFunction, timeStart } from "./src/server_timing/timing_measure.js"
-
-// SSE
-export { createSSERoom } from "./src/sse/createSSERoom.js"
-
-// content-negotiation
-export { negotiateContentType } from "./src/content_negotiation/negotiateContentType.js"
-export { negotiateContentEncoding } from "./src/content_negotiation/negotiateContentEncoding.js"
-export { negotiateContentLanguage } from "./src/content_negotiation/negotiateContentLanguage.js"
-export { pluginContentNegotiationCheck } from "./src/content_negotiation/plugin_content_negotiation_check.js"
-
-// others
-export { fetchUrl } from "./src/fetch_url.js"
-export { serveDirectory } from "./src/serve_directory.js"
-export { fromFetchResponse } from "./src/from_fetch_response.js"
-export { composeTwoResponses } from "./src/internal/response_composition.js"
-export { pluginRessourceAliases } from "./src/ressource_aliases/plugin_ressource_aliases.js"
-export { pluginRequestWaitingCheck } from "./src/plugin_request_waiting_check.js"
-export { findFreePort } from "./src/internal/listen.js"
-export { urlToContentType } from "./src/urlToContentType.js"

package/src/fetch_url.js

@@ -1,112 +0,0 @@
-// https://github.com/node-fetch/node-fetch/blob/8c197f8982a238b3c345c64b17bfa92e16b4f7c4/src/response.js#L1
-
-import { Agent } from "node:https"
-import nodeFetch, { Response } from "node-fetch"
-
-import { fetchFileSystem } from "./fetch_filesystem.js"
-import { isFileHandle, fileHandleToReadableStream } from "./internal/body.js"
-
-export const fetchUrl = async (
-  url,
-  {
-    signal = new AbortController().signal,
-    ignoreHttpsError = false,
-    canReadDirectory,
-    contentTypeMap,
-    cacheStrategy,
-    method = "GET",
-    headers = {},
-    ...rest
-  } = {},
-) => {
-  try {
-    url = String(new URL(url))
-  } catch (e) {
-    throw new Error(
-      `fetchUrl first argument must be an absolute url, received ${url}`,
-    )
-  }
-
-  if (url.startsWith("file://")) {
-    const responseProperties = await fetchFileSystem(url, {
-      signal,
-      method,
-      headers,
-      rootDirectoryUrl: "file://",
-      cacheStrategy,
-      canReadDirectory,
-      contentTypeMap,
-      ...rest,
-    })
-    const responseBody = responseProperties.body
-
-    const response = new Response(
-      typeof responseBody === "string"
-        ? Buffer.from(responseBody)
-        : isFileHandle(responseBody)
-        ? fileHandleToReadableStream(responseBody)
-        : responseBody,
-      {
-        url,
-        status: responseProperties.status,
-        statusText: responseProperties.statusText,
-        headers: responseProperties.headers,
-      },
-    )
-    return response
-  }
-
-  if (url.startsWith("data:")) {
-    const { mediaType, base64Flag, data } = parseDataUrl(url)
-    const body = base64Flag ? Buffer.from(data, "base64") : Buffer.from(data)
-    const response = new Response(body, {
-      url,
-      status: 200,
-      headers: {
-        "content-type": mediaType,
-      },
-    })
-    return response
-  }
-
-  const response = await nodeFetch(url, {
-    signal,
-    method,
-    headers,
-    ...(ignoreHttpsError && url.startsWith("https")
-      ? {
-          agent: () => {
-            return new Agent({
-              rejectUnauthorized: false,
-            })
-          },
-        }
-      : {}),
-    ...rest,
-  })
-
-  return response
-}
-
-const parseDataUrl = (dataUrl) => {
-  const afterDataProtocol = dataUrl.slice("data:".length)
-  const commaIndex = afterDataProtocol.indexOf(",")
-  const beforeComma = afterDataProtocol.slice(0, commaIndex)
-
-  let mediaType
-  let base64Flag
-  if (beforeComma.endsWith(`;base64`)) {
-    mediaType = beforeComma.slice(0, -`;base64`.length)
-    base64Flag = true
-  } else {
-    mediaType = beforeComma
-    base64Flag = false
-  }
-
-  const afterComma = afterDataProtocol.slice(commaIndex + 1)
-  return {
-    mediaType: mediaType === "" ? "text/plain;charset=US-ASCII" : mediaType,
-    base64Flag,
-    data: afterComma,
-  }
-}

package/src/internal/memoize.js

@@ -1,24 +0,0 @@
-export const memoize = (compute) => {
-  let memoized = false
-  let memoizedValue
-
-  const fnWithMemoization = (...args) => {
-    if (memoized) {
-      return memoizedValue
-    }
-    // if compute is recursive wait for it to be fully done before storing the value
-    // so set memoized boolean after the call
-    memoizedValue = compute(...args)
-    memoized = true
-    return memoizedValue
-  }
-
-  fnWithMemoization.forget = () => {
-    const value = memoizedValue
-    memoized = false
-    memoizedValue = undefined
-    return value
-  }
-
-  return fnWithMemoization
-}

package/src/jsenvContentTypeMap.js

@@ -1,102 +0,0 @@
-export const jsenvContentTypeMap = {
-  "application/javascript": {
-    extensions: ["js", "cjs", "mjs", "ts", "jsx"],
-  },
-  "application/json": {
-    extensions: ["json"],
-  },
-  "application/importmap+json": {
-    extensions: ["importmap"],
-  },
-  "application/manifest+json": {
-    extensions: ["webmanifest"],
-  },
-  "application/octet-stream": {},
-  "application/pdf": {
-    extensions: ["pdf"],
-  },
-  "application/xml": {
-    extensions: ["xml"],
-  },
-  "application/x-gzip": {
-    extensions: ["gz"],
-  },
-  "application/wasm": {
-    extensions: ["wasm"],
-  },
-  "application/zip": {
-    extensions: ["zip"],
-  },
-  "audio/basic": {
-    extensions: ["au", "snd"],
-  },
-  "audio/mpeg": {
-    extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"],
-  },
-  "audio/midi": {
-    extensions: ["midi", "mid", "kar", "rmi"],
-  },
-  "audio/mp4": {
-    extensions: ["m4a", "mp4a"],
-  },
-  "audio/ogg": {
-    extensions: ["oga", "ogg", "spx"],
-  },
-  "audio/webm": {
-    extensions: ["weba"],
-  },
-  "audio/x-wav": {
-    extensions: ["wav"],
-  },
-  "font/ttf": {
-    extensions: ["ttf"],
-  },
-  "font/woff": {
-    extensions: ["woff"],
-  },
-  "font/woff2": {
-    extensions: ["woff2"],
-  },
-  "image/png": {
-    extensions: ["png"],
-  },
-  "image/gif": {
-    extensions: ["gif"],
-  },
-  "image/jpeg": {
-    extensions: ["jpg"],
-  },
-  "image/svg+xml": {
-    extensions: ["svg", "svgz"],
-  },
-  "text/plain": {
-    extensions: ["txt"],
-  },
-  "text/html": {
-    extensions: ["html"],
-  },
-  "text/css": {
-    extensions: ["css"],
-  },
-  "text/x-sass": {
-    extensions: ["sass"],
-  },
-  "text/x-scss": {
-    extensions: ["scss"],
-  },
-  "text/cache-manifest": {
-    extensions: ["appcache"],
-  },
-  "video/mp4": {
-    extensions: ["mp4", "mp4v", "mpg4"],
-  },
-  "video/mpeg": {
-    extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"],
-  },
-  "video/ogg": {
-    extensions: ["ogv"],
-  },
-  "video/webm": {
-    extensions: ["webm"],
-  },
-}

package/src/urlToContentType.js

@@ -1,36 +0,0 @@
-// https://github.com/jshttp/mime-db/blob/master/src/apache-types.json
-
-import { extname } from "node:path"
-
-import { jsenvContentTypeMap } from "./jsenvContentTypeMap.js"
-
-export const urlToContentType = (
-  url,
-  contentTypeMap = jsenvContentTypeMap,
-  contentTypeDefault = "application/octet-stream",
-) => {
-  if (typeof contentTypeMap !== "object") {
-    throw new TypeError(
-      `contentTypeMap must be an object, got ${contentTypeMap}`,
-    )
-  }
-  const { pathname } = new URL(url)
-
-  const extensionWithDot = extname(pathname)
-
-  if (!extensionWithDot || extensionWithDot === ".") {
-    return contentTypeDefault
-  }
-
-  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
-      )
-    },
-  )
-  return contentTypeForExtension || contentTypeDefault
-}