kempo-server 1.7.0 → 1.7.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kempo-server",
   "type": "module",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "A lightweight, zero-dependency, file based routing server.",
   "main": "dist/index.js",
   "bin": {

package/src/router.js

@@ -17,7 +17,7 @@ import {
 
 export default async (flags, log) => {
   log('Initializing router', 2);
-  const rootPath = path.join(process.cwd(), flags.root);
+  const rootPath = path.isAbsolute(flags.root) ? flags.root : path.join(process.cwd(), flags.root);
   log(`Root path: ${rootPath}`, 2);
   
   let config = defaultConfig;
@@ -136,27 +136,19 @@ export default async (flags, log) => {
   
   if (config.customRoutes && Object.keys(config.customRoutes).length > 0) {
     log(`Processing ${Object.keys(config.customRoutes).length} custom routes`, 2);
-    
     for (const [urlPath, filePath] of Object.entries(config.customRoutes)) {
-      try {
-        // Check if this is a wildcard route
-        if (urlPath.includes('*')) {
-          // Store wildcard routes separately for pattern matching
-          wildcardRoutes.set(urlPath, filePath);
-          log(`Wildcard route mapped: ${urlPath} -> ${filePath}`, 2);
-        } else {
-          // Resolve the file path relative to the current working directory
-          const resolvedPath = path.resolve(filePath);
-          
-          // Check if the file exists (we'll do this async)
-          const { stat } = await import('fs/promises');
-          await stat(resolvedPath);
-          
-          customRoutes.set(urlPath, resolvedPath);
-          log(`Custom route mapped: ${urlPath} -> ${resolvedPath}`, 2);
-        }
-      } catch (error) {
-        log(`Custom route error for ${urlPath} -> ${filePath}: ${error.message}`, 1);
+      // Check if this is a wildcard route
+      if (urlPath.includes('*')) {
+        // Resolve the file path relative to the current working directory
+        const resolvedPath = path.resolve(filePath);
+        // Store wildcard routes separately for pattern matching
+        wildcardRoutes.set(urlPath, resolvedPath);
+        log(`Wildcard route mapped: ${urlPath} -> ${resolvedPath}`, 2);
+      } else {
+        // Resolve the file path relative to the current working directory
+        const resolvedPath = path.resolve(filePath);
+        customRoutes.set(urlPath, resolvedPath);
+        log(`Custom route mapped: ${urlPath} -> ${resolvedPath}`, 2);
       }
     }
   }
@@ -247,39 +239,63 @@ export default async (flags, log) => {
       const requestPath = req.url.split('?')[0];
       log(`${req.method} ${requestPath}`, 0);
       
-      // Check custom routes first
-      if (customRoutes.has(requestPath)) {
-        const customFilePath = customRoutes.get(requestPath);
-        log(`Serving custom route: ${requestPath} -> ${customFilePath}`, 2);
-        
+
+      // Check custom routes first (allow outside rootPath)
+      log(`customRoutes keys: ${Array.from(customRoutes.keys()).join(', ')}`, 1);
+      // Normalize requestPath and keys for matching
+      const normalizePath = p => {
+        let np = decodeURIComponent(p);
+        if (!np.startsWith('/')) np = '/' + np;
+        if (np.length > 1 && np.endsWith('/')) np = np.slice(0, -1);
+        return np;
+      };
+      const normalizedRequestPath = normalizePath(requestPath);
+      log(`Normalized requestPath: ${normalizedRequestPath}`, 1);
+      let matchedKey = null;
+      for (const key of customRoutes.keys()) {
+        if (normalizePath(key) === normalizedRequestPath) {
+          matchedKey = key;
+          break;
+        }
+      }
+      if (matchedKey) {
+        const customFilePath = customRoutes.get(matchedKey);
+        log(`Serving custom route: ${normalizedRequestPath} -> ${customFilePath}`, 2);
         try {
+          const { stat } = await import('fs/promises');
+          try {
+            await stat(customFilePath);
+            log(`Custom route file exists: ${customFilePath}`, 2);
+          } catch (e) {
+            log(`Custom route file does NOT exist: ${customFilePath}`, 0);
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Custom route file not found');
+            return;
+          }
           const fileContent = await readFile(customFilePath);
           const fileExtension = path.extname(customFilePath).toLowerCase().slice(1);
           const mimeType = config.allowedMimes[fileExtension] || 'application/octet-stream';
-          
           log(`Serving custom file as ${mimeType} (${fileContent.length} bytes)`, 2);
           res.writeHead(200, { 'Content-Type': mimeType });
           res.end(fileContent);
           return; // Successfully served custom route
         } catch (error) {
-          log(`Error serving custom route ${requestPath}: ${error.message}`, 0);
+          log(`Error serving custom route ${normalizedRequestPath}: ${error.message}`, 0);
           res.writeHead(500, { 'Content-Type': 'text/plain' });
           res.end('Internal Server Error');
           return;
         }
       }
-      
-      // Check wildcard routes
+
+      // Check wildcard routes (allow outside rootPath)
       const wildcardMatch = findWildcardRoute(requestPath);
       if (wildcardMatch) {
         const resolvedFilePath = resolveWildcardPath(wildcardMatch.filePath, wildcardMatch.matches);
         log(`Serving wildcard route: ${requestPath} -> ${resolvedFilePath}`, 2);
-        
         try {
           const fileContent = await readFile(resolvedFilePath);
           const fileExtension = path.extname(resolvedFilePath).toLowerCase().slice(1);
           const mimeType = config.allowedMimes[fileExtension] || 'application/octet-stream';
-          
           log(`Serving wildcard file as ${mimeType} (${fileContent.length} bytes)`, 2);
           res.writeHead(200, { 'Content-Type': mimeType });
           res.end(fileContent);

package/tests/customRoute-outside-root.node-test.js

@@ -0,0 +1,81 @@
+import router from '../src/router.js';
+import http from 'http';
+import { writeFile, mkdir } from 'fs/promises';
+import path from 'path';
+import { randomPort, httpGet, withTempDir, write } from './test-utils.js';
+
+/*
+  This test verifies that a customRoute pointing outside the rootPath is served
+  instead of a static file inside the rootPath, if both exist.
+*/
+
+export default {
+  'customRoute outside rootPath takes precedence over static file': async ({pass, fail, log}) => {
+    try {
+  await withTempDir(async (dir) => {
+        // Print initial working directory
+        log('Initial process.cwd(): ' + process.cwd());
+
+        // Setup: create static file in rootPath
+        const rootDir = path.join(dir, 'public');
+        await mkdir(path.join(rootDir, 'src'), { recursive: true });
+        await writeFile(path.join(rootDir, 'src', 'file.txt'), 'static');
+  // Create custom file outside rootPath, matching resolved customRoute
+  const customFilePath = path.resolve(dir, '..', 'src', 'file.txt');
+  await mkdir(path.dirname(customFilePath), { recursive: true });
+  await writeFile(customFilePath, 'custom');
+  log('Custom file path: ' + customFilePath);
+
+        // Check file existence
+        try {
+          const { stat } = await import('fs/promises');
+          await stat(customFilePath);
+          log('Custom file exists at setup');
+        } catch (e) {
+          log('Custom file does NOT exist at setup');
+        }
+
+        // Write config with customRoute pointing outside rootPath
+        const config = {
+          customRoutes: {
+            '/src/file.txt': '../src/file.txt'
+          }
+        };
+        await writeFile(path.join(rootDir, '.config.json'), JSON.stringify(config));
+        log('Config written: ' + JSON.stringify(config));
+
+  // Set working directory to temp dir so relative paths resolve correctly
+  const prevCwd = process.cwd();
+  process.chdir(dir);
+  const flags = { root: rootDir, logging: 4 };
+  const logFn = (...args) => log(args.map(String).join(' '));
+  log('Starting server with flags: ' + JSON.stringify(flags));
+  log('process.cwd() before router: ' + process.cwd());
+  const handler = await router(flags, logFn);
+  const server = http.createServer(handler);
+  const port = randomPort();
+  await new Promise(r => server.listen(port, r));
+  await new Promise(r => setTimeout(r, 50));
+
+        try {
+          // Print process.cwd() before request
+          log('process.cwd() before request: ' + process.cwd());
+          // Request the file
+          const requestUrl = `http://localhost:${port}/src/file.txt`;
+          log('Requesting URL: ' + requestUrl);
+          const response = await httpGet(requestUrl);
+          log('status: ' + response.res.statusCode);
+          log('response body: ' + response.body.toString());
+          if(response.res.statusCode !== 200) throw new Error('status not 200');
+          if(response.body.toString() !== 'custom') throw new Error('did not serve customRoute file');
+        } finally {
+          server.close();
+          process.chdir(prevCwd);
+        }
+      });
+      pass('customRoute outside rootPath is served');
+    } catch(e){
+      fail(e.message);
+    }
+  }
+};