@jsenv/server 15.0.2 → 15.0.4

package/src/start_server.js

@@ -1,33 +1,33 @@
-import { isIP } from "node:net"
-import cluster from "node:cluster"
-import { createDetailedMessage, createLogger } from "@jsenv/log"
+import { isIP } from "node:net";
+import cluster from "node:cluster";
+import { createDetailedMessage, createLogger } from "@jsenv/log";
 import {
   Abort,
   raceProcessTeardownEvents,
   createCallbackListNotifiedOnce,
-} from "@jsenv/abort"
-import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
+} from "@jsenv/abort";
+import { memoize } from "@jsenv/utils/src/memoize/memoize.js";
 
-import { createServiceController } from "./service_controller.js"
-import { timingToServerTimingResponseHeaders } from "./server_timing/timing_header.js"
-import { createPolyglotServer } from "./internal/server-polyglot.js"
-import { trackServerPendingConnections } from "./internal/trackServerPendingConnections.js"
-import { trackServerPendingRequests } from "./internal/trackServerPendingRequests.js"
+import { createServiceController } from "./service_controller.js";
+import { timingToServerTimingResponseHeaders } from "./server_timing/timing_header.js";
+import { createPolyglotServer } from "./internal/server-polyglot.js";
+import { trackServerPendingConnections } from "./internal/trackServerPendingConnections.js";
+import { trackServerPendingRequests } from "./internal/trackServerPendingRequests.js";
 import {
   fromNodeRequest,
   createPushRequest,
   applyRedirectionToRequest,
-} from "./interfacing_with_node/request_factory.js"
-import { writeNodeResponse } from "./interfacing_with_node/write_node_response.js"
+} from "./interfacing_with_node/request_factory.js";
+import { writeNodeResponse } from "./interfacing_with_node/write_node_response.js";
 import {
   statusToType,
   colorizeResponseStatus,
-} from "./internal/colorizeResponseStatus.js"
-import { listen, stopListening } from "./internal/listen.js"
-import { composeTwoResponses } from "./internal/response_composition.js"
-import { listenRequest } from "./internal/listenRequest.js"
-import { listenEvent } from "./internal/listenEvent.js"
-import { listenServerConnectionError } from "./internal/listenServerConnectionError.js"
+} from "./internal/colorizeResponseStatus.js";
+import { listen, stopListening } from "./internal/listen.js";
+import { composeTwoResponses } from "./internal/response_composition.js";
+import { listenRequest } from "./internal/listenRequest.js";
+import { listenEvent } from "./internal/listenEvent.js";
+import { listenServerConnectionError } from "./internal/listenServerConnectionError.js";
 import {
   STOP_REASON_INTERNAL_ERROR,
   STOP_REASON_PROCESS_SIGHUP,
@@ -36,12 +36,12 @@ import {
   STOP_REASON_PROCESS_BEFORE_EXIT,
   STOP_REASON_PROCESS_EXIT,
   STOP_REASON_NOT_SPECIFIED,
-} from "./stopReasons.js"
-import { composeTwoHeaders } from "./internal/headers_composition.js"
+} 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"
+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,
@@ -82,7 +82,7 @@ export const startServer = async ({
           "request headers": JSON.stringify(request.headers, null, "  "),
         },
       ),
-    )
+    );
   },
   // timeAllocated to start responding to a request
   // after this delay the server will respond with 504
@@ -95,28 +95,28 @@ export const startServer = async ({
 } = {}) => {
   // param validations
   {
-    const unexpectedParamNames = Object.keys(rest)
+    const unexpectedParamNames = Object.keys(rest);
     if (unexpectedParamNames.length > 0) {
       throw new TypeError(
         `${unexpectedParamNames.join(",")}: there is no such param`,
-      )
+      );
     }
     if (https) {
       if (typeof https !== "object") {
-        throw new TypeError(`https must be an object, got ${https}`)
+        throw new TypeError(`https must be an object, got ${https}`);
       }
-      const { certificate, privateKey } = https
+      const { certificate, privateKey } = https;
       if (!certificate || !privateKey) {
         throw new TypeError(
           `https must be an object with { certificate, privateKey }`,
-        )
+        );
       }
     }
     if (http2 && !https) {
-      throw new Error(`http2 needs https`)
+      throw new Error(`http2 needs https`);
     }
   }
