navis.js 3.1.0 → 5.0.0

package/src/core/app.js

@@ -1,177 +1,265 @@
-const http = require('http');
-const Router = require('./router');
-const { executeMiddleware } = require('./middleware');
-const { error: errorResponse } = require('../utils/response');
-
-/**
- * NavisApp - Main application class
- */
-class NavisApp {
-  constructor() {
-    this.router = new Router();
-    this.middlewares = [];
-    this.server = null;
-  }
-
-  /**
-   * Register middleware
-   * @param {Function} fn - Middleware function (req, res, next)
-   */
-  use(fn) {
-    this.middlewares.push(fn);
-  }
-
-  /**
-   * Register GET route
-   */
-  get(path, handler) {
-    this.router.get(path, handler);
-  }
-
-  /**
-   * Register POST route
-   */
-  post(path, handler) {
-    this.router.post(path, handler);
-  }
-
-  /**
-   * Register PUT route
-   */
-  put(path, handler) {
-    this.router.put(path, handler);
-  }
-
-  /**
-   * Register DELETE route
-   */
-  delete(path, handler) {
-    this.router.delete(path, handler);
-  }
-
-  /**
-   * Handle HTTP request (Node.js)
-   * @param {Object} req - Node.js HTTP request
-   * @param {Object} res - Node.js HTTP response
-   */
-  async handleRequest(req, res) {
-    const method = req.method;
-    const url = new URL(req.url, `http://${req.headers.host}`);
-    const path = url.pathname;
-
-    // Find route handler
-    const handler = this.router.find(method, path);
-
-    if (!handler) {
-      errorResponse(res, 'Not Found', 404);
-      return;
-    }
-
-    // Execute middleware chain, then route handler
-    try {
-      await executeMiddleware(
-        this.middlewares,
-        req,
-        res,
-        handler,
-        false
-      );
-    } catch (err) {
-      errorResponse(res, err.message || 'Internal Server Error', 500);
-    }
-  }
-
-  /**
-   * Handle AWS Lambda event
-   * @param {Object} event - Lambda event
-   * @returns {Object} - Lambda response
-   */
-  async handleLambda(event) {
-    const method = event.httpMethod || event.requestContext?.http?.method || 'GET';
-    const path = event.path || event.rawPath || '/';
-
-    // Find route handler
-    const handler = this.router.find(method, path);
-
-    if (!handler) {
-      return {
-        statusCode: 404,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ error: 'Not Found' }),
-      };
-    }
-
-    // Create Lambda-compatible req/res objects
-    const req = {
-      method,
-      path,
-      headers: event.headers || {},
-      body: event.body ? JSON.parse(event.body) : {},
-      query: event.queryStringParameters || {},
-      // Store original event for advanced use cases
-      event,
-    };
-
-    const res = {
-      statusCode: 200,
-      headers: {},
-      body: null,
-    };
-
-    // Execute middleware chain, then route handler
-    try {
-      const result = await executeMiddleware(
-        this.middlewares,
-        req,
-        res,
-        handler,
-        true
-      );
-
-      // If handler returned a Lambda response directly, use it
-      if (result && result.statusCode) {
-        return result;
-      }
-
-      // Otherwise, construct response from res object
-      return {
-        statusCode: res.statusCode || 200,
-        headers: {
-          'Content-Type': 'application/json',
-          ...res.headers,
-        },
-        body: res.body ? JSON.stringify(res.body) : JSON.stringify(result || {}),
-      };
-    } catch (err) {
-      return {
-        statusCode: 500,
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ error: err.message || 'Internal Server Error' }),
-      };
-    }
-  }
-
-  /**
-   * Start HTTP server (Node.js)
-   * @param {number} port - Port number
-   * @param {Function} callback - Optional callback
-   */
-  listen(port = 3000, callback) {
-    this.server = http.createServer((req, res) => {
-      this.handleRequest(req, res);
-    });
-
-    this.server.listen(port, () => {
-      if (callback) callback();
-      console.log(`Navis.js server listening on port ${port}`);
-    });
-
-    return this.server;
-  }
-}
-
+const http = require('http');
+const Router = require('./router');
+const AdvancedRouter = require('./advanced-router');
+const { executeMiddleware } = require('./middleware');
+const { error: errorResponse } = require('../utils/response');
+
+/**
+ * NavisApp - Main application class
+ */
+class NavisApp {
+  constructor(options = {}) {
+    // Use advanced router if enabled (v4)
+    this.useAdvancedRouter = options.useAdvancedRouter !== false; // Default true in v4
+    this.router = this.useAdvancedRouter ? new AdvancedRouter() : new Router();
+    this.middlewares = [];
+    this.server = null;
+    this.errorHandler = null;
+  }
+
+  /**
+   * Register middleware
+   * @param {Function} fn - Middleware function (req, res, next)
+   */
+  use(fn) {
+    this.middlewares.push(fn);
+  }
+
+  /**
+   * Register GET route
+   */
+  get(path, handler) {
+    this.router.get(path, handler);
+  }
+
+  /**
+   * Register POST route
+   */
+  post(path, handler) {
+    this.router.post(path, handler);
+  }
+
+  /**
+   * Register PUT route
+   */
+  put(path, handler) {
+    this.router.put(path, handler);
+  }
+
+  /**
+   * Register DELETE route
+   */
+  delete(path, handler) {
+    this.router.delete(path, handler);
+  }
+
+  /**
+   * Register PATCH route (v4)
+   */
+  patch(path, handler) {
+    if (this.router.patch) {
+      this.router.patch(path, handler);
+    } else {
+      throw new Error('PATCH method requires advanced router');
+    }
+  }
+
+  /**
+   * Set error handler (v4)
+   * @param {Function} handler - Error handler function
+   */
+  setErrorHandler(handler) {
+    this.errorHandler = handler;
+  }
+
+  /**
+   * Handle HTTP request (Node.js)
+   * @param {Object} req - Node.js HTTP request
+   * @param {Object} res - Node.js HTTP response
+   */
+  async handleRequest(req, res) {
+    const method = req.method;
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const path = url.pathname;
+
+    // Parse query string
+    req.query = {};
+    url.searchParams.forEach((value, key) => {
+      req.query[key] = value;
+    });
+
+    // Find route handler
+    let routeResult;
+    if (this.useAdvancedRouter) {
+      routeResult = this.router.find(method, path);
+      if (routeResult) {
+        req.params = routeResult.params || {};
+        req.handler = routeResult.handler;
+      }
+    } else {
+      const handler = this.router.find(method, path);
+      if (handler) {
+        routeResult = { handler };
+        req.params = {};
+      }
+    }
+
+    if (!routeResult) {
+      if (this.errorHandler) {
+        const notFoundError = new Error('Not Found');
+        notFoundError.statusCode = 404;
+        await this.errorHandler(notFoundError, req, res, () => {});
+      } else {
+        errorResponse(res, 'Not Found', 404);
+      }
+      return;
+    }
+
+    // Execute middleware chain, then route handler
+    try {
+      await executeMiddleware(
+        this.middlewares,
+        req,
+        res,
+        routeResult.handler,
+        false
+      );
+    } catch (err) {
+      if (this.errorHandler) {
+        await this.errorHandler(err, req, res, () => {});
+      } else {
+        errorResponse(res, err.message || 'Internal Server Error', err.statusCode || 500);
+      }
+    }
+  }
+
+  /**
+   * Handle AWS Lambda event
+   * @param {Object} event - Lambda event
+   * @returns {Object} - Lambda response
+   */
+  async handleLambda(event) {
+    const method = event.httpMethod || event.requestContext?.http?.method || 'GET';
+    const path = event.path || event.rawPath || '/';
+
+    // Find route handler
+    let routeResult;
+    if (this.useAdvancedRouter) {
+      routeResult = this.router.find(method, path);
+    } else {
+      const handler = this.router.find(method, path);
+      if (handler) {
+        routeResult = { handler, params: {} };
+      }
+    }
+
+    if (!routeResult) {
+      return {
+        statusCode: 404,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ error: 'Not Found' }),
+      };
+    }
+
+    // Create Lambda-compatible req/res objects
+    const req = {
+      method,
+      path,
+      headers: event.headers || {},
+      body: event.body ? (typeof event.body === 'string' ? JSON.parse(event.body) : event.body) : {},
+      query: event.queryStringParameters || {},
+      params: routeResult.params || {},
+      // Store original event for advanced use cases
+      event,
+    };
+
+    const res = {
+      statusCode: 200,
+      headers: {},
+      body: null,
+    };
+
+    // Execute middleware chain, then route handler
+    try {
+      const result = await executeMiddleware(
+        this.middlewares,
+        req,
+        res,
+        routeResult.handler,
+        true
+      );
+
+      // If handler returned a Lambda response directly, use it
+      if (result && result.statusCode) {
+        return result;
+      }
+
+      // Otherwise, construct response from res object
+      return {
+        statusCode: res.statusCode || 200,
+        headers: {
+          'Content-Type': 'application/json',
+          ...res.headers,
+        },
+        body: res.body ? JSON.stringify(res.body) : JSON.stringify(result || {}),
+      };
+    } catch (err) {
+      // Use error handler if set
+      if (this.errorHandler) {
+        // Create a mock res object for error handler
+        const errorRes = {
+          statusCode: err.statusCode || 500,
+          headers: { 'Content-Type': 'application/json' },
+          body: null,
+        };
+        
+        await this.errorHandler(err, req, errorRes, () => {});
+        
+        return {
+          statusCode: errorRes.statusCode,
+          headers: errorRes.headers,
+          body: typeof errorRes.body === 'string' ? errorRes.body : JSON.stringify(errorRes.body || { error: err.message }),
+        };
+      }
+
+      return {
+        statusCode: err.statusCode || 500,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ error: err.message || 'Internal Server Error' }),
+      };
+    }
+  }
+
+  /**
+   * Start HTTP server (Node.js)
+   * @param {number} port - Port number
+   * @param {Function} callback - Optional callback
+   * @returns {Object} - HTTP server instance
+   */
+  listen(port = 3000, callback) {
+    this.server = http.createServer((req, res) => {
+      this.handleRequest(req, res);
+    });
+
+    this.server.listen(port, () => {
+      if (callback) callback();
+      console.log(`Navis.js server listening on port ${port}`);
+    });
+
+    return this.server;
+  }
+
+  /**
+   * Get server instance
+   * @returns {Object|null} - HTTP server instance
+   */
+  getServer() {
+    return this.server;
+  }
+}
+
 module.exports = NavisApp;

