navis.js 3.1.0 → 5.0.0

package/src/health/health-checker.js

@@ -0,0 +1,120 @@
+/**
+ * Health Check Middleware
+ * v5: Liveness and readiness probes
+ */
+
+class HealthChecker {
+  constructor(options = {}) {
+    this.checks = options.checks || {};
+    this.livenessPath = options.livenessPath || '/health/live';
+    this.readinessPath = options.readinessPath || '/health/ready';
+    this.enabled = options.enabled !== false;
+  }
+
+  /**
+   * Add a health check
+   * @param {string} name - Check name
+   * @param {Function} checkFn - Async function that returns true/false or throws
+   */
+  addCheck(name, checkFn) {
+    this.checks[name] = checkFn;
+  }
+
+  /**
+   * Remove a health check
+   * @param {string} name - Check name
+   */
+  removeCheck(name) {
+    delete this.checks[name];
+  }
+
+  /**
+   * Run all checks
+   * @param {boolean} includeReadiness - Include readiness checks
+   * @returns {Promise<Object>} - Health status
+   */
+  async runChecks(includeReadiness = true) {
+    const results = {};
+    let allHealthy = true;
+
+    for (const [name, checkFn] of Object.entries(this.checks)) {
+      try {
+        const result = await checkFn();
+        results[name] = {
+          status: result === false ? 'unhealthy' : 'healthy',
+          timestamp: new Date().toISOString(),
+        };
+        
+        if (result === false) {
+          allHealthy = false;
+        }
+      } catch (error) {
+        results[name] = {
+          status: 'unhealthy',
+          error: error.message,
+          timestamp: new Date().toISOString(),
+        };
+        allHealthy = false;
+      }
+    }
+
+    return {
+      status: allHealthy ? 'healthy' : 'unhealthy',
+      checks: results,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Create health check middleware
+   * @returns {Function} - Middleware function
+   */
+  middleware() {
+    return async (req, res, next) => {
+      if (!this.enabled) {
+        return next();
+      }
+
+      const path = req.path || req.url;
+
+      // Liveness probe (always returns 200 if service is running)
+      if (path === this.livenessPath) {
+        res.statusCode = 200;
+        res.headers = res.headers || {};
+        res.headers['Content-Type'] = 'application/json';
+        res.body = {
+          status: 'alive',
+          timestamp: new Date().toISOString(),
+        };
+        return;
+      }
+
+      // Readiness probe (checks all health checks)
+      if (path === this.readinessPath) {
+        const healthStatus = await this.runChecks(true);
+        res.statusCode = healthStatus.status === 'healthy' ? 200 : 503;
+        res.headers = res.headers || {};
+        res.headers['Content-Type'] = 'application/json';
+        res.body = healthStatus;
+        return;
+      }
+
+      next();
+    };
+  }
+}
+
+/**
+ * Create health checker
+ * @param {Object} options - Health checker options
+ * @returns {HealthChecker} - Health checker instance
+ */
+function createHealthChecker(options = {}) {
+  return new HealthChecker(options);
+}
+
+module.exports = {
+  HealthChecker,
+  createHealthChecker,
+};
+

package/src/index.js

@@ -22,6 +22,41 @@ const { LazyInit, createLazyInit } = require('./utils/lazy-init');
 const LambdaHandler = require('./core/lambda-handler');
 const { coldStartTracker } = require('./middleware/cold-start-tracker');
 
+// v4: Advanced Features
+const AdvancedRouter = require('./core/advanced-router');
+const { validate, ValidationError } = require('./validation/validator');
+const {
+  authenticateJWT,
+  authenticateAPIKey,
+  authorize,
+  optionalAuth,
+  AuthenticationError,
+  AuthorizationError,
+} = require('./auth/authenticator');
+const { rateLimit, RateLimiter } = require('./middleware/rate-limiter');
+const {
+  AppError,
+  NotFoundError,
+  BadRequestError,
+  UnauthorizedError,
+  ForbiddenError,
+  ConflictError,
+  InternalServerError,
+  errorHandler,
+  asyncHandler,
+  notFoundHandler,
+} = require('./errors/error-handler');
+
+// v5: Enterprise Features
+const Cache = require('./cache/cache');
+const RedisCache = require('./cache/redis-cache');
+const cache = require('./middleware/cache-middleware');
+const cors = require('./middleware/cors');
+const security = require('./middleware/security');
+const compress = require('./middleware/compression');
+const { HealthChecker, createHealthChecker } = require('./health/health-checker');
+const gracefulShutdown = require('./core/graceful-shutdown');
+
 module.exports = {
   // Core
   NavisApp,
@@ -52,6 +87,40 @@ module.exports = {
   LambdaHandler,
   coldStartTracker,
   
+  // v4: Advanced Features
+  AdvancedRouter,
+  validate,
+  ValidationError,
+  authenticateJWT,
+  authenticateAPIKey,
+  authorize,
+  optionalAuth,
+  AuthenticationError,
+  AuthorizationError,
+  rateLimit,
+  RateLimiter,
+  AppError,
+  NotFoundError,
+  BadRequestError,
+  UnauthorizedError,
+  ForbiddenError,
+  ConflictError,
+  InternalServerError,
+  errorHandler,
+  asyncHandler,
+  notFoundHandler,
+  
+  // v5: Enterprise Features
+  Cache,
+  RedisCache,
+  cache,
+  cors,
+  security,
+  compress,
+  HealthChecker,
+  createHealthChecker,
+  gracefulShutdown,
+  
   // Utilities
   response: {
     success,

package/src/middleware/cache-middleware.js

@@ -0,0 +1,105 @@
+/**
+ * Cache Middleware
+ * v5: Response caching middleware
+ */
+
+const crypto = require('crypto');
+
+/**
+ * Create cache middleware
+ * @param {Object} options - Cache options
+ * @returns {Function} - Middleware function
+ */
+function cache(options = {}) {
+  const {
+    ttl = 3600, // 1 hour in seconds
+    keyGenerator = (req) => {
+      // Default: method + path + query string
+      const queryStr = JSON.stringify(req.query || {});
+      return `${req.method}:${req.path}:${queryStr}`;
+    },
+    cacheStore = null, // Must be provided
+    skipCache = (req, res) => {
+      // Skip cache for non-GET requests or if status >= 400
+      return req.method !== 'GET' || (res.statusCode && res.statusCode >= 400);
+    },
+    vary = [], // Vary headers
+  } = options;
+
+  if (!cacheStore) {
+    throw new Error('cacheStore is required');
+  }
+
+  return async (req, res, next) => {
+    // Generate cache key
+    const cacheKey = keyGenerator(req);
+    
+    // Check if should skip cache
+    if (skipCache(req, res)) {
+      return next();
+    }
+
+    // Try to get from cache
+    try {
+      const cached = await (cacheStore.get ? cacheStore.get(cacheKey) : cacheStore.get(cacheKey));
+      
+      if (cached) {
+        // Set cache headers
+        res.headers = res.headers || {};
+        res.headers['X-Cache'] = 'HIT';
+        res.headers['Cache-Control'] = `public, max-age=${ttl}`;
+        
+        // Set Vary headers
+        if (vary.length > 0) {
+          res.headers['Vary'] = vary.join(', ');
+        }
+
+        // Return cached response
+        res.statusCode = cached.statusCode || 200;
+        res.body = cached.body;
+        return;
+      }
+    } catch (error) {
+      // Cache error - continue without cache
+      console.error('Cache get error:', error);
+    }
+
+    // Cache miss - continue to handler
+    res.headers = res.headers || {};
+    res.headers['X-Cache'] = 'MISS';
+
+    // Store original end/finish to capture response
+    const originalBody = res.body;
+    const originalStatusCode = res.statusCode;
+
+    // Wrap response to cache it
+    const originalFinish = res.finish || (() => {});
+    res.finish = async function(...args) {
+      // Only cache successful GET requests
+      if (req.method === 'GET' && res.statusCode < 400) {
+        try {
+          const cacheValue = {
+            statusCode: res.statusCode,
+            body: res.body,
+            headers: res.headers,
+          };
+
+          if (cacheStore.set) {
+            await cacheStore.set(cacheKey, cacheValue, ttl * 1000);
+          } else {
+            cacheStore.set(cacheKey, cacheValue, ttl * 1000);
+          }
+        } catch (error) {
+          console.error('Cache set error:', error);
+        }
+      }
+
+      return originalFinish.apply(this, args);
+    };
+
+    next();
+  };
+}
+
+module.exports = cache;
+

package/src/middleware/compression.js

@@ -0,0 +1,97 @@
+/**
+ * Response Compression Middleware
+ * v5: Gzip and Brotli compression support
+ */
+
+const zlib = require('zlib');
+
+/**
+ * Compression middleware
+ * @param {Object} options - Compression options
+ * @returns {Function} - Middleware function
+ */
+function compress(options = {}) {
+  const {
+    level = 6, // Compression level (1-9)
+    threshold = 1024, // Minimum size to compress (bytes)
+    algorithm = 'gzip', // 'gzip' or 'brotli'
+    filter = (req, res) => {
+      // Default: compress JSON and text responses
+      const contentType = res.headers?.['content-type'] || '';
+      return contentType.includes('application/json') ||
+             contentType.includes('text/') ||
+             contentType.includes('application/javascript');
+    },
+  } = options;
+
+  return async (req, res, next) => {
+    // Store original body setter
+    const originalBody = res.body;
+    const originalEnd = res.end || (() => {});
+
+    // Wrap response to compress before sending
+    res.end = function(...args) {
+      // Check if should compress
+      if (!filter(req, res)) {
+        return originalEnd.apply(this, args);
+      }
+
+      // Get response body
+      let body = res.body;
+      if (typeof body === 'object') {
+        body = JSON.stringify(body);
+      } else if (typeof body !== 'string') {
+        body = String(body);
+      }
+
+      // Check threshold
+      if (Buffer.byteLength(body, 'utf8') < threshold) {
+        return originalEnd.apply(this, args);
+      }
+
+      // Check if client supports compression
+      const acceptEncoding = req.headers['accept-encoding'] || req.headers['Accept-Encoding'] || '';
+      const supportsGzip = acceptEncoding.includes('gzip');
+      const supportsBrotli = acceptEncoding.includes('br');
+
+      // Choose compression algorithm
+      let compressed;
+      let encoding;
+
+      if (algorithm === 'brotli' && supportsBrotli) {
+        try {
+          compressed = zlib.brotliCompressSync(body, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: level } });
+          encoding = 'br';
+        } catch (error) {
+          // Fallback to gzip if brotli fails
+          compressed = zlib.gzipSync(body, { level });
+          encoding = 'gzip';
+        }
+      } else if (supportsGzip) {
+        compressed = zlib.gzipSync(body, { level });
+        encoding = 'gzip';
+      } else {
+        // No compression support
+        return originalEnd.apply(this, args);
+      }
+
+      // Set compression headers
+      res.headers = res.headers || {};
+      res.headers['Content-Encoding'] = encoding;
+      res.headers['Vary'] = 'Accept-Encoding';
+      
+      // Update content length
+      res.headers['Content-Length'] = compressed.length.toString();
+
+      // Update body with compressed data
+      res.body = compressed;
+
+      return originalEnd.apply(this, args);
+    };
+
+    next();
+  };
+}
+
+module.exports = compress;
+

package/src/middleware/cors.js

@@ -0,0 +1,86 @@
+/**
+ * CORS Middleware
+ * v5: Cross-Origin Resource Sharing support
+ */
+
+/**
+ * CORS middleware
+ * @param {Object} options - CORS options
+ * @returns {Function} - Middleware function
+ */
+function cors(options = {}) {
+  const {
+    origin = '*',
+    methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
+    allowedHeaders = ['Content-Type', 'Authorization', 'X-Requested-With'],
+    exposedHeaders = [],
+    credentials = false,
+    maxAge = 86400, // 24 hours
+    preflightContinue = false,
+  } = options;
+
+  // Normalize origin
+  const allowedOrigins = Array.isArray(origin) ? origin : [origin];
+  const isWildcard = allowedOrigins.includes('*');
+
+  return async (req, res, next) => {
+    const requestOrigin = req.headers.origin || req.headers.Origin;
+
+    // Determine allowed origin
+    let allowedOrigin = null;
+    if (isWildcard) {
+      allowedOrigin = '*';
+    } else if (requestOrigin && allowedOrigins.includes(requestOrigin)) {
+      allowedOrigin = requestOrigin;
+    } else if (allowedOrigins.length === 1 && allowedOrigins[0] !== '*') {
+      allowedOrigin = allowedOrigins[0];
+    }
+
+    // Handle preflight requests
+    if (req.method === 'OPTIONS') {
+      res.headers = res.headers || {};
+      
+      if (allowedOrigin) {
+        res.headers['Access-Control-Allow-Origin'] = allowedOrigin;
+      }
+      
+      res.headers['Access-Control-Allow-Methods'] = methods.join(', ');
+      res.headers['Access-Control-Allow-Headers'] = allowedHeaders.join(', ');
+      res.headers['Access-Control-Max-Age'] = maxAge.toString();
+
+      if (credentials) {
+        res.headers['Access-Control-Allow-Credentials'] = 'true';
+      }
+
+      if (exposedHeaders.length > 0) {
+        res.headers['Access-Control-Expose-Headers'] = exposedHeaders.join(', ');
+      }
+
+      if (!preflightContinue) {
+        res.statusCode = 204;
+        res.body = null;
+        return;
+      }
+    }
+
+    // Set CORS headers for all responses
+    res.headers = res.headers || {};
+    
+    if (allowedOrigin) {
+      res.headers['Access-Control-Allow-Origin'] = allowedOrigin;
+    }
+
+    if (credentials && allowedOrigin && allowedOrigin !== '*') {
+      res.headers['Access-Control-Allow-Credentials'] = 'true';
+    }
+
+    if (exposedHeaders.length > 0) {
+      res.headers['Access-Control-Expose-Headers'] = exposedHeaders.join(', ');
+    }
+
+    next();
+  };
+}
+
+module.exports = cors;
+

package/src/middleware/rate-limiter.js

@@ -0,0 +1,159 @@
+/**
+ * Rate Limiting Middleware
+ * v4: In-memory rate limiting with configurable windows
+ */
+
+class RateLimiter {
+  constructor(options = {}) {
+    this.windowMs = options.windowMs || 60000; // 1 minute default
+    this.max = options.max || 100; // 100 requests default
+    this.store = new Map(); // In-memory store
+    this.skipSuccessfulRequests = options.skipSuccessfulRequests || false;
+    this.skipFailedRequests = options.skipFailedRequests || false;
+    this.keyGenerator = options.keyGenerator || ((req) => {
+      // Default: IP address
+      return req.headers['x-forwarded-for']?.split(',')[0]?.trim() ||
+             req.headers['x-real-ip'] ||
+             'unknown';
+    });
+
+    // Cleanup old entries periodically
+    this.cleanupInterval = setInterval(() => {
+      this._cleanup();
+    }, this.windowMs);
+  }
+
+  /**
+   * Rate limit middleware
+   * @returns {Function} - Middleware function
+   */
+  middleware() {
+    const self = this; // Capture 'this' reference
+    
+    return async (req, res, next) => {
+      const key = self.keyGenerator(req);
+      const now = Date.now();
+
+      // Get or create rate limit entry
+      let entry = self.store.get(key);
+
+      if (!entry || now - entry.resetTime > self.windowMs) {
+        // Create new entry or reset expired one
+        entry = {
+          count: 0,
+          resetTime: now + self.windowMs,
+        };
+        self.store.set(key, entry);
+      }
+
+      // Increment count
+      entry.count++;
+
+      // Set rate limit headers
+      res.headers = res.headers || {};
+      res.headers['X-RateLimit-Limit'] = self.max.toString();
+      res.headers['X-RateLimit-Remaining'] = Math.max(0, self.max - entry.count).toString();
+      res.headers['X-RateLimit-Reset'] = new Date(entry.resetTime).toISOString();
+
+      // Check if limit exceeded
+      if (entry.count > self.max) {
+        res.statusCode = 429;
+        res.body = {
+          error: 'Too many requests',
+          retryAfter: Math.ceil((entry.resetTime - now) / 1000),
+        };
+        return;
+      }
+
+      // Track response status for skip options
+      const originalStatusCode = res.statusCode;
+      const originalFinish = res.finish || (() => {});
+      
+      // Wrap response finish to track status
+      res.finish = function(...args) {
+        const statusCode = res.statusCode || 200;
+        
+        if (self.skipSuccessfulRequests && statusCode < 400) {
+          entry.count = Math.max(0, entry.count - 1);
+        }
+        
+        if (self.skipFailedRequests && statusCode >= 400) {
+          entry.count = Math.max(0, entry.count - 1);
+        }
+
+        return originalFinish.apply(this, args);
+      };
+
+      next();
+    };
+  }
+
+  /**
+   * Cleanup expired entries
+   * @private
+   */
+  _cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (now - entry.resetTime > this.windowMs) {
+        this.store.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Reset rate limit for a key
+   * @param {string} key - Rate limit key
+   */
+  reset(key) {
+    this.store.delete(key);
+  }
+
+  /**
+   * Get rate limit info for a key
+   * @param {string} key - Rate limit key
+   * @returns {Object|null} - Rate limit info
+   */
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+
+    const now = Date.now();
+    if (now - entry.resetTime > this.windowMs) {
+      this.store.delete(key);
+      return null;
+    }
+
+    return {
+      count: entry.count,
+      remaining: Math.max(0, this.max - entry.count),
+      resetTime: entry.resetTime,
+    };
+  }
+
+  /**
+   * Destroy rate limiter (cleanup)
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.store.clear();
+  }
+}
+
+/**
+ * Create rate limit middleware
+ * @param {Object} options - Rate limit options
+ * @returns {Function} - Middleware function
+ */
+function rateLimit(options = {}) {
+  const limiter = new RateLimiter(options);
+  return limiter.middleware();
+}
+
+module.exports = {
+  rateLimit,
+  RateLimiter,
+};
+