-  const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel });
   // param warnings and normalization
   {
     if (
@@ -124,121 +124,121 @@ export const startServer = async ({
       https &&
       !allowHttpRequestOnHttps
     ) {
-      redirectHttpToHttps = true
+      redirectHttpToHttps = true;
     }
     if (redirectHttpToHttps && !https) {
-      logger.warn(`redirectHttpToHttps ignored because protocol is http`)
-      redirectHttpToHttps = false
+      logger.warn(`redirectHttpToHttps ignored because protocol is http`);
+      redirectHttpToHttps = false;
     }
     if (allowHttpRequestOnHttps && redirectHttpToHttps) {
       logger.warn(
         `redirectHttpToHttps ignored because allowHttpRequestOnHttps is enabled`,
-      )
-      redirectHttpToHttps = false
+      );
+      redirectHttpToHttps = false;
     }
 
     if (allowHttpRequestOnHttps && !https) {
-      logger.warn(`allowHttpRequestOnHttps ignored because protocol is http`)
-      allowHttpRequestOnHttps = false
+      logger.warn(`allowHttpRequestOnHttps ignored because protocol is http`);
+      allowHttpRequestOnHttps = false;
     }
   }
 
-  const server = {}
-  const serviceController = createServiceController(services)
+  const server = {};
+  const serviceController = createServiceController(services);
   const processTeardownEvents = {
     SIGHUP: stopOnExit,
     SIGTERM: stopOnExit,
     SIGINT: stopOnSIGINT,
     beforeExit: stopOnExit,
     exit: stopOnExit,
-  }
+  };
 
-  let status = "starting"
-  let nodeServer
-  const startServerOperation = Abort.startOperation()
-  const stopCallbackList = createCallbackListNotifiedOnce()
+  let status = "starting";
+  let nodeServer;
+  const startServerOperation = Abort.startOperation();
+  const stopCallbackList = createCallbackListNotifiedOnce();
   const serverOrigins = {
     local: "", // favors hostname when possible
-  }
+  };
 
   try {
-    startServerOperation.addAbortSignal(signal)
+    startServerOperation.addAbortSignal(signal);
     startServerOperation.addAbortSource((abort) => {
       return raceProcessTeardownEvents(processTeardownEvents, ({ name }) => {
-        logger.info(`process teardown (${name}) -> aborting start server`)
-        abort()
-      })
-    })
-    startServerOperation.throwIfAborted()
+        logger.info(`process teardown (${name}) -> aborting start server`);
+        abort();
+      });
+    });
+    startServerOperation.throwIfAborted();
     nodeServer = await createNodeServer({
       https,
       redirectHttpToHttps,
       allowHttpRequestOnHttps,
       http2,
       http1Allowed,
-    })
-    startServerOperation.throwIfAborted()
+    });
+    startServerOperation.throwIfAborted();
 
     // https://nodejs.org/api/net.html#net_server_unref
     if (!keepProcessAlive) {
-      nodeServer.unref()
+      nodeServer.unref();
     }
 
     const createOrigin = (hostname) => {
-      const protocol = https ? "https" : "http"
+      const protocol = https ? "https" : "http";
       if (isIP(hostname) === 6) {
-        return `${protocol}://[${hostname}]`
+        return `${protocol}://[${hostname}]`;
       }
-      return `${protocol}://${hostname}`
-    }
+      return `${protocol}://${hostname}`;
+    };
 
-    const ipGetters = createIpGetters()
-    let hostnameToListen
+    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"
+      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
+      hostnameToListen = hostname;
     }
-    const hostnameInfo = parseHostname(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)
+      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)
+        const firstExternalIp = ipGetters.getFirstExternalIp({ preferIpv6 });
+        serverOrigins.externalip = createOrigin(firstExternalIp);
       } else if (hostnameInfo.label === "loopback") {
         // nothing
       } else {
-        serverOrigins.local = createOrigin(hostname)
+        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)
+        const hostnameIp = hostnameDnsResolution.address;
+        serverOrigins.localip = createOrigin(hostnameIp);
+        serverOrigins.local = createOrigin(hostname);
       } else {
-        const firstInternalIp = ipGetters.getFirstInternalIp({ preferIpv6 })
+        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)
+        hostname = firstInternalIp;
+        hostnameToListen = firstInternalIp;
+        serverOrigins.local = createOrigin(firstInternalIp);
       }
     }
 
@@ -248,20 +248,20 @@ export const startServer = async ({
       port,
       portHint,
       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
-    })
+      serverOrigins[key] = new URL(`${serverOrigins[key]}:${port}`).origin;
+    });
 
-    serviceController.callHooks("serverListening", { port })
+    serviceController.callHooks("serverListening", { port });
     startServerOperation.addAbortCallback(async () => {
-      await stopListening(nodeServer)
-    })
-    startServerOperation.throwIfAborted()
+      await stopListening(nodeServer);
+    });
+    startServerOperation.throwIfAborted();
   } finally {
-    await startServerOperation.end()
+    await startServerOperation.end();
   }
 
   // the main server origin
