@jsenv/server 12.3.0 → 12.4.0

package/main.js

@@ -42,6 +42,7 @@ export { pluginContentNegotiationCheck } from "./src/content_negotiation/plugin_
 
 // others
 export { fetchUrl } from "./src/fetch_url.js"
+export { fromFetchResponse } from "./src/from_fetch_response.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"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "12.3.0",
+  "version": "12.4.0",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {

package/src/from_fetch_response.js

@@ -0,0 +1,15 @@
+export const fromFetchResponse = (fetchResponse) => {
+  const responseHeaders = {}
+  const headersToIgnore = ["connection"]
+  fetchResponse.headers.forEach((value, name) => {
+    if (!headersToIgnore.includes(name)) {
+      responseHeaders[name] = value
+    }
+  })
+  return {
+    status: fetchResponse.status,
+    statusText: fetchResponse.statusText,
+    headers: responseHeaders,
+    body: fetchResponse.body, // node-fetch assumed
+  }
+}

package/src/internal/nodeStreamToObservable.js

@@ -1,12 +1,17 @@
 // https://github.com/jamestalmage/stream-to-observable/blob/master/index.js
 import { Readable } from "node:stream"
-
 import { createObservable } from "./observable.js"
 
 const readableStreamLifetimeInSeconds = 120
 
 export const nodeStreamToObservable = (nodeStream) => {
   const observable = createObservable(({ next, error, complete }) => {
+    if (nodeStream.isPaused()) {
+      nodeStream.resume()
+    } else if (nodeStream.complete) {
+      complete()
+      return null
+    }
     const cleanup = () => {
       nodeStream.removeListener("data", next)
       nodeStream.removeListener("error", error)
@@ -14,13 +19,17 @@ export const nodeStreamToObservable = (nodeStream) => {
       nodeStream.removeListener("close", cleanup)
       nodeStream.destroy()
     }
-
     // should we do nodeStream.resume() in case the stream was paused ?
     nodeStream.once("error", error)
-    nodeStream.on("data", next)
-    nodeStream.once("close", cleanup)
-    nodeStream.once("end", complete)
-
+    nodeStream.on("data", (data) => {
+      next(data)
+    })
+    nodeStream.once("close", () => {
+      cleanup()
+    })
+    nodeStream.once("end", () => {
+      complete()
+    })
     return cleanup
   })
 

package/src/internal/populateNodeResponse.js

@@ -1,3 +1,4 @@
+import http from "node:http"
 import { Http2ServerResponse } from "node:http2"
 import { raceCallbacks } from "@jsenv/abort"
 
@@ -22,8 +23,8 @@ export const populateNodeResponse = async (
     status,
     statusText,
     headers,
+    onHeadersSent,
   })
-  onHeadersSent()
 
   if (!body) {
     onEnd()
@@ -134,41 +135,48 @@ export const populateNodeResponse = async (
   })
 }
 
-const writeHead = (responseStream, { status, statusText, headers }) => {
+const writeHead = (
+  responseStream,
+  { status, statusText, headers, onHeadersSent },
+) => {
   const responseIsHttp2ServerResponse =
     responseStream instanceof Http2ServerResponse
   const responseIsServerHttp2Stream =
     responseStream.constructor.name === "ServerHttp2Stream"
-
   let nodeHeaders = headersToNodeHeaders(headers, {
     // https://github.com/nodejs/node/blob/79296dc2d02c0b9872bbfcbb89148ea036a546d0/lib/internal/http2/compat.js#L112
     ignoreConnectionHeader:
       responseIsHttp2ServerResponse || responseIsServerHttp2Stream,
   })
-
+  if (statusText === undefined) {
+    statusText = statusTextFromStatus(status)
+  }
   if (responseIsServerHttp2Stream) {
     nodeHeaders = {
       ...nodeHeaders,
       ":status": status,
     }
     responseStream.respond(nodeHeaders)
+    onHeadersSent({ nodeHeaders, status, statusText })
     return
   }
-
   // nodejs strange signature for writeHead force this
   // https://nodejs.org/api/http.html#http_response_writehead_statuscode_statusmessage_headers
   if (
-    statusText === undefined ||
     // https://github.com/nodejs/node/blob/79296dc2d02c0b9872bbfcbb89148ea036a546d0/lib/internal/http2/compat.js#L97
     responseIsHttp2ServerResponse
   ) {
     responseStream.writeHead(status, nodeHeaders)
+    onHeadersSent({ nodeHeaders, status, statusText })
     return
   }
-
   responseStream.writeHead(status, statusText, nodeHeaders)
+  onHeadersSent({ nodeHeaders, status, statusText })
 }
 
+const statusTextFromStatus = (status) =>
+  http.STATUS_CODES[status] || "not specified"
+
 const headersToNodeHeaders = (headers, { ignoreConnectionHeader }) => {
   const nodeHeaders = {}
 

package/src/ressource_aliases/plugin_ressource_aliases.js

@@ -1,15 +1,21 @@
 import { urlToMeta, normalizeStructuredMetaMap } from "@jsenv/url-meta"
 
+import { escapeRegexpSpecialCharacters } from "./regex_escape.js"
+
 export const pluginRessourceAliases = (ressourceAliases) => {
-  const ressourceAliasMap = {}
+  const alias = {}
   Object.keys(ressourceAliases).forEach((key) => {
-    ressourceAliasMap[ressourceAliases[key]] = key
+    alias[key] = {
+      pattern: key,
+      replacement: ressourceAliases[key],
+    }
   })
   const structuredMetaMap = normalizeStructuredMetaMap(
-    { alias: ressourceAliasMap },
+    {
+      alias,
+    },
     "file:///",
   )
-
   const getRessourceAlias = (pathname) => {
     const { alias } = urlToMeta({
       url: `file://${pathname}`,
@@ -25,14 +31,35 @@ export const pluginRessourceAliases = (ressourceAliases) => {
         if (!ressourceAlias) {
           return
         }
-
-        const urlObjectAfterAlias = replaceUrlRessource(
-          request.url,
-          ressourceAlias,
-        )
-        const ressource = `${urlObjectAfterAlias.pathname}${urlObjectAfterAlias.search}`
+        const { pattern, replacement } = ressourceAlias
+        let newValue
+        const ressourceBeforeAlias = request.ressource
+        if (replacement.includes("*")) {
+          let regexsource = ""
+          let i = 0
+          while (i < pattern.length) {
+            const char = pattern[i]
+            i++
+            if (char === "*") {
+              regexsource += "(.+)"
+            } else {
+              regexsource += escapeRegexpSpecialCharacters(char)
+            }
+          }
+          const regex = new RegExp(regexsource)
+          const matchResult = ressourceBeforeAlias.match(regex)
+          const parts = replacement.split("*")
+          newValue = parts.reduce((previous, value, index) => {
+            return `${previous}${value}${
+              index === parts.length - 1 ? "" : matchResult[index + 1]
+            }`
+          }, "")
+        } else {
+          newValue = replacement
+        }
+        const ressource = replaceRessource(ressourceBeforeAlias, newValue)
         redirectRequest({
-          ressourceBeforeAlias: request.ressource,
+          ressourceBeforeAlias,
           ressource,
         })
       },
@@ -40,16 +67,13 @@ export const pluginRessourceAliases = (ressourceAliases) => {
   }
 }
 
-const replaceUrlRessource = (url, ressource) => {
-  const urlObject = new URL(url)
-
-  const searchSeparatorIndex = ressource.indexOf("?")
-  if (searchSeparatorIndex === -1) {
-    urlObject.pathname = ressource
-    return urlObject
+const replaceRessource = (ressourceBeforeAlias, newValue) => {
+  const urlObject = new URL(ressourceBeforeAlias, "file://")
+  const searchSeparatorIndex = newValue.indexOf("?")
+  if (searchSeparatorIndex > -1) {
+    return newValue // let new value override search params
   }
-
-  const pathname = ressource.slice(0, searchSeparatorIndex)
-  urlObject.pathname = pathname
-  return urlObject
+  urlObject.pathname = newValue
+  const ressource = `${urlObject.pathname}${urlObject.search}`
+  return ressource
 }

package/src/ressource_aliases/regex_escape.js

@@ -0,0 +1,34 @@
+// https://github.com/benjamingr/RegExp.escape/blob/master/polyfill.js
+
+export const escapeRegexpSpecialCharacters = (string) => {
+  string = String(string)
+  let i = 0
+  let escapedString = ""
+
+  while (i < string.length) {
+    const char = string[i]
+    i++
+    escapedString += isRegExpSpecialChar(char) ? `\\${char}` : char
+  }
+  return escapedString
+}
+
+const isRegExpSpecialChar = (char) => regexpSpecialChars.indexOf(char) > -1
+
+const regexpSpecialChars = [
+  "/",
+  "^",
+  "\\",
+  "[",
+  "]",
+  "(",
+  ")",
+  "{",
+  "}",
+  "?",
+  "+",
+  "*",
+  ".",
+  "|",
+  "$",
+]

package/src/startServer.js

@@ -230,6 +230,10 @@ export const startServer = async ({
   })
 
   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()
     if (!nagle) {
       nodeRequest.connection.setNoDelay(true)
     }
@@ -309,7 +313,6 @@ export const startServer = async ({
 
       visitRequestNodeToLog(rootRequestNode, 0)
     }
-
     nodeRequest.on("error", (error) => {
       if (error.message === "aborted") {
         addRequestLog(rootRequestNode, {
@@ -570,7 +573,7 @@ export const startServer = async ({
           return composeTwoResponses(
             {
               status: 500,
-              statusText: statusToStatusText(500),
+              statusText: "Internal Server Error",
               headers: {
                 // ensure error are not cached
                 "cache-control": "no-store",
@@ -580,9 +583,21 @@ export const startServer = async ({
             propertiesFromError,
           )
         }
-        const responseProperties = normalizeResponseProperties(
-          result.returnValue,
-        )
+
+        const {
+          status = 501,
+          statusText,
+          headers = {},
+          body,
+          ...rest
+        } = result.returnValue || {}
+        const responseProperties = {
+          status,
+          statusText,
+          headers,
+          body,
+          ...rest,
+        }
         return responseProperties
       }
 
@@ -652,12 +667,10 @@ export const startServer = async ({
           })
           onRequestHandled(requestNode)
         },
-        onHeadersSent: () => {
+        onHeadersSent: ({ status, statusText }) => {
           addRequestLog(requestNode, {
             type: "info",
-            value: `${colorizeResponseStatus(responseProperties.status)} ${
-              responseProperties.statusText
-            }`,
+            value: `${colorizeResponseStatus(status)} ${statusText}`,
           })
         },
         onEnd: () => {
@@ -673,6 +686,7 @@ export const startServer = async ({
       const responseProperties = await handleRequest(request, {
         requestNode: rootRequestNode,
       })
+      nodeRequest.resume()
       if (receiveRequestOperation.signal.aborted) {
         return
       }
@@ -742,38 +756,6 @@ const createNodeServer = async ({
   })
 }
 
-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,
@@ -797,10 +779,6 @@ const generateResponseDescription = async ({
     }
   }
 }
-
-const statusToStatusText = (status) =>
-  http.STATUS_CODES[status] || "not specified"
-
 const testCanPushStream = (http2Stream) => {
   if (!http2Stream.pushAllowed) {
     return {