kempo-server 1.6.0 → 1.6.2

package/docs/configuration.html

@@ -27,6 +27,7 @@
       <li><a href="#routeFiles">routeFiles</a> - Files that should be treated as route handlers</li>
       <li><a href="#noRescanPaths">noRescanPaths</a> - Paths that should not trigger file system rescans</li>
       <li><a href="#maxRescanAttempts">maxRescanAttempts</a> - Maximum number of rescan attempts</li>
+      <li><a href="#cache">cache</a> - Module caching configuration</li>
       <li><a href="#middleware">middleware</a> - Middleware configuration</li>
     </ul>
 
@@ -91,6 +92,76 @@
     <pre><code class="hljs json">{<br />  <span class="hljs-attr">"allowedMimes"</span>: {<br />    <span class="hljs-attr">"html"</span>: <span class="hljs-string">"text/html"</span>,<br />    <span class="hljs-attr">"css"</span>: <span class="hljs-string">"text/css"</span>,<br />    <span class="hljs-attr">"js"</span>: <span class="hljs-string">"application/javascript"</span>,<br />    <span class="hljs-attr">"json"</span>: <span class="hljs-string">"application/json"</span>,<br />    <span class="hljs-attr">"png"</span>: <span class="hljs-string">"image/png"</span>,<br />    <span class="hljs-attr">"jpg"</span>: <span class="hljs-string">"image/jpeg"</span><br />  },<br />  <span class="hljs-attr">"disallowedRegex"</span>: [<br />    <span class="hljs-string">"^/\\..*"</span>,<br />    <span class="hljs-string">"\\.env$"</span>,<br />    <span class="hljs-string">"\\.config$"</span>,<br />    <span class="hljs-string">"password"</span>,<br />    <span class="hljs-string">"node_modules"</span>,<br />    <span class="hljs-string">"\\.git"</span>,<br />    <span class="hljs-string">"\\.map$"</span><br />  ],<br />  <span class="hljs-attr">"middleware"</span>: {<br />    <span class="hljs-attr">"cors"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"origin"</span>: <span class="hljs-string">"https://yourdomain.com"</span><br />    },<br />    <span class="hljs-attr">"compression"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"threshold"</span>: <span class="hljs-number">1024</span><br />    },<br />    <span class="hljs-attr">"security"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"headers"</span>: {<br />        <span class="hljs-attr">"X-Content-Type-Options"</span>: <span class="hljs-string">"nosniff"</span>,<br />        <span class="hljs-attr">"X-Frame-Options"</span>: <span class="hljs-string">"DENY"</span>,<br />        <span class="hljs-attr">"X-XSS-Protection"</span>: <span class="hljs-string">"1; mode=block"</span>,<br />        <span class="hljs-attr">"Strict-Transport-Security"</span>: <span class="hljs-string">"max-age=31536000; includeSubDomains"</span><br />      }<br />    }<br />  }<br />}</code></pre>
     <p>Use with: <code>kempo-server --root public --config .config.prod.json</code></p>
 