@@ -274,116 +274,116 @@ export const startServer = async ({
   //   for hostnames, not for ips
   //   so we prefer https://locahost or https://local_hostname
   //   over the ip
-  const serverOrigin = serverOrigins.local
+  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
   // and add a request handler
   stopCallbackList.add(({ reason }) => {
-    logger.info(`${serverName} stopping server (reason: ${reason})`)
-  })
+    logger.info(`${serverName} stopping server (reason: ${reason})`);
+  });
   stopCallbackList.add(async () => {
-    await stopListening(nodeServer)
-  })
-  let stoppedResolve
+    await stopListening(nodeServer);
+  });
+  let stoppedResolve;
   const stoppedPromise = new Promise((resolve) => {
-    stoppedResolve = resolve
-  })
+    stoppedResolve = resolve;
+  });
   const stop = memoize(async (reason = STOP_REASON_NOT_SPECIFIED) => {
-    status = "stopping"
-    await Promise.all(stopCallbackList.notify({ reason }))
-    serviceController.callHooks("serverStopped", { reason })
-    status = "stopped"
-    stoppedResolve(reason)
-  })
+    status = "stopping";
+    await Promise.all(stopCallbackList.notify({ reason }));
+    serviceController.callHooks("serverStopped", { reason });
+    status = "stopped";
+    stoppedResolve(reason);
+  });
 
   const cancelProcessTeardownRace = raceProcessTeardownEvents(
     processTeardownEvents,
     (winner) => {
-      stop(PROCESS_TEARDOWN_EVENTS_MAP[winner.name])
+      stop(PROCESS_TEARDOWN_EVENTS_MAP[winner.name]);
     },
-  )
-  stopCallbackList.add(cancelProcessTeardownRace)
+  );
+  stopCallbackList.add(cancelProcessTeardownRace);
 
   const onError = (error) => {
     if (status === "stopping" && error.code === "ECONNRESET") {
-      return
+      return;
     }
-    throw error
-  }
+    throw error;
+  };
 
-  status = "opened"
+  status = "opened";
 
   const removeConnectionErrorListener = listenServerConnectionError(
     nodeServer,
     onError,
-  )
-  stopCallbackList.add(removeConnectionErrorListener)
+  );
+  stopCallbackList.add(removeConnectionErrorListener);
 
   const connectionsTracker = trackServerPendingConnections(nodeServer, {
     http2,
-  })
+  });
   // opened connection must be shutdown before the close event is emitted
-  stopCallbackList.add(connectionsTracker.stop)
+  stopCallbackList.add(connectionsTracker.stop);
 
   const pendingRequestsTracker = trackServerPendingRequests(nodeServer, {
     http2,
-  })
+  });
   // ensure pending requests got a response from the server
   stopCallbackList.add((reason) => {
     pendingRequestsTracker.stop({
       status: reason === STOP_REASON_INTERNAL_ERROR ? 500 : 503,
       reason,
-    })
-  })
+    });
+  });
 
   request: {
     const requestCallback = async (nodeRequest, nodeResponse) => {
       // pause the stream to let a chance to "requestToResponse"
       // to call "requestRequestBody". Without this the request body readable stream
       // might be closed when we'll try to attach "data" and "end" listeners to it
-      nodeRequest.pause()
+      nodeRequest.pause();
       if (!nagle) {
-        nodeRequest.connection.setNoDelay(true)
+        nodeRequest.connection.setNoDelay(true);
       }
       if (redirectHttpToHttps && !nodeRequest.connection.encrypted) {
         nodeResponse.writeHead(301, {
           location: `${serverOrigin}${nodeRequest.url}`,
-        })
-        nodeResponse.end()
-        return
+        });
+        nodeResponse.end();
+        return;
       }
 
-      const receiveRequestOperation = Abort.startOperation()
+      const receiveRequestOperation = Abort.startOperation();
       receiveRequestOperation.addAbortSource((abort) => {
         const closeEventCallback = () => {
           if (nodeRequest.complete) {
-            receiveRequestOperation.end()
+            receiveRequestOperation.end();
           } else {
-            nodeResponse.destroy()
-            abort()
+            nodeResponse.destroy();
+            abort();
           }
-        }
-        nodeRequest.once("close", closeEventCallback)
+        };
+        nodeRequest.once("close", closeEventCallback);
         return () => {
-          nodeRequest.removeListener("close", closeEventCallback)
-        }
-      })
+          nodeRequest.removeListener("close", closeEventCallback);
+        };
+      });
       receiveRequestOperation.addAbortSource((abort) => {
-        return stopCallbackList.add(abort)
-      })
+        return stopCallbackList.add(abort);
+      });
 
