lumisjs 1.0.0

package/src/security/SecurityMiddleware.js

@@ -0,0 +1,231 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const InputSanitizer = require('./InputSanitizer');
+
+/**
+ * Security Middleware
+ * Provides security checks and sanitization for incoming requests and data.
+ */
+
+class SecurityMiddleware extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      maxRequestSize: options.maxRequestSize || 1024 * 1024, // 1MB
+      rateLimitWindow: options.rateLimitWindow || 60000, // 1 minute
+      rateLimitMax: options.rateLimitMax || 100,
+      blockSuspiciousPatterns: options.blockSuspiciousPatterns !== false,
+      ...options,
+    };
+
+    this._rateLimits = new Map();
+    this._blockedIPs = new Set();
+    this._suspiciousPatterns = [
+      /<script/i,
+      /javascript:/i,
+      /data:/i,
+      /on\w+\s*=/i,
+      /exec\(/i,
+      /system\(/i,
+      /\.\.\//i,
+      /<iframe/i,
+      /<object/i,
+    ];
+  }
+
+  /**
+   * Check if a request should be rate limited.
+   * @param {string} identifier - IP address or user ID
+   * @returns {boolean}
+   */
+  isRateLimited(identifier) {
+    const now = Date.now();
+    const windowStart = now - this.options.rateLimitWindow;
+    
+    let requests = this._rateLimits.get(identifier) || [];
+    
+    // Remove old requests outside the window
+    requests = requests.filter(time => time > windowStart);
+    
+    if (requests.length >= this.options.rateLimitMax) {
+      this.emit('rateLimit', { identifier, count: requests.length });
+      return true;
+    }
+    
+    // Add current request
+    requests.push(now);
+    this._rateLimits.set(identifier, requests);
+    
+    return false;
+  }
+
+  /**
+   * Block an IP address.
+   * @param {string} ip
+   * @param {number} [duration] - Duration in milliseconds (0 = permanent)
+   */
+  blockIP(ip, duration = 0) {
+    this._blockedIPs.add(ip);
+    this.emit('ipBlocked', { ip, duration });
+    
+    if (duration > 0) {
+      setTimeout(() => {
+        this._blockedIPs.delete(ip);
+        this.emit('ipUnblocked', { ip });
+      }, duration);
+    }
+  }
+
+  /**
+   * Check if an IP is blocked.
+   * @param {string} ip
+   * @returns {boolean}
+   */
+  isIPBlocked(ip) {
+    return this._blockedIPs.has(ip);
+  }
+
+  /**
+   * Sanitize and validate input data.
+   * @param {any} data
+   * @param {object} [options]
+   * @returns {any}
+   */
+  sanitizeInput(data, options = {}) {
+    if (typeof data === 'string') {
+      return InputSanitizer.sanitize(data, options);
+    }
+    
+    if (typeof data === 'object' && data !== null) {
+      return InputSanitizer.sanitizeObject(data, options);
+    }
+    
+    return data;
+  }
+
+  /**
+   * Check for suspicious patterns in input.
+   * @param {string} input
+   * @returns {boolean}
+   */
+  containsSuspiciousPatterns(input) {
+    if (!this.options.blockSuspiciousPatterns) return false;
+    
+    if (typeof input !== 'string') return false;
+    
+    for (const pattern of this._suspiciousPatterns) {
+      if (pattern.test(input)) {
+        this.emit('suspiciousPattern', { input, pattern: pattern.source });
+        return true;
+      }
+    }
+    
+    return false;
+  }
+
+  /**
+   * Validate request size.
+   * @param {number} size
+   * @returns {boolean}
+   */
+  isValidRequestSize(size) {
+    if (size > this.options.maxRequestSize) {
+      this.emit('requestTooLarge', { size, max: this.options.maxRequestSize });
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Create a middleware function for Express-like frameworks.
+   * @returns {Function}
+   */
+  createMiddleware() {
+    return (req, res, next) => {
+      const identifier = req.ip || req.connection.remoteAddress;
+      
+      // Check IP block
+      if (this.isIPBlocked(identifier)) {
+        return res.status(403).json({ error: 'IP blocked' });
+      }
+      
+      // Check rate limit
+      if (this.isRateLimited(identifier)) {
+        return res.status(429).json({ error: 'Rate limit exceeded' });
+      }
+      
+      // Check request size
+      const contentLength = parseInt(req.headers['content-length'] || '0');
+      if (!this.isValidRequestSize(contentLength)) {
+        return res.status(413).json({ error: 'Request too large' });
+      }
+      
+      // Sanitize body if present
+      if (req.body) {
+        try {
+          req.body = this.sanitizeInput(req.body);
+        } catch (err) {
+          this.emit('sanitizationError', { error: err });
+          return res.status(400).json({ error: 'Invalid input' });
+        }
+      }
+      
+      // Check for suspicious patterns
+      if (req.body && this.containsSuspiciousPatterns(JSON.stringify(req.body))) {
+        this.emit('suspiciousRequest', { body: req.body });
+        return res.status(400).json({ error: 'Suspicious input detected' });
+      }
+      
+      next();
+    };
+  }
+
+  /**
+   * Clean up rate limit data.
+   */
+  cleanup() {
+    const now = Date.now();
+    const windowStart = now - this.options.rateLimitWindow;
+    
+    for (const [identifier, requests] of this._rateLimits) {
+      const filtered = requests.filter(time => time > windowStart);
+      if (filtered.length === 0) {
+        this._rateLimits.delete(identifier);
+      } else {
+        this._rateLimits.set(identifier, filtered);
+      }
+    }
+  }
+
+  /**
+   * Get security statistics.
+   * @returns {object}
+   */
+  getStats() {
+    return {
+      blockedIPs: this._blockedIPs.size,
+      rateLimitedIdentifiers: this._rateLimits.size,
+      totalRequests: Array.from(this._rateLimits.values()).reduce((sum, reqs) => sum + reqs.length, 0),
+    };
+  }
+
+  /**
+   * Reset all security data.
+   */
+  reset() {
+    this._rateLimits.clear();
+    this._blockedIPs.clear();
+  }
+
+  /**
+   * Destroy the middleware.
+   */
+  destroy() {
+    this.reset();
+    this.removeAllListeners();
+  }
+}
+
+module.exports = SecurityMiddleware;

package/src/security/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const InputSanitizer = require('./InputSanitizer');
+const SecurityMiddleware = require('./SecurityMiddleware');
+
+module.exports = {
+  InputSanitizer,
+  SecurityMiddleware,
+};

package/src/shutdown/GracefulShutdown.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const { EventEmitter } = require('node:events');
+const Logger = require('../utils/Logger');
+
+/**
+ * Graceful Shutdown Handler
+ * Handles graceful shutdown of the application with proper cleanup.
+ */
+
+class GracefulShutdown extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    
+    this.options = {
+      timeout: options.timeout || 30000, // 30 seconds
+      signals: options.signals || ['SIGINT', 'SIGTERM'],
+      ...options,
+    };
+
+    this.logger = new Logger({ prefix: 'Shutdown', level: 'info' });
+
+    this.shutdownHandlers = new Map();
+    this.isShuttingDown = false;
+    this._setupSignalHandlers();
+  }
+
+  /**
+   * Register a shutdown handler.
+   * @param {string} name
+   * @param {Function} handler - Async function to run during shutdown
+   * @param {number} [priority=0] - Higher priority runs first
+   */
+  register(name, handler, priority = 0) {
+    if (typeof handler !== 'function') {
+      throw new TypeError('Shutdown handler must be a function');
+    }
+    
+    this.shutdownHandlers.set(name, { handler, priority });
+    this.logger.info(`Registered shutdown handler: ${name} (priority: ${priority})`);
+  }
+
+  /**
+   * Unregister a shutdown handler.
+   * @param {string} name
+   */
+  unregister(name) {
+    this.shutdownHandlers.delete(name);
+    this.logger.info(`Unregistered shutdown handler: ${name}`);
+  }
+
+  /**
+   * Setup signal handlers for graceful shutdown.
+   * @private
+   */
+  _setupSignalHandlers() {
+    for (const signal of this.options.signals) {
+      process.on(signal, () => {
+        this.logger.info(`Received ${signal} signal`);
+        this.shutdown(signal);
+      });
+    }
+  }
+
+  /**
+   * Initiate graceful shutdown.
+   * @param {string} [reason='manual']
+   * @returns {Promise<void>}
+   */
+  async shutdown(reason = 'manual') {
+    if (this.isShuttingDown) {
+      this.logger.warn('Shutdown already in progress');
+      return;
+    }
+
+    this.isShuttingDown = true;
+    this.logger.info(`Initiating graceful shutdown: ${reason}`);
+    this.emit('shutdown', { reason });
+
+    // Sort handlers by priority (higher first)
+    const sortedHandlers = Array.from(this.shutdownHandlers.entries())
+      .sort(([, a], [, b]) => b.priority - a.priority);
+
+    // Run all shutdown handlers with timeout
+    const shutdownPromises = sortedHandlers.map(([name, { handler }]) => {
+      return Promise.race([
+        handler().catch(error => {
+          this.logger.error(`Shutdown handler failed: ${name}`, error);
+          throw error;
+        }),
+        new Promise((_, reject) => 
+          setTimeout(() => reject(new Error('Handler timeout')), this.options.timeout)
+        ),
+      ]);
+    });
+
+    try {
+      await Promise.allSettled(shutdownPromises);
+      this.logger.info('All shutdown handlers completed');
+      this.emit('complete');
+    } catch (error) {
+      this.logger.error('Error during shutdown', error);
+      this.emit('error', error);
+    }
+
+    // Force exit after timeout
+    setTimeout(() => {
+      this.logger.warn('Forcing exit after timeout');
+      process.exit(1);
+    }, this.options.timeout + 1000);
+  }
+
+  /**
+   * Abort shutdown (if not too late).
+   */
+  abort() {
+    if (!this.isShuttingDown) {
+      this.logger.warn('No shutdown in progress to abort');
+      return;
+    }
+    
+    this.logger.warn('Shutdown abort requested (may not be possible)');
+    this.emit('abort');
+  }
+
+  /**
+   * Check if shutdown is in progress.
+   * @returns {boolean}
+   */
+  isShuttingDown() {
+    return this.isShuttingDown;
+  }
+
+  /**
+   * Get registered handlers.
+   * @returns {Array}
+   */
+  getHandlers() {
+    return Array.from(this.shutdownHandlers.entries()).map(([name, { priority }]) => ({
+      name,
+      priority,
+    }));
+  }
+
+  /**
+   * Destroy the shutdown handler.
+   */
+  destroy() {
+    this.shutdownHandlers.clear();
+    this.removeAllListeners();
+    
+    // Remove signal handlers
+    for (const signal of this.options.signals) {
+      process.removeAllListeners(signal);
+    }
+  }
+}
+
+module.exports = GracefulShutdown;