package/src/core/graceful-shutdown.js

@@ -0,0 +1,77 @@
+/**
+ * Graceful Shutdown Handler
+ * v5: Clean shutdown handling for Node.js servers
+ */
+
+/**
+ * Graceful shutdown handler
+ * @param {Object} server - HTTP server instance
+ * @param {Object} options - Shutdown options
+ */
+function gracefulShutdown(server, options = {}) {
+  const {
+    timeout = 10000, // 10 seconds default
+    onShutdown = async () => {}, // Cleanup function
+    signals = ['SIGTERM', 'SIGINT'],
+    log = console.log,
+  } = options;
+
+  let isShuttingDown = false;
+
+  const shutdown = async (signal) => {
+    if (isShuttingDown) {
+      return;
+    }
+
+    isShuttingDown = true;
+    log(`Received ${signal}, starting graceful shutdown...`);
+
+    // Stop accepting new connections
+    server.close(() => {
+      log('HTTP server closed');
+    });
+
+    // Set timeout for forced shutdown
+    const shutdownTimer = setTimeout(() => {
+      log('Forced shutdown after timeout');
+      process.exit(1);
+    }, timeout);
+
+    try {
+      // Run cleanup
+      await onShutdown();
+      clearTimeout(shutdownTimer);
+      log('Graceful shutdown completed');
+      process.exit(0);
+    } catch (error) {
+      clearTimeout(shutdownTimer);
+      log('Error during shutdown:', error);
+      process.exit(1);
+    }
+  };
+
+  // Register signal handlers
+  for (const signal of signals) {
+    process.on(signal, () => shutdown(signal));
+  }
+
+  // Handle uncaught exceptions
+  process.on('uncaughtException', async (error) => {
+    log('Uncaught exception:', error);
+    await shutdown('uncaughtException');
+  });
+
+  // Handle unhandled promise rejections
+  process.on('unhandledRejection', async (reason, promise) => {
+    log('Unhandled rejection:', reason);
+    await shutdown('unhandledRejection');
+  });
+
+  return {
+    shutdown: () => shutdown('manual'),
+    isShuttingDown: () => isShuttingDown,
+  };
+}
+
+module.exports = gracefulShutdown;
+