-      const sendResponseOperation = Abort.startOperation()
-      sendResponseOperation.addAbortSignal(receiveRequestOperation.signal)
+      const sendResponseOperation = Abort.startOperation();
+      sendResponseOperation.addAbortSignal(receiveRequestOperation.signal);
       sendResponseOperation.addAbortSource((abort) => {
-        return stopCallbackList.add(abort)
-      })
+        return stopCallbackList.add(abort);
+      });
 
       const request = fromNodeRequest(nodeRequest, {
         serverOrigin,
         signal: receiveRequestOperation.signal,
-      })
+      });
 
       // Handling request is asynchronous, we buffer logs for that request
       // until we know what happens with that request
@@ -392,67 +392,67 @@ export const startServer = async ({
       const rootRequestNode = {
         logs: [],
         children: [],
-      }
+      };
       const addRequestLog = (node, { type, value }) => {
-        node.logs.push({ type, value })
-      }
+        node.logs.push({ type, value });
+      };
       const onRequestHandled = (node) => {
         if (node !== rootRequestNode) {
           // keep buffering until root request write logs for everyone
-          return
+          return;
         }
         const prefixLines = (string, prefix) => {
-          return string.replace(/^(?!\s*$)/gm, prefix)
-        }
+          return string.replace(/^(?!\s*$)/gm, prefix);
+        };
         const writeLog = (
           { type, value },
           { someLogIsError, someLogIsWarn, depth },
         ) => {
           if (depth > 0) {
-            value = prefixLines(value, "  ".repeat(depth))
+            value = prefixLines(value, "  ".repeat(depth));
           }
           if (type === "info") {
             if (someLogIsError) {
-              type = "error"
+              type = "error";
             } else if (someLogIsWarn) {
-              type = "warn"
+              type = "warn";
             }
           }
-          logger[type](value)
-        }
+          logger[type](value);
+        };
         const visitRequestNodeToLog = (requestNode, depth) => {
-          let someLogIsError = false
-          let someLogIsWarn = false
+          let someLogIsError = false;
+          let someLogIsWarn = false;
           requestNode.logs.forEach((log) => {
             if (log.type === "error") {
-              someLogIsError = true
+              someLogIsError = true;
             }
             if (log.type === "warn") {
-              someLogIsWarn = true
+              someLogIsWarn = true;
             }
-          })
+          });
 
-          const firstLog = requestNode.logs.shift()
-          const lastLog = requestNode.logs.pop()
-          const middleLogs = requestNode.logs
+          const firstLog = requestNode.logs.shift();
+          const lastLog = requestNode.logs.pop();
+          const middleLogs = requestNode.logs;
 
-          writeLog(firstLog, { someLogIsError, someLogIsWarn, depth })
+          writeLog(firstLog, { someLogIsError, someLogIsWarn, depth });
           middleLogs.forEach((log) => {
-            writeLog(log, { someLogIsError, someLogIsWarn, depth })
-          })
+            writeLog(log, { someLogIsError, someLogIsWarn, depth });
+          });
           requestNode.children.forEach((child) => {
-            visitRequestNodeToLog(child, depth + 1)
-          })
+            visitRequestNodeToLog(child, depth + 1);
+          });
           if (lastLog) {
             writeLog(lastLog, {
               someLogIsError,
               someLogIsWarn,
               depth: depth + 1,
-            })
+            });
           }
-        }
-        visitRequestNodeToLog(rootRequestNode, 0)
-      }
+        };
+        visitRequestNodeToLog(rootRequestNode, 0);
+      };
       nodeRequest.on("error", (error) => {
         if (error.message === "aborted") {
           addRequestLog(rootRequestNode, {
@@ -460,7 +460,7 @@ export const startServer = async ({
             value: createDetailedMessage(`request aborted by client`, {
               "error message": error.message,
             }),
-          })
+          });
         } else {
           // I'm not sure this can happen but it's here in case
           addRequestLog(rootRequestNode, {
@@ -468,12 +468,12 @@ export const startServer = async ({
             value: createDetailedMessage(`"error" event emitted on request`, {
               "error stack": error.stack,
             }),
-          })
+          });
         }
-      })
+      });
 
       const pushResponse = async ({ path, method }, { requestNode }) => {
-        const http2Stream = nodeResponse.stream
+        const http2Stream = nodeResponse.stream;
 
         // being able to push a stream is nice to have
         // so when it fails it's not critical
@@ -486,12 +486,12 @@ export const startServer = async ({
                 "error stack": e.stack,
               },
             ),
-          })
-        }
+          });
+        };
 
         // not aborted, let's try to push a stream into that response
         // https://nodejs.org/docs/latest-v16.x/api/http2.html#http2streampushstreamheaders-options-callback
-        let pushStream
+        let pushStream;
         try {
           pushStream = await new Promise((resolve, reject) => {
             http2Stream.pushStream(
@@ -505,55 +505,55 @@ export const startServer = async ({
                 // headers
               ) => {
                 if (error) {
-                  reject(error)
+                  reject(error);
                 }
-                resolve(pushStream)
+                resolve(pushStream);
               },
-            )
-          })
+            );
+          });
         } catch (e) {
-          onPushStreamError(e)
-          return
+          onPushStreamError(e);
+          return;
         }
 