+    <h3 id="cache">cache</h3>
+    <p>Module caching configuration to improve performance by keeping compiled JavaScript modules in memory. The cache supports LRU eviction, TTL expiration, memory monitoring, and automatic file watching.</p>
+    <pre><code class="hljs json">{<br />  <span class="hljs-attr">"cache"</span>: {<br />    <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />    <span class="hljs-attr">"maxSize"</span>: <span class="hljs-number">1000</span>,<br />    <span class="hljs-attr">"ttlMs"</span>: <span class="hljs-number">3600000</span>,<br />    <span class="hljs-attr">"maxMemoryUsageMB"</span>: <span class="hljs-number">500</span>,<br />    <span class="hljs-attr">"checkIntervalMs"</span>: <span class="hljs-number">30000</span>,<br />    <span class="hljs-attr">"fileWatching"</span>: <span class="hljs-literal">true</span><br />  }<br />}</code></pre>
+
+    <h4>Cache Configuration Options</h4>
+    <table>
+      <thead>
+        <tr>
+          <th>Option</th>
+          <th>Type</th>
+          <th>Default</th>
+          <th>Description</th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td><code>enabled</code></td>
+          <td>boolean</td>
+          <td>true</td>
+          <td>Enable/disable module caching system</td>
+        </tr>
+        <tr>
+          <td><code>maxSize</code></td>
+          <td>number</td>
+          <td>1000</td>
+          <td>Maximum number of modules to cache (LRU eviction)</td>
+        </tr>
+        <tr>
+          <td><code>ttlMs</code></td>
+          <td>number</td>
+          <td>3600000</td>
+          <td>Time-to-live in milliseconds (default: 1 hour)</td>
+        </tr>
+        <tr>
+          <td><code>maxMemoryUsageMB</code></td>
+          <td>number</td>
+          <td>500</td>
+          <td>Maximum memory usage in MB before triggering cleanup</td>
+        </tr>
+        <tr>
+          <td><code>checkIntervalMs</code></td>
+          <td>number</td>
+          <td>30000</td>
+          <td>Memory check interval in milliseconds (default: 30 seconds)</td>
+        </tr>
+        <tr>
+          <td><code>fileWatching</code></td>
+          <td>boolean</td>
+          <td>true</td>
+          <td>Watch files for changes and auto-invalidate cache</td>
+        </tr>
+      </tbody>
+    </table>
+
+    <h4>Environment-Specific Cache Settings</h4>
+    <h5>Development (.config.dev.json)</h5>
+    <pre><code class="hljs json">{<br />  <span class="hljs-attr">"cache"</span>: {<br />    <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />    <span class="hljs-attr">"maxSize"</span>: <span class="hljs-number">100</span>,<br />    <span class="hljs-attr">"ttlMs"</span>: <span class="hljs-number">300000</span>,<br />    <span class="hljs-attr">"fileWatching"</span>: <span class="hljs-literal">true</span><br />  }<br />}</code></pre>
+
+    <h5>Production (.config.prod.json)</h5>
+    <pre><code class="hljs json">{<br />  <span class="hljs-attr">"cache"</span>: {<br />    <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />    <span class="hljs-attr">"maxSize"</span>: <span class="hljs-number">5000</span>,<br />    <span class="hljs-attr">"ttlMs"</span>: <span class="hljs-number">7200000</span>,<br />    <span class="hljs-attr">"maxMemoryUsageMB"</span>: <span class="hljs-number">1000</span>,<br />    <span class="hljs-attr">"fileWatching"</span>: <span class="hljs-literal">false</span><br />  }<br />}</code></pre>
+
+    <h4>Cache Monitoring</h4>
+    <p>Access cache statistics and management via admin endpoints:</p>
+    <ul>
+      <li><code>GET /_admin/cache</code> - View cache statistics (hits, misses, size, memory usage)</li>
+      <li><code>DELETE /_admin/cache</code> - Clear all cached modules</li>
+    </ul>
+
+    <p>For detailed cache usage and configuration examples, see the <a href="caching.html">Caching Guide</a>.</p>
+
     <h3>Package.json Scripts</h3>
     <p>Add environment-specific scripts to your <code>package.json</code>:</p>
     <pre><code class="hljs json">{<br />  <span class="hljs-attr">"scripts"</span>: {<br />    <span class="hljs-attr">"start"</span>: <span class="hljs-string">"kempo-server --root public"</span>,<br />    <span class="hljs-attr">"start:dev"</span>: <span class="hljs-string">"kempo-server --root public --config .config.dev.json --verbose"</span>,<br />    <span class="hljs-attr">"start:staging"</span>: <span class="hljs-string">"kempo-server --root public --config .config.staging.json"</span>,<br />    <span class="hljs-attr">"start:prod"</span>: <span class="hljs-string">"kempo-server --root public --config .config.prod.json"</span><br />  }<br />}</code></pre>
@@ -107,10 +178,12 @@
 
     <h3>Performance Optimization</h3>
     <ul>
+      <li>Enable module caching with appropriate <code>maxSize</code> and <code>ttlMs</code> settings</li>
       <li>Use <code>noRescanPaths</code> for static assets to improve performance</li>
       <li>Enable compression for larger files</li>
       <li>Use custom routes to serve files from CDN or optimized locations</li>
       <li>Limit <code>maxRescanAttempts</code> to prevent excessive file system scanning</li>
+      <li>Configure <code>maxMemoryUsageMB</code> to prevent memory issues in production</li>
     </ul>
 
     <h3>Development vs Production</h3>
@@ -119,6 +192,9 @@
       <li>Use relaxed CORS in development, strict in production</li>
       <li>Enable compression in production for better performance</li>
       <li>Add more security headers in production</li>
