@jsenv/server 12.0.0 → 12.3.0

package/README.md

@@ -92,8 +92,8 @@ import { startServer } from "@jsenv/server"
 
 await startServer({
   protocol: "https",
-  serverCertificate: readFileSyncAsString("./server.crt"),
-  serverCertificatePrivateKey: readFileSyncAsString("./server.key"),
+  certificate: readFileSyncAsString("./server.crt"),
+  privateKey: readFileSyncAsString("./server.key"),
   allowHttpRequestOnHttps: true,
   requestToResponse: (request) => {
     const clientUsesHttp = request.origin.startsWith("http:")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "12.0.0",
+  "version": "12.3.0",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -13,7 +13,7 @@
     "url": "https://github.com/jsenv/server"
   },
   "engines": {
-    "node": ">=16.12.0"
+    "node": ">=16.13.0"
   },
   "publishConfig": {
     "access": "public"
@@ -31,45 +31,40 @@
     "/main.js"
   ],
   "scripts": {
-    "eslint-check": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
-    "importmap-generate": "node ./script/importmap/generate_importmap.mjs",
-    "measure-performances": "node --expose-gc ./script/performance/generate_performance_report.mjs --log",
-    "test": "node --unhandled-rejections=strict ./script/test/test.mjs",
+    "importmap": "node ./script/importmap/importmap.mjs",
+    "eslint": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
+    "performance": "node --expose-gc ./script/performance/performance.mjs --log",
+    "test": "node ./script/test/test.mjs",
     "test-with-coverage": "npm run test -- --coverage",
     "generate-html-snapshots": "node ./test/internal_error/generate_html_snapshot_files.mjs",
-    "prettier-format": "node ./script/prettier/prettier_format.mjs",
-    "prettier-format-stage": "npm run prettier-format -- --staged",
-    "prettier-check": "npm run prettier-format -- --dry-run",
-    "certificate-authority-install": "node ./script/certificate/certificate_authority_install.mjs",
-    "playwright-install": "npx playwright install-deps && npx playwright install",
-    "prepublishOnly": "node ./script/publish/remove_postinstall.mjs",
-    "postpublish": "node ./script/publish/restore_postinstall.mjs"
+    "prettier": "prettier --write .",
+    "certificate-install": "node ./script/certificate/certificate_install.mjs",
+    "playwright-install": "npx playwright install-deps && npx playwright install"
   },
   "dependencies": {
-    "@jsenv/abort": "4.1.1",
+    "@jsenv/abort": "4.1.2",
     "@jsenv/logger": "4.0.1",
-    "@jsenv/url-meta": "6.0.1",
+    "@jsenv/url-meta": "6.0.3",
     "node-fetch": "2.6.2",
     "path-to-regexp": "6.2.0"
   },
   "devDependencies": {
-    "@jsenv/assert": "2.3.2",
-    "@jsenv/core": "23.10.0",
+    "@jsenv/assert": "2.4.1",
+    "@jsenv/core": "25.1.0",
     "@jsenv/eslint-config": "16.0.9",
-    "@jsenv/filesystem": "2.5.1",
+    "@jsenv/filesystem": "2.6.1",
     "@jsenv/github-release-package": "1.2.3",
     "@jsenv/https-local": "1.0.3",
-    "@jsenv/importmap-eslint-resolver": "5.1.2",
-    "@jsenv/importmap-node-module": "2.7.1",
+    "@jsenv/importmap-eslint-resolver": "5.2.2",
+    "@jsenv/importmap-node-module": "5.1.0",
     "@jsenv/package-publish": "1.6.2",
     "@jsenv/performance-impact": "2.2.1",
-    "@jsenv/prettier-check-project": "5.6.1",
-    "eslint": "8.2.0",
-    "eslint-plugin-import": "2.25.3",
+    "eslint": "8.7.0",
+    "eslint-plugin-import": "2.25.4",
     "eventsource": "1.1.0",
-    "fastify": "3.24.0",
+    "fastify": "3.25.3",
     "fastify-static": "4.5.0",
-    "playwright": "1.16.3",
-    "prettier": "2.4.1"
+    "playwright": "1.17.2",
+    "prettier": "2.5.1"
   }
-}
+}

