kempo-server 1.2.1 → 1.4.1

package/router.js

@@ -5,6 +5,14 @@ import defaultConfig from './defaultConfig.js';
 import getFiles from './getFiles.js';
 import findFile from './findFile.js';
 import serveFile from './serveFile.js';
+import MiddlewareRunner from './middlewareRunner.js';
+import { 
+  corsMiddleware, 
+  compressionMiddleware, 
+  rateLimitMiddleware, 
+  securityMiddleware, 
+  loggingMiddleware 
+} from './builtinMiddleware.js';
 
 export default async (flags, log) => {
   log('Initializing router', 2);
@@ -39,6 +47,57 @@ export default async (flags, log) => {
   let files = await getFiles(rootPath, config, log);
   log(`Initial scan found ${files.length} files`, 1);
   
+  // Initialize middleware runner
+  const middlewareRunner = new MiddlewareRunner();
+  
+  // Load built-in middleware based on config
+  if (config.middleware?.cors?.enabled) {
+    middlewareRunner.use(corsMiddleware(config.middleware.cors));
+    log('CORS middleware enabled', 2);
+  }
+  
+  if (config.middleware?.compression?.enabled) {
+    middlewareRunner.use(compressionMiddleware(config.middleware.compression));
+    log('Compression middleware enabled', 2);
+  }
+  
+  if (config.middleware?.rateLimit?.enabled) {
+    middlewareRunner.use(rateLimitMiddleware(config.middleware.rateLimit));
+    log('Rate limit middleware enabled', 2);
+  }
+  
+  if (config.middleware?.security?.enabled) {
+    middlewareRunner.use(securityMiddleware(config.middleware.security));
+    log('Security middleware enabled', 2);
+  }
+  
+  if (config.middleware?.logging?.enabled) {
+    middlewareRunner.use(loggingMiddleware(config.middleware.logging, log));
+    log('Logging middleware enabled', 2);
+  }
+  
+  // Load custom middleware files
+  if (config.middleware?.custom && config.middleware.custom.length > 0) {
+    log(`Loading ${config.middleware.custom.length} custom middleware files`, 2);
+    
+    for (const middlewarePath of config.middleware.custom) {
+      try {
+        const resolvedPath = path.resolve(middlewarePath);
+        const middlewareModule = await import(pathToFileURL(resolvedPath));
+        const customMiddleware = middlewareModule.default;
+        
+        if (typeof customMiddleware === 'function') {
+          middlewareRunner.use(customMiddleware(config.middleware));
+          log(`Custom middleware loaded: ${middlewarePath}`, 2);
+        } else {
+          log(`Custom middleware error: ${middlewarePath} does not export a default function`, 1);
+        }
+      } catch (error) {
+        log(`Custom middleware error for ${middlewarePath}: ${error.message}`, 1);
+      }
+    }
+  }
+  
   // Process custom routes - resolve paths and validate files exist
   const customRoutes = new Map();
   const wildcardRoutes = new Map();
@@ -146,80 +205,82 @@ export default async (flags, log) => {
   };
   
   return async (req, res) => {
-    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);
+    await middlewareRunner.run(req, res, async () => {
+      const requestPath = req.url.split('?')[0];
+      log(`${req.method} ${requestPath}`, 0);
       
-      try {
-        const fileContent = await readFile(customFilePath);
-        const fileExtension = path.extname(customFilePath).toLowerCase().slice(1);
-        const mimeType = config.allowedMimes[fileExtension] || 'application/octet-stream';
+      // Check custom routes first
+      if (customRoutes.has(requestPath)) {
+        const customFilePath = customRoutes.get(requestPath);
+        log(`Serving custom route: ${requestPath} -> ${customFilePath}`, 2);
         
-        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);
-        res.writeHead(500, { 'Content-Type': 'text/plain' });
-        res.end('Internal Server Error');
-        return;
+        try {
+          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);
+          res.writeHead(500, { 'Content-Type': 'text/plain' });
+          res.end('Internal Server Error');
+          return;
+        }
       }
-    }
-    
-    // Check wildcard routes
-    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';
+      // Check wildcard routes
+      const wildcardMatch = findWildcardRoute(requestPath);
+      if (wildcardMatch) {
+        const resolvedFilePath = resolveWildcardPath(wildcardMatch.filePath, wildcardMatch.matches);
+        log(`Serving wildcard route: ${requestPath} -> ${resolvedFilePath}`, 2);
         
-        log(`Serving wildcard file as ${mimeType} (${fileContent.length} bytes)`, 2);
-        res.writeHead(200, { 'Content-Type': mimeType });
-        res.end(fileContent);
-        return; // Successfully served wildcard route
-      } catch (error) {
-        log(`Error serving wildcard route ${requestPath}: ${error.message}`, 0);
-        res.writeHead(500, { 'Content-Type': 'text/plain' });
-        res.end('Internal Server Error');
-        return;
+        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);
+          return; // Successfully served wildcard route
+        } catch (error) {
+          log(`Error serving wildcard route ${requestPath}: ${error.message}`, 0);
+          res.writeHead(500, { 'Content-Type': 'text/plain' });
+          res.end('Internal Server Error');
+          return;
+        }
       }
-    }
-    
-    // Try to serve the file normally
-    const served = await serveFile(files, rootPath, requestPath, req.method, config, req, res, log);
-    
-    // If not served and scan flag is enabled, try rescanning once (with blacklist check)
-    if (!served && flags.scan && !shouldSkipRescan(requestPath)) {
-      trackRescanAttempt(requestPath);
-      log('File not found, rescanning directory...', 1);
-      files = await getFiles(rootPath, config, log);
-      log(`Rescan found ${files.length} files`, 2);
       
-      // Try to serve again after rescan
-      const reserved = await serveFile(files, rootPath, requestPath, req.method, config, req, res, log);
+      // Try to serve the file normally
+      const served = await serveFile(files, rootPath, requestPath, req.method, config, req, res, log);
       
-      if (!reserved) {
-        log(`404 - File not found after rescan: ${requestPath}`, 1);
+      // If not served and scan flag is enabled, try rescanning once (with blacklist check)
+      if (!served && flags.scan && !shouldSkipRescan(requestPath)) {
+        trackRescanAttempt(requestPath);
+        log('File not found, rescanning directory...', 1);
+        files = await getFiles(rootPath, config, log);
+        log(`Rescan found ${files.length} files`, 2);
+        
+        // Try to serve again after rescan
+        const reserved = await serveFile(files, rootPath, requestPath, req.method, config, req, res, log);
+        
+        if (!reserved) {
+          log(`404 - File not found after rescan: ${requestPath}`, 1);
+          res.writeHead(404, { 'Content-Type': 'text/plain' });
+          res.end('Not Found');
+        }
+      } else if (!served) {
+        if (shouldSkipRescan(requestPath)) {
+          log(`404 - Skipped rescan for: ${requestPath}`, 2);
+        } else {
+          log(`404 - File not found: ${requestPath}`, 1);
+        }
         res.writeHead(404, { 'Content-Type': 'text/plain' });
         res.end('Not Found');
       }
-    } else if (!served) {
-      if (shouldSkipRescan(requestPath)) {
-        log(`404 - Skipped rescan for: ${requestPath}`, 2);
-      } else {
-        log(`404 - File not found: ${requestPath}`, 1);
-      }
-      res.writeHead(404, { 'Content-Type': 'text/plain' });
-      res.end('Not Found');
-    }
+    });
   }
 }