+      <li>Use smaller cache sizes in development, larger in production</li>
+      <li>Enable file watching in development, disable in production for stability</li>
+      <li>Use shorter TTL in development for faster iteration</li>
     </ul>
   </main>
   <div style="height:25vh"></div>

package/docs/index.html

@@ -34,6 +34,7 @@
           <ul>
             <li><a href="configuration.html">Configuration</a></li>
             <li><a href="middleware.html">Middleware</a></li>
+            <li><a href="caching.html">Module Caching</a></li>
             <li><a href="examples.html">Examples & Demos</a></li>
           </ul>
         </div>

package/example-cache.config.json

@@ -0,0 +1,45 @@
+{
+  "cache": {
+    "enabled": true,
+    "maxSize": 200,
+    "maxMemoryMB": 75,
+    "ttlMs": 600000,
+    "maxHeapUsagePercent": 75,
+    "memoryCheckInterval": 15000,
+    "watchFiles": true,
+    "enableMemoryMonitoring": true,
+    "production": {
+      "maxSize": 1000,
+      "maxMemoryMB": 200,
+      "ttlMs": 3600000,
+      "maxHeapUsagePercent": 85,
+      "memoryCheckInterval": 60000,
+      "watchFiles": false
+    }
+  },
+  "middleware": {
+    "cors": {
+      "enabled": true,
+      "origin": "*",
+      "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+      "headers": ["Content-Type", "Authorization"]
+    },
+    "compression": {
+      "enabled": true,
+      "threshold": 1024
+    },
+    "security": {
+      "enabled": true,
+      "headers": {
+        "X-Content-Type-Options": "nosniff",
+        "X-Frame-Options": "DENY",
+        "X-XSS-Protection": "1; mode=block"
+      }
+    },
+    "logging": {
+      "enabled": true,
+      "includeUserAgent": false,
+      "includeResponseTime": true
+    }
+  }
+}

package/package.json

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

package/src/defaultConfig.js

@@ -126,5 +126,15 @@ export default {
     custom: [
       // Example: "./middleware/auth.js"
     ]
+  },
+  cache: {
+    enabled: false,                  // Disabled by default - opt-in for performance  
+    maxSize: 100,                    // Maximum number of cached modules
+    maxMemoryMB: 50,                 // Memory limit for cache in MB
+    ttlMs: 300000,                   // Cache TTL (5 minutes default)
+    maxHeapUsagePercent: 70,         // Clear cache if heap usage exceeds this
+    memoryCheckInterval: 30000,      // Memory check interval (30 seconds)
+    watchFiles: true,                // Auto-invalidate on file changes
+    enableMemoryMonitoring: true     // Enable automatic memory monitoring
   }
 }

package/src/moduleCache.js

