@jsenv/server 12.6.0 → 12.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/server",
-  "version": "12.6.0",
+  "version": "12.6.3",
   "description": "Write your Node.js server using pure functions",
   "license": "MIT",
   "author": {
@@ -43,7 +43,7 @@
   },
   "dependencies": {
     "@jsenv/abort": "4.1.2",
-    "@jsenv/logger": "4.0.1",
+    "@jsenv/logger": "4.1.1",
     "@jsenv/url-meta": "6.2.0",
     "node-fetch": "2.6.7",
     "path-to-regexp": "6.2.0"

package/src/fetch_filesystem.js

@@ -39,20 +39,37 @@ export const fetchFileSystem = async (
       ? "private,max-age=0,must-revalidate"
       : "no-store",
     canReadDirectory = false,
-    rootDirectoryUrl,
+    rootDirectoryUrl, //  = `${pathToFileURL(process.cwd())}/`,
   } = {},
 ) => {
   const urlString = asUrlString(filesystemUrl)
   if (!urlString) {
-    return send500DueToFilesystemUrlParameter(
+    return create500Response(
       `fetchFileSystem first parameter must be a file url, got ${filesystemUrl}`,
     )
   }
   if (!urlString.startsWith("file://")) {
-    return send500DueToFilesystemUrlParameter(
+    return create500Response(
       `fetchFileSystem url must use "file://" scheme, got ${filesystemUrl}`,
     )
   }
+  if (rootDirectoryUrl) {
+    let rootDirectoryUrlString = asUrlString(rootDirectoryUrl)
+    if (!rootDirectoryUrlString) {
+      return create500Response(
+        `rootDirectoryUrl must be a string or an url, got ${rootDirectoryUrl}`,
+      )
+    }
+    if (!rootDirectoryUrlString.endsWith("/")) {
+      rootDirectoryUrlString = `${rootDirectoryUrlString}/`
+    }
+    if (!urlString.startsWith(rootDirectoryUrlString)) {
+      return create500Response(
+        `fetchFileSystem url must be inside root directory, got ${urlString}`,
+      )
+    }
+    rootDirectoryUrl = rootDirectoryUrlString
+  }
 
   // here you might be tempted to add || cacheControl === 'no-cache'
   // but no-cache means ressource can be cache but must be revalidated (yeah naming is strange)
@@ -180,7 +197,7 @@ export const fetchFileSystem = async (
   }
 }
 
-const send500DueToFilesystemUrlParameter = (message) => {
+const create500Response = (message) => {
   return {
     status: 500,
     headers: {
@@ -419,12 +436,10 @@ const asUrlString = (value) => {
   if (value instanceof URL) {
     return value.href
   }
-
   if (typeof value === "string") {
     if (isFileSystemPath(value)) {
       return fileSystemPathToUrl(value)
     }
-
     try {
       const urlObject = new URL(value)
       return String(urlObject)
@@ -432,6 +447,5 @@ const asUrlString = (value) => {
       return null
     }
   }
-
   return null
 }

package/src/fetch_url.js

@@ -28,12 +28,11 @@ export const fetchUrl = async (
   }
 
   if (url.startsWith("file://")) {
-    const origin = new URL(url).origin
     const responseProperties = await fetchFileSystem(url, {
       signal,
       method,
       headers,
-      rootDirectoryUrl: origin,
+      rootDirectoryUrl: "file://",
       cacheStrategy,
       canReadDirectory,
       contentTypeMap,

package/src/serve_directory.js

@@ -1,11 +1,10 @@
 import { readdirSync } from "node:fs"
-import { pathToFileURL } from "node:url"
 
 import { negotiateContentType } from "./content_negotiation/negotiateContentType.js"
 
 export const serveDirectory = (
   url,
-  { headers = {}, rootDirectoryUrl = `${pathToFileURL(process.cwd())}/` } = {},
+  { headers = {}, rootDirectoryUrl } = {},
 ) => {
   url = String(url)
   url = url[url.length - 1] === "/" ? url : `${url}/`

package/src/startServer.js

@@ -299,25 +299,47 @@ export const startServer = async ({
       const prefixLines = (string, prefix) => {
         return string.replace(/^(?!\s*$)/gm, prefix)
       }
-      const writeLog = ({ type, value }, depth) => {
+      const writeLog = (
+        { type, value },
+        { someLogIsError, someLogIsWarn, depth },
+      ) => {
         if (depth > 0) {
           value = prefixLines(value, "  ".repeat(depth))
         }
+        if (type === "info") {
+          if (someLogIsError) {
+            type = "error"
+          } else if (someLogIsWarn) {
+            type = "warn"
+          }
+        }
         logger[type](value)
       }
       const visitRequestNodeToLog = (requestNode, depth) => {
+        let someLogIsError = false
+        let someLogIsWarn = false
+        requestNode.logs.forEach((log) => {
+          if (log.type === "error") {
+            someLogIsError = true
+          }
+          if (log.type === "warn") {
+            someLogIsWarn = true
+          }
+        })
+
         const firstLog = requestNode.logs.shift()
         const lastLog = requestNode.logs.pop()
         const middleLogs = requestNode.logs
-        writeLog(firstLog, depth)
+
+        writeLog(firstLog, { someLogIsError, someLogIsWarn, depth })
         middleLogs.forEach((log) => {
-          writeLog(log, depth)
+          writeLog(log, { someLogIsError, someLogIsWarn, depth })
         })
         requestNode.children.forEach((child) => {
           visitRequestNodeToLog(child, depth + 1)
         })
         if (lastLog) {
-          writeLog(lastLog, depth + 1)
+          writeLog(lastLog, { someLogIsError, someLogIsWarn, depth: depth + 1 })
         }
       }
       visitRequestNodeToLog(rootRequestNode, 0)