@jsenv/server 10.2.1 → 12.2.0

package/README.md

@@ -70,7 +70,10 @@ const notFoundService = (request) => {
 }
 
 const server = await startServer({
-  requestToResponse: composeServices(indexService, notFoundService),
+  requestToResponse: composeServices({
+    index: indexService,
+    otherwise: notFoundService,
+  }),
 })
 
 const fetch = await import("node-fetch")
@@ -89,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/main.js

@@ -5,11 +5,8 @@
  */
 
 export { startServer } from "./src/startServer.js"
-export {
-  composeServices,
-  composeServicesWithTiming,
-  redirectRequest,
-} from "./src/service_composition/service_composition.js"
+export { composeServices } from "./src/service_composition/service_composition.js"
+export { setupRoutes } from "./src/service_composition/routing.js"
 export { jsenvServerInternalErrorToResponse } from "./src/jsenvServerInternalErrorToResponse.js"
 export { readRequestBody } from "./src/readRequestBody.js"
 export { fetchFileSystem } from "./src/fetch_filesystem.js"
@@ -46,6 +43,7 @@ export { pluginContentNegotiationCheck } from "./src/content_negotiation/plugin_
 // others
 export { fetchUrl } from "./src/fetch_url.js"
 export { composeTwoResponses } from "./src/internal/response_composition.js"
+export { pluginRessourceAliases } from "./src/ressource_aliases/plugin_ressource_aliases.js"
 export { pluginRequestWaitingCheck } from "./src/plugin_request_waiting_check.js"
 export { findFreePort } from "./src/internal/listen.js"
 export { urlToContentType } from "./src/urlToContentType.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "10.2.1",
+  "version": "12.2.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": ">=14.17.0"
+    "node": ">=16.12.0"
   },
   "publishConfig": {
     "access": "public"
@@ -25,20 +25,20 @@
     },
     "./*": "./*"
   },
+  "main": "./main.js",
   "files": [
     "/src/",
     "/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",
@@ -48,28 +48,25 @@
     "@jsenv/abort": "4.1.1",
     "@jsenv/logger": "4.0.1",
     "@jsenv/url-meta": "6.0.1",
-    "node-fetch": "2.6.2"
+    "node-fetch": "2.6.2",
+    "path-to-regexp": "6.2.0"
   },
   "devDependencies": {
-    "@babel/core": "7.16.0",
-    "@babel/eslint-parser": "7.16.0",
     "@jsenv/assert": "2.3.2",
-    "@jsenv/codecov-upload": "3.5.0",
-    "@jsenv/core": "23.7.1",
-    "@jsenv/eslint-config": "16.0.8",
+    "@jsenv/core": "23.10.0",
+    "@jsenv/eslint-config": "16.0.9",
     "@jsenv/filesystem": "2.5.1",
     "@jsenv/github-release-package": "1.2.3",
-    "@jsenv/https-local": "1.0.2",
+    "@jsenv/https-local": "1.0.3",
     "@jsenv/importmap-eslint-resolver": "5.1.2",
-    "@jsenv/importmap-node-module": "2.4.1",
+    "@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": "7.32.0",
-    "eslint-plugin-import": "2.25.2",
+    "eslint": "8.2.0",
+    "eslint-plugin-import": "2.25.3",
     "eventsource": "1.1.0",
-    "fastify": "3.22.1",
-    "fastify-static": "4.4.2",
+    "fastify": "3.24.0",
+    "fastify-static": "4.5.0",
     "playwright": "1.16.3",
     "prettier": "2.4.1"
   }

package/src/internal/request_factory.js

@@ -1,125 +1,93 @@
-import { urlToMeta, normalizeStructuredMetaMap } from "@jsenv/url-meta"
-
 import { nodeStreamToObservable } from "./nodeStreamToObservable.js"
 import { headersFromObject } from "./headersFromObject.js"
 
