@jsenv/server 15.0.1 → 15.0.3

package/src/internal/object_composition.js

@@ -7,14 +7,14 @@ export const composeTwoObjects = (
     return applyCompositionForcingLowerCase(firstObject, secondObject, {
       keysComposition,
       strict,
-    })
+    });
   }
 
   return applyCaseSensitiveComposition(firstObject, secondObject, {
     keysComposition,
     strict,
-  })
-}
+  });
+};
 
 const applyCaseSensitiveComposition = (
   firstObject,
@@ -22,7 +22,7 @@ const applyCaseSensitiveComposition = (
   { keysComposition, strict },
 ) => {
   if (strict) {
-    const composed = {}
+    const composed = {};
     Object.keys(keysComposition).forEach((key) => {
       composed[key] = composeValueAtKey({
         firstObject,
@@ -31,15 +31,15 @@ const applyCaseSensitiveComposition = (
         key,
         firstKey: keyExistsIn(key, firstObject) ? key : null,
         secondKey: keyExistsIn(key, secondObject) ? key : null,
-      })
-    })
-    return composed
+      });
+    });
+    return composed;
   }
 
-  const composed = {}
+  const composed = {};
   Object.keys(firstObject).forEach((key) => {
-    composed[key] = firstObject[key]
-  })
+    composed[key] = firstObject[key];
+  });
   Object.keys(secondObject).forEach((key) => {
     composed[key] = composeValueAtKey({
       firstObject,
@@ -48,10 +48,10 @@ const applyCaseSensitiveComposition = (
       key,
       firstKey: keyExistsIn(key, firstObject) ? key : null,
       secondKey: keyExistsIn(key, secondObject) ? key : null,
-    })
-  })
-  return composed
-}
+    });
+  });
+  return composed;
+};
 
 const applyCompositionForcingLowerCase = (
   firstObject,
@@ -59,14 +59,14 @@ const applyCompositionForcingLowerCase = (
   { keysComposition, strict },
 ) => {
   if (strict) {
-    const firstObjectKeyMapping = {}
+    const firstObjectKeyMapping = {};
     Object.keys(firstObject).forEach((key) => {
-      firstObjectKeyMapping[key.toLowerCase()] = key
-    })
-    const secondObjectKeyMapping = {}
+      firstObjectKeyMapping[key.toLowerCase()] = key;
+    });
+    const secondObjectKeyMapping = {};
     Object.keys(secondObject).forEach((key) => {
-      secondObjectKeyMapping[key.toLowerCase()] = key
-    })
+      secondObjectKeyMapping[key.toLowerCase()] = key;
+    });
     Object.keys(keysComposition).forEach((key) => {
       composed[key] = composeValueAtKey({
         firstObject,
@@ -75,16 +75,16 @@ const applyCompositionForcingLowerCase = (
         key,
         firstKey: firstObjectKeyMapping[key] || null,
         secondKey: secondObjectKeyMapping[key] || null,
-      })
-    })
+      });
+    });
   }
 
-  const composed = {}
+  const composed = {};
   Object.keys(firstObject).forEach((key) => {
-    composed[key.toLowerCase()] = firstObject[key]
-  })
+    composed[key.toLowerCase()] = firstObject[key];
+  });
   Object.keys(secondObject).forEach((key) => {
-    const keyLowercased = key.toLowerCase()
+    const keyLowercased = key.toLowerCase();
 
     composed[key.toLowerCase()] = composeValueAtKey({
       firstObject,
@@ -101,10 +101,10 @@ const applyCompositionForcingLowerCase = (
         : keyExistsIn(key, secondObject)
         ? key
         : null,
-    })
-  })
-  return composed
-}
+    });
+  });
+  return composed;
+};
 
 const composeValueAtKey = ({
   firstObject,
@@ -115,22 +115,24 @@ const composeValueAtKey = ({
   keysComposition,
 }) => {
   if (!firstKey) {
-    return secondObject[secondKey]
+    return secondObject[secondKey];
   }
 
   if (!secondKey) {
-    return firstObject[firstKey]
+    return firstObject[firstKey];
   }
 
-  const keyForCustomComposition = keyExistsIn(key, keysComposition) ? key : null
+  const keyForCustomComposition = keyExistsIn(key, keysComposition)
+    ? key
+    : null;
   if (!keyForCustomComposition) {
-    return secondObject[secondKey]
+    return secondObject[secondKey];
   }
 
-  const composeTwoValues = keysComposition[keyForCustomComposition]
-  return composeTwoValues(firstObject[firstKey], secondObject[secondKey])
-}
+  const composeTwoValues = keysComposition[keyForCustomComposition];
+  return composeTwoValues(firstObject[firstKey], secondObject[secondKey]);
+};
 
 const keyExistsIn = (key, object) => {
-  return Object.prototype.hasOwnProperty.call(object, key)
-}
+  return Object.prototype.hasOwnProperty.call(object, key);
+};

