@jsenv/server 15.0.2 → 15.0.4

package/src/interfacing_with_node/write_node_response.js

@@ -1,22 +1,22 @@
-import http from "node:http"
-import { Http2ServerResponse } from "node:http2"
-import { raceCallbacks } from "@jsenv/abort"
+import http from "node:http";
+import { Http2ServerResponse } from "node:http2";
+import { raceCallbacks } from "@jsenv/abort";
 
-import { normalizeBodyMethods } from "./body.js"
+import { normalizeBodyMethods } from "./body.js";
 
 export const writeNodeResponse = async (
   responseStream,
   { status, statusText, headers, body, bodyEncoding },
   { signal, ignoreBody, onAbort, onError, onHeadersSent, onEnd } = {},
 ) => {
-  body = await body
-  const bodyMethods = normalizeBodyMethods(body)
+  body = await body;
+  const bodyMethods = normalizeBodyMethods(body);
 
   if (signal.aborted) {
-    bodyMethods.destroy()
-    responseStream.destroy()
-    onAbort()
-    return
+    bodyMethods.destroy();
+    responseStream.destroy();
+    onAbort();
+    return;
   }
 
   writeHead(responseStream, {
@@ -24,31 +24,31 @@ export const writeNodeResponse = async (
     statusText,
     headers,
     onHeadersSent,
-  })
+  });
 
   if (!body) {
-    onEnd()
-    responseStream.end()
-    return
+    onEnd();
+    responseStream.end();
+    return;
   }
 
   if (ignoreBody) {
-    onEnd()
-    bodyMethods.destroy()
-    responseStream.end()
-    return
+    onEnd();
+    bodyMethods.destroy();
+    responseStream.end();
+    return;
   }
 
   if (bodyEncoding) {
-    responseStream.setEncoding(bodyEncoding)
+    responseStream.setEncoding(bodyEncoding);
   }
 
   await new Promise((resolve) => {
-    const observable = bodyMethods.asObservable()
+    const observable = bodyMethods.asObservable();
     const subscription = observable.subscribe({
       next: (data) => {
         try {
-          responseStream.write(data)
+          responseStream.write(data);
         } catch (e) {
           // Something inside Node.js sometimes puts stream
           // in a state where .write() throw despites nodeResponse.destroyed
@@ -59,59 +59,59 @@ export const writeNodeResponse = async (
           // For the record it's "hard" to reproduce but can be by running
           // a lot of tests against a browser in the context of @jsenv/core testing
           if (e.code === "ERR_HTTP2_INVALID_STREAM") {
-            return
+            return;
           }
-          responseStream.emit("error", e)
+          responseStream.emit("error", e);
         }
       },
       error: (value) => {
-        responseStream.emit("error", value)
+        responseStream.emit("error", value);
       },
       complete: () => {
-        responseStream.end()
+        responseStream.end();
       },
-    })
+    });
 
     raceCallbacks(
       {
         abort: (cb) => {
-          signal.addEventListener("abort", cb)
+          signal.addEventListener("abort", cb);
           return () => {
-            signal.removeEventListener("abort", cb)
-          }
+            signal.removeEventListener("abort", cb);
+          };
         },
         error: (cb) => {
-          responseStream.on("error", cb)
+          responseStream.on("error", cb);
           return () => {
-            responseStream.removeListener("error", cb)
-          }
+            responseStream.removeListener("error", cb);
+          };
         },
         close: (cb) => {
-          responseStream.on("close", cb)
+          responseStream.on("close", cb);
           return () => {
-            responseStream.removeListener("close", cb)
-          }
+            responseStream.removeListener("close", cb);
+          };
         },
         finish: (cb) => {
-          responseStream.on("finish", cb)
+          responseStream.on("finish", cb);
           return () => {
-            responseStream.removeListener("finish", cb)
-          }
+            responseStream.removeListener("finish", cb);
+          };
         },
       },
       (winner) => {
         const raceEffects = {
           abort: () => {
-            subscription.unsubscribe()
-            responseStream.destroy()
-            onAbort()
-            resolve()
+            subscription.unsubscribe();
+            responseStream.destroy();
+            onAbort();
+            resolve();
           },
           error: (error) => {
-            subscription.unsubscribe()
-            responseStream.destroy()
-            onError(error)
-            resolve()
+            subscription.unsubscribe();
+            responseStream.destroy();
+            onError(error);
+            resolve();
           },
           close: () => {
             // close body in case nodeResponse is prematurely closed
@@ -119,46 +119,46 @@ export const writeNodeResponse = async (
             // it may happen in case of server sent event
             // where body is kept open to write to client
             // and the browser is reloaded or closed for instance
-            subscription.unsubscribe()
-            responseStream.destroy()
-            onAbort()
-            resolve()
+            subscription.unsubscribe();
+            responseStream.destroy();
+            onAbort();
+            resolve();
           },
           finish: () => {
-            onEnd()
-            resolve()
+            onEnd();
+            resolve();
           },
-        }
-        raceEffects[winner.name](winner.data)
+        };
+        raceEffects[winner.name](winner.data);
       },