-        const abortController = new AbortController()
+        const abortController = new AbortController();
         // It's possible to get NGHTTP2_REFUSED_STREAM errors here
         // https://github.com/nodejs/node/issues/20824
         const pushErrorCallback = (error) => {
-          onPushStreamError(error)
-          abortController.abort()
-        }
-        pushStream.on("error", pushErrorCallback)
+          onPushStreamError(error);
+          abortController.abort();
+        };
+        pushStream.on("error", pushErrorCallback);
         sendResponseOperation.addEndCallback(() => {
-          pushStream.removeListener("error", onPushStreamError)
-        })
+          pushStream.removeListener("error", onPushStreamError);
+        });
 
         await sendResponseOperation.withSignal(async (signal) => {
-          const pushResponseOperation = Abort.startOperation()
-          pushResponseOperation.addAbortSignal(signal)
-          pushResponseOperation.addAbortSignal(abortController.signal)
+          const pushResponseOperation = Abort.startOperation();
+          pushResponseOperation.addAbortSignal(signal);
+          pushResponseOperation.addAbortSignal(abortController.signal);
 
           const pushRequest = createPushRequest(request, {
             signal: pushResponseOperation.signal,
             pathname: path,
             method,
-          })
+          });
 
           try {
             const responseProperties = await handleRequest(pushRequest, {
               requestNode,
-            })
+            });
             if (!abortController.signal.aborted) {
               if (pushStream.destroyed) {
-                abortController.abort()
+                abortController.abort();
               } else if (!http2Stream.pushAllowed) {
-                abortController.abort()
+                abortController.abort();
               } else if (responseProperties.requestAborted) {
               } else {
                 const responseLength =
-                  responseProperties.headers["content-length"] || 0
+                  responseProperties.headers["content-length"] || 0;
                 const { effectiveRecvDataLength, remoteWindowSize } =
-                  http2Stream.session.state
+                  http2Stream.session.state;
                 if (
                   effectiveRecvDataLength + responseLength >
                   remoteWindowSize
@@ -561,8 +561,8 @@ export const startServer = async ({
                   addRequestLog(requestNode, {
                     type: "debug",
                     value: `Aborting stream to prevent exceeding remoteWindowSize`,
-                  })
-                  abortController.abort()
+                  });
+                  abortController.abort();
                 }
               }
             }
@@ -572,37 +572,37 @@ export const startServer = async ({
               requestNode,
               responseStream: pushStream,
               responseProperties,
-            })
+            });
           } finally {
-            await pushResponseOperation.end()
+            await pushResponseOperation.end();
           }
-        })
-      }
+        });
+      };
 
       const handleRequest = async (request, { requestNode }) => {
-        let requestReceivedMeasure
+        let requestReceivedMeasure;
         if (serverTiming) {
-          requestReceivedMeasure = performance.now()
+          requestReceivedMeasure = performance.now();
         }
         addRequestLog(requestNode, {
           type: "info",
           value: request.parent
             ? `Push ${request.resource}`
             : `${request.method} ${request.url}`,
-        })
+        });
         const warn = (value) => {
           addRequestLog(requestNode, {
             type: "warn",
             value,
-          })
-        }
+          });
+        };
 
-        let requestWaitingTimeout
+        let requestWaitingTimeout;
         if (requestWaitingMs) {
           requestWaitingTimeout = setTimeout(
             () => requestWaitingCallback({ request, warn, requestWaitingMs }),
             requestWaitingMs,
-          ).unref()
+          ).unref();
         }
 
         serviceController.callHooks(
@@ -615,16 +615,16 @@ export const startServer = async ({
                 original: request.original || request,
                 previous: request,
                 ...newRequestProperties,
-              })
+              });
             }
           },
-        )
+        );
 
-        let handleRequestReturnValue
-        let errorWhileHandlingRequest = null
-        let handleRequestTimings = serverTiming ? {} : null
+        let handleRequestReturnValue;
+        let errorWhileHandlingRequest = null;
+        let handleRequestTimings = serverTiming ? {} : null;
 
-        let timeout
+        let timeout;
         const timeoutPromise = new Promise((resolve) => {
           timeout = setTimeout(() => {
             resolve({
@@ -636,9 +636,9 @@ export const startServer = async ({
               statusText: `server timeout after ${
                 responseTimeout / 1000
               }s waiting to handle request`,
-            })
-          }, responseTimeout)
-        })
+            });
+          }, responseTimeout);
+        });
         const handleRequestPromise = serviceController.callAsyncHooksUntil(
           "handleRequest",
           request,
@@ -650,29 +650,29 @@ export const startServer = async ({
                 addRequestLog(requestNode, {
                   type: "warn",
                   value: `response push ignored because path is invalid (must be a string starting with "/", found ${path})`,
-                })
-                return
+                });
+                return;
               }
               if (!request.http2) {
                 addRequestLog(requestNode, {
                   type: "warn",
                   value: `response push ignored because request is not http2`,
-                })
-                return
+                });
+                return;
               }