@@ -0,0 +1,270 @@
+import { watch } from 'fs';
+import path from 'path';
+
+/*
+  Hybrid Module Cache System
+  Combines LRU, time-based expiration, and memory monitoring
+*/
+export default class ModuleCache {
+  constructor(config = {}) {
+    this.cache = new Map();
+    this.watchers = new Map();
+    
+    // Configuration
+    this.maxSize = config.maxSize || 100;
+    this.maxMemoryMB = config.maxMemoryMB || 50;
+    this.ttlMs = config.ttlMs || 300000; // 5 minutes default
+    this.maxHeapUsagePercent = config.maxHeapUsagePercent || 70;
+    this.memoryCheckInterval = config.memoryCheckInterval || 30000; // 30 seconds
+    this.watchFiles = config.watchFiles !== false; // Default to true
+    
+    // State tracking
+    this.currentMemoryMB = 0;
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      evictions: 0,
+      fileChanges: 0
+    };
+    
+    // Start memory monitoring
+    if (config.enableMemoryMonitoring !== false) {
+      this.startMemoryMonitoring();
+    }
+  }
+
+  /*
+    Lifecycle Management
+  */
+  startMemoryMonitoring() {
+    this.memoryTimer = setInterval(() => {
+      const usage = process.memoryUsage();
+      const heapPercent = (usage.heapUsed / usage.heapTotal) * 100;
+      
+      if (heapPercent > this.maxHeapUsagePercent) {
+        const clearedCount = this.clearExpiredEntries();
+        this.stats.evictions += clearedCount;
+        
+        // If still over limit, clear oldest entries
+        while (this.cache.size > 0 && heapPercent > this.maxHeapUsagePercent) {
+          this.evictOldest();
+        }
+      }
+    }, this.memoryCheckInterval);
+  }
+
+  destroy() {
+    if (this.memoryTimer) {
+      clearInterval(this.memoryTimer);
+    }
+    
+    // Clean up file watchers
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    this.cache.clear();
+  }
+
+  /*
+    Cache Operations
+  */
+  get(filePath, stats) {
+    const entry = this.cache.get(filePath);
+    if (!entry) {
+      this.stats.misses++;
+      return null;
+    }
+    
+    const now = Date.now();
+    
+    // Check if expired by time
+    if (now - entry.timestamp > this.ttlMs) {
+      this.delete(filePath);
+      this.stats.misses++;
+      return null;
+    }
+    
+    // Check if file was modified
+    if (entry.mtime < stats.mtime) {
+      this.delete(filePath);
+      this.stats.misses++;
+      return null;
+    }
+    
+    // Move to end (most recently used)
+    this.cache.delete(filePath);
+    this.cache.set(filePath, entry);
+    
+    this.stats.hits++;
+    return entry.module;
+  }
+
+  set(filePath, module, stats, estimatedSizeKB = 1) {
+    // Evict entries if we'd exceed limits
+    const sizeInMB = estimatedSizeKB / 1024;
+    
+    while (
+      this.cache.size >= this.maxSize || 
+      this.currentMemoryMB + sizeInMB > this.maxMemoryMB
+    ) {
+      this.evictOldest();
+    }
+    
+    // Create cache entry
+    const entry = {
+      module,
+      mtime: stats.mtime,
+      timestamp: Date.now(),
+      sizeKB: estimatedSizeKB,
+      filePath
+    };
+    
+    this.cache.set(filePath, entry);
+    this.currentMemoryMB += sizeInMB;
+    
+    // Set up file watcher if enabled
+    if (this.watchFiles) {
+      this.setupFileWatcher(filePath);
+    }
+  }
+
+  delete(filePath) {
+    const entry = this.cache.get(filePath);
+    if (entry) {
+      this.cache.delete(filePath);
+      this.currentMemoryMB -= entry.sizeKB / 1024;
+      
+      // Remove file watcher
+      const watcher = this.watchers.get(filePath);
+      if (watcher) {
+        watcher.close();
+        this.watchers.delete(filePath);
+      }
+      
+      return true;
+    }
+    return false;
+  }
+
+  clear() {
+    const size = this.cache.size;
+    this.cache.clear();
+    this.currentMemoryMB = 0;
+    
+    // Clean up all watchers
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    
+    this.stats.evictions += size;
+  }
+
+  /*
+    Cache Management
+  */
+  evictOldest() {
+    if (this.cache.size === 0) return;
+    
+    const [oldestKey, oldestEntry] = this.cache.entries().next().value;
+    this.delete(oldestKey);
+    this.stats.evictions++;
+  }
+
+  clearExpiredEntries() {
+    const now = Date.now();
+    let clearedCount = 0;
+    
+    for (const [filePath, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > this.ttlMs) {
+        this.delete(filePath);
+        clearedCount++;
+      }
+    }
+    
+    return clearedCount;
+  }
+
+  /*
+    File Watching
+  */
+  setupFileWatcher(filePath) {
+    // Don't create duplicate watchers
+    if (this.watchers.has(filePath)) return;
+    
+    try {
+      const watcher = watch(filePath, (eventType) => {
+        if (eventType === 'change') {
+          this.delete(filePath);
+          this.stats.fileChanges++;
+        }
+      });
+      
+      // Handle watcher errors gracefully
+      watcher.on('error', (error) => {
+        // File might have been deleted or moved
+        this.delete(filePath);
+      });
+      
+      this.watchers.set(filePath, watcher);
+    } catch (error) {
+      // File watching failed, but cache can still work
+      console.warn(`Could not watch file ${filePath}: ${error.message}`);
+    }
+  }
+
+  /*
+    Utilities and Stats
+  */
+  getStats() {
+    const memoryUsage = process.memoryUsage();
+    
+    return {
+      cache: {
+        size: this.cache.size,
+        maxSize: this.maxSize,
+        memoryUsageMB: Math.round(this.currentMemoryMB * 100) / 100,
+        maxMemoryMB: this.maxMemoryMB,
+        watchersActive: this.watchers.size
+      },
+      stats: { ...this.stats },
+      memory: {
+        heapUsedMB: Math.round(memoryUsage.heapUsed / 1024 / 1024 * 100) / 100,
+        heapTotalMB: Math.round(memoryUsage.heapTotal / 1024 / 1024 * 100) / 100,
+        heapUsagePercent: Math.round((memoryUsage.heapUsed / memoryUsage.heapTotal) * 100),
+        rssMB: Math.round(memoryUsage.rss / 1024 / 1024 * 100) / 100
+      },
+      config: {
+        ttlMs: this.ttlMs,
+        maxHeapUsagePercent: this.maxHeapUsagePercent,
+        watchFiles: this.watchFiles
+      }
+    };
+  }
+
+  getHitRate() {
+    const total = this.stats.hits + this.stats.misses;
+    return total === 0 ? 0 : Math.round((this.stats.hits / total) * 100);
+  }
+
+  /*
+    Development Helpers
+  */
+  logStats(log) {
+    const stats = this.getStats();
+    log(`Cache Stats: ${stats.cache.size}/${stats.cache.maxSize} entries, ` +
+        `${stats.cache.memoryUsageMB}/${stats.cache.maxMemoryMB}MB, ` +
+        `${this.getHitRate()}% hit rate`, 2);
+  }
+
+  // For debugging - list all cached files
+  getCachedFiles() {
+    return Array.from(this.cache.keys()).map(filePath => ({
+      path: filePath,
+      relativePath: path.relative(process.cwd(), filePath),
+      age: Date.now() - this.cache.get(filePath).timestamp,
+      sizeKB: this.cache.get(filePath).sizeKB
+    }));
+  }
+}

