@jsenv/server 12.5.8 → 12.6.1

package/README.md

@@ -1,4 +1,4 @@
-# server [![npm package](https://img.shields.io/npm/v/@jsenv/server.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/server) [![github workflow](https://github.com/jsenv/server/workflows/main/badge.svg)](https://github.com/jsenv/server/actions?workflow=main) [![codecov coverage](https://codecov.io/gh/jsenv/server/branch/main/graph/badge.svg)](https://codecov.io/gh/jsenv/server)
+# server [![npm package](https://img.shields.io/npm/v/@jsenv/server.svg?logo=npm&label=package)](https://www.npmjs.com/package/@jsenv/server)
 
 `@jsenv/server` helps to write flexible server code with a declarative API.
 
@@ -7,7 +7,6 @@ import { startServer } from "@jsenv/server"
 
 await startServer({
   protocol: "http",
-  ip: "127.0.0.1",
   port: 8080,
   requestToResponse: () => {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "12.5.8",
+  "version": "12.6.1",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -16,8 +16,7 @@
     "node": ">=16.13.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "exports": {
@@ -68,4 +67,4 @@
     "playwright": "1.18.1",
     "prettier": "2.5.1"
   }
-}
+}

package/src/fetch_filesystem.js

@@ -39,20 +39,37 @@ export const fetchFileSystem = async (
       ? "private,max-age=0,must-revalidate"
       : "no-store",
     canReadDirectory = false,
-    rootDirectoryUrl,
+    rootDirectoryUrl, //  = `${pathToFileURL(process.cwd())}/`,
   } = {},
 ) => {
   const urlString = asUrlString(filesystemUrl)
   if (!urlString) {
-    return send500DueToFilesystemUrlParameter(
+    return create500Response(
       `fetchFileSystem first parameter must be a file url, got ${filesystemUrl}`,
     )
   }
   if (!urlString.startsWith("file://")) {
-    return send500DueToFilesystemUrlParameter(
+    return create500Response(
       `fetchFileSystem url must use "file://" scheme, got ${filesystemUrl}`,
     )
   }
+  if (rootDirectoryUrl) {
+    let rootDirectoryUrlString = asUrlString(rootDirectoryUrl)
+    if (!rootDirectoryUrlString) {
+      return create500Response(
+        `rootDirectoryUrl must be a string or an url, got ${rootDirectoryUrl}`,
+      )
+    }
+    if (!rootDirectoryUrlString.endsWith("/")) {
+      rootDirectoryUrlString = `${rootDirectoryUrlString}/`
+    }
+    if (!urlString.startsWith(rootDirectoryUrlString)) {
+      return create500Response(
+        `fetchFileSystem url must be inside root directory, got ${urlString}`,
+      )
+    }
+    rootDirectoryUrl = rootDirectoryUrlString
+  }
 
   // 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)
@@ -180,7 +197,7 @@ export const fetchFileSystem = async (
   }
 }
 
-const send500DueToFilesystemUrlParameter = (message) => {
+const create500Response = (message) => {
   return {
     status: 500,
     headers: {
@@ -419,12 +436,10 @@ const asUrlString = (value) => {
   if (value instanceof URL) {
     return value.href
   }
-
   if (typeof value === "string") {
     if (isFileSystemPath(value)) {
       return fileSystemPathToUrl(value)
     }
-
     try {
       const urlObject = new URL(value)
       return String(urlObject)
@@ -432,6 +447,5 @@ const asUrlString = (value) => {
       return null
     }
   }
-
   return null
 }

package/src/fetch_url.js

@@ -28,12 +28,11 @@ export const fetchUrl = async (
   }
 
   if (url.startsWith("file://")) {
-    const origin = new URL(url).origin
     const responseProperties = await fetchFileSystem(url, {
       signal,
       method,
       headers,
-      rootDirectoryUrl: origin,
+      rootDirectoryUrl: "file://",
       cacheStrategy,
       canReadDirectory,
       contentTypeMap,

package/src/internal/colorizeResponseStatus.js

@@ -11,22 +11,21 @@ const cyan = "\x1b[36m"
 
 export const colorizeResponseStatus = (status) => {
   const statusType = statusToType(status)
-
   if (statusType === "information") return `${cyan}${status}${close}`
   if (statusType === "success") return `${green}${status}${close}`
   if (statusType === "redirection") return `${magenta}${status}${close}`
-  if (statusType === "client-error") return `${yellow}${status}${close}`
-  if (statusType === "server-error") return `${red}${status}${close}`
+  if (statusType === "client_error") return `${yellow}${status}${close}`
+  if (statusType === "server_error") return `${red}${status}${close}`
   return status
 }
 
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
-const statusToType = (status) => {
+export const statusToType = (status) => {
   if (statusIsInformation(status)) return "information"
   if (statusIsSuccess(status)) return "success"
   if (statusIsRedirection(status)) return "redirection"
-  if (statusIsClientError(status)) return "client-error"
-  if (statusIsServerError(status)) return "server-error"
+  if (statusIsClientError(status)) return "client_error"
+  if (statusIsServerError(status)) return "server_error"
   return "unknown"
 }
 

package/src/internal/getServerOrigins.js

@@ -2,43 +2,37 @@ import { networkInterfaces } from "os"
 import { URL } from "url"
 
 export const getServerOrigins = ({ protocol, ip, port }) => {
+  const isInternalIp = ip === "127.0.0.1"
+  const internalOrigin = createServerOrigin({
+    protocol,
+    hostname: "localhost",
+    port,
+  })
+  if (isInternalIp) {
+    return { internal: internalOrigin }
+  }
+  const isAnyIp = !ip || ip === "::" || ip === "0.0.0.0"
   return {
-    main: createServerOrigin({ protocol, ip, port }),
-    external: createServerOrigin({ protocol, ip: getExternalIp(ip), port }),
+    internal: internalOrigin,
+    external: createServerOrigin({
+      protocol,
+      hostname: isAnyIp ? getExternalIp(ip) : ip,
+      port,
+    }),
   }
 }
 
-const createServerOrigin = ({ protocol, ip, port }) => {
+const createServerOrigin = ({ protocol, hostname, port }) => {
   const url = new URL("https://127.0.0.1:80")
-
   url.protocol = protocol
-  url.hostname = ipToHostname(ip)
+  url.hostname = hostname
   url.port = port
-
   return url.origin
 }
 
-const ipToHostname = (
-  ip,
-  {
-    preferLocalhost = true,
-    preferLocalIp = false,
-    preferExternalIp = false,
-  } = {},
-) => {
-  if (ip === "0.0.0.0" || !ip) {
-    if (preferLocalhost) return "localhost"
-    if (preferLocalIp) return "127.0.0.1"
-    if (preferExternalIp) return getExternalIp(ip) || "0.0.0.0"
-    return "0.0.0.0"
-  }
-  return ip
-}
-
 const getExternalIp = () => {
   const networkInterfaceMap = networkInterfaces()
   let internalIPV4NetworkAddress
-
   Object.keys(networkInterfaceMap).find((key) => {
     const networkAddressArray = networkInterfaceMap[key]
     return networkAddressArray.find((networkAddress) => {
@@ -48,6 +42,5 @@ const getExternalIp = () => {
       return true
     })
   })
-
   return internalIPV4NetworkAddress ? internalIPV4NetworkAddress.address : null
 }

package/src/internal/listen.js

@@ -20,7 +20,6 @@ const listen = async ({
         ip,
       })
     }
-
     listeningOperation.throwIfAborted()
     port = await startListening({ server, port, ip })
     listeningOperation.addAbortCallback(() => stopListening(server))
@@ -43,7 +42,6 @@ export const findFreePort = async (
   } = {},
 ) => {
   const findFreePortOperation = Abort.startOperation()
-
   try {
     findFreePortOperation.addAbortSignal(signal)
     findFreePortOperation.throwIfAborted()
@@ -61,7 +59,6 @@ export const findFreePort = async (
       }
       return testUntil(nextPort, ip)
     }
-
     const freePort = await testUntil(initialPort, ip)
     return freePort
   } finally {

package/src/serve_directory.js

@@ -1,11 +1,10 @@
 import { readdirSync } from "node:fs"
-import { pathToFileURL } from "node:url"
 
 import { negotiateContentType } from "./content_negotiation/negotiateContentType.js"
 
 export const serveDirectory = (
   url,
-  { headers = {}, rootDirectoryUrl = `${pathToFileURL(process.cwd())}/` } = {},
+  { headers = {}, rootDirectoryUrl } = {},
 ) => {
   url = String(url)
   url = url[url.length - 1] === "/" ? url : `${url}/`

package/src/startServer.js

@@ -16,7 +16,10 @@ import {
   applyRedirectionToRequest,
 } from "./internal/request_factory.js"
 import { populateNodeResponse } from "./internal/populateNodeResponse.js"
-import { colorizeResponseStatus } from "./internal/colorizeResponseStatus.js"
+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"
@@ -37,6 +40,7 @@ import {
 export const startServer = async ({
   signal = new AbortController().signal,
   logLevel,
+  startLog = true,
   serverName = "server",
 
   protocol = "http",
@@ -44,7 +48,8 @@ export const startServer = async ({
   http1Allowed = true,
   redirectHttpToHttps,
   allowHttpRequestOnHttps = false,
-  ip = "0.0.0.0", // will it work on windows ? https://github.com/nodejs/node/issues/14900
+  listenAnyIp = false,
+  ip = listenAnyIp ? undefined : "127.0.0.1",
   port = 0, // assign a random available port
   portHint,
   privateKey,
@@ -204,7 +209,7 @@ export const startServer = async ({
 
   status = "opened"
   const serverOrigins = getServerOrigins({ protocol, ip, port })
-  const serverOrigin = serverOrigins.main
+  const serverOrigin = serverOrigins.internal
 
   const removeConnectionErrorListener = listenServerConnectionError(
     nodeServer,
@@ -676,8 +681,15 @@ export const startServer = async ({
           onRequestHandled(requestNode)
         },
         onHeadersSent: ({ status, statusText }) => {
+          const statusType = statusToType(status)
           addRequestLog(requestNode, {
-            type: "info",
+            type: {
+              information: "info",
+              success: "info",
+              redirection: "info",
+              client_error: "warn",
+              server_error: "error",
+            }[statusType],
             value: `${colorizeResponseStatus(status)} ${
               responseProperties.statusMessage || statusText
             }`,
@@ -724,9 +736,11 @@ export const startServer = async ({
   // ensure we don't try to handle new requests while server is stopping
   stopCallbackList.add(removeRequestListener)
 
-  logger.info(
-    `${serverName} started at ${serverOrigin} (${serverOrigins.external})`,
-  )
+  if (startLog) {
+    logger.info(
+      `${serverName} started at ${serverOrigin} (${serverOrigins.external})`,
+    )
+  }
 
   const addEffect = (callback) => {
     const cleanup = callback()
@@ -738,6 +752,7 @@ export const startServer = async ({
   return {
     getStatus: () => status,
     origin: serverOrigin,
+    origins: serverOrigins,
     nodeServer,
     stop,
     stoppedPromise,