-              const canPushStream = testCanPushStream(nodeResponse.stream)
+              const canPushStream = testCanPushStream(nodeResponse.stream);
               if (!canPushStream.can) {
                 addRequestLog(requestNode, {
                   type: "debug",
                   value: `response push ignored because ${canPushStream.reason}`,
-                })
-                return
+                });
+                return;
               }
 
-              let preventedByService = null
+              let preventedByService = null;
               const prevent = () => {
-                preventedByService = serviceController.getCurrentService()
-              }
+                preventedByService = serviceController.getCurrentService();
+              };
               serviceController.callHooksUntil(
                 "onResponsePush",
                 { path, method },
@@ -682,44 +682,44 @@ export const startServer = async ({
                   prevent,
                 },
                 () => preventedByService,
-              )
+              );
               if (preventedByService) {
                 addRequestLog(requestNode, {
                   type: "debug",
                   value: `response push prevented by "${preventedByService.name}" service`,
-                })
-                return
+                });
+                return;
               }
 
-              const requestChildNode = { logs: [], children: [] }
-              requestNode.children.push(requestChildNode)
+              const requestChildNode = { logs: [], children: [] };
+              requestNode.children.push(requestChildNode);
               await pushResponse(
                 { path, method },
                 {
                   requestNode: requestChildNode,
                   parentHttp2Stream: nodeResponse.stream,
                 },
-              )
+              );
             },
           },
-        )
+        );
         try {
           handleRequestReturnValue = await Promise.race([
             timeoutPromise,
             handleRequestPromise,
-          ])
+          ]);
         } catch (e) {
-          errorWhileHandlingRequest = e
+          errorWhileHandlingRequest = e;
         }
-        clearTimeout(timeout)
+        clearTimeout(timeout);
 
-        let responseProperties
+        let responseProperties;
         if (errorWhileHandlingRequest) {
           if (
             errorWhileHandlingRequest.name === "AbortError" &&
             request.signal.aborted
           ) {
-            responseProperties = { requestAborted: true }
+            responseProperties = { requestAborted: true };
           } else {
             // internal error, create 500 response
             if (
@@ -730,7 +730,7 @@ export const startServer = async ({
               stopOnInternalError
             ) {
               // il faudrais pouvoir stop que les autres response ?
-              stop(STOP_REASON_INTERNAL_ERROR)
+              stop(STOP_REASON_INTERNAL_ERROR);
             }
             const handleErrorReturnValue =
               await serviceController.callAsyncHooksUntil(
@@ -740,9 +740,9 @@ export const startServer = async ({
                   request,
                   warn,
                 },
-              )
+              );
             if (!handleErrorReturnValue) {
-              throw errorWhileHandlingRequest
+              throw errorWhileHandlingRequest;
             }
             addRequestLog(requestNode, {
               type: "error",
@@ -752,7 +752,7 @@ export const startServer = async ({
                   "error stack": errorWhileHandlingRequest.stack,
                 },
               ),
-            })
+            });
             responseProperties = composeTwoResponses(
               {
                 status: 500,
@@ -764,7 +764,7 @@ export const startServer = async ({
                 },
               },
               handleErrorReturnValue,
-            )
+            );
           }
         } else {
           const {
@@ -774,7 +774,7 @@ export const startServer = async ({
             headers = {},
             body,
             ...rest
-          } = handleRequestReturnValue || {}
+          } = handleRequestReturnValue || {};
           responseProperties = {
             status,
             statusText,
@@ -782,25 +782,25 @@ export const startServer = async ({
             headers,
             body,
             ...rest,
-          }
+          };
         }
 
         if (serverTiming) {
-          const responseReadyMeasure = performance.now()
+          const responseReadyMeasure = performance.now();
           const timeToStartResponding =
-            responseReadyMeasure - requestReceivedMeasure
+            responseReadyMeasure - requestReceivedMeasure;
           const serverTiming = {
             ...handleRequestTimings,
             ...responseProperties.timing,
             "time to start responding": timeToStartResponding,
-          }
+          };
           responseProperties.headers = composeTwoHeaders(
             responseProperties.headers,
             timingToServerTimingResponseHeaders(serverTiming),
-          )
+          );
         }
         if (requestWaitingMs) {
-          clearTimeout(requestWaitingTimeout)
+          clearTimeout(requestWaitingTimeout);
         }
         if (
           request.method !== "HEAD" &&
@@ -810,7 +810,7 @@ export const startServer = async ({
           addRequestLog(requestNode, {
             type: "warn",
             value: `content-length header is ${responseProperties.headers["content-length"]} but body is empty`,
-          })
+          });
         }
         serviceController.callHooks(
           "injectResponseHeaders",
@@ -824,16 +824,16 @@ export const startServer = async ({
               responseProperties.headers = composeTwoHeaders(
                 responseProperties.headers,
                 returnValue,
-              )
+              );
             }
           },
