kempo-server 1.0.0

package/index.js

@@ -0,0 +1,46 @@
+import http from 'http';
+import router from './router.js';
+import getFlags from './getFlags.js';
+
+const flags = getFlags(process.argv.slice(2), {
+  port: 3000,
+  logging: 2,
+  root: './',
+  scan: false
+}, {
+  p: 'port',
+  l: 'logging',
+  r: 'root',
+  s: 'scan'
+});
+
+if(typeof(flags.logging) === 'string'){
+  switch(flags.logging.toLowerCase()) {
+    case 'silent':
+      flags.logging = 0;
+      break;
+    case 'minimal':
+      flags.logging = 1;
+      break;
+    case 'verbose':
+      flags.logging = 3;
+      break;
+    case 'debug':
+      flags.logging = 4;
+      break;
+    default:
+      flags.logging = 2;
+      break;
+  }
+}
+
+const log = (message, level = 2) => {
+  if(level <= flags.logging){
+    console.log(message);
+  }
+}
+
+const server = http.createServer(await router(flags, log));
+server.listen(flags.port);
+log(`Server started at: http://localhost:${flags.port}`);
+

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "kempo-server",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js -r docs"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "essentialcss": "^2.0.1"
+  }
+}

package/requestWrapper.js

@@ -0,0 +1,87 @@
+import { URL } from 'url';
+
+/**
+ * Creates an enhanced request object with Express-like functionality
+ * @param {IncomingMessage} request - The original Node.js request object
+ * @param {Object} params - Route parameters from dynamic routes
+ * @returns {Object} Enhanced request object
+ */
+export function createRequestWrapper(request, params = {}) {
+  // Parse URL to extract query parameters
+  const url = new URL(request.url, `http://${request.headers.host || 'localhost'}`);
+  const query = Object.fromEntries(url.searchParams);
+  
+  // Create the enhanced request object
+  const enhancedRequest = {
+    // Original request properties and methods
+    ...request,
+    method: request.method,
+    url: request.url,
+    headers: request.headers,
+    
+    // Enhanced properties
+    params,
+    query,
+    path: url.pathname,
+    
+    // Body parsing methods
+    async body() {
+      return new Promise((resolve, reject) => {
+        let body = '';
+        
+        request.on('data', chunk => {
+          body += chunk.toString();
+        });
+        
+        request.on('end', () => {
+          resolve(body);
+        });
+        
+        request.on('error', reject);
+      });
+    },
+    
+    async json() {
+      try {
+        const body = await this.body();
+        return JSON.parse(body);
+      } catch (error) {
+        throw new Error('Invalid JSON in request body');
+      }
+    },
+    
+    async text() {
+      return this.body();
+    },
+    
+    async buffer() {
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        
+        request.on('data', chunk => {
+          chunks.push(chunk);
+        });
+        
+        request.on('end', () => {
+          resolve(Buffer.concat(chunks));
+        });
+        
+        request.on('error', reject);
+      });
+    },
+    
+    // Utility methods
+    get(headerName) {
+      return request.headers[headerName.toLowerCase()];
+    },
+    
+    is(type) {
+      const contentType = this.get('content-type') || '';
+      return contentType.includes(type);
+    }
+  };
+  
+  return enhancedRequest;
+}
+
+export default createRequestWrapper;

package/responseWrapper.js