-export const createRequestFactory = ({ serverOrigin, ressourceAliases }) => {
-  const ressourceAliasMap = {}
-  Object.keys(ressourceAliases).forEach((key) => {
-    ressourceAliasMap[ressourceAliases[key]] = key
-  })
-  const structuredMetaMap = normalizeStructuredMetaMap(
-    { alias: ressourceAliasMap },
-    "file:///",
-  )
-
-  const getRessourceAlias = (pathname) => {
-    const { alias } = urlToMeta({
-      url: `file://${pathname}`,
-      structuredMetaMap,
-    })
-    return alias
+export const fromNodeRequest = (nodeRequest, { serverOrigin, signal }) => {
+  const headers = headersFromObject(nodeRequest.headers)
+  const body = nodeStreamToObservable(nodeRequest)
+
+  let requestOrigin
+  if (nodeRequest.authority) {
+    requestOrigin = nodeRequest.connection.encrypted
+      ? `https://${nodeRequest.authority}`
+      : `http://${nodeRequest.authority}`
+  } else if (nodeRequest.headers.host) {
+    requestOrigin = nodeRequest.connection.encrypted
+      ? `https://${nodeRequest.headers.host}`
+      : `http://${nodeRequest.headers.host}`
+  } else {
+    requestOrigin = serverOrigin
   }
 
-  const getPropertiesFromRessource = ({ ressource, baseUrl }) => {
-    const urlObject = new URL(ressource, baseUrl)
-    let pathname = urlObject.pathname
-    const ressourceAlias = getRessourceAlias(pathname)
-
-    if (!ressourceAlias) {
-      return {
-        url: String(urlObject),
-        pathname,
-        ressource,
-      }
-    }
+  return Object.freeze({
+    signal,
+    http2: Boolean(nodeRequest.stream),
+    origin: requestOrigin,
+    ...getPropertiesFromRessource({
+      ressource: nodeRequest.url,
+      baseUrl: requestOrigin,
+    }),
+    method: nodeRequest.method,
+    headers,
+    body,
+  })
+}
 
-    const urlObjectAfterAlias = replaceUrlRessource(urlObject, ressourceAlias)
-    return {
-      url: String(urlObjectAfterAlias),
-      pathname: urlObjectAfterAlias.pathname,
-      ressource: `${urlObjectAfterAlias.pathname}${urlObjectAfterAlias.search}`,
-      ressourceBeforeAlias: ressource,
-    }
+export const applyRedirectionToRequest = (
+  request,
+  { ressource, pathname, ...rest },
+) => {
+  return {
+    ...request,
+    ...(ressource
+      ? getPropertiesFromRessource({
+          ressource,
+          baseUrl: request.url,
+        })
+      : pathname
+      ? getPropertiesFromPathname({
+          pathname,
+          baseUrl: request.url,
+        })
+      : {}),
+    ...rest,
   }
+}
 
-  const getPropertiesFromPathname = ({ pathname, baseUrl }) => {
-    return getPropertiesFromRessource({
-      ressource: `${pathname}${new URL(baseUrl).search}`,
-      baseUrl,
-    })
-  }
+const getPropertiesFromRessource = ({ ressource, baseUrl }) => {
+  const urlObject = new URL(ressource, baseUrl)
+  let pathname = urlObject.pathname
 
   return {
-    fromNodeRequest: (nodeRequest, { signal }) => {
-      const headers = headersFromObject(nodeRequest.headers)
-      const body = nodeStreamToObservable(nodeRequest)
-
-      let requestOrigin
-      if (nodeRequest.authority) {
-        requestOrigin = nodeRequest.connection.encrypted
-          ? `https://${nodeRequest.authority}`
-          : `http://${nodeRequest.authority}`
-      } else if (nodeRequest.headers.host) {
-        requestOrigin = nodeRequest.connection.encrypted
-          ? `https://${nodeRequest.headers.host}`
-          : `http://${nodeRequest.headers.host}`
-      } else {
-        requestOrigin = serverOrigin
-      }
-
-      return Object.freeze({
-        signal,
-        http2: Boolean(nodeRequest.stream),
-        origin: requestOrigin,
-        ...getPropertiesFromRessource({
-          ressource: nodeRequest.url,
-          baseUrl: requestOrigin,
-        }),
-        method: nodeRequest.method,
-        headers,
-        body,
-      })
-    },
-
-    createPushRequest: (request, { signal, pathname, method }) => {
-      const pushRequest = Object.freeze({
-        ...request,
-        parent: request,
-        signal,
-        http2: true,
-        ...(pathname
-          ? getPropertiesFromPathname({
-              pathname,
-              baseUrl: request.url,
-            })
-          : {}),
-        method: method || request.method,
-        headers: getHeadersInheritedByPushRequest(request),
-        body: undefined,
-      })
+    url: String(urlObject),
+    pathname,
+    ressource,
+  }
+}
 
-      return pushRequest
-    },
+const getPropertiesFromPathname = ({ pathname, baseUrl }) => {
+  return getPropertiesFromRessource({
+    ressource: `${pathname}${new URL(baseUrl).search}`,
+    baseUrl,
+  })
+}
 
-    applyRedirectionToRequest: (request, { ressource, pathname, ...rest }) => {
-      return {
-        ...request,
-        ...(ressource
-          ? getPropertiesFromRessource({
-              ressource,
-              baseUrl: request.url,
-            })
-          : pathname
-          ? getPropertiesFromPathname({
-              pathname,
-              baseUrl: request.url,
-            })
-          : {}),
-        ...rest,
-      }
-    },
-  }
+export const createPushRequest = (request, { signal, pathname, method }) => {
+  const pushRequest = Object.freeze({
+    ...request,
+    parent: request,
+    signal,
+    http2: true,
+    ...(pathname
+      ? getPropertiesFromPathname({
+          pathname,
+          baseUrl: request.url,
+        })
+      : {}),
+    method: method || request.method,
+    headers: getHeadersInheritedByPushRequest(request),
+    body: undefined,
+  })
+  return pushRequest
 }
 
 const getHeadersInheritedByPushRequest = (request) => {
@@ -135,17 +103,3 @@ const getHeadersInheritedByPushRequest = (request) => {
 
   return headersInherited
 }
-
-const replaceUrlRessource = (url, ressource) => {
-  const urlObject = new URL(url)
-
-  const searchSeparatorIndex = ressource.indexOf("?")
-  if (searchSeparatorIndex === -1) {
-    urlObject.pathname = ressource
-    return urlObject
-  }
-
-  const pathname = ressource.slice(0, searchSeparatorIndex)
-  urlObject.pathname = pathname
-  return urlObject
-}

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

@@ -16,8 +16,6 @@ export const pluginRequestWaitingCheck = ({
 } = {}) => {
   return {
     plugin_request_waiting_check: {
-      init: () => {},
-
       onRequest: (request, { logger }) => {
         const timeout = setTimeout(
           () => requestWaitingCallback({ request, logger, requestWaitingMs }),

package/src/ressource_aliases/plugin_ressource_aliases.js

@@ -0,0 +1,55 @@
+import { urlToMeta, normalizeStructuredMetaMap } from "@jsenv/url-meta"
+
+export const pluginRessourceAliases = (ressourceAliases) => {
+  const ressourceAliasMap = {}
+  Object.keys(ressourceAliases).forEach((key) => {
+    ressourceAliasMap[ressourceAliases[key]] = key
+  })
+  const structuredMetaMap = normalizeStructuredMetaMap(
+    { alias: ressourceAliasMap },
+    "file:///",
+  )
+
+  const getRessourceAlias = (pathname) => {
+    const { alias } = urlToMeta({
+      url: `file://${pathname}`,
+      structuredMetaMap,
+    })
+    return alias
+  }
+
+  return {
+    ressource_aliases: {
+      onRequest: (request, { redirectRequest }) => {
+        const ressourceAlias = getRessourceAlias(request.pathname)
+        if (!ressourceAlias) {
+          return
+        }
+
+        const urlObjectAfterAlias = replaceUrlRessource(
+          request.url,
+          ressourceAlias,
+        )
+        const ressource = `${urlObjectAfterAlias.pathname}${urlObjectAfterAlias.search}`
+        redirectRequest({
+          ressourceBeforeAlias: request.ressource,
+          ressource,
+        })
+      },
+    },
+  }
+}
+
+const replaceUrlRessource = (url, ressource) => {
+  const urlObject = new URL(url)
+
+  const searchSeparatorIndex = ressource.indexOf("?")
+  if (searchSeparatorIndex === -1) {
+    urlObject.pathname = ressource
+    return urlObject
+  }
+
+  const pathname = ressource.slice(0, searchSeparatorIndex)
+  urlObject.pathname = pathname
+  return urlObject
+}

package/src/service_composition/routing.js

@@ -0,0 +1,35 @@
+import { createRequire } from "node:module"
+
+const require = createRequire(import.meta.url)
+
+export const setupRoutes = (routes) => {
+  const { match } = require("path-to-regexp")
+
+  const candidates = Object.keys(routes).map((pathPattern) => {
+    const applyPatternMatching = match(pathPattern, {
+      decode: decodeURIComponent,
+    })
+    return {
+      applyPatternMatching,
+      requestHandler: routes[pathPattern],
+    }
+  })
+
+  return (request, { pushResponse, redirectRequest }) => {
+    let result
+    const found = candidates.find((candidate) => {
+      result = candidate.applyPatternMatching(request.pathname)
+      return Boolean(result)
+    })
+    if (found) {
+      return found.requestHandler(
+        {
+          ...request,
+          routeParams: result.params,
+        },
+        { pushResponse, redirectRequest },
+      )
+    }
+    return null
+  }
+}

package/src/service_composition/service_composition.js

@@ -1,39 +1,13 @@
 import { timeFunction } from "@jsenv/server/src/server_timing/timing_measure.js"
 import { composeTwoResponses } from "@jsenv/server/src/internal/response_composition.js"
+import { applyRedirectionToRequest } from "@jsenv/server/src/internal/request_factory.js"
 
-const requestRedirectionSymbol = Symbol("request_redirection")
-
-export const redirectRequest = (redirection) => {
-  return {
-    [requestRedirectionSymbol]: redirection,
-  }
-}
-
-export const composeServices = (...callbacks) => {
-  return (request, { pushResponse, requestFactory }) => {
-    return firstOperationMatching({
-      array: callbacks,
-      start: (callback) => callback(request, { pushResponse }),
-      predicate: (returnValue) => {
-        if (returnValue === null || typeof returnValue !== "object") {
-          return false
-        }
-        const requestRedirection = returnValue[requestRedirectionSymbol]
-        if (requestRedirection) {
-          request = requestFactory.applyRedirectionToRequest(
-            request,
-            requestRedirection,
-          )
-          return false
-        }
-        return true
-      },
-    })
-  }
-}
+export const composeServices = (namedServices) => {
+  return async (request, { pushResponse }) => {
+    const redirectRequest = (requestRedirection) => {
+      request = applyRedirectionToRequest(request, requestRedirection)
+    }
 
-export const composeServicesWithTiming = (namedServices) => {
-  return async (request, { pushResponse, requestFactory }) => {
     const servicesTiming = {}
     const response = await firstOperationMatching({
       array: Object.keys(namedServices).map((serviceName) => {
@@ -41,7 +15,7 @@ export const composeServicesWithTiming = (namedServices) => {
       }),
       start: async ({ serviceName, serviceFn }) => {
         const [serviceTiming, value] = await timeFunction(serviceName, () =>
-          serviceFn(request, { pushResponse }),
+          serviceFn(request, { pushResponse, redirectRequest }),
         )
         Object.assign(servicesTiming, serviceTiming)
         return value
@@ -50,14 +24,6 @@ export const composeServicesWithTiming = (namedServices) => {
         if (returnValue === null || typeof returnValue !== "object") {
           return false
         }
-        const requestRedirection = returnValue[requestRedirectionSymbol]
-        if (requestRedirection) {
-          request = requestFactory.applyRedirectionToRequest(
-            request,
-            requestRedirection,
-          )
-          return false
-        }
         return true
       },
     })

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

@@ -11,7 +11,11 @@ import {
 import { createPolyglotServer } from "./internal/server-polyglot.js"
 import { trackServerPendingConnections } from "./internal/trackServerPendingConnections.js"
 import { trackServerPendingRequests } from "./internal/trackServerPendingRequests.js"
-import { createRequestFactory } from "./internal/request_factory.js"
+import {
+  fromNodeRequest,
+  createPushRequest,
+  applyRedirectionToRequest,
+} from "./internal/request_factory.js"
 import { populateNodeResponse } from "./internal/populateNodeResponse.js"
 import { colorizeResponseStatus } from "./internal/colorizeResponseStatus.js"
 import { getServerOrigins } from "./internal/getServerOrigins.js"
@@ -43,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
@@ -56,7 +60,6 @@ export const startServer = async ({
   stopOnInternalError = false,
   keepProcessAlive = true,
   requestToResponse = () => null,
-  ressourceAliases = {},
   plugins = {},
 
   sendServerInternalErrorDetails = false,
@@ -71,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") {
@@ -131,8 +134,8 @@ export const startServer = async ({
       protocol,
       redirectHttpToHttps,
       allowHttpRequestOnHttps,
-      serverCertificate,
-      serverCertificatePrivateKey,
+      certificate,
+      privateKey,
       http2,
       http1Allowed,
     })
@@ -226,11 +229,6 @@ export const startServer = async ({
     })
   })
 
-  const requestFactory = createRequestFactory({
-    serverOrigin,
-    ressourceAliases,
-  })
-
   const requestCallback = async (nodeRequest, nodeResponse) => {
     if (!nagle) {
       nodeRequest.connection.setNoDelay(true)
@@ -268,7 +266,8 @@ export const startServer = async ({
       return stopCallbackList.add(abort)
     })
 
-    const request = requestFactory.fromNodeRequest(nodeRequest, {
+    const request = fromNodeRequest(nodeRequest, {
+      serverOrigin,
       signal: receiveRequestOperation.signal,
     })
 
@@ -333,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) => {
@@ -414,7 +390,7 @@ export const startServer = async ({
         pushResponseOperation.addAbortSignal(signal)
         pushResponseOperation.addAbortSignal(abortController.signal)
 
-        const pushRequest = requestFactory.createPushRequest(request, {
+        const pushRequest = createPushRequest(request, {
           signal: pushResponseOperation.signal,
           pathname: path,
           method,
@@ -476,15 +452,23 @@ export const startServer = async ({
       const shortcircuitResponse = (value) => {
         responseFromShortcircuit = value
       }
+      const redirectRequest = (requestRedirection) => {
+        request = applyRedirectionToRequest(request, requestRedirection)
+      }
       Object.keys(plugins).forEach((pluginName) => {
         const { onRequest } = plugins[pluginName]
         if (onRequest) {
           const returnValue = onRequest(request, {
             warn,
+            logger,
             shortcircuitResponse,
+            redirectRequest,
           })
           if (returnValue) {
-            requestPlugins.push(returnValue)
+            requestPlugins.push({
+              pluginName,
+              ...returnValue,
+            })
           }
         }
       })
@@ -493,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,
@@ -504,7 +531,6 @@ export const startServer = async ({
                 },
               )
             },
-            requestFactory,
           })
 
       if (aborted) {
@@ -698,8 +724,8 @@ const createNodeServer = async ({
   protocol,
   redirectHttpToHttps,
   allowHttpRequestOnHttps,
-  serverCertificate,
-  serverCertificatePrivateKey,
+  certificate,
+  privateKey,
   http2,
   http1Allowed,
 }) => {
@@ -709,8 +735,8 @@ const createNodeServer = async ({
 
   if (redirectHttpToHttps || allowHttpRequestOnHttps) {
     return createPolyglotServer({
-      serverCertificate,
-      serverCertificatePrivateKey,
+      certificate,
+      privateKey,
       http2,
       http1Allowed,
     })
@@ -718,8 +744,8 @@ const createNodeServer = async ({
 
   const { createServer } = await import("https")
   return createServer({
-    cert: serverCertificate,
-    key: serverCertificatePrivateKey,
+    cert: certificate,
+    key: privateKey,
   })
 }
 
@@ -727,12 +753,10 @@ const generateResponseDescription = async ({
   requestToResponse,
   request,
   pushResponse,
-  requestFactory,
 }) => {
   try {
     const returnValue = await requestToResponse(request, {
       pushResponse,
-      requestFactory,
     })
     return {
       responseProperties: returnValue,