navis.js 4.0.0 → 5.2.0

package/src/db/db-pool.js

@@ -0,0 +1,195 @@
+/**
+ * Database Connection Pool
+ * v5.2: Database integration helpers with connection pooling
+ */
+
+class DatabasePool {
+  constructor(options = {}) {
+    this.type = options.type || 'postgres';
+    this.connectionString = options.connectionString || process.env.DATABASE_URL;
+    this.pool = null;
+    this.maxConnections = options.maxConnections || 10;
+    this.minConnections = options.minConnections || 2;
+    this.idleTimeout = options.idleTimeout || 30000;
+  }
+
+  /**
+   * Initialize connection pool
+   */
+  async connect() {
+    if (this.pool) {
+      return;
+    }
+
+    switch (this.type.toLowerCase()) {
+      case 'postgres':
+      case 'postgresql':
+        await this._connectPostgres();
+        break;
+      case 'mysql':
+      case 'mariadb':
+        await this._connectMySQL();
+        break;
+      case 'mongodb':
+        await this._connectMongoDB();
+        break;
+      default:
+        throw new Error(`Unsupported database type: ${this.type}`);
+    }
+  }
+
+  /**
+   * Connect to PostgreSQL
+   * @private
+   */
+  async _connectPostgres() {
+    try {
+      const { Pool } = require('pg');
+      this.pool = new Pool({
+        connectionString: this.connectionString,
+        max: this.maxConnections,
+        min: this.minConnections,
+        idleTimeoutMillis: this.idleTimeout,
+      });
+    } catch (error) {
+      throw new Error('pg package not installed. Install with: npm install pg');
+    }
+  }
+
+  /**
+   * Connect to MySQL
+   * @private
+   */
+  async _connectMySQL() {
+    try {
+      const mysql = require('mysql2/promise');
+      this.pool = mysql.createPool({
+        uri: this.connectionString,
+        connectionLimit: this.maxConnections,
+        waitForConnections: true,
+        idleTimeout: this.idleTimeout,
+      });
+    } catch (error) {
+      throw new Error('mysql2 package not installed. Install with: npm install mysql2');
+    }
+  }
+
+  /**
+   * Connect to MongoDB
+   * @private
+   */
+  async _connectMongoDB() {
+    try {
+      const { MongoClient } = require('mongodb');
+      const client = new MongoClient(this.connectionString);
+      await client.connect();
+      this.pool = client;
+      this.db = client.db();
+    } catch (error) {
+      throw new Error('mongodb package not installed. Install with: npm install mongodb');
+    }
+  }
+
+  /**
+   * Execute a query
+   * @param {string} query - SQL query or MongoDB operation
+   * @param {Array} params - Query parameters
+   * @returns {Promise<*>} - Query result
+   */
+  async query(query, params = []) {
+    if (!this.pool) {
+      await this.connect();
+    }
+
+    switch (this.type.toLowerCase()) {
+      case 'postgres':
+      case 'postgresql':
+        return await this.pool.query(query, params);
+      case 'mysql':
+      case 'mariadb':
+        const [rows] = await this.pool.execute(query, params);
+        return rows;
+      case 'mongodb':
+        // MongoDB uses different query syntax
+        // This is a placeholder - implement based on your needs
+        return await this.db.collection(query).find(params[0] || {}).toArray();
+      default:
+        throw new Error(`Unsupported database type: ${this.type}`);
+    }
+  }
+
+  /**
+   * Get a connection from pool
+   * @returns {Promise<Object>} - Database connection
+   */
+  async getConnection() {
+    if (!this.pool) {
+      await this.connect();
+    }
+
+    if (this.type === 'mongodb') {
+      return this.pool;
+    }
+
+    return await this.pool.getConnection();
+  }
+
+  /**
+   * Close connection pool
+   */
+  async close() {
+    if (this.pool) {
+      if (this.pool.end) {
+        await this.pool.end();
+      } else if (this.pool.close) {
+        await this.pool.close();
+      }
+      this.pool = null;
+    }
+  }
+
+  /**
+   * Ping database connection
+   * @returns {Promise<boolean>} - True if connection is alive
+   */
+  async ping() {
+    try {
+      if (!this.pool) {
+        return false;
+      }
+
+      switch (this.type.toLowerCase()) {
+        case 'postgres':
+        case 'postgresql':
+          await this.pool.query('SELECT 1');
+          return true;
+        case 'mysql':
+        case 'mariadb':
+          await this.pool.execute('SELECT 1');
+          return true;
+        case 'mongodb':
+          await this.db.admin().ping();
+          return true;
+        default:
+          return false;
+      }
+    } catch (error) {
+      return false;
+    }
+  }
+}
+
+/**
+ * Create database pool
+ * @param {Object} options - Database options
+ * @returns {DatabasePool} - Database pool instance
+ */
+function createPool(options = {}) {
+  return new DatabasePool(options);
+}
+
+module.exports = {
+  DatabasePool,
+  createPool,
+};
+

package/src/docs/swagger.js