package/src/internal/response_composition.js

@@ -1,12 +1,12 @@
-import { composeTwoObjects } from "./object_composition.js"
-import { composeTwoHeaders } from "./headers_composition.js"
+import { composeTwoObjects } from "./object_composition.js";
+import { composeTwoHeaders } from "./headers_composition.js";
 
 export const composeTwoResponses = (firstResponse, secondResponse) => {
   return composeTwoObjects(firstResponse, secondResponse, {
     keysComposition: RESPONSE_KEYS_COMPOSITION,
     strict: true,
-  })
-}
+  });
+};
 
 const RESPONSE_KEYS_COMPOSITION = {
   status: (prevStatus, status) => status,
@@ -16,6 +16,6 @@ const RESPONSE_KEYS_COMPOSITION = {
   body: (prevBody, body) => body,
   bodyEncoding: (prevEncoding, encoding) => encoding,
   timing: (prevTiming, timing) => {
-    return { ...prevTiming, ...timing }
+    return { ...prevTiming, ...timing };
   },
-}
+};

package/src/internal/server-polyglot.js

@@ -4,9 +4,9 @@ https://stackoverflow.com/a/42019773/2634179
 
 */
 
-import http from "node:http"
-import net from "node:net"
-import { listenEvent } from "./listenEvent.js"
+import http from "node:http";
+import net from "node:net";
+import { listenEvent } from "./listenEvent.js";
 
 export const createPolyglotServer = async ({
   http2 = false,
@@ -14,27 +14,27 @@ export const createPolyglotServer = async ({
   certificate,
   privateKey,
 }) => {
-  const httpServer = http.createServer()
+  const httpServer = http.createServer();
   const tlsServer = await createSecureServer({
     certificate,
     privateKey,
     http2,
     http1Allowed,
-  })
+  });
   const netServer = net.createServer({
     allowHalfOpen: false,
-  })
+  });
 
   listenEvent(netServer, "connection", (socket) => {
     detectSocketProtocol(socket, (protocol) => {
       if (protocol === "http") {
-        httpServer.emit("connection", socket)
-        return
+        httpServer.emit("connection", socket);
+        return;
       }
 
       if (protocol === "tls") {
-        tlsServer.emit("connection", socket)
-        return
+        tlsServer.emit("connection", socket);
+        return;
       }
 
       const response = [
@@ -42,23 +42,23 @@ export const createPolyglotServer = async ({
         `Content-Length: 0`,
         "",
         "",
-      ].join("\r\n")
-      socket.write(response)
-      socket.end()
-      socket.destroy()
+      ].join("\r\n");
+      socket.write(response);
+      socket.end();
+      socket.destroy();
       netServer.emit(
         "clientError",
         new Error("protocol error, Neither http, nor tls"),
         socket,
-      )
-    })
-  })
+      );
+    });
+  });
 
-  netServer._httpServer = httpServer
-  netServer._tlsServer = tlsServer
+  netServer._httpServer = httpServer;
+  netServer._tlsServer = tlsServer;
 
-  return netServer
-}
+  return netServer;
+};
 
 // The async part is just to lazyly import "http2" or "https"
 // so that these module are parsed only if used.
@@ -70,47 +70,47 @@ const createSecureServer = async ({
   http1Allowed,
 }) => {
   if (http2) {
-    const { createSecureServer } = await import("node:http2")
+    const { createSecureServer } = await import("node:http2");
     return createSecureServer({
       cert: certificate,
       key: privateKey,
       allowHTTP1: http1Allowed,
-    })
+    });
   }
 