package/src/cors/plugin_cors.js

@@ -1,5 +1,3 @@
-import { urlToOrigin } from "@jsenv/filesystem"
-
 export const jsenvAccessControlAllowedHeaders = ["x-requested-with"]
 
 export const jsenvAccessControlAllowedMethods = [
@@ -107,7 +105,7 @@ const generateAccessControlHeaders = ({
       allowedOriginArray.push(headers.origin)
       vary.push("origin")
     } else if ("referer" in headers) {
-      allowedOriginArray.push(urlToOrigin(headers.referer))
+      allowedOriginArray.push(new URL(headers.referer).origin)
       vary.push("referer")
     } else {
       allowedOriginArray.push("*")

package/src/internal/memoize.js

@@ -0,0 +1,24 @@
+export const memoize = (compute) => {
+  let memoized = false
+  let memoizedValue
+
+  const fnWithMemoization = (...args) => {
+    if (memoized) {
+      return memoizedValue
+    }
+    // if compute is recursive wait for it to be fully done before storing the value
+    // so set memoized boolean after the call
+    memoizedValue = compute(...args)
+    memoized = true
+    return memoizedValue
+  }
+
+  fnWithMemoization.forget = () => {
+    const value = memoizedValue
+    memoized = false
+    memoizedValue = undefined
+    return value
+  }
+
+  return fnWithMemoization
+}

package/src/internal/server-polyglot.js

@@ -11,13 +11,13 @@ import { listenEvent } from "./listenEvent.js"
 export const createPolyglotServer = async ({
   http2 = false,
   http1Allowed = true,
-  serverCertificate,
-  serverCertificatePrivateKey,
+  certificate,
+  privateKey,
 }) => {
   const httpServer = http.createServer()
   const tlsServer = await createSecureServer({
-    serverCertificate,
-    serverCertificatePrivateKey,
+    certificate,
+    privateKey,
     http2,
     http1Allowed,
   })
@@ -63,24 +63,24 @@ export const createPolyglotServer = async ({
 // The async part is just to lazyly import "http2" or "https"
 // so that these module are parsed only if used.
 const createSecureServer = async ({
-  serverCertificate,
-  serverCertificatePrivateKey,
+  certificate,
+  privateKey,
   http2,
   http1Allowed,
 }) => {
   if (http2) {
     const { createSecureServer } = await import("http2")
     return createSecureServer({
-      cert: serverCertificate,
-      key: serverCertificatePrivateKey,
+      cert: certificate,
+      key: privateKey,
       allowHTTP1: http1Allowed,
     })
   }
 
   const { createServer } = await import("https")
   return createServer({
-    cert: serverCertificate,
-    key: serverCertificatePrivateKey,
+    cert: certificate,
+    key: privateKey,
   })
 }
 

package/src/sse/createSSERoom.js

@@ -8,6 +8,7 @@ import {
 // https://www.html5rocks.com/en/tutorials/eventsource/basics/
 export const createSSERoom = ({
   logLevel,
+  effect = () => {},
   // do not keep process alive because of rooms, something else must keep it alive
   keepProcessAlive = false,
   keepaliveDuration = 30 * 1000,
@@ -29,6 +30,7 @@ export const createSSERoom = ({
   let previousEventId = 0
   let opened = false
   let interval
+  let cleanupEffect = CLEANUP_NOOP
 
   const join = (request) => {
     // should we ensure a given request can join a room only once?
@@ -56,6 +58,14 @@ export const createSSERoom = ({
         next,
         complete,
       }
+      if (clients.size === 0) {
+        const effectReturnValue = effect()
+        if (typeof effectReturnValue === "function") {
+          cleanupEffect = effectReturnValue
+        } else {
+          cleanupEffect = CLEANUP_NOOP
+        }
+      }
       clients.add(client)
       logger.debug(
         `A client has joined. Number of client in room: ${clients.size}`,
@@ -101,6 +111,10 @@ export const createSSERoom = ({
 
       return () => {
         clients.delete(client)
+        if (clients.size === 0) {
+          cleanupEffect()
+          cleanupEffect = CLEANUP_NOOP
+        }
         logger.debug(`A client left. Number of client in room: ${clients.size}`)
       }
     })
@@ -210,6 +224,8 @@ export const createSSERoom = ({
   return room
 }
 
+const CLEANUP_NOOP = () => {}
+
 const requestMap = new Map()
 
 const connectRequestAndRoom = (request, room, roomObservable) => {

package/src/startServer.js

@@ -1,6 +1,5 @@
 import http from "node:http"
 import cluster from "node:cluster"
-import { memoize } from "@jsenv/filesystem"
 import { createDetailedMessage, createLogger } from "@jsenv/logger"
 import {
   Abort,
@@ -23,6 +22,7 @@ import { listen, stopListening } from "./internal/listen.js"
 import { composeTwoResponses } from "./internal/response_composition.js"
 import { listenRequest } from "./internal/listenRequest.js"
 import { listenServerConnectionError } from "./internal/listenServerConnectionError.js"
+import { memoize } from "./internal/memoize.js"
 import { jsenvServerInternalErrorToResponse } from "./jsenvServerInternalErrorToResponse.js"
 import {
   STOP_REASON_INTERNAL_ERROR,
@@ -47,8 +47,8 @@ export const startServer = async ({
   ip = "0.0.0.0", // will it work on windows ? https://github.com/nodejs/node/issues/14900
   port = 0, // assign a random available port
   portHint,
-  serverCertificatePrivateKey,
-  serverCertificate,
+  privateKey,
+  certificate,
 
   // when inside a worker, we should not try to stop server on SIGINT
   // otherwise it can create an EPIPE error while primary process tries
@@ -74,11 +74,11 @@ export const startServer = async ({
     throw new Error(`protocol must be http or https, got ${protocol}`)
   }
   if (protocol === "https") {
-    if (!serverCertificate) {
-      throw new Error(`missing serverCertificate for https server`)
+    if (!certificate) {
+      throw new Error(`missing certificate for https server`)
     }
-    if (!serverCertificatePrivateKey) {
-      throw new Error(`missing serverCertificatePrivateKey for https server`)
+    if (!privateKey) {
+      throw new Error(`missing privateKey for https server`)
     }
   }
   if (http2 && protocol !== "https") {
@@ -134,8 +134,8 @@ export const startServer = async ({
       protocol,
       redirectHttpToHttps,
       allowHttpRequestOnHttps,
-      serverCertificate,
-      serverCertificatePrivateKey,
+      certificate,
+      privateKey,
       http2,
       http1Allowed,
     })
@@ -332,29 +332,6 @@ export const startServer = async ({
     const pushResponse = async ({ path, method }, { requestNode }) => {
       const http2Stream = nodeResponse.stream
 
-      if (typeof path !== "string" || path[0] !== "/") {
-        addRequestLog(requestNode, {
-          type: "warn",
-          value: `pushResponse call ignored because path is invalid (must be a string starting with "/", found ${path})`,
-        })
-        return
-      }
-      if (!request.http2) {
-        addRequestLog(requestNode, {
-          type: "warn",
-          value: `pushResponse call ignored because request is not http2`,
-        })
-        return
-      }
-      const canPushStream = testCanPushStream(http2Stream)
-      if (!canPushStream.can) {
-        addRequestLog(requestNode, {
-          type: "debug",
-          value: `Ignoring call to pushResponse because ${canPushStream.reason}`,
-        })
-        return
-      }
-
       // being able to push a stream is nice to have
       // so when it fails it's not critical
       const onPushStreamError = (e) => {
@@ -488,19 +465,65 @@ export const startServer = async ({
             redirectRequest,
           })
           if (returnValue) {
-            requestPlugins.push(returnValue)
+            requestPlugins.push({
+              pluginName,
+              ...returnValue,
+            })
           }
         }
       })
-      let { aborted, error, responseProperties } = responseFromShortcircuit
-        ? { responseProperties: responseFromShortcircuit }
+      const result = responseFromShortcircuit
+        ? { returnValue: responseFromShortcircuit }
         : await generateResponseDescription({
             requestToResponse,
             request,
-            pushResponse: ({ path, method }) => {
+            pushResponse: async ({ path, method }) => {
+              if (typeof path !== "string" || path[0] !== "/") {
+                addRequestLog(requestNode, {
+                  type: "warn",
+                  value: `response push ignored because path is invalid (must be a string starting with "/", found ${path})`,
+                })
+                return
+              }
+              if (!request.http2) {
+                addRequestLog(requestNode, {
+                  type: "warn",
+                  value: `response push ignored because request is not http2`,
+                })
+                return
+              }
+              const canPushStream = testCanPushStream(nodeResponse.stream)
+              if (!canPushStream.can) {
+                addRequestLog(requestNode, {
+                  type: "debug",
+                  value: `response push ignored because ${canPushStream.reason}`,
+                })
+                return
+              }
+
+              let prevented = false
+              const prevent = () => {
+                prevented = true
+              }
+              const preventedByPlugin = requestPlugins.find((requestPlugin) => {
+                const { onPushResponse } = requestPlugin
+                if (!onPushResponse) {
+                  return false
+                }
+                onPushResponse({ path, method }, { prevent })
+                return prevented
+              })
+              if (prevented) {
+                addRequestLog(requestNode, {
+                  type: "debug",
+                  value: `response push prevented by "${preventedByPlugin.pluginName}" plugin`,
+                })
+                return
+              }
+
               const requestChildNode = { logs: [], children: [] }
               requestNode.children.push(requestChildNode)
-              return pushResponse(
+              await pushResponse(
                 { path, method },
                 {
                   requestNode: requestChildNode,
@@ -510,65 +533,60 @@ export const startServer = async ({
             },
           })
 
+      const { aborted } = result
       if (aborted) {
         return ABORTED_RESPONSE_PROPERTIES
       }
-
-      // internal error, create 500 response
-      if (error) {
-        if (
-          // stopOnInternalError stops server only if requestToResponse generated
-          // a non controlled error (internal error).
-          // if requestToResponse gracefully produced a 500 response (it did not throw)
-          // then we can assume we are still in control of what we are doing
-          stopOnInternalError
-        ) {
-          // il faudrais pouvoir stop que les autres response ?
-          stop(STOP_REASON_INTERNAL_ERROR)
-        }
-
-        const propertiesFromError = await serverInternalErrorToResponse(error, {
-          request,
-          sendServerInternalErrorDetails,
-        })
-        responseProperties = composeTwoResponses(
-          {
-            status: 500,
-            statusText: statusToStatusText(500),
-            headers: {
-              // ensure error are not cached
-              "cache-control": "no-store",
-              "content-type": "text/plain",
+      const readResponseProperties = async () => {
+        const { error } = result
+        // internal error, create 500 response
+        if (error) {
+          if (
+            // stopOnInternalError stops server only if requestToResponse generated
+            // a non controlled error (internal error).
+            // if requestToResponse gracefully produced a 500 response (it did not throw)
+            // then we can assume we are still in control of what we are doing
+            stopOnInternalError
+          ) {
+            // il faudrais pouvoir stop que les autres response ?
+            stop(STOP_REASON_INTERNAL_ERROR)
+          }
+          const propertiesFromError = await serverInternalErrorToResponse(
+            error,
+            {
+              request,
+              sendServerInternalErrorDetails,
             },
-          },
-          propertiesFromError,
-        )
-        addRequestLog(requestNode, {
-          type: "error",
-          value: createDetailedMessage(
-            `internal error while handling request`,
+          )
+          addRequestLog(requestNode, {
+            type: "error",
+            value: createDetailedMessage(
+              `internal error while handling request`,
+              {
+                "error stack": error.stack,
+              },
+            ),
+          })
+          return composeTwoResponses(
             {
-              "error stack": error.stack,
+              status: 500,
+              statusText: statusToStatusText(500),
+              headers: {
+                // ensure error are not cached
+                "cache-control": "no-store",
+                "content-type": "text/plain",
+              },
             },
-          ),
-        })
-      } else {
-        const {
-          status = 501,
-          statusText = statusToStatusText(status),
-          headers = {},
-          body,
-          ...rest
-        } = responseProperties || {}
-        responseProperties = {
-          status,
-          statusText,
-          headers,
-          body,
-          ...rest,
+            propertiesFromError,
+          )
         }
+        const responseProperties = normalizeResponseProperties(
+          result.returnValue,
+        )
+        return responseProperties
       }
 
+      let responseProperties = await readResponseProperties()
       // call every plugin "onResponse" hook
       requestPlugins.forEach((requestPlugin) => {
         const { onResponse } = requestPlugin
@@ -582,7 +600,6 @@ export const startServer = async ({
           }
         }
       })
-
       if (
         request.method !== "HEAD" &&
         responseProperties.headers["content-length"] > 0 &&
@@ -593,7 +610,6 @@ export const startServer = async ({
           value: `content-length header is ${responseProperties.headers["content-length"]} but body is empty`,
         })
       }
-
       return responseProperties
     }
 
@@ -701,8 +717,8 @@ const createNodeServer = async ({
   protocol,
   redirectHttpToHttps,
   allowHttpRequestOnHttps,
-  serverCertificate,
-  serverCertificatePrivateKey,
+  certificate,
+  privateKey,
   http2,
   http1Allowed,
 }) => {
@@ -712,8 +728,8 @@ const createNodeServer = async ({
 
   if (redirectHttpToHttps || allowHttpRequestOnHttps) {
     return createPolyglotServer({
-      serverCertificate,
-      serverCertificatePrivateKey,
+      certificate,
+      privateKey,
       http2,
       http1Allowed,
     })
@@ -721,11 +737,43 @@ const createNodeServer = async ({
 
   const { createServer } = await import("https")
   return createServer({
-    cert: serverCertificate,
-    key: serverCertificatePrivateKey,
+    cert: certificate,
+    key: privateKey,
   })
 }
 
+const normalizeResponseProperties = (returnValue) => {
+  if (returnValue && returnValue.constructor.name === "Response") {
+    const responseHeaders = {}
+    const headersToIgnore = ["connection"]
+    returnValue.headers.forEach((value, name) => {
+      if (!headersToIgnore.includes(name)) {
+        responseHeaders[name] = value
+      }
+    })
+    return {
+      status: returnValue.status,
+      statusText: returnValue.statusText,
+      headers: responseHeaders,
+      body: returnValue.body, // node-fetch assumed
+    }
+  }
+  const {
+    status = 501,
+    statusText = statusToStatusText(status),
+    headers = {},
+    body,
+    ...rest
+  } = returnValue || {}
+  return {
+    status,
+    statusText,
+    headers,
+    body,
+    ...rest,
+  }
+}
+
 const generateResponseDescription = async ({
   requestToResponse,
   request,
@@ -736,7 +784,7 @@ const generateResponseDescription = async ({
       pushResponse,
     })
     return {
-      responseProperties: returnValue,
+      returnValue,
     }
   } catch (error) {
     if (error.name === "AbortError" && request.signal.aborted) {