@@ -0,0 +1,188 @@
+/**
+ * OpenAPI/Swagger Documentation Generator
+ * v5.1: Auto-generate OpenAPI 3.0 specification
+ */
+
+class SwaggerGenerator {
+  constructor(options = {}) {
+    this.info = {
+      title: options.title || 'Navis.js API',
+      version: options.version || '1.0.0',
+      description: options.description || '',
+      ...options.info,
+    };
+    this.servers = options.servers || [{ url: '/', description: 'Default server' }];
+    this.paths = {};
+    this.components = {
+      schemas: {},
+      securitySchemes: {},
+    };
+    this.tags = options.tags || [];
+    this.basePath = options.basePath || '/';
+  }
+
+  /**
+   * Add a route to the specification
+   * @param {string} method - HTTP method
+   * @param {string} path - Route path
+   * @param {Object} spec - OpenAPI operation spec
+   */
+  addRoute(method, path, spec = {}) {
+    const normalizedPath = this._normalizePath(path);
+    
+    if (!this.paths[normalizedPath]) {
+      this.paths[normalizedPath] = {};
+    }
+
+    this.paths[normalizedPath][method.toLowerCase()] = {
+      summary: spec.summary || '',
+      description: spec.description || '',
+      tags: spec.tags || [],
+      parameters: spec.parameters || [],
+      requestBody: spec.requestBody || null,
+      responses: spec.responses || {
+        '200': { description: 'Success' },
+      },
+      security: spec.security || [],
+      ...spec,
+    };
+  }
+
+  /**
+   * Add a schema component
+   * @param {string} name - Schema name
+   * @param {Object} schema - JSON Schema
+   */
+  addSchema(name, schema) {
+    this.components.schemas[name] = schema;
+  }
+
+  /**
+   * Add a security scheme
+   * @param {string} name - Security scheme name
+   * @param {Object} scheme - Security scheme
+   */
+  addSecurityScheme(name, scheme) {
+    this.components.securitySchemes[name] = scheme;
+  }
+
+  /**
+   * Generate OpenAPI specification
+   * @returns {Object} - OpenAPI 3.0 specification
+   */
+  generate() {
+    return {
+      openapi: '3.0.0',
+      info: this.info,
+      servers: this.servers,
+      paths: this.paths,
+      components: this.components,
+      tags: this.tags,
+    };
+  }
+
+  /**
+   * Generate JSON string
+   * @returns {string} - JSON string
+   */
+  toJSON() {
+    return JSON.stringify(this.generate(), null, 2);
+  }
+
+  /**
+   * Normalize path for OpenAPI (convert :param to {param})
+   * @private
+   */
+  _normalizePath(path) {
+    return path.replace(/:([^/]+)/g, '{$1}');
+  }
+}
+
+/**
+ * Swagger middleware
+ * @param {Object} options - Swagger options
+ * @returns {Function} - Middleware function
+ */
+function swagger(options = {}) {
+  const {
+    title = 'Navis.js API',
+    version = '1.0.0',
+    description = '',
+    path = '/swagger.json',
+    uiPath = '/docs',
+    servers = [],
+    tags = [],
+  } = options;
+
+  const generator = new SwaggerGenerator({
+    title,
+    version,
+    description,
+    servers,
+    tags,
+  });
+
+  // Add default security schemes
+  generator.addSecurityScheme('bearerAuth', {
+    type: 'http',
+    scheme: 'bearer',
+    bearerFormat: 'JWT',
+  });
+
+  return {
+    generator,
+    middleware: async (req, res, next) => {
+      const requestPath = req.path || req.url;
+
+      // Serve OpenAPI JSON
+      if (requestPath === path) {
+        res.statusCode = 200;
+        res.headers = res.headers || {};
+        res.headers['Content-Type'] = 'application/json';
+        res.body = generator.generate();
+        return;
+      }
+
+      // Serve Swagger UI (basic HTML)
+      if (requestPath === uiPath) {
+        const spec = generator.toJSON();
+        const html = `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>${title} - API Documentation</title>
+  <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@4.15.5/swagger-ui.css" />
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@4.15.5/swagger-ui-bundle.js"></script>
+  <script>
+    SwaggerUIBundle({
+      url: '${path}',
+      dom_id: '#swagger-ui',
+      presets: [
+        SwaggerUIBundle.presets.apis,
+        SwaggerUIBundle.presets.standalone
+      ]
+    });
+  </script>
+</body>
+</html>
+        `;
+        res.statusCode = 200;
+        res.headers = res.headers || {};
+        res.headers['Content-Type'] = 'text/html';
+        res.body = html;
+        return;
+      }
+
+      next();
+    },
+  };
+}
+
+module.exports = {
+  SwaggerGenerator,
+  swagger,
+};
+

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

@@ -47,6 +47,27 @@ const {
   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');
+
+// v5.1: Developer Experience
+const { SwaggerGenerator, swagger } = require('./docs/swagger');
+const { VersionManager, createVersionManager, headerVersioning } = require('./core/versioning');
+const { upload, saveFile } = require('./middleware/upload');
+const { TestApp, testApp } = require('./testing/test-helper');
+
+// v5.2: Real-time Features
+const WebSocketServer = require('./websocket/websocket-server');
+const { SSEServer, createSSEServer, sse } = require('./sse/server-sent-events');
+const { DatabasePool, createPool } = require('./db/db-pool');
+
 module.exports = {
   // Core
   NavisApp,
@@ -100,6 +121,36 @@ module.exports = {
   asyncHandler,
   notFoundHandler,
   
+  // v5: Enterprise Features
+  Cache,
+  RedisCache,
+  cache,
+  cors,
+  security,
+  compress,
+  HealthChecker,
+  createHealthChecker,
+  gracefulShutdown,
+  
+  // v5.1: Developer Experience
+  SwaggerGenerator,
+  swagger,
+  VersionManager,
+  createVersionManager,
+  headerVersioning,
+  upload,
+  saveFile,
+  TestApp,
+  testApp,
+  
+  // v5.2: Real-time Features
+  WebSocketServer,
+  SSEServer,
+  createSSEServer,
+  sse,
+  DatabasePool,
+  createPool,
+  
   // 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;
+