@@ -0,0 +1,204 @@
+/**
+ * Creates an enhanced response object with Express-like functionality
+ * @param {ServerResponse} response - The original Node.js response object
+ * @returns {Object} Enhanced response object
+ */
+export function createResponseWrapper(response) {
+  // Track if response has been sent
+  let sent = false;
+  
+  // Create the enhanced response object
+  const enhancedResponse = {
+    // Original response properties and methods
+    ...response,
+    
+    // Status code management
+    status(code) {
+      if (sent) {
+        throw new Error('Cannot set status after response has been sent');
+      }
+      response.statusCode = code;
+      return enhancedResponse; // Allow chaining
+    },
+    
+    // Header management
+    set(field, value) {
+      if (sent) {
+        throw new Error('Cannot set headers after response has been sent');
+      }
+      if (typeof field === 'object') {
+        // Set multiple headers: res.set({ 'Content-Type': 'text/html', 'X-Custom': 'value' })
+        Object.entries(field).forEach(([key, val]) => {
+          response.setHeader(key, val);
+        });
+      } else {
+        // Set single header: res.set('Content-Type', 'text/html')
+        response.setHeader(field, value);
+      }
+      return enhancedResponse; // Allow chaining
+    },
+    
+    get(field) {
+      return response.getHeader(field);
+    },
+    
+    // Content type helpers
+    type(contentType) {
+      if (sent) {
+        throw new Error('Cannot set content type after response has been sent');
+      }
+      
+      // Handle common shortcuts
+      const typeMap = {
+        'html': 'text/html',
+        'json': 'application/json',
+        'xml': 'application/xml',
+        'text': 'text/plain',
+        'css': 'text/css',
+        'js': 'application/javascript'
+      };
+      
+      const mimeType = typeMap[contentType] || contentType;
+      response.setHeader('Content-Type', mimeType);
+      return enhancedResponse; // Allow chaining
+    },
+    
+    // JSON response
+    json(obj) {
+      if (sent) {
+        throw new Error('Cannot send response after it has already been sent');
+      }
+      
+      sent = true;
+      response.setHeader('Content-Type', 'application/json');
+      
+      try {
+        const jsonString = JSON.stringify(obj);
+        response.end(jsonString);
+      } catch (error) {
+        throw new Error('Failed to stringify object to JSON');
+      }
+      
+      return enhancedResponse;
+    },
+    
+    // Text response
+    send(data) {
+      if (sent) {
+        throw new Error('Cannot send response after it has already been sent');
+      }
+      
+      sent = true;
+      
+      if (data === null || data === undefined) {
+        response.end();
+        return enhancedResponse;
+      }
+      
+      // Handle different data types
+      if (typeof data === 'object') {
+        // If it's an object, send as JSON
+        response.setHeader('Content-Type', 'application/json');
+        response.end(JSON.stringify(data));
+      } else if (typeof data === 'string') {
+        // If Content-Type not set, default to text/html for strings
+        if (!response.getHeader('Content-Type')) {
+          response.setHeader('Content-Type', 'text/html');
+        }
+        response.end(data);
+      } else if (Buffer.isBuffer(data)) {
+        // Handle buffers
+        response.end(data);
+      } else {
+        // Convert to string
+        if (!response.getHeader('Content-Type')) {
+          response.setHeader('Content-Type', 'text/plain');
+        }
+        response.end(String(data));
+      }
+      
+      return enhancedResponse;
+    },
+    
+    // HTML response helper
+    html(htmlString) {
+      if (sent) {
+        throw new Error('Cannot send response after it has already been sent');
+      }
+      
+      sent = true;
+      response.setHeader('Content-Type', 'text/html');
+      response.end(htmlString);
+      return enhancedResponse;
+    },
+    
+    // Text response helper
+    text(textString) {
+      if (sent) {
+        throw new Error('Cannot send response after it has already been sent');
+      }
+      
+      sent = true;
+      response.setHeader('Content-Type', 'text/plain');
+      response.end(String(textString));
+      return enhancedResponse;
+    },
+    
+    // Redirect helper
+    redirect(url, statusCode = 302) {
+      if (sent) {
+        throw new Error('Cannot redirect after response has been sent');
+      }
+      
+      sent = true;
+      response.statusCode = statusCode;
+      response.setHeader('Location', url);
+      response.end();
+      return enhancedResponse;
+    },
+    
+    // Cookie management (basic)
+    cookie(name, value, options = {}) {
+      if (sent) {
+        throw new Error('Cannot set cookies after response has been sent');
+      }
+      
+      let cookieString = `${name}=${encodeURIComponent(value)}`;
+      
+      if (options.maxAge) {
+        cookieString += `; Max-Age=${options.maxAge}`;
+      }
+      if (options.domain) {
+        cookieString += `; Domain=${options.domain}`;
+      }
+      if (options.path) {
+        cookieString += `; Path=${options.path}`;
+      }
+      if (options.secure) {
+        cookieString += '; Secure';
+      }
+      if (options.httpOnly) {
+        cookieString += '; HttpOnly';
+      }
+      if (options.sameSite) {
+        cookieString += `; SameSite=${options.sameSite}`;
+      }
+      
+      const existingCookies = response.getHeader('Set-Cookie') || [];
+      const cookies = Array.isArray(existingCookies) ? existingCookies : [existingCookies];
+      cookies.push(cookieString);
+      
+      response.setHeader('Set-Cookie', cookies);
+      return enhancedResponse;
+    },
+    
+    // Clear cookie helper
+    clearCookie(name, options = {}) {
+      return this.cookie(name, '', { ...options, maxAge: 0 });
+    }
+  };
+  
+  return enhancedResponse;
+}
+
+export default createResponseWrapper;

package/router.js