-        )
+        );
         serviceController.callHooks("responseReady", responseProperties, {
           request,
           warn,
-        })
-        return responseProperties
-      }
+        });
+        return responseProperties;
+      };
 
       const sendResponse = async ({
         signal,
@@ -846,10 +846,10 @@ export const startServer = async ({
         // the parent response is immediatly ended. It means child responses (pushed streams)
         // won't get a chance to be pushed.
         // To let a chance to pushed streams we wait a little before sending the response
-        const ignoreBody = request.method === "HEAD"
-        const bodyIsEmpty = !responseProperties.body || ignoreBody
+        const ignoreBody = request.method === "HEAD";
+        const bodyIsEmpty = !responseProperties.body || ignoreBody;
         if (bodyIsEmpty && requestNode.children.length > 0) {
-          await new Promise((resolve) => setTimeout(resolve))
+          await new Promise((resolve) => setTimeout(resolve));
         }
 
         await writeNodeResponse(responseStream, responseProperties, {
@@ -859,8 +859,8 @@ export const startServer = async ({
             addRequestLog(requestNode, {
               type: "info",
               value: `response aborted`,
-            })
-            onRequestHandled(requestNode)
+            });
+            onRequestHandled(requestNode);
           },
           onError: (error) => {
             addRequestLog(requestNode, {
@@ -871,11 +871,11 @@ export const startServer = async ({
                   "error stack": error.stack,
                 },
               ),
-            })
-            onRequestHandled(requestNode)
+            });
+            onRequestHandled(requestNode);
           },
           onHeadersSent: ({ status, statusText }) => {
-            const statusType = statusToType(status)
+            const statusType = statusToType(status);
             addRequestLog(requestNode, {
               type:
                 status === 404 && request.pathname === "/favicon.ico"
@@ -890,31 +890,31 @@ export const startServer = async ({
               value: `${colorizeResponseStatus(status)} ${
                 responseProperties.statusMessage || statusText
               }`,
-            })
+            });
           },
           onEnd: () => {
-            onRequestHandled(requestNode)
+            onRequestHandled(requestNode);
           },
-        })
-      }
+        });
+      };
 
       try {
         if (receiveRequestOperation.signal.aborted) {
-          return
+          return;
         }
         const responseProperties = await handleRequest(request, {
           requestNode: rootRequestNode,
-        })
-        nodeRequest.resume()
+        });
+        nodeRequest.resume();
         if (receiveRequestOperation.signal.aborted) {
-          return
+          return;
         }
 
         // the node request readable stream is never closed because
         // the response headers contains "connection: keep-alive"
         // In this scenario we want to disable READABLE_STREAM_TIMEOUT warning
         if (responseProperties.headers.connection === "keep-alive") {
-          clearTimeout(request.body.timeout)
+          clearTimeout(request.body.timeout);
         }
 
         await sendResponse({
@@ -923,75 +923,75 @@ export const startServer = async ({
           requestNode: rootRequestNode,
           responseStream: nodeResponse,
           responseProperties,
-        })
+        });
       } finally {
-        await sendResponseOperation.end()
+        await sendResponseOperation.end();
       }
-    }
-    const removeRequestListener = listenRequest(nodeServer, requestCallback)
+    };
+    const removeRequestListener = listenRequest(nodeServer, requestCallback);
     // ensure we don't try to handle new requests while server is stopping