-    )
-  })
-}
+    );
+  });
+};
 
 const writeHead = (
   responseStream,
   { status, statusText, headers, onHeadersSent },
 ) => {
   const responseIsHttp2ServerResponse =
-    responseStream instanceof Http2ServerResponse
+    responseStream instanceof Http2ServerResponse;
   const responseIsServerHttp2Stream =
-    responseStream.constructor.name === "ServerHttp2Stream"
+    responseStream.constructor.name === "ServerHttp2Stream";
   let nodeHeaders = headersToNodeHeaders(headers, {
     // https://github.com/nodejs/node/blob/79296dc2d02c0b9872bbfcbb89148ea036a546d0/lib/internal/http2/compat.js#L112
     ignoreConnectionHeader:
       responseIsHttp2ServerResponse || responseIsServerHttp2Stream,
-  })
+  });
   if (statusText === undefined) {
-    statusText = statusTextFromStatus(status)
+    statusText = statusTextFromStatus(status);
   }
   if (responseIsServerHttp2Stream) {
     nodeHeaders = {
       ...nodeHeaders,
       ":status": status,
-    }
-    responseStream.respond(nodeHeaders)
-    onHeadersSent({ nodeHeaders, status, statusText })
-    return
+    };
+    responseStream.respond(nodeHeaders);
+    onHeadersSent({ nodeHeaders, status, statusText });
+    return;
   }
   // nodejs strange signature for writeHead force this
   // https://nodejs.org/api/http.html#http_response_writehead_statuscode_statusmessage_headers
