@jsenv/server 13.1.0 → 14.1.1

package/README.md

@@ -43,7 +43,7 @@ const server = await startServer({
     {
       name: "index",
       handleRequest: (request) => {
-        if (request.ressource === "/") {
+        if (request.resource === "/") {
           return { status: 200 }
         }
         return null
@@ -104,7 +104,7 @@ await startServer({
   services: [
     {
       handleRequest: async (request) => {
-        const fileUrl = new URL(request.ressource.slice(1), import.meta.url)
+        const fileUrl = new URL(request.resource.slice(1), import.meta.url)
         const response = await fetchFileSystem(fileUrl, request)
         return response
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "13.1.0",
+  "version": "14.1.1",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@jsenv/abort": "4.2.3",
-    "@jsenv/log": "3.1.0",
+    "@jsenv/log": "3.2.0",
     "@jsenv/url-meta": "7.0.0",
     "@jsenv/utils": "2.0.1",
     "ws": "8.8.1"

package/src/fetch_filesystem.js

@@ -64,7 +64,7 @@ export const fetchFileSystem = async (
   }
 
   // here you might be tempted to add || cacheControl === 'no-cache'
-  // but no-cache means ressource can be cache but must be revalidated (yeah naming is strange)
+  // but no-cache means resource can be cache but must be revalidated (yeah naming is strange)
   // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#Cacheability
   if (cacheControl === "no-store") {
     if (etagEnabled) {
@@ -206,7 +206,7 @@ const getClientCacheResponse = async ({
   sourceUrl,
 }) => {
   // here you might be tempted to add || headers["cache-control"] === "no-cache"
-  // but no-cache means ressource can be cache but must be revalidated (yeah naming is strange)
+  // but no-cache means resource can be cache but must be revalidated (yeah naming is strange)
   // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#Cacheability
 
   if (

package/src/internal/hostname_parser.js

@@ -0,0 +1,48 @@
+import { isIP } from "node:net"
+
+export const parseHostname = (hostname) => {
+  if (hostname === "0.0.0.0") {
+    return {
+      type: "ip",
+      label: "unspecified",
+      version: 4,
+    }
+  }
+  if (
+    hostname === "::" ||
+    hostname === "0000:0000:0000:0000:0000:0000:0000:0000"
+  ) {
+    return {
+      type: "ip",
+      label: "unspecified",
+      version: 6,
+    }
+  }
+  if (hostname === "127.0.0.1") {
+    return {
+      type: "ip",
+      label: "loopback",
+      version: 4,
+    }
+  }
+  if (
+    hostname === "::1" ||
+    hostname === "0000:0000:0000:0000:0000:0000:0000:0001"
+  ) {
+    return {
+      type: "ip",
+      label: "loopback",
+      version: 6,
+    }
+  }
+  const ipVersion = isIP(hostname)
+  if (ipVersion === 0) {
+    return {
+      type: "hostname",
+    }
+  }
+  return {
+    type: "ip",
+    version: ipVersion,
+  }
+}

package/src/internal/listen.js

@@ -6,7 +6,7 @@ const listen = async ({
   server,
   port,
   portHint,
-  host,
+  hostname,
 }) => {
   const listeningOperation = Abort.startOperation()
 
@@ -17,11 +17,11 @@ const listen = async ({
       listeningOperation.throwIfAborted()
       port = await findFreePort(portHint, {
         signal: listeningOperation.signal,
-        host,
+        hostname,
       })
     }
     listeningOperation.throwIfAborted()
-    port = await startListening({ server, port, host })
+    port = await startListening({ server, port, hostname })
     listeningOperation.addAbortCallback(() => stopListening(server))
     listeningOperation.throwIfAborted()
 
@@ -35,7 +35,7 @@ export const findFreePort = async (
   initialPort = 1,
   {
     signal = new AbortController().signal,
-    host = "127.0.0.1",
+    hostname = "127.0.0.1",
     min = 1,
     max = 65534,
     next = (port) => port + 1,
@@ -56,26 +56,26 @@ export const findFreePort = async (
       const nextPort = next(port)
       if (nextPort > max) {
         throw new Error(
-          `${host} has no available port between ${min} and ${max}`,
+          `${hostname} has no available port between ${min} and ${max}`,
         )
       }
-      return testUntil(nextPort, host)
+      return testUntil(nextPort, hostname)
     }
-    const freePort = await testUntil(initialPort, host)
+    const freePort = await testUntil(initialPort, hostname)
     return freePort
   } finally {
     await findFreePortOperation.end()
   }
 }
 
-const portIsFree = async (port, host) => {
+const portIsFree = async (port, hostname) => {
   const server = createServer()
 
   try {
     await startListening({
       server,
       port,
-      host,
+      hostname,
     })
   } catch (error) {
     if (error && error.code === "EADDRINUSE") {
@@ -91,7 +91,7 @@ const portIsFree = async (port, host) => {
   return true
 }
 
-const startListening = ({ server, port, host }) => {
+const startListening = ({ server, port, hostname }) => {
   return new Promise((resolve, reject) => {
     server.on("error", reject)
     server.on("listening", () => {
@@ -99,7 +99,7 @@ const startListening = ({ server, port, host }) => {
       // https://nodejs.org/api/net.html#net_server_listen_port_host_backlog_callback
       resolve(server.address().port)
     })
-    server.listen(port, host)
+    server.listen(port, hostname)
   })
 }
 

package/src/internal/nodeStreamToObservable.js

@@ -38,7 +38,7 @@ export const nodeStreamToObservable = (nodeStream) => {
     // used in the next ${readableStreamLifetimeInSeconds} otherwise destroys it
     const timeout = setTimeout(() => {
       process.emitWarning(
-        `Readable stream not used after ${readableStreamLifetimeInSeconds} seconds. It will be destroyed to release ressources`,
+        `Readable stream not used after ${readableStreamLifetimeInSeconds} seconds. It will be destroyed to release resources`,
         {
           CODE: "READABLE_STREAM_TIMEOUT",
           // url is for http client request

package/src/internal/request_factory.js

@@ -24,8 +24,8 @@ export const fromNodeRequest = (nodeRequest, { serverOrigin, signal }) => {
     signal,
     http2: Boolean(nodeRequest.stream),
     origin: requestOrigin,
-    ...getPropertiesFromRessource({
-      ressource: nodeRequest.url,
+    ...getPropertiesFromResource({
+      resource: nodeRequest.url,
       baseUrl: requestOrigin,
     }),
     method: nodeRequest.method,
@@ -36,13 +36,13 @@ export const fromNodeRequest = (nodeRequest, { serverOrigin, signal }) => {
 
 export const applyRedirectionToRequest = (
   request,
-  { ressource, pathname, ...rest },
+  { resource, pathname, ...rest },
 ) => {
   return {
     ...request,
-    ...(ressource
-      ? getPropertiesFromRessource({
-          ressource,
+    ...(resource
+      ? getPropertiesFromResource({
+          resource,
           baseUrl: request.url,
         })
       : pathname
@@ -55,20 +55,20 @@ export const applyRedirectionToRequest = (
   }
 }
 
-const getPropertiesFromRessource = ({ ressource, baseUrl }) => {
-  const urlObject = new URL(ressource, baseUrl)
+const getPropertiesFromResource = ({ resource, baseUrl }) => {
+  const urlObject = new URL(resource, baseUrl)
   let pathname = urlObject.pathname
 
   return {
     url: String(urlObject),
     pathname,
-    ressource,
+    resource,
   }
 }
 
 const getPropertiesFromPathname = ({ pathname, baseUrl }) => {
-  return getPropertiesFromRessource({
-    ressource: `${pathname}${new URL(baseUrl).search}`,
+  return getPropertiesFromResource({
+    resource: `${pathname}${new URL(baseUrl).search}`,
     baseUrl,
   })
 }
@@ -95,12 +95,12 @@ export const createPushRequest = (request, { signal, pathname, method }) => {
 const getHeadersInheritedByPushRequest = (request) => {
   const headersInherited = { ...request.headers }
   // mtime sent by the client in request headers concerns the main request
-  // Time remains valid for request to other ressources so we keep it
+  // Time remains valid for request to other resources so we keep it
   // in child requests
   // delete childHeaders["if-modified-since"]
 
   // eTag sent by the client in request headers concerns the main request
-  // A request made to an other ressource must not inherit the eTag
+  // A request made to an other resource must not inherit the eTag
   delete headersInherited["if-none-match"]
 
   return headersInherited

package/src/internal/server_ips.js

@@ -0,0 +1,49 @@
+import { networkInterfaces } from "node:os"
+
+export const createIpGetters = () => {
+  const networkAddresses = []
+  const networkInterfaceMap = networkInterfaces()
+  for (const key of Object.keys(networkInterfaceMap)) {
+    for (const networkAddress of networkInterfaceMap[key]) {
+      networkAddresses.push(networkAddress)
+    }
+  }
+  return {
+    getFirstInternalIp: ({ preferIpv6 }) => {
+      const isPref = preferIpv6 ? isIpV6 : isIpV4
+      let firstInternalIp
+      for (const networkAddress of networkAddresses) {
+        if (networkAddress.internal) {
+          firstInternalIp = networkAddress.address
+          if (isPref(networkAddress)) {
+            break
+          }
+        }
+      }
+      return firstInternalIp
+    },
+    getFirstExternalIp: ({ preferIpv6 }) => {
+      const isPref = preferIpv6 ? isIpV6 : isIpV4
+      let firstExternalIp
+      for (const networkAddress of networkAddresses) {
+        if (!networkAddress.internal) {
+          firstExternalIp = networkAddress.address
+          if (isPref(networkAddress)) {
+            break
+          }
+        }
+      }
+      return firstExternalIp
+    },
+  }
+}
+
+const isIpV4 = (networkAddress) => {
+  // node 18.5
+  if (typeof networkAddress.family === "number") {
+    return networkAddress.family === 4
+  }
+  return networkAddress.family === "IPv4"
+}
+
+const isIpV6 = (networkAddress) => !isIpV4(networkAddress)

package/src/main.js

@@ -42,5 +42,5 @@ export { jsenvServiceResponseAcceptanceCheck } from "./services/response_accepta
 export { serveDirectory } from "./serve_directory.js"
 export { fromFetchResponse } from "./from_fetch_response.js"
 export { composeTwoResponses } from "./internal/response_composition.js"
-export { jsenvServiceRessourceAliases } from "./services/ressource_aliases/jsenv_service_ressource_aliases.js"
+export { jsenvServiceRequestAliases } from "./services/request_aliases/jsenv_service_request_aliases.js"
 export { findFreePort } from "./internal/listen.js"

package/src/services/request_aliases/jsenv_service_request_aliases.js

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

package/src/sse/sse_room.js

@@ -37,9 +37,7 @@ export const createSSERoom = ({
 
     const lastKnownId =
       request.headers["last-event-id"] ||
-      new URL(request.ressource, request.origin).searchParams.get(
-        "last-event-id",
-      )
+      new URL(request.url).searchParams.get("last-event-id")
 
     if (clients.size >= maxClientAllowed) {
       return {

package/src/start_server.js

@@ -1,3 +1,4 @@
+import { isIP } from "node:net"
 import http from "node:http"
 import cluster from "node:cluster"
 import { createDetailedMessage, createLogger } from "@jsenv/log"
@@ -23,7 +24,6 @@ import {
   statusToType,
   colorizeResponseStatus,
 } from "./internal/colorizeResponseStatus.js"
-import { getServerOrigins } from "./internal/getServerOrigins.js"
 import { listen, stopListening } from "./internal/listen.js"
 import { composeTwoResponses } from "./internal/response_composition.js"
 import { listenRequest } from "./internal/listenRequest.js"
@@ -40,6 +40,10 @@ import {
 } from "./stopReasons.js"
 import { composeTwoHeaders } from "./internal/headers_composition.js"
 
+import { createIpGetters } from "./internal/server_ips.js"
+import { parseHostname } from "./internal/hostname_parser.js"
+import { applyDnsResolution } from "./internal/dns_resolution.js"
+
 export const startServer = async ({
   signal = new AbortController().signal,
   logLevel,
@@ -52,7 +56,8 @@ export const startServer = async ({
   redirectHttpToHttps,
   allowHttpRequestOnHttps = false,
   acceptAnyIp = false,
-  host = acceptAnyIp ? undefined : "localhost",
+  preferIpv6,
+  hostname = "localhost",
   port = 0, // assign a random available port
   portHint,
   privateKey,
@@ -76,13 +81,15 @@ export const startServer = async ({
       createDetailedMessage(
         `still no response found for request after ${requestWaitingMs} ms`,
         {
-          "request url": `${request.origin}${request.ressource}`,
+          "request url": request.url,
           "request headers": JSON.stringify(request.headers, null, "  "),
         },
       ),
     )
   },
 } = {}) => {
+  const logger = createLogger({ logLevel })
+
   if (protocol !== "http" && protocol !== "https") {
     throw new Error(`protocol must be http or https, got ${protocol}`)
   }
@@ -98,7 +105,6 @@ export const startServer = async ({
     throw new Error(`http2 needs "https" but protocol is "${protocol}"`)
   }
 
-  const logger = createLogger({ logLevel })
   if (
     redirectHttpToHttps === undefined &&
     protocol === "https" &&
@@ -137,6 +143,9 @@ export const startServer = async ({
   let nodeServer
   const startServerOperation = Abort.startOperation()
   const stopCallbackList = createCallbackListNotifiedOnce()
+  const serverOrigins = {
+    local: "", // favors hostname when possible
+  }
 
   try {
     startServerOperation.addAbortSignal(signal)
@@ -163,12 +172,73 @@ export const startServer = async ({
       nodeServer.unref()
     }
 
+    const createOrigin = (hostname) => {
+      if (isIP(hostname) === 6) {
+        return `${protocol}://[${hostname}]`
+      }
+      return `${protocol}://${hostname}`
+    }
+
+    const ipGetters = createIpGetters()
+    let hostnameToListen
+    if (acceptAnyIp) {
+      const firstInternalIp = ipGetters.getFirstInternalIp({ preferIpv6 })
+      serverOrigins.local = createOrigin(firstInternalIp)
+      serverOrigins.localip = createOrigin(firstInternalIp)
+      const firstExternalIp = ipGetters.getFirstExternalIp({ preferIpv6 })
+      serverOrigins.externalip = createOrigin(firstExternalIp)
+      hostnameToListen = preferIpv6 ? "::" : "0.0.0.0"
+    } else {
+      hostnameToListen = hostname
+    }
+    const hostnameInfo = parseHostname(hostname)
+    if (hostnameInfo.type === "ip") {
+      if (acceptAnyIp) {
+        throw new Error(
+          `hostname cannot be an ip when acceptAnyIp is enabled, got ${hostname}`,
+        )
+      }
+
+      preferIpv6 = hostnameInfo.version === 6
+      const firstInternalIp = ipGetters.getFirstInternalIp({ preferIpv6 })
+      serverOrigins.local = createOrigin(firstInternalIp)
+      serverOrigins.localip = createOrigin(firstInternalIp)
+      if (hostnameInfo.label === "unspecified") {
+        const firstExternalIp = ipGetters.getFirstExternalIp({ preferIpv6 })
+        serverOrigins.externalip = createOrigin(firstExternalIp)
+      } else if (hostnameInfo.label === "loopback") {
+      } else {
+        serverOrigins.local = createOrigin(hostname)
+      }
+    } else {
+      const hostnameDnsResolution = await applyDnsResolution(hostname, {
+        verbatim: true,
+      })
+      if (hostnameDnsResolution) {
+        const hostnameIp = hostnameDnsResolution.address
+        serverOrigins.localip = createOrigin(hostnameIp)
+        serverOrigins.local = createOrigin(hostname)
+      } else {
+        const firstInternalIp = ipGetters.getFirstInternalIp({ preferIpv6 })
+        // fallback to internal ip because there is no ip
+        // associated to this hostname on operating system (in hosts file)
+        hostname = firstInternalIp
+        hostnameToListen = firstInternalIp
+        serverOrigins.local = createOrigin(firstInternalIp)
+      }
+    }
+
     port = await listen({
       signal: startServerOperation.signal,
       server: nodeServer,
       port,
       portHint,
-      host,
+      hostname: hostnameToListen,
+    })
+
+    // normalize origins (remove :80 when port is 80 for instance)
+    Object.keys(serverOrigins).forEach((key) => {
+      serverOrigins[key] = new URL(`${serverOrigins[key]}:${port}`).origin
     })
 
     serviceController.callHooks("serverListening", { port })
@@ -180,6 +250,18 @@ export const startServer = async ({
     await startServerOperation.end()
   }
 
+  // the main server origin
+  // - when protocol is http
+  //   node-fetch do not apply local dns resolution to map localhost back to 127.0.0.1
+  //   despites localhost being mapped so we prefer to use the internal ip
+  //   (127.0.0.1)
+  // - when protocol is https
+  //   using the hostname becomes important because the certificate is generated
+  //   for hostnames, not for ips
+  //   so we prefer https://locahost or https://local_hostname
+  //   over the ip
+  const serverOrigin = serverOrigins.local
+
   // now the server is started (listening) it cannot be aborted anymore
   // (otherwise an AbortError is thrown to the code calling "startServer")
   // we can proceed to create a stop function to stop it gacefully
@@ -218,8 +300,6 @@ export const startServer = async ({
   }
 
   status = "opened"
-  const serverOrigins = await getServerOrigins({ protocol, host, port })
-  const serverOrigin = serverOrigins.local
 
   const removeConnectionErrorListener = listenServerConnectionError(
     nodeServer,
@@ -387,7 +467,7 @@ export const startServer = async ({
           addRequestLog(requestNode, {
             type: "error",
             value: createDetailedMessage(
-              `An error occured while pushing a stream to the response for ${request.ressource}`,
+              `An error occured while pushing a stream to the response for ${request.resource}`,
               {
                 "error stack": e.stack,
               },
@@ -492,8 +572,8 @@ export const startServer = async ({
         addRequestLog(requestNode, {
           type: "info",
           value: request.parent
-            ? `Push ${request.ressource}`
-            : `${request.method} ${request.origin}${request.ressource}`,
+            ? `Push ${request.resource}`
+            : `${request.method} ${request.url}`,
         })
         const warn = (value) => {
           addRequestLog(requestNode, {
@@ -829,7 +909,9 @@ export const startServer = async ({
       const { WebSocketServer } = await import("ws")
       let websocketServer = new WebSocketServer({ noServer: true })
       const websocketOrigin =
-        protocol === "https" ? `wss://${host}:${port}` : `ws://${host}:${port}`
+        protocol === "https"
+          ? `wss://${hostname}:${port}`
+          : `ws://${hostname}:${port}`
       server.websocketOrigin = websocketOrigin
       const upgradeCallback = (nodeRequest, socket, head) => {
         websocketServer.handleUpgrade(
@@ -884,6 +966,7 @@ export const startServer = async ({
   Object.assign(server, {
     getStatus: () => status,
     port,
+    hostname,
     origin: serverOrigin,
     origins: serverOrigins,
     nodeServer,

package/src/internal/getServerOrigins.js

@@ -1,74 +0,0 @@
-import { networkInterfaces } from "node:os"
-
-import { applyDnsResolution } from "./dns_resolution.js"
-
-export const getServerOrigins = async ({ protocol, host, port }) => {
-  const isLocal = LOOPBACK_HOSTNAMES.includes(host)
-  const localhostDnsResolution = await applyDnsResolution("localhost")
-  const localOrigin = createServerOrigin({
-    protocol,
-    hostname:
-      localhostDnsResolution.address === "127.0.0.1"
-        ? "localhost"
-        : "127.0.0.1",
-    port,
-  })
-  if (isLocal) {
-    return { local: localOrigin }
-  }
-  const isAnyIp = WILDCARD_HOSTNAMES.includes(host)
-  const networkOrigin = createServerOrigin({
-    protocol,
-    hostname: isAnyIp ? getExternalIp() : host,
-    port,
-  })
-  return {
-    local: localOrigin,
-    network: networkOrigin,
-  }
-}
-
-const LOOPBACK_HOSTNAMES = [
-  "localhost",
-  "127.0.0.1",
-  "::1",
-  "0000:0000:0000:0000:0000:0000:0000:0001",
-]
-
-const WILDCARD_HOSTNAMES = [
-  undefined,
-  "0.0.0.0",
-  "::",
-  "0000:0000:0000:0000:0000:0000:0000:0000",
-]
-
-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 (!isIpV4(networkAddress)) return false
-      internalIPV4NetworkAddress = networkAddress
-      return true
-    })
-  })
-  return internalIPV4NetworkAddress ? internalIPV4NetworkAddress.address : null
-}
-
-const isIpV4 = (networkAddress) => {
-  // node 18+
-  if (typeof networkAddress.family === "number") {
-    return networkAddress.family === 4
-  }
-  return networkAddress.family === "IPv4"
-}

package/src/services/ressource_aliases/jsenv_service_ressource_aliases.js

@@ -1,40 +0,0 @@
-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
-}