package/src/router.js

@@ -6,6 +6,7 @@ import getFiles from './getFiles.js';
 import findFile from './findFile.js';
 import serveFile from './serveFile.js';
 import MiddlewareRunner from './middlewareRunner.js';
+import ModuleCache from './moduleCache.js';
 import { 
   corsMiddleware, 
   compressionMiddleware, 
@@ -44,6 +45,10 @@ export default async (flags, log) => {
       customRoutes: {
         ...defaultConfig.customRoutes,
         ...userConfig.customRoutes
+      },
+      cache: {
+        ...defaultConfig.cache,
+        ...userConfig.cache
       }
     };
     log('User config loaded and merged with defaults', 2);
@@ -115,6 +120,16 @@ export default async (flags, log) => {
     }
   }
   
+  /*
+    Initialize Module Cache
+  */
+  let moduleCache = null;
+  if (config.cache?.enabled) {
+    moduleCache = new ModuleCache(config.cache);
+    log(`Module cache initialized: ${config.cache.maxSize} max modules, ` +
+        `${config.cache.maxMemoryMB}MB limit, ${config.cache.ttlMs}ms TTL`, 2);
+  }
+  
   // Process custom routes - resolve paths and validate files exist
   const customRoutes = new Map();
   const wildcardRoutes = new Map();
@@ -227,7 +242,7 @@ export default async (flags, log) => {
     return newAttempts;
   };
   
