koa-classic-server 1.1.0 → 2.0.0

package/jest.config.js

@@ -0,0 +1,18 @@
+module.exports = {
+  testEnvironment: 'node',
+  testMatch: [
+    '**/__tests__/**/*.test.js'
+  ],
+  testTimeout: 120000, // 2 minutes for performance tests
+  verbose: true,
+  collectCoverageFrom: [
+    'index.cjs',
+    'index.mjs'
+  ],
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '/customTest/',
+    '/benchmark-data/',
+    '/scripts/'
+  ]
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koa-classic-server",
-  "version": "1.1.0",
-  "description": "a server in style Apache 2",
+  "version": "2.0.0",
+  "description": "High-performance Koa middleware for serving static files with Apache-like directory listing, HTTP caching, template engine support, and comprehensive security fixes",
   "main": "index.cjs",
   "exports": {
     "import": "./index.mjs",
@@ -10,18 +10,31 @@
   "scripts": {
     "start": "node index.cjs",
     "test": "jest",
+    "test:security": "jest __tests__/security.test.js",
+    "test:performance": "jest __tests__/performance.test.js --runInBand",
+    "benchmark": "node benchmark.js",
+    "benchmark:save": "node benchmark.js --save",
+    "benchmark:setup": "node scripts/setup-benchmark.js",
     "loadConfig": "node ./customTest/loadConfig.util.js"
   },
   "keywords": [
-    "file",
-    "server"
+    "koa",
+    "middleware",
+    "static",
+    "file-server",
+    "directory-listing",
+    "apache",
+    "secure",
+    "template-engine"
   ],
   "author": "Italo Paesano",
   "license": "MIT",
   "dependencies": {
-    "koa": "^2.13.4"
+    "koa": "^3.1.1",
+    "mime-types": "^2.1.35"
   },
   "devDependencies": {
+    "autocannon": "^7.15.0",
     "inquirer": "^12.4.1",
     "jest": "^29.7.0",
     "supertest": "^7.0.0"

package/publish-to-npm.sh

@@ -0,0 +1,65 @@
+#!/bin/bash
+# Script per pubblicare koa-classic-server v1.2.0 su npm
+
+set -e  # Exit on error
+
+echo "📦 Publishing koa-classic-server v1.2.0 to npm"
+echo ""
+
+# Verifica login
+echo "🔐 Verifying npm login..."
+if ! npm whoami > /dev/null 2>&1; then
+    echo "❌ Not logged in to npm. Please run: npm login"
+    exit 1
+fi
+
+echo "✅ Logged in as: $(npm whoami)"
+echo ""
+
+# Verifica versione
+echo "📋 Package info:"
+echo "   Name: $(node -p "require('./package.json').name")"
+echo "   Version: $(node -p "require('./package.json').version")"
+echo ""
+
+# Verifica che non ci siano modifiche non committate
+if [ -n "$(git status --porcelain)" ]; then
+    echo "⚠️  Warning: You have uncommitted changes"
+    git status --short
+    read -p "Continue anyway? (y/N) " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        exit 1
+    fi
+fi
+
+# Dry run per vedere cosa verrà pubblicato
+echo "🔍 Files that will be published:"
+npm pack --dry-run | tail -20
+echo ""
+
+# Chiedi conferma
+read -p "🚀 Publish to npm? (y/N) " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo "❌ Publish cancelled"
+    exit 0
+fi
+
+# Pubblica
+echo "📤 Publishing to npm..."
+npm publish
+
+if [ $? -eq 0 ]; then
+    echo ""
+    echo "✅ Successfully published koa-classic-server@1.2.0!"
+    echo ""
+    echo "🔗 View on npm: https://www.npmjs.com/package/koa-classic-server"
+    echo ""
+    echo "📝 Users can now install with:"
+    echo "   npm install koa-classic-server@1.2.0"
+    echo "   npm install koa-classic-server@latest"
+else
+    echo "❌ Publish failed"
+    exit 1
+fi

package/scripts/setup-benchmark.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+/**
+ * Setup script for performance benchmarks
+ * Creates test files and directories for realistic performance testing
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const BENCHMARK_DIR = path.join(__dirname, '../benchmark-data');
+
+console.log('🔧 Setting up benchmark environment...\n');
+
+// Clean up old benchmark data
+if (fs.existsSync(BENCHMARK_DIR)) {
+    console.log('Cleaning old benchmark data...');
+    fs.rmSync(BENCHMARK_DIR, { recursive: true, force: true });
+}
+
+// Create benchmark directory
+fs.mkdirSync(BENCHMARK_DIR, { recursive: true });
+
+// Create small files (1KB each)
+console.log('Creating small files (1KB each)...');
+const smallDir = path.join(BENCHMARK_DIR, 'small-files');
+fs.mkdirSync(smallDir);
+for (let i = 1; i <= 100; i++) {
+    const content = 'X'.repeat(1024); // 1KB
+    fs.writeFileSync(path.join(smallDir, `file-${i}.txt`), content);
+}
+console.log(`✓ Created 100 small files (1KB each) = 100KB total`);
+
+// Create medium files (100KB each)
+console.log('Creating medium files (100KB each)...');
+const mediumDir = path.join(BENCHMARK_DIR, 'medium-files');
+fs.mkdirSync(mediumDir);
+for (let i = 1; i <= 50; i++) {
+    const content = 'X'.repeat(100 * 1024); // 100KB
+    fs.writeFileSync(path.join(mediumDir, `file-${i}.txt`), content);
+}
+console.log(`✓ Created 50 medium files (100KB each) = 5MB total`);
+
+// Create large files (1MB each)
+console.log('Creating large files (1MB each)...');
+const largeDir = path.join(BENCHMARK_DIR, 'large-files');
+fs.mkdirSync(largeDir);
+for (let i = 1; i <= 10; i++) {
+    const content = 'X'.repeat(1024 * 1024); // 1MB
+    fs.writeFileSync(path.join(largeDir, `file-${i}.txt`), content);
+}
+console.log(`✓ Created 10 large files (1MB each) = 10MB total`);
+
+// Create directory with many files for listing test
+console.log('Creating large directory (1000 files)...');
+const largeDirListing = path.join(BENCHMARK_DIR, 'large-directory');
+fs.mkdirSync(largeDirListing);
+for (let i = 1; i <= 1000; i++) {
+    const content = `File number ${i}\n`;
+    fs.writeFileSync(path.join(largeDirListing, `item-${String(i).padStart(4, '0')}.txt`), content);
+}
+console.log(`✓ Created directory with 1000 files`);
+
+// Create directory with very many files (10,000) for stress test
+console.log('Creating very large directory (10,000 files) - this may take a while...');
+const veryLargeDirListing = path.join(BENCHMARK_DIR, 'very-large-directory');
+fs.mkdirSync(veryLargeDirListing);
+for (let i = 1; i <= 10000; i++) {
+    const content = `File number ${i}\n`;
+    fs.writeFileSync(path.join(veryLargeDirListing, `item-${String(i).padStart(5, '0')}.txt`), content);
+    if (i % 1000 === 0) {
+        process.stdout.write(`  Progress: ${i}/10000 files created...\r`);
+    }
+}
+console.log(`✓ Created directory with 10,000 files                    `);
+
+// Create HTML file for caching test
+console.log('Creating HTML files for caching test...');
+const htmlContent = `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Benchmark Test Page</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; }
+        h1 { color: #333; }
+        p { line-height: 1.6; }
+    </style>
+</head>
+<body>
+    <h1>Benchmark Test Page</h1>
+    <p>${'Lorem ipsum dolor sit amet. '.repeat(100)}</p>
+</body>
+</html>`;
+fs.writeFileSync(path.join(BENCHMARK_DIR, 'test.html'), htmlContent);
+console.log(`✓ Created HTML file for caching test`);
+
+// Create CSS file
+const cssContent = `
+body {
+    margin: 0;
+    padding: 20px;
+    font-family: system-ui, -apple-system, sans-serif;
+}
+${'h1 { color: #333; }\n'.repeat(50)}
+`.trim();
+fs.writeFileSync(path.join(BENCHMARK_DIR, 'style.css'), cssContent);
+console.log(`✓ Created CSS file`);
+
+// Create JS file
+const jsContent = `
+function benchmark() {
+    console.log('Benchmark test');
+    ${'console.log("test");\n'.repeat(100)}
+}
+`.trim();
+fs.writeFileSync(path.join(BENCHMARK_DIR, 'script.js'), jsContent);
+console.log(`✓ Created JS file`);
+
+// Create nested directory structure
+console.log('Creating nested directory structure...');
+const nestedBase = path.join(BENCHMARK_DIR, 'nested');
+fs.mkdirSync(nestedBase);
+for (let depth = 1; depth <= 5; depth++) {
+    const dirPath = path.join(nestedBase, ...Array(depth).fill('level'));
+    fs.mkdirSync(dirPath, { recursive: true });
+    for (let i = 1; i <= 10; i++) {
+        fs.writeFileSync(
+            path.join(dirPath, `file-depth${depth}-${i}.txt`),
+            `Depth ${depth}, File ${i}\n`
+        );
+    }
+}
+console.log(`✓ Created nested directory structure (5 levels deep)`);
+
+// Create .gitignore for benchmark-data
+const gitignorePath = path.join(BENCHMARK_DIR, '.gitignore');
+fs.writeFileSync(gitignorePath, '*\n');
+console.log(`✓ Created .gitignore to exclude benchmark data from git`);
+
+// Summary
+console.log('\n✅ Benchmark environment setup complete!\n');
+console.log('Directory structure:');
+console.log('  benchmark-data/');
+console.log('    ├── small-files/        (100 files × 1KB = 100KB)');
+console.log('    ├── medium-files/       (50 files × 100KB = 5MB)');
+console.log('    ├── large-files/        (10 files × 1MB = 10MB)');
+console.log('    ├── large-directory/    (1,000 files for listing test)');
+console.log('    ├── very-large-directory/ (10,000 files for stress test)');
+console.log('    ├── nested/             (5 levels deep, 10 files each)');
+console.log('    ├── test.html           (HTML for caching test)');
+console.log('    ├── style.css           (CSS file)');
+console.log('    └── script.js           (JS file)');
+
+const stats = getDirSize(BENCHMARK_DIR);
+console.log(`\nTotal size: ${(stats.size / 1024 / 1024).toFixed(2)} MB`);
+console.log(`Total files: ${stats.files}`);
+
+function getDirSize(dir) {
+    let totalSize = 0;
+    let totalFiles = 0;
+
+    function traverse(currentPath) {
+        const items = fs.readdirSync(currentPath, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = path.join(currentPath, item.name);
+            if (item.isDirectory()) {
+                traverse(fullPath);
+            } else {
+                totalSize += fs.statSync(fullPath).size;
+                totalFiles++;
+            }
+        }
+    }
+
+    traverse(dir);
+    return { size: totalSize, files: totalFiles };
+}

package/test-regex-quick.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+/**
+ * Quick test: RegExp index option
+ */
+
+const Koa = require('koa');
+const koaClassicServer = require('./index.cjs');
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+
+// Crea directory di test
+const testDir = path.join(__dirname, 'test-regex-temp');
+if (fs.existsSync(testDir)) {
+    fs.readdirSync(testDir).forEach(file => {
+        fs.unlinkSync(path.join(testDir, file));
+    });
+    fs.rmdirSync(testDir);
+}
+fs.mkdirSync(testDir);
+
+// Test case 1: Case-insensitive matching
+console.log('\n📋 TEST 1: Case-insensitive /index\\.html/i\n');
+console.log('File creati:');
+console.log('  - INDEX.HTML (maiuscolo)');
+console.log('  - other.txt\n');
+
+fs.writeFileSync(path.join(testDir, 'INDEX.HTML'), '<h1>INDEX.HTML (MAIUSCOLO)</h1>');
+fs.writeFileSync(path.join(testDir, 'other.txt'), 'altro file');
+
+const app1 = new Koa();
+app1.use(koaClassicServer(testDir, {
+    index: [/index\.html/i]  // ← REGEXP CASE-INSENSITIVE!
+}));
+
+const server1 = app1.listen(9001);
+
+// Test la richiesta
+setTimeout(() => {
+    http.get('http://localhost:9001/', (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+            if (data.includes('INDEX.HTML (MAIUSCOLO)')) {
+                console.log('✅ SUCCESS: Il server ha trovato INDEX.HTML usando /index\\.html/i');
+                console.log('   Contenuto ricevuto: ' + data.trim());
+            } else {
+                console.log('❌ FAIL: Pattern non ha matchato');
+                console.log('   Contenuto ricevuto: ' + data);
+            }
+
+            server1.close();
+
+            // Test case 2
+            runTest2();
+        });
+    });
+}, 100);
+
+function runTest2() {
+    // Pulisci directory
+    fs.readdirSync(testDir).forEach(file => {
+        fs.unlinkSync(path.join(testDir, file));
+    });
+
+    console.log('\n📋 TEST 2: Multi-extension /index\\.(html|htm)/i\n');
+    console.log('File creati:');
+    console.log('  - Index.HTM (mixed case, estensione .htm)');
+    console.log('  - other.html\n');
+
+    fs.writeFileSync(path.join(testDir, 'Index.HTM'), '<h1>Index.HTM (mixed case)</h1>');
+    fs.writeFileSync(path.join(testDir, 'other.html'), '<h1>altro</h1>');
+
+    const app2 = new Koa();
+    app2.use(koaClassicServer(testDir, {
+        index: [/index\.(html|htm)/i]  // ← REGEXP con (html|htm)!
+    }));
+
+    const server2 = app2.listen(9002);
+
+    setTimeout(() => {
+        http.get('http://localhost:9002/', (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                if (data.includes('Index.HTM (mixed case)')) {
+                    console.log('✅ SUCCESS: Il server ha trovato Index.HTM usando /index\\.(html|htm)/i');
+                    console.log('   Contenuto ricevuto: ' + data.trim());
+                } else {
+                    console.log('❌ FAIL: Pattern non ha matchato');
+                    console.log('   Contenuto ricevuto: ' + data);
+                }
+
+                server2.close();
+
+                // Test case 3
+                runTest3();
+            });
+        });
+    }, 100);
+}
+
+function runTest3() {
+    // Pulisci directory
+    fs.readdirSync(testDir).forEach(file => {
+        fs.unlinkSync(path.join(testDir, file));
+    });
+
+    console.log('\n📋 TEST 3: Array con priorità [/index\\.html/i, /default\\.html/i]\n');
+    console.log('File creati:');
+    console.log('  - DEFAULT.HTML (maiuscolo)');
+    console.log('  - other.txt\n');
+    console.log('Nota: index.html NON esiste, dovrebbe trovare default.html\n');
+
+    fs.writeFileSync(path.join(testDir, 'DEFAULT.HTML'), '<h1>DEFAULT.HTML (fallback)</h1>');
+    fs.writeFileSync(path.join(testDir, 'other.txt'), 'altro');
+
+    const app3 = new Koa();
+    app3.use(koaClassicServer(testDir, {
+        index: [
+            /index\.html/i,    // Prima cerca index.html (NON esiste)
+            /default\.html/i   // Poi cerca default.html (ESISTE!)
+        ]
+    }));
+
+    const server3 = app3.listen(9003);
+
+    setTimeout(() => {
+        http.get('http://localhost:9003/', (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                if (data.includes('DEFAULT.HTML (fallback)')) {
+                    console.log('✅ SUCCESS: Il server ha fatto fallback a DEFAULT.HTML');
+                    console.log('   Contenuto ricevuto: ' + data.trim());
+                } else {
+                    console.log('❌ FAIL: Fallback non ha funzionato');
+                    console.log('   Contenuto ricevuto: ' + data);
+                }
+
+                server3.close();
+
+                // Cleanup finale
+                cleanup();
+            });
+        });
+    }, 100);
+}
+
+function cleanup() {
+    console.log('\n🧹 Pulizia...\n');
+    fs.readdirSync(testDir).forEach(file => {
+        fs.unlinkSync(path.join(testDir, file));
+    });
+    fs.rmdirSync(testDir);
+    console.log('✅ Tutti i test completati!\n');
+}