@@ -166,13 +166,13 @@ const writeHead = (
     // https://github.com/nodejs/node/blob/79296dc2d02c0b9872bbfcbb89148ea036a546d0/lib/internal/http2/compat.js#L97
     responseIsHttp2ServerResponse
   ) {
-    responseStream.writeHead(status, nodeHeaders)
-    onHeadersSent({ nodeHeaders, status, statusText })
-    return
+    responseStream.writeHead(status, nodeHeaders);
+    onHeadersSent({ nodeHeaders, status, statusText });
+    return;
   }
 
   try {
-    responseStream.writeHead(status, statusText, nodeHeaders)
+    responseStream.writeHead(status, statusText, nodeHeaders);
   } catch (e) {
     if (
       e.code === "ERR_INVALID_CHAR" &&
@@ -180,29 +180,29 @@ const writeHead = (
     ) {
       throw new Error(`Invalid character in statusMessage
 --- status message ---
-${statusText}`)
+${statusText}`);
     }
-    throw e
+    throw e;
   }
-  onHeadersSent({ nodeHeaders, status, statusText })
-}
+  onHeadersSent({ nodeHeaders, status, statusText });
+};
 
 const statusTextFromStatus = (status) =>
-  http.STATUS_CODES[status] || "not specified"
+  http.STATUS_CODES[status] || "not specified";
 
 const headersToNodeHeaders = (headers, { ignoreConnectionHeader }) => {
-  const nodeHeaders = {}
+  const nodeHeaders = {};
 
   Object.keys(headers).forEach((name) => {
-    if (name === "connection" && ignoreConnectionHeader) return
-    const nodeHeaderName = name in mapping ? mapping[name] : name
-    nodeHeaders[nodeHeaderName] = headers[name]
-  })
+    if (name === "connection" && ignoreConnectionHeader) return;
+    const nodeHeaderName = name in mapping ? mapping[name] : name;
+    nodeHeaders[nodeHeaderName] = headers[name];
+  });
 
-  return nodeHeaders
-}
+  return nodeHeaders;
+};
 
 const mapping = {
   // "content-type": "Content-Type",
   // "last-modified": "Last-Modified",
-}
+};

package/src/internal/colorizeResponseStatus.js

@@ -1,40 +1,40 @@
 // https://github.com/Marak/colors.js/blob/b63ef88e521b42920a9e908848de340b31e68c9d/lib/styles.js#L29
 
-const close = "\x1b[0m"
-const red = "\x1b[31m"
-const green = "\x1b[32m"
-const yellow = "\x1b[33m"
+const close = "\x1b[0m";
+const red = "\x1b[31m";
+const green = "\x1b[32m";
+const yellow = "\x1b[33m";
 // const blue = "\x1b[34m"
-const magenta = "\x1b[35m"
-const cyan = "\x1b[36m"
+const magenta = "\x1b[35m";
+const cyan = "\x1b[36m";
 // const white = "\x1b[37m"
 
 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}`
-  return 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}`;
+  return status;
+};
 
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/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"
-  return "unknown"
-}
+  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";
+  return "unknown";
+};
 
-const statusIsInformation = (status) => status >= 100 && status < 200
+const statusIsInformation = (status) => status >= 100 && status < 200;
 
-const statusIsSuccess = (status) => status >= 200 && status < 300
+const statusIsSuccess = (status) => status >= 200 && status < 300;
 
-const statusIsRedirection = (status) => status >= 300 && status < 400
+const statusIsRedirection = (status) => status >= 300 && status < 400;
 
-const statusIsClientError = (status) => status >= 400 && status < 500
+const statusIsClientError = (status) => status >= 400 && status < 500;
 
-const statusIsServerError = (status) => status >= 500 && status < 600
+const statusIsServerError = (status) => status >= 500 && status < 600;

package/src/internal/convertFileSystemErrorToResponseProperties.js

@@ -4,19 +4,19 @@ export const convertFileSystemErrorToResponseProperties = (error) => {
     return {
       status: 403,
       statusText: `EACCES: No permission to read file at ${error.path}`,
-    }
+    };
   }
   if (isErrorWithCode(error, "EPERM")) {
     return {
       status: 403,
       statusText: `EPERM: No permission to read file at ${error.path}`,
-    }
+    };
   }
   if (isErrorWithCode(error, "ENOENT")) {
     return {
       status: 404,
       statusText: `ENOENT: File not found at ${error.path}`,
-    }
+    };
   }
   // file access may be temporarily blocked
   // (by an antivirus scanning it because recently modified for instance)
@@ -27,7 +27,7 @@ export const convertFileSystemErrorToResponseProperties = (error) => {
       headers: {
         "retry-after": 0.01, // retry in 10ms
       },
-    }
+    };
   }
   // emfile means there is too many files currently opened
   if (isErrorWithCode(error, "EMFILE")) {
@@ -37,17 +37,17 @@ export const convertFileSystemErrorToResponseProperties = (error) => {
       headers: {
         "retry-after": 0.1, // retry in 100ms
       },
-    }
+    };
   }
   if (isErrorWithCode(error, "EISDIR")) {
     return {
       status: 500,
       statusText: `EISDIR: Unexpected directory operation at ${error.path}`,
-    }
+    };
   }
-  return null
-}
+  return null;
+};
 
 const isErrorWithCode = (error, code) => {
-  return typeof error === "object" && error.code === code
-}
+  return typeof error === "object" && error.code === code;
+};

package/src/internal/dns_resolution.js

@@ -1,4 +1,4 @@
-import { lookup } from "node:dns"
+import { lookup } from "node:dns";
 
 export const applyDnsResolution = async (
   hostname,
@@ -7,11 +7,11 @@ export const applyDnsResolution = async (
   const dnsResolution = await new Promise((resolve, reject) => {
     lookup(hostname, { verbatim }, (error, address, family) => {
       if (error) {
-        reject(error)
+        reject(error);
       } else {
-        resolve({ address, family })
+        resolve({ address, family });
       }
-    })
-  })
-  return dnsResolution
-}
+    });
+  });
+  return dnsResolution;
+};

package/src/internal/etag.js

@@ -1,22 +1,22 @@
-import { createHash } from "node:crypto"
+import { createHash } from "node:crypto";
 
-const ETAG_FOR_EMPTY_CONTENT = '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"'
+const ETAG_FOR_EMPTY_CONTENT = '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
 
 export const bufferToEtag = (buffer) => {
   if (!Buffer.isBuffer(buffer)) {
-    throw new TypeError(`buffer expected, got ${buffer}`)
+    throw new TypeError(`buffer expected, got ${buffer}`);
   }
 
   if (buffer.length === 0) {
-    return ETAG_FOR_EMPTY_CONTENT
+    return ETAG_FOR_EMPTY_CONTENT;
   }
 
-  const hash = createHash("sha1")
-  hash.update(buffer, "utf8")
+  const hash = createHash("sha1");
+  hash.update(buffer, "utf8");
 
-  const hashBase64String = hash.digest("base64")
-  const hashBase64StringSubset = hashBase64String.slice(0, 27)
-  const length = buffer.length
+  const hashBase64String = hash.digest("base64");
+  const hashBase64StringSubset = hashBase64String.slice(0, 27);
+  const length = buffer.length;
 
-  return `"${length.toString(16)}-${hashBase64StringSubset}"`
-}
+  return `"${length.toString(16)}-${hashBase64StringSubset}"`;
+};

package/src/internal/filesystem.js

@@ -1,43 +1,43 @@
-import { pathToFileURL, fileURLToPath } from "node:url"
+import { pathToFileURL, fileURLToPath } from "node:url";
 
 export const isFileSystemPath = (value) => {
   if (typeof value !== "string") {
     throw new TypeError(
       `isFileSystemPath first arg must be a string, got ${value}`,
-    )
+    );
   }
 
   if (value[0] === "/") {
-    return true
+    return true;
   }
 
-  return startsWithWindowsDriveLetter(value)
-}
+  return startsWithWindowsDriveLetter(value);
+};
 
 const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0]
-  if (!/[a-zA-Z]/.test(firstChar)) return false
+  const firstChar = string[0];
+  if (!/[a-zA-Z]/.test(firstChar)) return false;
 
-  const secondChar = string[1]
-  if (secondChar !== ":") return false
+  const secondChar = string[1];
+  if (secondChar !== ":") return false;
 
-  return true
-}
+  return true;
+};
 
 export const fileSystemPathToUrl = (value) => {
   if (!isFileSystemPath(value)) {
-    throw new Error(`received an invalid value for fileSystemPath: ${value}`)
+    throw new Error(`received an invalid value for fileSystemPath: ${value}`);
   }
-  return String(pathToFileURL(value))
-}
+  return String(pathToFileURL(value));
+};
 
 export const urlToFileSystemPath = (url) => {
-  let urlString = String(url)
+  let urlString = String(url);
   if (urlString[urlString.length - 1] === "/") {
     // remove trailing / so that nodejs path becomes predictable otherwise it logs
     // the trailing slash on linux but does not on windows
-    urlString = urlString.slice(0, -1)
+    urlString = urlString.slice(0, -1);
   }
-  const fileSystemPath = fileURLToPath(urlString)
-  return fileSystemPath
-}
+  const fileSystemPath = fileURLToPath(urlString);
+  return fileSystemPath;
+};

package/src/internal/headersFromObject.js

@@ -3,21 +3,21 @@ https://developer.mozilla.org/en-US/docs/Web/API/Headers
 https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch
 */
 
-import { normalizeHeaderName } from "./normalizeHeaderName.js"
-import { normalizeHeaderValue } from "./normalizeHeaderValue.js"
+import { normalizeHeaderName } from "./normalizeHeaderName.js";
+import { normalizeHeaderValue } from "./normalizeHeaderValue.js";
 
 export const headersFromObject = (headersObject) => {
-  const headers = {}
+  const headers = {};
 
   Object.keys(headersObject).forEach((headerName) => {
     if (headerName[0] === ":") {
       // exclude http2 headers
-      return
+      return;
     }
     headers[normalizeHeaderName(headerName)] = normalizeHeaderValue(
       headersObject[headerName],
-    )
-  })
+    );
+  });
 
-  return headers
-}
+  return headers;
+};

package/src/internal/headersFromString.js

@@ -1,21 +1,21 @@
-import { normalizeHeaderName } from "./normalizeHeaderName.js"
-import { normalizeHeaderValue } from "./normalizeHeaderValue.js"
+import { normalizeHeaderName } from "./normalizeHeaderName.js";
+import { normalizeHeaderValue } from "./normalizeHeaderValue.js";
 
 // https://gist.github.com/mmazer/5404301
 export const headersFromString = (headerString) => {
-  const headers = {}
+  const headers = {};
 
   if (headerString) {
-    const pairs = headerString.split("\r\n")
+    const pairs = headerString.split("\r\n");
     pairs.forEach((pair) => {
-      const index = pair.indexOf(": ")
+      const index = pair.indexOf(": ");
       if (index > 0) {
-        const key = pair.slice(0, index)
-        const value = pair.slice(index + 2)
-        headers[normalizeHeaderName(key)] = normalizeHeaderValue(value)
+        const key = pair.slice(0, index);
+        const value = pair.slice(index + 2);
+        headers[normalizeHeaderName(key)] = normalizeHeaderValue(value);
       }
-    })
+    });
   }
 
-  return headers
-}
+  return headers;
+};

package/src/internal/headersToObject.js

@@ -1,7 +1,7 @@
 export const headersToObject = (headers) => {
-  const headersObject = {}
+  const headersObject = {};
   headers.forEach((value, name) => {
-    headersObject[name] = value
-  })
-  return headersObject
-}
+    headersObject[name] = value;
+  });
+  return headersObject;
+};

package/src/internal/headersToString.js

@@ -1,16 +1,16 @@
 export const headersToString = (headers, { convertName = (name) => name }) => {
   const headersString = headersToArray(headers).map(({ name, value }) => {
-    return `${convertName(name)}: ${value}`
-  })
+    return `${convertName(name)}: ${value}`;
+  });
 
-  return headersString.join("\r\n")
-}
+  return headersString.join("\r\n");
+};
 
 const headersToArray = (headers) => {
   return Object.keys(headers).map((name) => {
     return {
       name,
       value: headers[name],
-    }
-  })
-}
+    };
+  });
+};

package/src/internal/headers_composition.js

@@ -1,21 +1,21 @@
-import { composeTwoObjects } from "./object_composition.js"
+import { composeTwoObjects } from "./object_composition.js";
 
 export const composeTwoHeaders = (firstHeaders, secondHeaders) => {
   return composeTwoObjects(firstHeaders, secondHeaders, {
     keysComposition: HEADER_NAMES_COMPOSITION,
     forceLowerCase: true,
-  })
-}
+  });
+};
 
 const composeHeaderValues = (value, nextValue) => {
-  const headerValues = value.split(", ")
+  const headerValues = value.split(", ");
   nextValue.split(", ").forEach((value) => {
     if (!headerValues.includes(value)) {
-      headerValues.push(value)
+      headerValues.push(value);
     }
-  })
-  return headerValues.join(", ")
-}
+  });
+  return headerValues.join(", ");
+};
 
 const HEADER_NAMES_COMPOSITION = {
   "accept": composeHeaderValues,
@@ -29,4 +29,4 @@ const HEADER_NAMES_COMPOSITION = {
   "server-timing": composeHeaderValues,
   // 'content-type', // https://github.com/ninenines/cowboy/issues/1230
   "vary": composeHeaderValues,
-}
+};