@jsenv/server 15.3.3 → 15.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "15.3.3",
+  "version": "15.4.1",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -37,6 +37,7 @@
     "ws": "8.18.0"
   },
   "devDependencies": {
-    "eventsource": "2.0.2"
+    "eventsource": "3.0.2",
+    "undici": "7.2.3"
   }
 }

package/src/fetch_filesystem.js

@@ -6,7 +6,6 @@
 
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
 import { createReadStream, readFile, statSync } from "node:fs";
-
 import { pickContentEncoding } from "./content_negotiation/pick_content_encoding.js";
 import { convertFileSystemErrorToResponseProperties } from "./internal/convertFileSystemErrorToResponseProperties.js";
 import { bufferToEtag } from "./internal/etag.js";
@@ -35,6 +34,7 @@ export const fetchFileSystem = async (
       : "no-store",
     canReadDirectory = false,
     rootDirectoryUrl, //  = `${pathToFileURL(process.cwd())}/`,
+    ENOENTFallback = () => {},
   } = {},
 ) => {
   const urlString = asUrlString(filesystemUrl);
@@ -92,100 +92,109 @@ export const fetchFileSystem = async (
     };
   }
 
-  const sourceUrl = `file://${new URL(urlString).pathname}`;
-  try {
-    const [readStatTiming, sourceStat] = await timeFunction(
-      "file service>read file stat",
-      () => statSync(new URL(sourceUrl)),
-    );
-    if (sourceStat.isDirectory()) {
-      if (canReadDirectory) {
-        return serveDirectory(urlString, {
+  const serveFile = async (fileUrl) => {
+    try {
+      const [readStatTiming, fileStat] = timeFunction(
+        "file service>read file stat",
+        () => statSync(new URL(fileUrl)),
+      );
+      if (fileStat.isDirectory()) {
+        if (canReadDirectory) {
+          return serveDirectory(fileUrl, {
+            headers,
+            canReadDirectory,
+            rootDirectoryUrl,
+          });
+        }
+        return {
+          status: 403,
+          statusText: "not allowed to read directory",
+        };
+      }
+      // not a file, give up
+      if (!fileStat.isFile()) {
+        return {
+          status: 404,
+          timing: readStatTiming,
+        };
+      }
+
+      const clientCacheResponse = await getClientCacheResponse({
+        headers,
+        etagEnabled,
+        etagMemory,
+        etagMemoryMaxSize,
+        mtimeEnabled,
+        fileStat,
+        fileUrl,
+      });
+
+      // send 304 (redirect response to client cache)
+      // because the response body does not have to be transmitted
+      if (clientCacheResponse.status === 304) {
+        return composeTwoResponses(
+          {
+            timing: readStatTiming,
+            headers: {
+              ...(cacheControl ? { "cache-control": cacheControl } : {}),
+            },
+          },
+          clientCacheResponse,
+        );
+      }
+
+      let response;
+      if (compressionEnabled && fileStat.size >= compressionSizeThreshold) {
+        const compressedResponse = await getCompressedResponse({
           headers,
-          canReadDirectory,
-          rootDirectoryUrl,
+          fileUrl,
+        });
+        if (compressedResponse) {
+          response = compressedResponse;
+        }
+      }
+      if (!response) {
+        response = await getRawResponse({
+          fileStat,
+          fileUrl,
         });
       }
-      return {
-        status: 403,
-        statusText: "not allowed to read directory",
-      };
-    }
-    // not a file, give up
-    if (!sourceStat.isFile()) {
-      return {
-        status: 404,
-        timing: readStatTiming,
-      };
-    }
-
-    const clientCacheResponse = await getClientCacheResponse({
-      headers,
-      etagEnabled,
-      etagMemory,
-      etagMemoryMaxSize,
-      mtimeEnabled,
-      sourceStat,
-      sourceUrl,
-    });
 
-    // send 304 (redirect response to client cache)
-    // because the response body does not have to be transmitted
-    if (clientCacheResponse.status === 304) {
-      return composeTwoResponses(
+      const intermediateResponse = composeTwoResponses(
         {
           timing: readStatTiming,
           headers: {
             ...(cacheControl ? { "cache-control": cacheControl } : {}),
+            // even if client cache is disabled, server can still
+            // send his own cache control but client should just ignore it
+            // and keep sending cache-control: 'no-store'
+            // if not, uncomment the line below to preserve client
+            // desire to ignore cache
+            // ...(headers["cache-control"] === "no-store" ? { "cache-control": "no-store" } : {}),
           },
         },
-        clientCacheResponse,
+        response,
       );
-    }
-
-    let response;
-    if (compressionEnabled && sourceStat.size >= compressionSizeThreshold) {
-      const compressedResponse = await getCompressedResponse({
-        headers,
-        sourceUrl,
-      });
-      if (compressedResponse) {
-        response = compressedResponse;
+      return composeTwoResponses(intermediateResponse, clientCacheResponse);
+    } catch (e) {
+      if (e.code === "ENOENT") {
+        const fallbackFileUrl = ENOENTFallback();
+        if (fallbackFileUrl) {
+          return serveFile(fallbackFileUrl);
+        }
       }
+      return composeTwoResponses(
+        {
+          headers: {
+            ...(cacheControl ? { "cache-control": cacheControl } : {}),
+          },
+        },
+        convertFileSystemErrorToResponseProperties(e) || {},
+      );
     }
-    if (!response) {
-      response = await getRawResponse({
-        sourceStat,
-        sourceUrl,
-      });
-    }
+  };
 
-    const intermediateResponse = composeTwoResponses(
-      {
-        timing: readStatTiming,
-        headers: {
-          ...(cacheControl ? { "cache-control": cacheControl } : {}),
-          // even if client cache is disabled, server can still
-          // send his own cache control but client should just ignore it
-          // and keep sending cache-control: 'no-store'
-          // if not, uncomment the line below to preserve client
-          // desire to ignore cache
-          // ...(headers["cache-control"] === "no-store" ? { "cache-control": "no-store" } : {}),
-        },
-      },
-      response,
-    );
-    return composeTwoResponses(intermediateResponse, clientCacheResponse);
-  } catch (e) {
-    return composeTwoResponses(
-      {
-        headers: {
-          ...(cacheControl ? { "cache-control": cacheControl } : {}),
-        },
-      },
-      convertFileSystemErrorToResponseProperties(e) || {},
-    );
-  }
+  return serveFile(`file://${new URL(urlString).pathname}`);
 };
 
 const create500Response = (message) => {
@@ -205,8 +214,8 @@ const getClientCacheResponse = async ({
   etagMemory,
   etagMemoryMaxSize,
   mtimeEnabled,
-  sourceStat,
-  sourceUrl,
+  fileStat,
+  fileUrl,
 }) => {
   // here you might be tempted to add || headers["cache-control"] === "no-cache"
   // but no-cache means resource can be cache but must be revalidated (yeah naming is strange)
@@ -225,15 +234,15 @@ const getClientCacheResponse = async ({
       headers,
       etagMemory,
       etagMemoryMaxSize,
-      sourceStat,
-      sourceUrl,
+      fileStat,
+      fileUrl,
     });
   }
 
   if (mtimeEnabled) {
     return getMtimeResponse({
       headers,
-      sourceStat,
+      fileStat,
     });
   }
 
@@ -244,8 +253,8 @@ const getEtagResponse = async ({
   headers,
   etagMemory,
   etagMemoryMaxSize,
-  sourceUrl,
-  sourceStat,
+  fileUrl,
+  fileStat,
 }) => {
   const [computeEtagTiming, fileContentEtag] = await timeFunction(
     "file service>generate file etag",
@@ -253,8 +262,8 @@ const getEtagResponse = async ({
       computeEtag({
         etagMemory,
         etagMemoryMaxSize,
-        sourceUrl,
-        sourceStat,
+        fileUrl,
+        fileStat,
       }),
   );
 
@@ -282,20 +291,20 @@ const ETAG_MEMORY_MAP = new Map();
 const computeEtag = async ({
   etagMemory,
   etagMemoryMaxSize,
-  sourceUrl,
-  sourceStat,
+  fileUrl,
+  fileStat,
 }) => {
   if (etagMemory) {
-    const etagMemoryEntry = ETAG_MEMORY_MAP.get(sourceUrl);
+    const etagMemoryEntry = ETAG_MEMORY_MAP.get(fileUrl);
     if (
       etagMemoryEntry &&
-      fileStatAreTheSame(etagMemoryEntry.sourceStat, sourceStat)
+      fileStatAreTheSame(etagMemoryEntry.fileStat, fileStat)
     ) {
       return etagMemoryEntry.eTag;
     }
   }
   const fileContentAsBuffer = await new Promise((resolve, reject) => {
-    readFile(new URL(sourceUrl), (error, buffer) => {
+    readFile(new URL(fileUrl), (error, buffer) => {
       if (error) {
         reject(error);
       } else {
@@ -309,7 +318,7 @@ const computeEtag = async ({
       const firstKey = Array.from(ETAG_MEMORY_MAP.keys())[0];
       ETAG_MEMORY_MAP.delete(firstKey);
     }
-    ETAG_MEMORY_MAP.set(sourceUrl, { sourceStat, eTag });
+    ETAG_MEMORY_MAP.set(fileUrl, { fileStat, eTag });
   }
   return eTag;
 };
@@ -334,7 +343,7 @@ const fileStatKeysToCompare = [
   "blksize",
 ];
 
-const getMtimeResponse = async ({ headers, sourceStat }) => {
+const getMtimeResponse = async ({ headers, fileStat }) => {
   if ("if-modified-since" in headers) {
     let cachedModificationDate;
     try {
@@ -346,7 +355,7 @@ const getMtimeResponse = async ({ headers, sourceStat }) => {
       };
     }
 
-    const actualModificationDate = dateToSecondsPrecision(sourceStat.mtime);
+    const actualModificationDate = dateToSecondsPrecision(fileStat.mtime);
     if (Number(cachedModificationDate) >= Number(actualModificationDate)) {
       return {
         status: 304,
@@ -357,12 +366,16 @@ const getMtimeResponse = async ({ headers, sourceStat }) => {
   return {
     status: 200,
     headers: {
-      "last-modified": dateToUTCString(sourceStat.mtime),
+      "last-modified": dateToUTCString(fileStat.mtime),
     },
   };
 };
 
-const getCompressedResponse = async ({ sourceUrl, headers }) => {
+const getCompressedResponse = async ({ fileUrl, headers }) => {
+  const contentType = CONTENT_TYPE.fromUrlExtension(fileUrl);
+  if (CONTENT_TYPE.isBinary(contentType)) {
+    return null;
+  }
   const acceptedCompressionFormat = pickContentEncoding(
     { headers },
     Object.keys(availableCompressionFormats),
@@ -371,7 +384,7 @@ const getCompressedResponse = async ({ sourceUrl, headers }) => {
     return null;
   }
 
-  const fileReadableStream = fileUrlToReadableStream(sourceUrl);
+  const fileReadableStream = fileUrlToReadableStream(fileUrl);
   const body =
     await availableCompressionFormats[acceptedCompressionFormat](
       fileReadableStream,
@@ -380,7 +393,7 @@ const getCompressedResponse = async ({ sourceUrl, headers }) => {
   return {
     status: 200,
     headers: {
-      "content-type": CONTENT_TYPE.fromUrlExtension(sourceUrl),
+      "content-type": contentType,
       "content-encoding": acceptedCompressionFormat,
       "vary": "accept-encoding",
     },
@@ -410,14 +423,14 @@ const availableCompressionFormats = {
   },
 };
 
-const getRawResponse = async ({ sourceUrl, sourceStat }) => {
+const getRawResponse = async ({ fileUrl, fileStat }) => {
   return {
     status: 200,
     headers: {
-      "content-type": CONTENT_TYPE.fromUrlExtension(sourceUrl),
-      "content-length": sourceStat.size,
+      "content-type": CONTENT_TYPE.fromUrlExtension(fileUrl),
+      "content-length": fileStat.size,
     },
-    body: fileUrlToReadableStream(sourceUrl),
+    body: fileUrlToReadableStream(fileUrl),
   };
 };
 

package/src/internal/filesystem.js

@@ -32,12 +32,26 @@ export const fileSystemPathToUrl = (value) => {
 };
 
 export const urlToFileSystemPath = (url) => {
-  let urlString = String(url);
-  if (urlString[urlString.length - 1] === "/") {
+  const urlObject = new URL(url);
+  let { origin, pathname, hash } = urlObject;
+  if (urlObject.protocol === "file:") {
+    origin = "file://";
+  }
+  pathname = pathname
+    .split("/")
+    .map((part) => {
+      return encodeURIComponent(part); // part.replace(/%(?![0-9A-F][0-9A-F])/g, "%25");
+    })
+    .join("/");
+  if (hash) {
+    pathname += `%23${encodeURIComponent(hash.slice(1))}`;
+  }
+  const urlString = `${origin}${pathname}`;
+  const fileSystemPath = fileURLToPath(urlString);
+  if (fileSystemPath[fileSystemPath.length - 1] === "/") {
     // remove trailing / so that nodejs path becomes predictable otherwise it logs
     // the trailing slash on linux but does not on windows
-    urlString = urlString.slice(0, -1);
+    return fileSystemPath.slice(0, -1);
   }
-  const fileSystemPath = fileURLToPath(urlString);
   return fileSystemPath;
 };

package/src/start_server.js

@@ -355,6 +355,14 @@ export const startServer = async ({
         nodeResponse.end();
         return;
       }
+      try {
+        // eslint-disable-next-line no-new
+        new URL(nodeRequest.url, "http://example.com");
+      } catch {
+        nodeResponse.writeHead(400, "Request url is not supported");
+        nodeResponse.end();
+        return;
+      }
 
       const receiveRequestOperation = Abort.startOperation();
       receiveRequestOperation.addAbortSource((abort) => {