-  const { createServer } = await import("node:https")
+  const { createServer } = await import("node:https");
   return createServer({
     cert: certificate,
     key: privateKey,
-  })
-}
+  });
+};
 
 const detectSocketProtocol = (socket, protocolDetectedCallback) => {
-  let removeOnceReadableListener = () => {}
+  let removeOnceReadableListener = () => {};
 
   const tryToRead = () => {
-    const buffer = socket.read(1)
+    const buffer = socket.read(1);
     if (buffer === null) {
-      removeOnceReadableListener = socket.once("readable", tryToRead)
-      return
+      removeOnceReadableListener = socket.once("readable", tryToRead);
+      return;
     }
 
-    const firstByte = buffer[0]
-    socket.unshift(buffer)
+    const firstByte = buffer[0];
+    socket.unshift(buffer);
     if (firstByte === 22) {
-      protocolDetectedCallback("tls")
-      return
+      protocolDetectedCallback("tls");
+      return;
     }
     if (firstByte > 32 && firstByte < 127) {
-      protocolDetectedCallback("http")
-      return
+      protocolDetectedCallback("http");
+      return;
     }
-    protocolDetectedCallback(null)
-  }
+    protocolDetectedCallback(null);
+  };
 
-  tryToRead()
+  tryToRead();
 
   return () => {
-    removeOnceReadableListener()
-  }
-}
+    removeOnceReadableListener();
+  };
+};

package/src/internal/server_ips.js

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

package/src/internal/trackServerPendingConnections.js

@@ -1,64 +1,64 @@
-import { listenEvent } from "./listenEvent.js"
+import { listenEvent } from "./listenEvent.js";
 
 export const trackServerPendingConnections = (nodeServer, { http2 }) => {
   if (http2) {
     // see http2.js: we rely on https://nodejs.org/api/http2.html#http2_compatibility_api
-    return trackHttp1ServerPendingConnections(nodeServer)
+    return trackHttp1ServerPendingConnections(nodeServer);
   }
-  return trackHttp1ServerPendingConnections(nodeServer)
-}
+  return trackHttp1ServerPendingConnections(nodeServer);
+};
 
 // const trackHttp2ServerPendingSessions = () => {}
 
 const trackHttp1ServerPendingConnections = (nodeServer) => {
-  const pendingConnections = new Set()
+  const pendingConnections = new Set();
 
   const removeConnectionListener = listenEvent(
     nodeServer,
     "connection",
     (connection) => {
-      pendingConnections.add(connection)
+      pendingConnections.add(connection);
       listenEvent(
         connection,
         "close",
         () => {
-          pendingConnections.delete(connection)
+          pendingConnections.delete(connection);
         },
         { once: true },
-      )
+      );
     },
-  )
+  );
 
   const stop = async (reason) => {
-    removeConnectionListener()
-    const pendingConnectionsArray = Array.from(pendingConnections)
-    pendingConnections.clear()
+    removeConnectionListener();
+    const pendingConnectionsArray = Array.from(pendingConnections);
+    pendingConnections.clear();
 
     await Promise.all(
       pendingConnectionsArray.map(async (pendingConnection) => {
-        await destroyConnection(pendingConnection, reason)
+        await destroyConnection(pendingConnection, reason);
       }),
-    )
-  }
+    );
+  };
 
-  return { stop }
-}
+  return { stop };
+};
 
 const destroyConnection = (connection, reason) => {
   return new Promise((resolve, reject) => {
     connection.destroy(reason, (error) => {
       if (error) {
         if (error === reason || error.code === "ENOTCONN") {
-          resolve()
+          resolve();
         } else {
-          reject(error)
+          reject(error);
         }
       } else {
-        resolve()
+        resolve();
       }
-    })
-  })
-}
+    });
+  });
+};
 
 // export const trackServerPendingStreams = (nodeServer) => {
 //   const pendingClients = new Set()

package/src/internal/trackServerPendingRequests.js

@@ -1,68 +1,68 @@
-import { listenRequest } from "./listenRequest.js"
+import { listenRequest } from "./listenRequest.js";
 
 export const trackServerPendingRequests = (nodeServer, { http2 }) => {
   if (http2) {
     // see http2.js: we rely on https://nodejs.org/api/http2.html#http2_compatibility_api
-    return trackHttp1ServerPendingRequests(nodeServer)
+    return trackHttp1ServerPendingRequests(nodeServer);
   }
-  return trackHttp1ServerPendingRequests(nodeServer)
-}
+  return trackHttp1ServerPendingRequests(nodeServer);
+};
 
 const trackHttp1ServerPendingRequests = (nodeServer) => {
-  const pendingClients = new Set()
+  const pendingClients = new Set();
 
   const removeRequestListener = listenRequest(
     nodeServer,
     (nodeRequest, nodeResponse) => {
-      const client = { nodeRequest, nodeResponse }
-      pendingClients.add(client)
+      const client = { nodeRequest, nodeResponse };
+      pendingClients.add(client);
       nodeResponse.once("close", () => {
-        pendingClients.delete(client)
-      })
+        pendingClients.delete(client);
+      });
     },
