navis.js 5.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/index.js

@@ -57,6 +57,17 @@ 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,
@@ -121,6 +132,25 @@ module.exports = {
   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/upload.js

@@ -0,0 +1,151 @@
+/**
+ * File Upload Middleware
+ * v5.1: Multipart form data and file upload handling
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * File upload middleware
+ * @param {Object} options - Upload options
+ * @returns {Function} - Middleware function
+ */
+function upload(options = {}) {
+  const {
+    dest = '/tmp/uploads',
+    limits = {
+      fileSize: 5 * 1024 * 1024, // 5MB default
+      files: 10, // Max 10 files
+    },
+    fileFilter = null, // Function to filter files
+    preserveExtension = true,
+    generateFilename = (file) => {
+      // Generate unique filename
+      const ext = preserveExtension ? path.extname(file.originalName || '') : '';
+      return `${crypto.randomBytes(16).toString('hex')}${ext}`;
+    },
+  } = options;
+
+  // Ensure destination directory exists
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+
+  return async (req, res, next) => {
+    // Check content type
+    const contentType = req.headers['content-type'] || req.headers['Content-Type'] || '';
+    
+    if (!contentType.includes('multipart/form-data')) {
+      return next();
+    }
+
+    // Parse multipart form data (simplified implementation)
+    // In production, use a library like busboy or multer
+    try {
+      req.files = [];
+      req.body = req.body || {};
+
+      // For Lambda, body is already parsed
+      if (req.event && req.event.isBase64Encoded) {
+        // Handle base64 encoded body
+        const body = Buffer.from(req.event.body, 'base64').toString();
+        // Parse multipart data (simplified)
+        // In production, use proper multipart parser
+      }
+
+      // For Node.js HTTP, parse from request stream
+      if (req.on && typeof req.on === 'function') {
+        await parseMultipart(req, dest, limits, fileFilter, generateFilename, (files, fields) => {
+          req.files = files;
+          req.body = { ...req.body, ...fields };
+        });
+      }
+
+      next();
+    } catch (error) {
+      res.statusCode = 400;
+      res.body = { error: error.message || 'File upload failed' };
+    }
+  };
+}
+
+/**
+ * Parse multipart form data (simplified)
+ * @private
+ */
+function parseMultipart(req, dest, limits, fileFilter, generateFilename, callback) {
+  return new Promise((resolve, reject) => {
+    const files = [];
+    const fields = {};
+    let totalSize = 0;
+    let fileCount = 0;
+
+    // Simplified multipart parser
+    // In production, use busboy or multer
+    let buffer = '';
+    
+    req.on('data', (chunk) => {
+      buffer += chunk.toString();
+      totalSize += chunk.length;
+
+      if (totalSize > limits.fileSize) {
+        reject(new Error('File size exceeds limit'));
+        return;
+      }
+    });
+
+    req.on('end', () => {
+      // Basic multipart parsing (simplified)
+      // This is a placeholder - in production use proper parser
+      try {
+        callback(files, fields);
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    });
+
+    req.on('error', reject);
+  });
+}
+
+/**
+ * Save uploaded file
+ * @param {Object} file - File object
+ * @param {string} dest - Destination directory
+ * @param {Function} generateFilename - Filename generator
+ * @returns {Promise<string>} - File path
+ */
+async function saveFile(file, dest, generateFilename) {
+  const filename = generateFilename(file);
+  const filepath = path.join(dest, filename);
+
+  // Ensure directory exists
+  const dir = path.dirname(filepath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Write file
+  if (file.buffer) {
+    fs.writeFileSync(filepath, file.buffer);
+  } else if (file.stream) {
+    // Handle stream
+    const writeStream = fs.createWriteStream(filepath);
+    file.stream.pipe(writeStream);
+    await new Promise((resolve, reject) => {
+      writeStream.on('finish', resolve);
+      writeStream.on('error', reject);
+    });
+  }
+
+  return filepath;
+}
+
+module.exports = {
+  upload,
+  saveFile,
+};
+