kempo-server 1.6.0 → 1.6.2

package/tests/router.node-test.js

@@ -5,84 +5,104 @@ import router from '../src/router.js';
 import defaultConfig from '../src/defaultConfig.js';
 
 export default {
-  'serves static files and 404s unknown': async ({pass, fail, log}) => {
-    try {
-  await withTempDir(async (dir) => {
-    await write(dir, 'index.html', '<h1>Home</h1>');
-  const prev = process.cwd();
-  process.chdir(dir);
-  const flags = {root: '.', logging: 0, scan: false};
-  const logFn = () => {};
-  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 {
-          const ok = await httpGet(`http://localhost:${port}/index.html`);
-          log('ok status: ' + ok.res.statusCode);
-          if(ok.res.statusCode !== 200) throw new Error('static 200');
-          const miss = await httpGet(`http://localhost:${port}/nope`);
-          log('miss status: ' + miss.res.statusCode);
-          if(miss.res.statusCode !== 404) throw new Error('404');
-        } finally {
-          server.close();
+  'serves static files and 404s unknown': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      await write(dir, 'index.html', '<h1>Home</h1>');
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: false};
+      const logFn = () => {};
+      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));
+      
+      const ok = await httpGet(`http://localhost:${port}/index.html`);
+      if(ok.res.statusCode !== 200) {
+        server.close();
+        process.chdir(prev);
+        return fail('static 200');
+      }
+      
+      const miss = await httpGet(`http://localhost:${port}/nope`);
+      if(miss.res.statusCode !== 404) {
+        server.close();
+        process.chdir(prev);
+        return fail('404');
+      }
+      
+      server.close();
       process.chdir(prev);
-        }
-      });
-      pass('static + 404');
-    } catch(e){ fail(e.message); }
+    });
+    pass('static + 404');
   },
-  'rescan on 404 when enabled and not blacklisted': async ({pass, fail, log}) => {
-    try {
-  await withTempDir(async (dir) => {
-  const prev = process.cwd();
-  process.chdir(dir);
-  const flags = {root: '.', logging: 0, scan: true};
-  const handler = await router(flags, log);
-        const server = http.createServer(handler);
-        const port = randomPort();
-  await new Promise(r => server.listen(port, r));
-  await new Promise(r => setTimeout(r, 50));
-        try {
-          const miss1 = await httpGet(`http://localhost:${port}/late.html`);
-          log('first miss: ' + miss1.res.statusCode);
-          if(miss1.res.statusCode !== 404) throw new Error('first 404');
-          await write(dir, 'late.html', 'later');
-          const hit = await httpGet(`http://localhost:${port}/late.html`);
-          log('hit after rescan: ' + hit.res.statusCode);
-          if(hit.res.statusCode !== 200) throw new Error('served after rescan');
-    } finally { server.close(); process.chdir(prev); }
-      });
-      pass('rescan');
-    } catch(e){ fail(e.message); }
+  'rescan on 404 when enabled and not blacklisted': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: true};
+      const handler = await router(flags, log);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      const miss1 = await httpGet(`http://localhost:${port}/late.html`);
+      if(miss1.res.statusCode !== 404) {
+        server.close();
+        process.chdir(prev);
+        return fail('first 404');
+      }
+      
+      await write(dir, 'late.html', 'later');
+      const hit = await httpGet(`http://localhost:${port}/late.html`);
+      if(hit.res.statusCode !== 200) {
+        server.close();
+        process.chdir(prev);
+        return fail('served after rescan');
+      }
+      
+      server.close();
+      process.chdir(prev);
+    });
+    pass('rescan');
   },
