wurzel 0.0.15 → 0.0.18

package/dist/bin/wurzel.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 import express from "express";
-import { expressRouter as wurzel } from "../lib/index.js";
+import { expressRouter } from "../lib/index.js";
 import path from "node:path";
 
 const app = express();
 
 const rootFolder = path.resolve(".");
 
-app.use("/", wurzel({ express, baseFolder: rootFolder }));
+app.use("/", expressRouter({ express, baseFolder: rootFolder }));
 
 const port = 8080;
 

package/dist/lib/index.js

@@ -11,9 +11,8 @@ import {
 import { readFile } from "node:fs/promises";
 import { pathToFileURL, fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
-import { resolve as resolveImport } from "import-meta-resolve";
-// @ts-expect-error missing types
-import { transpileCode } from "commentscript";
+import * as importMetaResolve from "import-meta-resolve";
+import tsBlankSpace from "ts-blank-space";
 import { LRUCache } from "lru-cache";
 /*import type Express from "express";*/
 
@@ -41,7 +40,7 @@ const defaultResolveImportPath/*: TResolveImportPathFunc*/ = async ({ importer,
   let resolvedUrl/*: string | undefined*/ = undefined;
 
   try {
-    resolvedUrl = resolveImport(specifier, parentUrl.toString());
+    resolvedUrl = importMetaResolve.resolve(specifier, parentUrl.toString());
   } catch (error) {
     return {
       error: error /*as Error*/
@@ -67,6 +66,40 @@ const defaultResolveImportPath/*: TResolveImportPathFunc*/ = async ({ importer,
   };
 };
 
+// es6-debug-server rejects uris containing "//" or "..", and a file path must not contain null bytes,
+// such uris are answered right away, whatever else es6-debug-server rejects is caught in serveScript
+const isMalformedUri = ({ uri }/*: { uri: string }*/) => {
+  return uri.includes("//") || uri.split("/").includes("..") || uri.includes("\0");
+};
+
+const decodePath = ({ path }/*: { path: string }*/) => {
+  try {
+    return decodeURIComponent(path);
+  } catch (ex) {
+    const error/*: Error & { status?: number }*/ = Error(`failed to decode path "${path}"`, { cause: ex });
+    // express answers errors with their status
+    // eslint-disable-next-line immutable/no-mutation
+    error.status = 400;
+    throw error;
+  }
+};
+
+const encodePath = ({ path }/*: { path: string }*/) => {
+  return path.split("/").map((segment) => {
+    return encodeURIComponent(segment);
+  }).join("/");
+};
+
+const queryOf = ({ url }/*: { url: string }*/) => {
+  const queryStart = url.indexOf("?");
+  return queryStart < 0 ? "" : url.substring(queryStart);
+};
+
+// ENOTDIR means that a parent folder of the path is a file, so there is no such file either
+const isFileNotFoundError = ({ error }/*: { error: NodeJS.ErrnoException }*/) => {
+  return error.code === "ENOENT" || error.code === "ENOTDIR";
+};
+
 const defaultScriptFileEndings = [".js", ".ts", ".cjs", ".mjs", ".cts", ".mts"];
 
 const defaultDetermineFileTypeByPath = ({ filePath }/*: { filePath: string }*/)/*: TFileType*/ => {
@@ -99,7 +132,6 @@ const expressRouter = ({
   maxTranspileCacheSize?: number,
 
   analyzeCode?: TCodeAnalyzeFunc,
-  // eslint-disable-next-line no-unused-vars
   determineFileTypeByPath?: (args: { filePath: string }) => TFileType,
   resolveImportPath?: TResolveImportPathFunc
 // eslint-disable-next-line complexity
@@ -107,22 +139,26 @@ const expressRouter = ({
 
   const router = express.Router();
 
+  // eslint-disable-next-line k13-engineering/no-new
   const transpileCache = new LRUCache/*<string, string>*/({
     maxSize: maxTranspileCacheSize,
+    // eslint-disable-next-line k13-engineering/prefer-single-object-parameters
     sizeCalculation: (value, key) => {
       return key.length + value.length;
     }
   });
 
+  // eslint-disable-next-line k13-engineering/no-new
   const analyzeCache = new LRUCache/*<string, ICodeAnalyzeResult>*/({
     maxSize: maxAnalyzeCacheSize,
+    // eslint-disable-next-line k13-engineering/prefer-single-object-parameters
     sizeCalculation: (value, key) => {
       return key.length + JSON.stringify(value).length;
     }
   });
 
   // eslint-disable-next-line complexity
-  const maybeTranspile = async ({ filePath, code }/*: { filePath: string, code: string }*/)/*: Promise<TTranspileResult>*/ => {
+  const maybeTranspile = ({ filePath, code }/*: { filePath: string, code: string }*/)/*: TTranspileResult*/ => {
     if (filePath.endsWith(".js") || filePath.endsWith(".mjs")) {
       return {
         error: undefined,
@@ -144,18 +180,17 @@ const expressRouter = ({
     let transpiled/*: string | undefined*/ = undefined;
 
     try {
-      const result = await transpileCode({ code });
-      transpiled = result.transpiledCode;
+      // ts-blank-space reports syntax that cannot simply be blanked out, e.g. enums, instead of failing
+      transpiled = tsBlankSpace(code, (node) => {
+        const syntax = code.substring(node.pos, node.end).trim();
+        throw Error(`unsupported TypeScript syntax "${syntax}"`);
+      });
     } catch (ex) {
       return {
         error: ex /*as Error*/,
       };
     }
 
-    if (transpiled === undefined) {
-      throw Error("BUG: transpiled code is undefined");
-    }
-
     transpileCache.set(hash, transpiled);
 
     return {
@@ -168,6 +203,13 @@ const expressRouter = ({
 
     scriptRootFolder: baseFolder,
 
+    // es6-debug-server serves only the scripts in the script root and what they import, which files are
+    // scripts has to agree with the routing below, or scripts classified by a custom determineFileTypeByPath
+    // are routed to es6-debug-server but not served
+    isScriptFile: ({ filePath }) => {
+      return determineFileTypeByPath({ filePath }) === "script";
+    },
+
     tryReadScriptAsString: async ({ filePath }) => {
 
       const { error: readError, content } = await readFile(filePath, "utf8").then((fileContent) => {
@@ -177,7 +219,7 @@ const expressRouter = ({
       });
 
       if (readError !== undefined) {
-        if (readError.code === "ENOENT") {
+        if (isFileNotFoundError({ error: readError })) {
 
           return {
             error: createReadError({
@@ -197,7 +239,7 @@ const expressRouter = ({
         };
       }
 
-      const { error: transpileError, transpiled } = await maybeTranspile({
+      const { error: transpileError, transpiled } = maybeTranspile({
         filePath,
         code: content
       });
@@ -244,45 +286,63 @@ const expressRouter = ({
     resolveImportPath
   });
 
+  const serveScript = ({ filePath, req, res }/*: { filePath: string, req: Express.Request, res: Express.Response }*/) => {
+
+    if (isMalformedUri({ uri: filePath })) {
+      res.status(400).end("bad request");
+      return;
+    }
+
+    // up to es6-debug-server 0.0.15, handleRequest is declared as returning unknown, not as a promise
+    Promise.resolve(server.handleRequest({
+      uri: filePath,
+
+      // a relative redirect is resolved by the client against the url it requested, which keeps it below
+      // wherever the router is reachable, even below a path prefix of a reverse proxy the router cannot see
+      handleRedirect: ({ relativeUri }) => {
+        const redirectLocation = `${encodePath({ path: relativeUri })}${queryOf({ url: req.url })}`;
+        res.redirect(redirectLocation);
+      },
+
+      handleContent: ({ contentType, content }) => {
+        res.writeHead(200, {
+          "Content-Type": contentType
+        });
+        res.end(content);
+      },
+
+      handleFileNotFound: () => {
+        res.status(404).end("not found");
+      },
+
+      handleInternalError: ({ error }) => {
+        console.error(error);
+        res.status(500).end("internal server error");
+      }
+
+    // es6-debug-server rejects a uri it takes for malformed, e.g. one with a ".." segment between backslashes,
+    // unanswered that rejection would take down the whole process
+    })).catch(() => {
+      res.status(400).end("bad request");
+    });
+  };
+
+  // eslint-disable-next-line k13-engineering/prefer-single-object-parameters
   router.use((req, res, next) => {
 
     if (req.method === "HEAD") {
       throw Error("HEAD not supported yet");
     }
 
-    const fileType = determineFileTypeByPath({ filePath: req.url });
+    const filePath = decodePath({ path: req.path });
+    const fileType = determineFileTypeByPath({ filePath });
 
     if (fileType === "script-resource") {
       throw Error(`file type ${fileType} is not supported yet`);
     }
 
     if (fileType === "script") {
-
-      server.handleRequest({
-        uri: req.url,
-
-        handleRedirect: ({ uri }) => {
-          const redirectLocation = `${req.baseUrl}${uri}`;
-          res.redirect(redirectLocation);
-        },
-
-        handleContent: ({ contentType, content }) => {
-          res.writeHead(200, {
-            "Content-Type": contentType
-          });
-          res.end(content);
-        },
-
-        handleFileNotFound: () => {
-          res.status(404).end("not found");
-        },
-
-        handleInternalError: ({ error }) => {
-          console.error(error);
-          res.status(500).end("internal server error");
-        }
-      });
-
+      serveScript({ filePath, req, res });
       return;
     }
 

package/dist/samples/express/main.js

@@ -1,5 +1,5 @@
 import {
-  expressRouter as wurzelExpressRouter,
+  expressRouter,
   defaultResolveImportPath,
   /*type TResolveImportPathFunc
 */} from "../../lib/index.js";
@@ -27,7 +27,7 @@ const resolveImportPath/*: TResolveImportPathFunc*/ = async ({ importer, specifi
 
 const app = express();
 
-app.use("/", wurzelExpressRouter({
+app.use("/", expressRouter({
   express,
   baseFolder,
   resolveImportPath

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.15",
+  "version": "0.0.18",
   "name": "wurzel",
   "type": "module",
   "description": "A tool to serve script files from different directories",
@@ -8,21 +8,25 @@
   ],
   "main": "dist/lib/index.js",
   "dependencies": {
-    "commentscript": "^0.0.10",
-    "es6-debug-server": "^0.0.13",
+    "es6-debug-server": "^0.0.15",
     "esm-resource": "^0.0.3",
     "import-meta-resolve": "^4.0.0",
-    "lru-cache": "^10.2.1"
+    "lru-cache": "^10.2.1",
+    "ts-blank-space": "^0.9.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@k13engineering/eslint-rules": "^0.0.6",
     "@k13engineering/releasetool": "^0.0.5",
     "@types/express": "^4.17.21",
-    "@types/node": "^20.12.7",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^25.6.0",
+    "c8": "^11.0.0",
     "deno-node": "^0.0.12",
     "express": "^5.2.1",
+    "mocha": "^12.0.2",
     "npm-check-updates": "^20.0.2",
-    "typescript-eslint": "^8.58.2"
+    "typescript": "^6.0.3"
   },
   "bin": {
     "wurzel": "dist/bin/wurzel.js"
@@ -30,7 +34,7 @@
   "scripts": {
     "build": "rm -rf dist/ && deno-node-build --root . --out dist/ --entry lib/index.ts --entry bin/wurzel.ts --entry samples/express/main.ts && cp -r samples/express/frontend dist/samples/express/",
     "lint": "eslint .",
-    "test": "true",
+    "test": "c8 --reporter lcov --reporter html --reporter text --all --src lib/ --exclude 'lib/**/*.spec.ts' mocha 'lib/**/*.spec.ts'",
     "type-check": "tsc --noEmit",
     "update-deps": "npm-check-updates -u"
   },