-  return async (req, res) => {
+  const requestHandler = async (req, res) => {
     await middlewareRunner.run(req, res, async () => {
       const requestPath = req.url.split('?')[0];
       log(`${req.method} ${requestPath}`, 0);
@@ -278,7 +293,7 @@ export default async (flags, log) => {
       }
       
       // Try to serve the file normally
-      const served = await serveFile(files, rootPath, requestPath, req.method, config, req, res, log);
+      const served = await serveFile(files, rootPath, requestPath, req.method, config, req, res, log, moduleCache);
       
       // If not served and scan flag is enabled, try rescanning once (with blacklist check)
       if (!served && flags.scan && !shouldSkipRescan(requestPath)) {
@@ -288,7 +303,7 @@ export default async (flags, 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);
+        const reserved = await serveFile(files, rootPath, requestPath, req.method, config, req, res, log, moduleCache);
         
         if (!reserved) {
           log(`404 - File not found after rescan: ${requestPath}`, 1);
@@ -305,5 +320,14 @@ export default async (flags, log) => {
         res.end('Not Found');
       }
     });
-  }
+  };
+
+  // Return handler with cache instance for external access
+  const handler = requestHandler;
+  handler.moduleCache = moduleCache;
+  handler.getStats = () => moduleCache?.getStats() || null;
+  handler.logCacheStats = () => moduleCache?.logStats(log);
+  handler.clearCache = () => moduleCache?.clear();
+  
+  return handler;
 }

package/src/serveFile.js

@@ -1,11 +1,11 @@
 import path from 'path';
-import { readFile } from 'fs/promises';
+import { readFile, stat } from 'fs/promises';
 import { pathToFileURL } from 'url';
 import findFile from './findFile.js';
 import createRequestWrapper from './requestWrapper.js';
 import createResponseWrapper from './responseWrapper.js';
 
-export default async (files, rootPath, requestPath, method, config, req, res, log) => {
+export default async (files, rootPath, requestPath, method, config, req, res, log, moduleCache = null) => {
   log(`Attempting to serve: ${requestPath}`, 3);
   const [file, params] = await findFile(files, rootPath, requestPath, method, log);
   
@@ -21,10 +21,34 @@ export default async (files, rootPath, requestPath, method, config, req, res, lo
   if (config.routeFiles.includes(fileName)) {
     log(`Executing route file: ${fileName}`, 2);
     try {
-      // Load the file as a module
-      const fileUrl = pathToFileURL(file).href;
-      log(`Loading module from: ${fileUrl}`, 3);
-      const module = await import(fileUrl);
+      let module;
+      
+      if (moduleCache && config.cache?.enabled) {
+        // Get file stats for cache validation
+        const fileStats = await stat(file);
+        
+        // Try to get from cache first
+        module = moduleCache.get(file, fileStats);
+        
+        if (!module) {
+          // Cache miss - load module
+          const fileUrl = pathToFileURL(file).href + `?t=${Date.now()}`;
+          log(`Loading module from: ${fileUrl}`, 3);
+          module = await import(fileUrl);
+          
+          // Estimate module size (rough approximation based on file size)
+          const estimatedSizeKB = fileStats.size / 1024;
+          moduleCache.set(file, module, fileStats, estimatedSizeKB);
+          log(`Cached module: ${fileName} (${estimatedSizeKB.toFixed(1)}KB)`, 3);
+        } else {
+          log(`Using cached module: ${fileName}`, 3);
+        }
+      } else {
+        // No caching - load fresh each time
+        const fileUrl = pathToFileURL(file).href + `?t=${Date.now()}`;
+        log(`Loading module from: ${fileUrl}`, 3);
+        module = await import(fileUrl);
+      }
       
       // Execute the default export function
       if (typeof module.default === 'function') {
@@ -34,6 +58,11 @@ export default async (files, rootPath, requestPath, method, config, req, res, lo
         const enhancedRequest = createRequestWrapper(req, params);
         const enhancedResponse = createResponseWrapper(res);
         
+        // Make module cache accessible for admin endpoints
+        if (moduleCache) {
+          enhancedRequest._kempoCache = moduleCache;
+        }
+        
         await module.default(enhancedRequest, enhancedResponse);
         log(`Route executed successfully: ${fileName}`, 2);
         return true; // Successfully served

package/tests/builtinMiddleware-cors.node-test.js

@@ -3,15 +3,15 @@ import {createMockReq, createMockRes} from './test-utils.js';
 
 export default {
   'cors origin array and non-OPTIONS continues to next': async ({pass, fail}) => {
-    try {
-      const res = createMockRes();
-      const mw = corsMiddleware({origin: ['http://a','http://b'], methods: ['GET'], headers: ['X']});
-      const req = createMockReq({method: 'GET', headers: {origin: 'http://b'}});
-      let called = false;
-      await mw(req, res, async () => { called = true; });
-      if(!called) return fail('next not called');
-      if(res.getHeader('Access-Control-Allow-Origin') !== 'http://b') return fail('allowed origin');
-      pass('cors array');
-    } catch(e){ fail(e.message); }
+    const res = createMockRes();
+    const mw = corsMiddleware({origin: ['http://a','http://b'], methods: ['GET'], headers: ['X']});
+    const req = createMockReq({method: 'GET', headers: {origin: 'http://b'}});
+    let called = false;
+    await mw(req, res, async () => { called = true; });
+    
+    if(!called) return fail('next not called');
+    if(res.getHeader('Access-Control-Allow-Origin') !== 'http://b') return fail('allowed origin');
+    
+    pass('cors array');
   }
 };