-  'custom and wildcard routes serve mapped files': async ({pass, fail, log}) => {
-    try {
-  await withTempDir(async (dir) => {
-  const fileA = await write(dir, 'a.txt', 'A');
-  const fileB = await write(dir, 'b/1.txt', 'B1');
-  const prev = process.cwd();
-  process.chdir(dir);
-  const flags = {root: '.', logging: 0, scan: false};
-  const logFn = () => {};
-  // write config before init
-  await write(dir, '.config.json', JSON.stringify({customRoutes: {'/a': fileA, 'b/*': path.join(dir, 'b/*')}}));
-  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 {
-          const r1 = await httpGet(`http://localhost:${port}/a`);
-          log('custom status: ' + r1.res.statusCode);
-          if(r1.body.toString() !== 'A') throw new Error('custom route');
-          const r2 = await httpGet(`http://localhost:${port}/b/1.txt`);
-          log('wildcard status: ' + r2.res.statusCode);
-          if(r2.body.toString() !== 'B1') throw new Error('wildcard');
-    } finally { server.close(); process.chdir(prev); }
-      });
-      pass('custom+wildcard');
-    } catch(e){ fail(e.message); }
+  'custom and wildcard routes serve mapped files': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      const fileA = await write(dir, 'a.txt', 'A');
+      const fileB = await write(dir, 'b/1.txt', 'B1');
+      const prev = process.cwd();
+      process.chdir(dir);
+      const flags = {root: '.', logging: 0, scan: false};
+      const logFn = () => {};
+      // write config before init
+      await write(dir, '.config.json', JSON.stringify({
+        customRoutes: {'/a': fileA, 'b/*': path.join(dir, 'b/*')}
+      }));
+      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));
+      
+      const r1 = await httpGet(`http://localhost:${port}/a`);
+      if(r1.body.toString() !== 'A') {
+        server.close();
+        process.chdir(prev);
+        return fail('custom route');
+      }
+      
+      const r2 = await httpGet(`http://localhost:${port}/b/1.txt`);
+      if(r2.body.toString() !== 'B1') {
+        server.close();
+        process.chdir(prev);
+        return fail('wildcard');
+      }
+      
+      server.close();
+      process.chdir(prev);
+    });
+    pass('custom+wildcard');
   }
 };