-    stopCallbackList.add(removeRequestListener)
+    stopCallbackList.add(removeRequestListener);
   }
 
   websocket: {
     // https://github.com/websockets/ws/blob/master/doc/ws.md#class-websocket
-    const websocketHandlers = []
+    const websocketHandlers = [];
     serviceController.services.forEach((service) => {
-      const { handleWebsocket } = service
+      const { handleWebsocket } = service;
       if (handleWebsocket) {
-        websocketHandlers.push(handleWebsocket)
+        websocketHandlers.push(handleWebsocket);
       }
-    })
+    });
     if (websocketHandlers.length > 0) {
-      const websocketClients = new Set()
-      const { WebSocketServer } = await import("ws")
-      let websocketServer = new WebSocketServer({ noServer: true })
+      const websocketClients = new Set();
+      const { WebSocketServer } = await import("ws");
+      let websocketServer = new WebSocketServer({ noServer: true });
       const websocketOrigin = https
         ? `wss://${hostname}:${port}`
-        : `ws://${hostname}:${port}`
-      server.websocketOrigin = websocketOrigin
+        : `ws://${hostname}:${port}`;
+      server.websocketOrigin = websocketOrigin;
       const upgradeCallback = (nodeRequest, socket, head) => {
         websocketServer.handleUpgrade(
           nodeRequest,
           socket,
           head,
           async (websocket) => {
-            websocketClients.add(websocket)
+            websocketClients.add(websocket);
             websocket.once("close", () => {
-              websocketClients.delete(websocket)
-            })
+              websocketClients.delete(websocket);
+            });
             const request = fromNodeRequest(nodeRequest, {
               serverOrigin: websocketOrigin,
               signal: new AbortController().signal,
               requestBodyLifetime,
-            })
+            });
             serviceController.callAsyncHooksUntil(
               "handleWebsocket",
               websocket,
               {
                 request,
               },
-            )
+            );
           },
-        )
-      }
+        );
+      };
 
       // see server-polyglot.js, upgrade must be listened on https server when used
-      const facadeServer = nodeServer._tlsServer || nodeServer
+      const facadeServer = nodeServer._tlsServer || nodeServer;
       const removeUpgradeCallback = listenEvent(
         facadeServer,
         "upgrade",
         upgradeCallback,
-      )
-      stopCallbackList.add(removeUpgradeCallback)
+      );
+      stopCallbackList.add(removeUpgradeCallback);
       stopCallbackList.add(() => {
         websocketClients.forEach((websocketClient) => {
-          websocketClient.close()
-        })
-        websocketClients.clear()
-        websocketServer.close()
-        websocketServer = null
-      })
+          websocketClient.close();
+        });
+        websocketClients.clear();
+        websocketServer.close();
+        websocketServer = null;
+      });
     }
   }
 
@@ -999,9 +999,9 @@ export const startServer = async ({
     if (serverOrigins.network) {
       logger.info(
         `${serverName} started at ${serverOrigins.local} (${serverOrigins.network})`,
-      )
+      );
     } else {
-      logger.info(`${serverName} started at ${serverOrigins.local}`)
+      logger.info(`${serverName} started at ${serverOrigins.local}`);
     }
   }
 
@@ -1015,14 +1015,14 @@ export const startServer = async ({
     stop,
     stoppedPromise,
     addEffect: (callback) => {
-      const cleanup = callback()
+      const cleanup = callback();
       if (typeof cleanup === "function") {
-        stopCallbackList.add(cleanup)
+        stopCallbackList.add(cleanup);
       }
     },
-  })
-  return server
-}
+  });
+  return server;
+};
 
 const createNodeServer = async ({
   https,
@@ -1032,47 +1032,47 @@ const createNodeServer = async ({
   http1Allowed,
 }) => {
   if (https) {
-    const { certificate, privateKey } = https
+    const { certificate, privateKey } = https;
     if (redirectHttpToHttps || allowHttpRequestOnHttps) {
       return createPolyglotServer({
         certificate,
         privateKey,
         http2,
         http1Allowed,
-      })
+      });
     }
-    const { createServer } = await import("node:https")
+    const { createServer } = await import("node:https");
     return createServer({
       cert: certificate,
       key: privateKey,
-    })
+    });
   }
-  const { createServer } = await import("node:http")
-  return createServer()
-}
+  const { createServer } = await import("node:http");
+  return createServer();
+};
 
 const testCanPushStream = (http2Stream) => {
   if (!http2Stream.pushAllowed) {
     return {
       can: false,
       reason: `stream.pushAllowed is false`,
-    }
+    };
   }
 
   // See https://nodejs.org/dist/latest-v16.x/docs/api/http2.html#http2sessionstate
   // And https://github.com/google/node-h2-auto-push/blob/67a36c04cbbd6da7b066a4e8d361c593d38853a4/src/index.ts#L100-L106
-  const { remoteWindowSize } = http2Stream.session.state
+  const { remoteWindowSize } = http2Stream.session.state;
   if (remoteWindowSize === 0) {
     return {
       can: false,
       reason: `no more remoteWindowSize`,
-    }
+    };
   }
 
   return {
     can: true,
-  }
-}
+  };
+};
 
 const PROCESS_TEARDOWN_EVENTS_MAP = {
   SIGHUP: STOP_REASON_PROCESS_SIGHUP,
@@ -1080,4 +1080,4 @@ const PROCESS_TEARDOWN_EVENTS_MAP = {
   SIGINT: STOP_REASON_PROCESS_SIGINT,
   beforeExit: STOP_REASON_PROCESS_BEFORE_EXIT,
   exit: STOP_REASON_PROCESS_EXIT,
-}
+};