package/src/shutdown/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const GracefulShutdown = require('./GracefulShutdown');
+
+module.exports = {
+  GracefulShutdown,
+};

package/src/utils/StructuredLogger.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const winston = require('winston');
+
+/**
+ * Structured Logger
+ * Provides structured logging with winston.
+ */
+
+class StructuredLogger {
+  constructor(options = {}) {
+    const {
+      level = options.level || 'info',
+      service = options.service || 'lumis',
+      environment = options.environment || 'development',
+      ...winstonOptions
+    } = options;
+
+    this.logger = winston.createLogger({
+      level,
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.errors({ stack: true }),
+        winston.format.splat(),
+        winston.format.json()
+      ),
+      defaultMeta: { service, environment },
+      transports: [
+        new winston.transports.Console({
+          format: winston.format.combine(
+            winston.format.colorize(),
+            winston.format.printf(({ timestamp, level, message, service, environment, ...meta }) => {
+              const metaStr = Object.keys(meta).length ? JSON.stringify(meta) : '';
+              return `${timestamp} [${service}] [${environment}] ${level}: ${message} ${metaStr}`;
+            })
+          ),
+        }),
+      ],
+      ...winstonOptions,
+    });
+
+    // Add file transport in production
+    if (environment === 'production') {
+      this.logger.add(new winston.transports.File({ filename: 'error.log', level: 'error' }));
+      this.logger.add(new winston.transports.File({ filename: 'combined.log' }));
+    }
+  }
+
+  /**
+   * Log an error.
+   * @param {string} message
+   * @param {object} [meta]
+   */
+  error(message, meta) {
+    this.logger.error(message, meta);
+  }
+
+  /**
+   * Log a warning.
+   * @param {string} message
+   * @param {object} [meta]
+   */
+  warn(message, meta) {
+    this.logger.warn(message, meta);
+  }
+
+  /**
+   * Log info.
+   * @param {string} message
+   * @param {object} [meta]
+   */
+  info(message, meta) {
+    this.logger.info(message, meta);
+  }
+
+  /**
+   * Log debug.
+   * @param {string} message
+   * @param {object} [meta]
+   */
+  debug(message, meta) {
+    this.logger.debug(message, meta);
+  }
+
+  /**
+   * Log verbose.
+   * @param {string} message
+   * @param {object} [meta]
+   */
+  verbose(message, meta) {
+    this.logger.verbose(message, meta);
+  }
+
+  /**
+   * Create a child logger with additional metadata.
+   * @param {object} meta
+   * @returns {StructuredLogger}
+   */
+  child(meta) {
+    const childLogger = new StructuredLogger({
+      level: this.logger.level,
+      service: this.logger.defaultMeta.service,
+      environment: this.logger.defaultMeta.environment,
+    });
+    childLogger.logger.defaultMeta = { ...this.logger.defaultMeta, ...meta };
+    return childLogger;
+  }
+
+  /**
+   * Get the underlying winston logger.
+   * @returns {winston.Logger}
+   */
+  getLogger() {
+    return this.logger;
+  }
+}
+
+module.exports = StructuredLogger;