package/utils/cache-demo.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+/*
+  Cache Demo Script
+  Demonstrates the module cache functionality with real-time monitoring
+*/
+
+import path from 'path';
+import { writeFile, unlink, mkdir, rm } from 'fs/promises';
+import ModuleCache from '../src/moduleCache.js';
+
+const createDemoFiles = async (demoDir) => {
+  await mkdir(demoDir, { recursive: true });
+  
+  // Create some demo route files
+  await writeFile(path.join(demoDir, 'users.js'), 
+    'export default async (req, res) => res.json({ users: ["alice", "bob"] });'
+  );
+  
+  await writeFile(path.join(demoDir, 'posts.js'), 
+    'export default async (req, res) => res.json({ posts: ["post1", "post2"] });'
+  );
+  
+  await writeFile(path.join(demoDir, 'auth.js'), 
+    'export default async (req, res) => res.json({ authenticated: true });'
+  );
+  
+  return [
+    path.join(demoDir, 'users.js'),
+    path.join(demoDir, 'posts.js'), 
+    path.join(demoDir, 'auth.js')
+  ];
+};
+
+const simulateFileAccess = async (cache, filePaths) => {
+  const { stat } = await import('fs/promises');
+  
+  for(const filePath of filePaths) {
+    const stats = await stat(filePath);
+    
+    // Try to get from cache first
+    let module = cache.get(filePath, stats);
+    
+    if(!module) {
+      // Simulate loading module
+      const fileUrl = `file://${filePath}?t=${Date.now()}`;
+      module = await import(fileUrl);
+      cache.set(filePath, module, stats, stats.size / 1024);
+    }
+    
+    console.log(`📁 ${path.basename(filePath)}: ${module ? '✅ cached' : '❌ loaded fresh'}`);
+  }
+};
+
+const displayCacheStats = (cache) => {
+  console.log('\n📊 Cache Statistics:');
+  console.log('─'.repeat(40));
+  
+  const stats = cache.getStats();
+  console.log(`Entries: ${stats.cache.size}/${stats.cache.maxSize}`);
+  console.log(`Memory: ${stats.cache.memoryUsageMB}/${stats.cache.maxMemoryMB}MB`);
+  console.log(`Hit Rate: ${cache.getHitRate()}%`);
+  console.log(`Hits: ${stats.stats.hits}, Misses: ${stats.stats.misses}`);
+  console.log(`File Changes: ${stats.stats.fileChanges}`);
+  console.log(`Heap Usage: ${stats.memory.heapUsedMB}MB (${stats.memory.heapUsagePercent}%)`);
+  
+  if(stats.cache.size > 0) {
+    console.log('\n📋 Cached Files:');
+    const cachedFiles = cache.getCachedFiles();
+    cachedFiles.forEach(file => {
+      const ageSeconds = Math.round(file.age / 1000);
+      console.log(`  • ${file.relativePath} (${file.sizeKB.toFixed(1)}KB, ${ageSeconds}s old)`);
+    });
+  }
+  console.log();
+};
+
+const main = async () => {
+  console.log('🚀 Kempo Server Module Cache Demo\n');
+  
+  // Create demo directory and files
+  const demoDir = path.join(process.cwd(), 'demo-cache-test');
+  console.log('📝 Creating demo files...');
+  const filePaths = await createDemoFiles(demoDir);
+  
+  // Initialize cache with small limits for demo
+  const cache = new ModuleCache({
+    maxSize: 2,
+    maxMemoryMB: 1,
+    ttlMs: 5000, // 5 seconds
+    watchFiles: true,
+    enableMemoryMonitoring: true
+  });
+  
+  console.log('✅ Cache initialized\n');
+  
+  try {
+    // Round 1: Initial loads (cache misses)
+    console.log('🔄 Round 1: Initial file access (expect cache misses)');
+    await simulateFileAccess(cache, filePaths);
+    displayCacheStats(cache);
+    
+    // Round 2: Immediate re-access (cache hits)
+    console.log('🔄 Round 2: Immediate re-access (expect cache hits)');
+    await simulateFileAccess(cache, [filePaths[0], filePaths[1]]);
+    displayCacheStats(cache);
+    
+    // Round 3: Add third file (should evict oldest due to maxSize=2)
+    console.log('🔄 Round 3: Access third file (expect LRU eviction)');
+    await simulateFileAccess(cache, [filePaths[2]]);
+    displayCacheStats(cache);
+    
+    // Round 4: Wait for TTL expiration
+    console.log('⏱️  Waiting 6 seconds for TTL expiration...');
+    await new Promise(resolve => setTimeout(resolve, 6000));
+    
+    console.log('🔄 Round 4: Access after TTL expiration (expect cache misses)');
+    await simulateFileAccess(cache, [filePaths[1]]);
+    displayCacheStats(cache);
+    
+    // Round 5: Demonstrate file watching
+    console.log('📝 Round 5: Modifying file to test file watching...');
+    await writeFile(filePaths[1], 
+      'export default async (req, res) => res.json({ posts: ["updated post"] });'
+    );
+    
+    // Wait for file watcher to detect change
+    await new Promise(resolve => setTimeout(resolve, 200));
+    
+    console.log('🔄 Accessing modified file (expect cache invalidation)');
+    await simulateFileAccess(cache, [filePaths[1]]);
+    displayCacheStats(cache);
+    
+  } finally {
+    // Cleanup
+    console.log('🧹 Cleaning up...');
+    cache.destroy();
+    await rm(demoDir, { recursive: true });
+    console.log('✅ Demo completed successfully!');
+  }
+};
+
+if(import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(console.error);
+}

