@jsenv/server 12.1.0 → 12.2.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.1.0",
+  "version": "12.2.0",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -31,15 +31,14 @@
     "/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",
+    "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",
+    "eslint-check": "node ./node_modules/eslint/bin/eslint.js . --ext=.js,.mjs",
+    "prettier-check": "prettier --check .",
+    "prettier-write": "prettier --write .",
     "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",
@@ -63,7 +62,6 @@
     "@jsenv/importmap-node-module": "2.7.1",
     "@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",
     "eventsource": "1.1.0",

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/startServer.js

@@ -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,7 +465,10 @@ export const startServer = async ({
             redirectRequest,
           })
           if (returnValue) {
-            requestPlugins.push(returnValue)
+            requestPlugins.push({
+              pluginName,
+              ...returnValue,
+            })
           }
         }
       })
@@ -497,10 +477,53 @@ export const startServer = async ({
         : 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,
@@ -701,8 +724,8 @@ const createNodeServer = async ({
   protocol,
   redirectHttpToHttps,
   allowHttpRequestOnHttps,
-  serverCertificate,
-  serverCertificatePrivateKey,
+  certificate,
+  privateKey,
   http2,
   http1Allowed,
 }) => {
@@ -712,8 +735,8 @@ const createNodeServer = async ({
 
   if (redirectHttpToHttps || allowHttpRequestOnHttps) {
     return createPolyglotServer({
-      serverCertificate,
-      serverCertificatePrivateKey,
+      certificate,
+      privateKey,
       http2,
       http1Allowed,
     })
@@ -721,8 +744,8 @@ const createNodeServer = async ({
 
   const { createServer } = await import("https")
   return createServer({
-    cert: serverCertificate,
-    key: serverCertificatePrivateKey,
+    cert: certificate,
+    key: privateKey,
   })
 }