-  )
+  );
 
   const stop = async ({ status, reason }) => {
-    removeRequestListener()
-    const pendingClientsArray = Array.from(pendingClients)
-    pendingClients.clear()
+    removeRequestListener();
+    const pendingClientsArray = Array.from(pendingClients);
+    pendingClients.clear();
     await Promise.all(
       pendingClientsArray.map(({ nodeResponse }) => {
         if (nodeResponse.headersSent === false) {
-          nodeResponse.writeHead(status, String(reason))
+          nodeResponse.writeHead(status, String(reason));
         }
 
         // http2
         if (nodeResponse.close) {
           return new Promise((resolve, reject) => {
             if (nodeResponse.closed) {
-              resolve()
+              resolve();
             } else {
               nodeResponse.close((error) => {
                 if (error) {
-                  reject(error)
+                  reject(error);
                 } else {
-                  resolve()
+                  resolve();
                 }
-              })
+              });
             }
-          })
+          });
         }
 
         // http
         return new Promise((resolve) => {
           if (nodeResponse.destroyed) {
-            resolve()
+            resolve();
           } else {
             nodeResponse.once("close", () => {
-              resolve()
-            })
-            nodeResponse.destroy()
+              resolve();
+            });
+            nodeResponse.destroy();
           }
-        })
+        });
       }),
-    )
-  }
+    );
+  };
 
-  return { stop }
-}
+  return { stop };
+};

package/src/main.js

@@ -4,10 +4,10 @@
  * Ideally this file should be kept simple to help discovering codebase progressively.
  */
 
-export { startServer } from "./start_server.js"
-export { setupRoutes } from "./service_composition/routing.js"
-export { readRequestBody } from "./readRequestBody.js"
-export { fetchFileSystem } from "./fetch_filesystem.js"
+export { startServer } from "./start_server.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,
@@ -16,31 +16,31 @@ export {
   STOP_REASON_PROCESS_BEFORE_EXIT,
   STOP_REASON_PROCESS_EXIT,
   STOP_REASON_NOT_SPECIFIED,
-} from "./stopReasons.js"
-export { jsenvServiceErrorHandler } from "./services/error_handler/jsenv_service_error_handler.js"
+} from "./stopReasons.js";
+export { jsenvServiceErrorHandler } from "./services/error_handler/jsenv_service_error_handler.js";
 
 // CORS
 export {
   jsenvServiceCORS,
   jsenvAccessControlAllowedHeaders,
   jsenvAccessControlAllowedMethods,
-} from "./services/cors/jsenv_service_cors.js"
+} from "./services/cors/jsenv_service_cors.js";
 
 // server timing
-export { timeFunction, timeStart } from "./server_timing/timing_measure.js"
+export { timeFunction, timeStart } from "./server_timing/timing_measure.js";
 
 // SSE
-export { createSSERoom } from "./sse/sse_room.js"
+export { createSSERoom } from "./sse/sse_room.js";
 
 // content-negotiation
-export { pickContentType } from "./content_negotiation/pick_content_type.js"
-export { pickContentEncoding } from "./content_negotiation/pick_content_encoding.js"
-export { pickContentLanguage } from "./content_negotiation/pick_content_language.js"
-export { jsenvServiceResponseAcceptanceCheck } from "./services/response_acceptance_check/jsenv_service_response_acceptance_check.js"
+export { pickContentType } from "./content_negotiation/pick_content_type.js";
+export { pickContentEncoding } from "./content_negotiation/pick_content_encoding.js";
+export { pickContentLanguage } from "./content_negotiation/pick_content_language.js";
+export { jsenvServiceResponseAcceptanceCheck } from "./services/response_acceptance_check/jsenv_service_response_acceptance_check.js";
 
 // others
-export { serveDirectory } from "./serve_directory.js"
-export { fromFetchResponse } from "./from_fetch_response.js"
-export { composeTwoResponses } from "./internal/response_composition.js"
-export { jsenvServiceRequestAliases } from "./services/request_aliases/jsenv_service_request_aliases.js"
-export { findFreePort } from "./internal/listen.js"
+export { serveDirectory } from "./serve_directory.js";
+export { fromFetchResponse } from "./from_fetch_response.js";
+export { composeTwoResponses } from "./internal/response_composition.js";
+export { jsenvServiceRequestAliases } from "./services/request_aliases/jsenv_service_request_aliases.js";
+export { findFreePort } from "./internal/listen.js";