package/utils/cache-monitor.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+/*
+  Cache Monitor Utility
+  Displays real-time cache statistics and memory usage
+*/
+
+import { spawn } from 'child_process';
+import { pathToFileURL } from 'url';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const formatBytes = (bytes) => {
+  const mb = bytes / 1024 / 1024;
+  return `${mb.toFixed(2)}MB`;
+};
+
+const formatPercent = (value) => `${value.toFixed(1)}%`;
+
+const clearScreen = () => process.stdout.write('\x1b[2J\x1b[0f');
+
+const displayStats = (stats) => {
+  clearScreen();
+  console.log('='.repeat(60));
+  console.log('📦 KEMPO SERVER - MODULE CACHE MONITOR');
+  console.log('='.repeat(60));
+  console.log();
+  
+  if (!stats) {
+    console.log('❌ Cache not available or disabled');
+    return;
+  }
+  
+  const { cache, stats: cacheStats, memory, config } = stats;
+  
+  // Cache Status
+  console.log('📊 CACHE STATUS');
+  console.log('-'.repeat(30));
+  console.log(`Entries:     ${cache.size}/${cache.maxSize} (${((cache.size/cache.maxSize)*100).toFixed(1)}%)`);
+  console.log(`Memory:      ${cache.memoryUsageMB}/${cache.maxMemoryMB}MB (${((cache.memoryUsageMB/cache.maxMemoryMB)*100).toFixed(1)}%)`);
+  console.log(`Watchers:    ${cache.watchersActive} active`);
+  console.log();
+  
+  // Performance Stats
+  console.log('⚡ PERFORMANCE');
+  console.log('-'.repeat(30));
+  const total = cacheStats.hits + cacheStats.misses;
+  const hitRate = total === 0 ? 0 : (cacheStats.hits / total * 100);
+  console.log(`Hit Rate:    ${hitRate.toFixed(1)}% (${cacheStats.hits} hits, ${cacheStats.misses} misses)`);
+  console.log(`Evictions:   ${cacheStats.evictions}`);
+  console.log(`File Changes: ${cacheStats.fileChanges}`);
+  console.log();
+  
+  // Memory Info
+  console.log('🧠 NODE.JS MEMORY');
+  console.log('-'.repeat(30));
+  console.log(`Heap Used:   ${memory.heapUsedMB}MB (${memory.heapUsagePercent}%)`);
+  console.log(`Heap Total:  ${memory.heapTotalMB}MB`);
+  console.log(`RSS:         ${memory.rssMB}MB`);
+  console.log();
+  
+  // Configuration
+  console.log('⚙️  CONFIGURATION');
+  console.log('-'.repeat(30));
+  console.log(`TTL:         ${Math.round(config.ttlMs / 1000)}s`);
+  console.log(`Max Heap:    ${config.maxHeapUsagePercent}%`);
+  console.log(`File Watch:  ${config.watchFiles ? '✅' : '❌'}`);
+  console.log();
+  
+  console.log(`Last updated: ${new Date().toLocaleTimeString()}`);
+  console.log('Press Ctrl+C to exit');
+};
+
+// Simulate getting stats from a running server
+// In a real implementation, you'd expose an endpoint or use IPC
+const getStatsFromServer = async () => {
+  // This is a placeholder - in practice you'd either:
+  // 1. Add an admin endpoint to your server that returns cache stats
+  // 2. Use process communication to get stats from the running server
+  // 3. Log stats to a file that this script reads
+  
+  // For demonstration, return mock stats
+  return {
+    cache: {
+      size: Math.floor(Math.random() * 100),
+      maxSize: 100,
+      memoryUsageMB: Math.random() * 50,
+      maxMemoryMB: 50,
+      watchersActive: Math.floor(Math.random() * 50)
+    },
+    stats: {
+      hits: Math.floor(Math.random() * 1000),
+      misses: Math.floor(Math.random() * 200),
+      evictions: Math.floor(Math.random() * 50),
+      fileChanges: Math.floor(Math.random() * 10)
+    },
+    memory: {
+      heapUsedMB: 45 + Math.random() * 20,
+      heapTotalMB: 70 + Math.random() * 30,
+      heapUsagePercent: 60 + Math.random() * 20,
+      rssMB: 80 + Math.random() * 40
+    },
+    config: {
+      ttlMs: 300000,
+      maxHeapUsagePercent: 70,
+      watchFiles: true
+    }
+  };
+};
+
+const main = async () => {
+  console.log('Starting cache monitor...');
+  
+  setInterval(async () => {
+    try {
+      const stats = await getStatsFromServer();
+      displayStats(stats);
+    } catch (error) {
+      console.error('Error getting stats:', error.message);
+    }
+  }, 2000); // Update every 2 seconds
+};
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+  console.log('\n\n👋 Cache monitor stopped');
+  process.exit(0);
+});
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main();
+}