package/src/errors/error-handler.js

@@ -0,0 +1,157 @@
+/**
+ * Enhanced Error Handling
+ * v4: Custom error classes and error handling middleware
+ */
+
+class AppError extends Error {
+  constructor(message, statusCode = 500, code = null) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.code = code || this.constructor.name.toUpperCase();
+    this.isOperational = true;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+class NotFoundError extends AppError {
+  constructor(message = 'Resource not found') {
+    super(message, 404, 'NOT_FOUND');
+  }
+}
+
+class BadRequestError extends AppError {
+  constructor(message = 'Bad request') {
+    super(message, 400, 'BAD_REQUEST');
+  }
+}
+
+class UnauthorizedError extends AppError {
+  constructor(message = 'Unauthorized') {
+    super(message, 401, 'UNAUTHORIZED');
+  }
+}
+
+class ForbiddenError extends AppError {
+  constructor(message = 'Forbidden') {
+    super(message, 403, 'FORBIDDEN');
+  }
+}
+
+class ConflictError extends AppError {
+  constructor(message = 'Conflict') {
+    super(message, 409, 'CONFLICT');
+  }
+}
+
+class InternalServerError extends AppError {
+  constructor(message = 'Internal server error') {
+    super(message, 500, 'INTERNAL_SERVER_ERROR');
+  }
+}
+
+/**
+ * Error handler middleware
+ * @param {Object} options - Error handler options
+ * @returns {Function} - Error handling middleware
+ */
+function errorHandler(options = {}) {
+  const {
+    format = 'json',
+    includeStack = process.env.NODE_ENV === 'development',
+    logErrors = true,
+    logger = console.error,
+  } = options;
+
+  return async (err, req, res, next) => {
+    // Determine status code
+    const statusCode = err.statusCode || err.status || 500;
+    const code = err.code || 'INTERNAL_SERVER_ERROR';
+    const message = err.message || 'Internal server error';
+
+    // Log error
+    if (logErrors) {
+      logger('Error:', {
+        message,
+        statusCode,
+        code,
+        stack: includeStack ? err.stack : undefined,
+        path: req.path,
+        method: req.method,
+      });
+    }
+
+    // Format error response
+    const errorResponse = {
+      error: {
+        message,
+        code,
+        statusCode,
+      },
+    };
+
+    // Include stack trace in development
+    if (includeStack && err.stack) {
+      errorResponse.error.stack = err.stack.split('\n');
+    }
+
+    // Include validation errors if present
+    if (err.errors && Array.isArray(err.errors)) {
+      errorResponse.error.errors = err.errors;
+    }
+
+    // Set response
+    res.statusCode = statusCode;
+    
+    if (format === 'json') {
+      res.headers = res.headers || {};
+      res.headers['Content-Type'] = 'application/json';
+      res.body = errorResponse;
+    } else {
+      res.body = `${statusCode} ${message}`;
+    }
+  };
+}
+
+/**
+ * Async error wrapper
+ * Wraps async route handlers to catch errors
+ * @param {Function} fn - Async function
+ * @returns {Function} - Wrapped function
+ */
+function asyncHandler(fn) {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}
+
+/**
+ * Not found handler
+ * @returns {Function} - Middleware function
+ */
+function notFoundHandler() {
+  return (req, res) => {
+    res.statusCode = 404;
+    res.body = {
+      error: {
+        message: `Route ${req.method} ${req.path} not found`,
+        code: 'NOT_FOUND',
+        statusCode: 404,
+      },
+    };
+  };
+}
+
+module.exports = {
+  AppError,
+  NotFoundError,
+  BadRequestError,
+  UnauthorizedError,
+  ForbiddenError,
+  ConflictError,
+  InternalServerError,
+  errorHandler,
+  asyncHandler,
+  notFoundHandler,
+};
+