@@ -0,0 +1,159 @@
+import path from 'path';
+import { readFile } from 'fs/promises';
+import { pathToFileURL } from 'url';
+import defaultConfig from './defaultConfig.js';
+import getFiles from './getFiles.js';
+import findFile from './findFile.js';
+import serveFile from './serveFile.js';
+
+export default async (flags, log) => {
+  log('Initializing router', 2);
+  const rootPath = path.join(process.cwd(), flags.root);
+  log(`Root path: ${rootPath}`, 2);
+  
+  let config = defaultConfig;
+  try {
+    const configPath = path.join(rootPath, '.config.json');
+    log(`Loading config from: ${configPath}`, 2);
+    const configContent = await readFile(configPath, 'utf8');
+    const userConfig = JSON.parse(configContent);
+    config = {
+      ...defaultConfig,
+      ...userConfig
+    };
+    log('User config loaded and merged with defaults', 2);
+  } catch (e){
+    log('Using default config (no .config.json found)', 2);
+  }
+  
+  /*
+    Inject mandatory disallowed patterns
+  */
+  const dis = new Set(config.disallowedRegex);
+  dis.add("^/\\..*");
+  dis.add("\\.config$");
+  dis.add("\\.git/"); 
+  config.disallowedRegex = [...dis];
+  log(`Config loaded with ${config.disallowedRegex.length} disallowed patterns`, 2);
+  
+  let files = await getFiles(rootPath, config, log);
+  log(`Initial scan found ${files.length} files`, 1);
+  
+  // Process custom routes - resolve paths and validate files exist
+  const customRoutes = new Map();
+  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 {
+        // 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);
+      }
+    }
+  }
+  
+  // Track 404 attempts to avoid unnecessary rescans
+  const rescanAttempts = new Map(); // path -> attempt count
+  const dynamicNoRescanPaths = new Set(); // paths that have exceeded max attempts
+  
+  // Helper function to check if a path should skip rescanning
+  const shouldSkipRescan = (requestPath) => {
+    // Check static config patterns
+    const matchesConfigPattern = config.noRescanPaths.some(pattern => {
+      const regex = new RegExp(pattern);
+      return regex.test(requestPath);
+    });
+    
+    if (matchesConfigPattern) {
+      log(`Skipping rescan for configured pattern: ${requestPath}`, 3);
+      return true;
+    }
+    
+    // Check dynamic blacklist
+    if (dynamicNoRescanPaths.has(requestPath)) {
+      log(`Skipping rescan for dynamically blacklisted path: ${requestPath}`, 3);
+      return true;
+    }
+    
+    return false;
+  };
+  
+  // Helper function to track rescan attempts
+  const trackRescanAttempt = (requestPath) => {
+    const currentAttempts = rescanAttempts.get(requestPath) || 0;
+    const newAttempts = currentAttempts + 1;
+    rescanAttempts.set(requestPath, newAttempts);
+    
+    if (newAttempts >= config.maxRescanAttempts) {
+      dynamicNoRescanPaths.add(requestPath);
+      log(`Path ${requestPath} added to dynamic blacklist after ${newAttempts} failed attempts`, 1);
+    }
+    
+    log(`Rescan attempt ${newAttempts}/${config.maxRescanAttempts} for: ${requestPath}`, 2);
+    return newAttempts;
+  };
+  
+  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);
+      
+      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;
+      }
+    }
+    
+    // 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);
+      
+      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');
+    }
+  }
+}

package/serveFile.js

@@ -0,0 +1,71 @@
+import path from 'path';
+import { readFile } 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) => {
+  log(`Attempting to serve: ${requestPath}`, 3);
+  const [file, params] = await findFile(files, rootPath, requestPath, method, log);
+  
+  if (!file) {
+    log(`No file found for: ${requestPath}`, 3);
+    return false; // Could not find file
+  }
+  
+  const fileName = path.basename(file);
+  log(`Found file: ${file}`, 2);
+  
+  // Check if this is a route file that should be executed as a module
+  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);
+      
+      // Execute the default export function
+      if (typeof module.default === 'function') {
+        log(`Executing route function with params: ${JSON.stringify(params)}`, 3);
+        
+        // Create enhanced request and response wrappers
+        const enhancedRequest = createRequestWrapper(req, params);
+        const enhancedResponse = createResponseWrapper(res);
+        
+        await module.default(enhancedRequest, enhancedResponse);
+        log(`Route executed successfully: ${fileName}`, 2);
+        return true; // Successfully served
+      } else {
+        log(`Route file does not export a function: ${fileName}`, 0);
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Route file does not export a function');
+        return true; // Handled (even though it's an error)
+      }
+    } catch (error) {
+      log(`Error loading route file ${fileName}: ${error.message}`, 0);
+      res.writeHead(500, { 'Content-Type': 'text/plain' });
+      res.end('Internal Server Error');
+      return true; // Handled (even though it's an error)
+    }
+  } else {
+    // Serve the file content with appropriate MIME type
+    log(`Serving static file: ${fileName}`, 2);
+    try {
+      const fileContent = await readFile(file);
+      const fileExtension = path.extname(file).toLowerCase().slice(1);
+      const mimeType = config.allowedMimes[fileExtension] || 'application/octet-stream';
+      
+      log(`Serving ${file} as ${mimeType} (${fileContent.length} bytes)`, 2);
+      res.writeHead(200, { 'Content-Type': mimeType });
+      res.end(fileContent);
+      return true; // Successfully served
+    } catch (error) {
+      log(`Error reading file ${file}: ${error.message}`, 0);
+      res.writeHead(500, { 'Content-Type': 'text/plain' });
+      res.end('Internal Server Error');
+      return true; // Handled (even though it's an error)
+    }
+  }
+};