xypriss 1.0.0 → 1.1.0

package/dist/cjs/server/components/fastapi/middlewares/middlewareManager.js

@@ -0,0 +1,953 @@
+'use strict';
+
+var express = require('express');
+var helmet = require('helmet');
+var cors = require('cors');
+var compression = require('compression');
+var rateLimit = require('express-rate-limit');
+var Logger = require('../../../utils/Logger.js');
+var nehoid = require('nehoid');
+
+/**
+ *  MiddlewareManager - Advanced middleware system with optimization, caching, and performance tracking
+ * Provides comprehensive middleware management withXyPriss FastXyPrissServer (FFS)performance enhancements
+ */
+class MiddlewareManager {
+    constructor(options, dependencies) {
+        // Middleware registry and management
+        this.middlewareRegistry = new Map();
+        this.middlewareCache = new Map();
+        this.executionOrder = [];
+        // Performance tracking
+        this.performanceMetrics = {
+            totalRequests: 0,
+            totalExecutionTime: 0,
+            averageExecutionTime: 0,
+            fastestExecution: Infinity,
+            slowestExecution: 0,
+            cacheHitRate: 0,
+            errorRate: 0,
+            throughput: 0,
+            optimizationGain: 0,
+        };
+        // Configuration
+        this.optimizationConfig = {
+            enableCaching: true,
+            enableBatching: true,
+            enablePrioritization: true,
+            enablePerformanceTracking: true,
+            cacheWarming: true,
+            optimizationThreshold: 10,
+            maxCacheSize: 1000,
+            defaultTTL: 300000, // 5 minutes
+        };
+        this.initialized = false;
+        this.options = options;
+        this.dependencies = dependencies;
+    }
+    /**
+     * Initialize the  middleware manager
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        Logger.logger.debug("middleware", "Initializing  Middleware Manager...");
+        // Configure built-in middleware
+        this.configureBuiltInMiddleware();
+        // Configure optimization middleware
+        this.configureOptimizationMiddleware();
+        // Configure request processing middleware
+        this.configureRequestProcessingMiddleware();
+        // Warm up cache if enabled
+        if (this.optimizationConfig.cacheWarming) {
+            await this.warmCache();
+        }
+        this.initialized = true;
+        Logger.logger.debug("middleware", " Middleware Manager initialized");
+    }
+    /**
+     * Register custom middleware
+     */
+    register(middleware, options) {
+        const id = nehoid.NehoID.generate({ prefix: "ufs.middleware", size: 16 });
+        const name = options?.name || `middleware-${id.slice(0, 8)}`;
+        let handler;
+        let priority = options?.priority || "normal";
+        let routes = options?.routes;
+        let cacheable = options?.cacheable === true; // Only cache if explicitly set to true
+        let ttl = options?.ttl || this.optimizationConfig.defaultTTL;
+        if (typeof middleware === "function") {
+            handler = middleware;
+        }
+        else {
+            handler = middleware.handler;
+            priority = middleware.priority || priority;
+            routes = middleware.routes || routes;
+            cacheable = middleware.cacheable || cacheable;
+            ttl = middleware.ttl || ttl;
+        }
+        const entry = {
+            id,
+            name,
+            handler: this.wrapMiddleware(handler, name),
+            priority,
+            order: this.calculateOrder(priority),
+            routes,
+            enabled: true,
+            cacheable,
+            ttl,
+            metadata: {},
+            stats: {
+                executionCount: 0,
+                totalExecutionTime: 0,
+                averageExecutionTime: 0,
+                cacheHits: 0,
+                cacheMisses: 0,
+                errors: 0,
+            },
+        };
+        this.middlewareRegistry.set(id, entry);
+        this.updateExecutionOrder();
+        // Apply middleware to Express app immediately
+        this.applyMiddlewareToApp(entry);
+        Logger.logger.debug("middleware", `Registered middleware: ${name} (${id})`);
+        return id;
+    }
+    /**
+     * Unregister middleware
+     */
+    unregister(id) {
+        const entry = this.middlewareRegistry.get(id);
+        if (!entry)
+            return false;
+        this.middlewareRegistry.delete(id);
+        this.updateExecutionOrder();
+        Logger.logger.debug("middleware", `Unregistered middleware: ${entry.name} (${id})`);
+        return true;
+    }
+    /**
+     * Enable middleware
+     */
+    enable(id) {
+        const entry = this.middlewareRegistry.get(id);
+        if (!entry)
+            return false;
+        entry.enabled = true;
+        this.updateExecutionOrder();
+        Logger.logger.debug("middleware", `Enabled middleware: ${entry.name} (${id})`);
+        return true;
+    }
+    /**
+     * Disable middleware
+     */
+    disable(id) {
+        const entry = this.middlewareRegistry.get(id);
+        if (!entry)
+            return false;
+        entry.enabled = false;
+        this.updateExecutionOrder();
+        Logger.logger.debug("middleware", `Disabled middleware: ${entry.name} (${id})`);
+        return true;
+    }
+    /**
+     * Enable security middleware
+     */
+    enableSecurity(options) {
+        if (this.options.security?.helmet !== false) {
+            try {
+                this.dependencies.app.use(helmet(options?.helmet));
+                Logger.logger.debug("middleware", "Security headers (Helmet) enabled");
+            }
+            catch (error) {
+                Logger.logger.warn("middleware", "Helmet not available, skipping security headers");
+            }
+        }
+        if (this.options.security?.cors !== false) {
+            try {
+                this.dependencies.app.use(cors(options?.cors));
+                Logger.logger.debug("middleware", "CORS enabled");
+            }
+            catch (error) {
+                Logger.logger.warn("middleware", "CORS not available, skipping CORS headers");
+            }
+        }
+    }
+    /**
+     * Enable compression middleware
+     */
+    enableCompression(options) {
+        if (this.options.performance?.compression !== false) {
+            try {
+                this.dependencies.app.use(compression(options));
+                Logger.logger.debug("middleware", "Compression enabled");
+            }
+            catch (error) {
+                Logger.logger.warn("middleware", "Compression not available, skipping compression");
+            }
+        }
+    }
+    /**
+     * Enable rate limiting middleware
+     */
+    enableRateLimit(options) {
+        if (this.options.security?.rateLimit !== false) {
+            try {
+                const rateLimitOptions = {
+                    windowMs: 15 * 60 * 1000, // 15 minutes
+                    max: 100, // limit each IP to 100 requests per windowMs
+                    standardHeaders: true,
+                    legacyHeaders: false,
+                    ...options,
+                };
+                this.dependencies.app.use(rateLimit(rateLimitOptions));
+                Logger.logger.debug("middleware", "Rate limiting enabled");
+            }
+            catch (error) {
+                Logger.logger.warn("middleware", "Rate limiting not available, skipping rate limiting");
+            }
+        }
+    }
+    /**
+     * Apply immediate middleware configuration during server initialization
+     * This method provides basic middleware functionality before the full system is initialized
+     */
+    applyImmediateMiddleware(config) {
+        // console.log("Applying immediate middleware configuration...");
+        Logger.logger.debug("middleware", "Applying immediate middleware configuration...");
+        // console.log("conf: ", config);
+        // Apply rate limiting if configured
+        if (config?.rateLimit && config.rateLimit !== true) {
+            try {
+                const rateLimitConfig = config.rateLimit;
+                const limiter = rateLimit({
+                    windowMs: rateLimitConfig.windowMs || 15 * 60 * 1000,
+                    max: rateLimitConfig.max || 100,
+                    message: "Too many requests from this IP, please try again later (msg2).",
+                    standardHeaders: true,
+                    legacyHeaders: false,
+                });
+                this.dependencies.app.use(limiter);
+                Logger.logger.debug("middleware", "Rate limiting applied immediately");
+            }
+            catch (error) {
+                Logger.logger.warn("middleware", "Failed to apply rate limiting:", error);
+            }
+        }
+        // Apply CORS if configured
+        if (config?.cors && config.cors !== true) {
+            try {
+                const corsConfig = config.cors;
+                const corsOptions = {
+                    origin: corsConfig.origin || "*",
+                    methods: corsConfig.methods || [
+                        "GET",
+                        "POST",
+                        "PUT",
+                        "DELETE",
+                        "OPTIONS",
+                    ],
+                    allowedHeaders: corsConfig.allowedHeaders || [
+                        "Origin",
+                        "X-Requested-With",
+                        "Content-Type",
+                        "Accept",
+                        "Authorization",
+                    ],
+                    credentials: corsConfig.credentials !== false,
+                };
+                this.dependencies.app.use(cors(corsOptions));
+                Logger.logger.debug("middleware", "CORS applied immediately");
+            }
+            catch (error) {
+                Logger.logger.warn("middleware", "Failed to apply CORS:", error);
+            }
+        }
+        // Apply security headers if configured
+        if (config?.security && config.security !== true) {
+            try {
+                this.dependencies.app.use(helmet());
+                Logger.logger.debug("middleware", "Helmet security headers applied immediately");
+            }
+            catch (error) {
+                Logger.logger.warn("middleware", "Failed to apply helmet:", error);
+            }
+        }
+        // Apply compression if configured
+        if (config?.compression && config.compression !== true) {
+            try {
+                this.dependencies.app.use(compression());
+                Logger.logger.debug("middleware", "Compression applied immediately");
+            }
+            catch (error) {
+                Logger.logger.warn("middleware", "Failed to apply compression:", error);
+            }
+        }
+        Logger.logger.debug("middleware", "Immediate middleware configuration completed");
+    }
+    /**
+     * Enable CORS middleware
+     */
+    enableCors(options) {
+        try {
+            // Transform XyPrissJS CORS config to standard cors package config
+            const corsConfig = this.transformCorsConfig(options);
+            this.dependencies.app.use(cors(corsConfig));
+            Logger.logger.debug("middleware", "CORS enabled with config:", corsConfig);
+        }
+        catch (error) {
+            Logger.logger.warn("middleware", "CORS not available, skipping CORS headers");
+        }
+    }
+    /**
+     * Transform XyPrissJS CORS configuration to standard cors package configuration
+     */
+    transformCorsConfig(XyPrissConfig) {
+        if (!XyPrissConfig)
+            return {};
+        const corsConfig = {};
+        // Map XyPrissJS config to standard cors config
+        if (XyPrissConfig.origin !== undefined) {
+            corsConfig.origin = XyPrissConfig.origin;
+        }
+        if (XyPrissConfig.methods !== undefined) {
+            corsConfig.methods = XyPrissConfig.methods;
+        }
+        if (XyPrissConfig.allowedHeaders !== undefined) {
+            corsConfig.allowedHeaders = XyPrissConfig.allowedHeaders;
+        }
+        if (XyPrissConfig.credentials !== undefined) {
+            corsConfig.credentials = XyPrissConfig.credentials;
+        }
+        if (XyPrissConfig.maxAge !== undefined) {
+            corsConfig.maxAge = XyPrissConfig.maxAge;
+        }
+        if (XyPrissConfig.preflightContinue !== undefined) {
+            corsConfig.preflightContinue = XyPrissConfig.preflightContinue;
+        }
+        if (XyPrissConfig.optionsSuccessStatus !== undefined) {
+            corsConfig.optionsSuccessStatus =
+                XyPrissConfig.optionsSuccessStatus;
+        }
+        // Don't pass the 'enabled' property to cors package
+        // Remove any other XyPrissJS-specific properties
+        return corsConfig;
+    }
+    /**
+     * Get middleware information
+     */
+    getInfo(id) {
+        if (id) {
+            const entry = this.middlewareRegistry.get(id);
+            if (!entry)
+                throw new Error(`Middleware not found: ${id}`);
+            return this.entryToInfo(entry);
+        }
+        return Array.from(this.middlewareRegistry.values()).map((entry) => this.entryToInfo(entry));
+    }
+    /**
+     * Get middleware statistics
+     */
+    getStats() {
+        const entries = Array.from(this.middlewareRegistry.values());
+        const enabledCount = entries.filter((e) => e.enabled).length;
+        const byPriority = entries.reduce((acc, entry) => {
+            acc[entry.priority] = (acc[entry.priority] || 0) + 1;
+            return acc;
+        }, {});
+        const byType = entries.reduce((acc, entry) => {
+            acc[entry.name] = this.entryToInfo(entry);
+            return acc;
+        }, {});
+        return {
+            totalMiddleware: entries.length,
+            enabledMiddleware: enabledCount,
+            totalExecutions: this.performanceMetrics.totalRequests,
+            averageExecutionTime: this.performanceMetrics.averageExecutionTime,
+            cacheHitRate: this.performanceMetrics.cacheHitRate,
+            optimizationRate: this.performanceMetrics.optimizationGain,
+            byPriority,
+            byType,
+            performance: {
+                fastestMiddleware: this.findFastestMiddleware(),
+                slowestMiddleware: this.findSlowestMiddleware(),
+                mostUsedMiddleware: this.findMostUsedMiddleware(),
+                cacheEfficiency: this.calculateCacheEfficiency(),
+            },
+        };
+    }
+    /**
+     * Get performance metrics
+     */
+    getPerformanceMetrics() {
+        return { ...this.performanceMetrics };
+    }
+    /**
+     * Optimize middleware execution
+     */
+    async optimize() {
+        Logger.logger.debug("middleware", "Optimizing middleware execution...");
+        // Reorder middleware based on performance data
+        this.optimizeExecutionOrder();
+        // Clean up cache
+        this.cleanupCache();
+        // Update optimization metrics
+        this.updateOptimizationMetrics();
+        Logger.logger.debug("middleware", "Middleware optimization completed");
+    }
+    /**
+     * Warm up middleware cache
+     */
+    async warmCache() {
+        Logger.logger.debug("middleware", "Warming up middleware cache...");
+        // Pre-cache common middleware results
+        const commonPaths = ["/health", "/ping", "/status"];
+        const commonMethods = ["GET", "POST"];
+        for (const path of commonPaths) {
+            for (const method of commonMethods) {
+                const cacheKey = `${method}:${path}`;
+                // Pre-populate cache with empty results for faster lookup
+                this.middlewareCache.set(cacheKey, {
+                    result: null,
+                    timestamp: Date.now(),
+                    ttl: this.optimizationConfig.defaultTTL,
+                    hits: 0,
+                    middleware: "warmup",
+                });
+            }
+        }
+        Logger.logger.debug("middleware", "Middleware cache warmed up");
+    }
+    /**
+     * Clear middleware cache
+     */
+    clearCache() {
+        this.middlewareCache.clear();
+        Logger.logger.debug("middleware", "Middleware cache cleared");
+    }
+    /**
+     * Execute middleware chain
+     */
+    async executeMiddleware(req, res, next) {
+        const startTime = performance.now();
+        try {
+            // Get applicable middleware for this request
+            const applicableMiddleware = this.matchRoute(req.path, req.method);
+            // Execute middleware in priority order
+            for (const entry of applicableMiddleware) {
+                if (!entry.enabled)
+                    continue;
+                const middlewareStartTime = performance.now();
+                try {
+                    await this.executeMiddlewareEntry(entry, req, res, next);
+                    const executionTime = performance.now() - middlewareStartTime;
+                    this.updateMiddlewareStats(entry, executionTime, false);
+                }
+                catch (error) {
+                    const executionTime = performance.now() - middlewareStartTime;
+                    this.updateMiddlewareStats(entry, executionTime, true);
+                    throw error;
+                }
+            }
+            const totalExecutionTime = performance.now() - startTime;
+            this.updatePerformanceMetrics(totalExecutionTime, false);
+        }
+        catch (error) {
+            const totalExecutionTime = performance.now() - startTime;
+            this.updatePerformanceMetrics(totalExecutionTime, true);
+            throw error;
+        }
+    }
+    /**
+     * Match middleware to route
+     */
+    matchRoute(path, method) {
+        return this.executionOrder
+            .map((id) => this.middlewareRegistry.get(id))
+            .filter((entry) => {
+            if (!entry || !entry.enabled)
+                return false;
+            // If no routes specified, apply to all routes
+            if (!entry.routes || entry.routes.length === 0)
+                return true;
+            // Check if path matches any of the specified routes
+            return entry.routes.some((route) => {
+                if (typeof route === "string") {
+                    return path === route || path.startsWith(route);
+                }
+                return false;
+            });
+        });
+    }
+    /**
+     * Configure middleware
+     */
+    configure(config) {
+        this.options.middleware = { ...this.options.middleware, ...config };
+        // Apply configuration changes
+        if (config.enableOptimization !== undefined) {
+            this.optimizationConfig.enableCaching = config.enableOptimization;
+        }
+        if (config.enableCaching !== undefined) {
+            this.optimizationConfig.enableCaching = config.enableCaching;
+        }
+        if (config.enablePerformanceTracking !== undefined) {
+            this.optimizationConfig.enablePerformanceTracking =
+                config.enablePerformanceTracking;
+        }
+        Logger.logger.debug("middleware", "Middleware configuration updated");
+    }
+    /**
+     * Get current configuration
+     */
+    getConfiguration() {
+        return { ...this.options.middleware };
+    }
+    /**
+     * Clear all middleware
+     */
+    clear() {
+        this.middlewareRegistry.clear();
+        this.middlewareCache.clear();
+        this.executionOrder = [];
+        Logger.logger.debug("middleware", "All middleware cleared");
+    }
+    /**
+     * Create cache middleware for route optimization
+     */
+    createCacheMiddleware(options) {
+        const ttl = options?.ttl || this.optimizationConfig.defaultTTL;
+        const keyGenerator = options?.keyGenerator ||
+            ((req) => `${req.method}:${req.path}`);
+        return (req, res, next) => {
+            const cacheKey = keyGenerator(req);
+            const cached = this.middlewareCache.get(cacheKey);
+            if (cached && this.isCacheValid(cached)) {
+                cached.hits++;
+                Logger.logger.debug("middleware", `Cache hit for route: ${cacheKey}`);
+                return next();
+            }
+            // Cache miss - continue with normal processing
+            const originalSend = res.send;
+            const self = this;
+            res.send = function (body) {
+                // Cache the response
+                self.middlewareCache.set(cacheKey, {
+                    result: body,
+                    timestamp: Date.now(),
+                    ttl,
+                    hits: 0,
+                    middleware: "route-cache",
+                });
+                return originalSend.call(this, body);
+            };
+            next();
+        };
+    }
+    /**
+     * Shutdown middleware manager
+     */
+    async shutdown() {
+        Logger.logger.debug("middleware", "Shutting down  Middleware Manager...");
+        this.middlewareRegistry.clear();
+        this.middlewareCache.clear();
+        this.executionOrder = [];
+        this.initialized = false;
+        Logger.logger.debug("middleware", " Middleware Manager shut down");
+    }
+    // ===== PRIVATE METHODS =====
+    /**
+     * Apply middleware to Express app
+     */
+    applyMiddlewareToApp(entry) {
+        if (!entry.enabled)
+            return;
+        // If routes are specified, apply middleware only to those routes
+        if (entry.routes && entry.routes.length > 0) {
+            entry.routes.forEach((route) => {
+                this.dependencies.app.use(route, entry.handler);
+                Logger.logger.debug("middleware", `Applied middleware "${entry.name}" to route: ${route}`);
+            });
+        }
+        else {
+            // Apply to all routes
+            this.dependencies.app.use(entry.handler);
+            Logger.logger.debug("middleware", `Applied middleware "${entry.name}" globally`);
+        }
+    }
+    /**
+     * Configure built-in middleware
+     */
+    configureBuiltInMiddleware() {
+        Logger.logger.debug("middleware", "Configuring built-in middleware...");
+        this.configureTrustProxy();
+        this.configureSecurityMiddleware();
+        this.configurePerformanceMiddleware();
+        this.configureBodyParsing();
+        Logger.logger.debug("middleware", "Built-in middleware configured");
+    }
+    /**
+     * Configure trust proxy settings
+     */
+    configureTrustProxy() {
+        if (this.options.server?.trustProxy) {
+            this.dependencies.app.set("trust proxy", true);
+        }
+    }
+    /**
+     * Configure security middleware
+     */
+    configureSecurityMiddleware() {
+        if (this.options.security?.helmet) {
+            this.enableSecurity();
+        }
+    }
+    /**
+     * Configure performance middleware
+     */
+    configurePerformanceMiddleware() {
+        if (this.options.performance?.compression) {
+            this.enableCompression();
+        }
+    }
+    /**
+     * Configure body parsing middleware
+     */
+    configureBodyParsing() {
+        this.dependencies.app.use(express.json({
+            limit: this.options.server?.jsonLimit,
+        }));
+        this.dependencies.app.use(express.urlencoded({
+            extended: true,
+            limit: this.options.server?.urlEncodedLimit,
+        }));
+    }
+    /**
+     * Configure optimization middleware
+     */
+    configureOptimizationMiddleware() {
+        // This will be handled by the existing MiddlewareManager for now
+        // to maintain backward compatibility
+    }
+    /**
+     * Configure request processing middleware
+     */
+    configureRequestProcessingMiddleware() {
+        this.dependencies.app.use(async (req, res, next) => {
+            // Start performance measurement
+            const requestId = this.dependencies.performanceProfiler.startMeasurement(req);
+            req.requestId = requestId;
+            req.startTime = performance.now();
+            try {
+                // Execute  middleware chain
+                await this.executeMiddleware(req, res, next);
+                // Classify request for optimal execution path
+                const classification = this.dependencies.executionPredictor.classify(req);
+                this.dependencies.performanceProfiler.setRequestType(requestId, classification.type, classification.executionPath);
+                // Update optimization stats
+                this.dependencies.optimizationStats.totalRequests++;
+                if (classification.type === "ultra-fast") {
+                    this.dependencies.optimizationStats.ultraFastRequests++;
+                }
+                else if (classification.type === "fast") {
+                    this.dependencies.optimizationStats.fastRequests++;
+                }
+                else {
+                    this.dependencies.optimizationStats.standardRequests++;
+                }
+                // Route to appropriate execution path
+                if (classification.type === "ultra-fast" &&
+                    this.dependencies.optimizationEnabled) {
+                    return await this.dependencies.handleUltraFastPath(req, res, next, requestId, classification);
+                }
+                else if (classification.type === "fast" &&
+                    this.dependencies.optimizationEnabled) {
+                    return await this.dependencies.handleFastPath(req, res, next, requestId, classification);
+                }
+                else {
+                    return await this.dependencies.handleStandardPath(req, res, next, requestId, classification);
+                }
+            }
+            catch (optimizationError) {
+                // Graceful fallback to standard path on optimization failure
+                Logger.logger.warn("middleware", `Optimization failed for ${req.method} ${req.path}:`, optimizationError.message);
+                this.dependencies.optimizationStats.optimizationFailures++;
+                return await this.dependencies.handleStandardPath(req, res, next, requestId, {
+                    type: "standard",
+                    confidence: 1.0,
+                    executionPath: "fallback",
+                    cacheStrategy: "standard",
+                    skipMiddleware: [],
+                    reason: "Optimization failure fallback",
+                    overhead: 0,
+                });
+            }
+        });
+    }
+    /**
+     * Wrap middleware with performance tracking and caching
+     */
+    wrapMiddleware(handler, name) {
+        return async (req, res, next) => {
+            const startTime = performance.now();
+            try {
+                // Check cache if middleware is cacheable AND the specific middleware entry allows caching
+                const cacheKey = this.generateCacheKey(req, name);
+                const middlewareEntry = Array.from(this.middlewareRegistry.values()).find((entry) => entry.name === name);
+                if (this.optimizationConfig.enableCaching &&
+                    middlewareEntry?.cacheable === true) {
+                    const cached = this.middlewareCache.get(cacheKey);
+                    if (cached && this.isCacheValid(cached)) {
+                        cached.hits++;
+                        const executionTime = performance.now() - startTime;
+                        Logger.logger.debug("middleware", `Cache hit for ${name}: ${executionTime}ms`);
+                        return next();
+                    }
+                }
+                // Execute middleware (Express middleware uses callbacks, not promises)
+                handler(req, res, (error) => {
+                    const executionTime = performance.now() - startTime;
+                    if (error) {
+                        Logger.logger.error("middleware", `Error in ${name}: ${error} (${executionTime}ms)`);
+                        return next(error);
+                    }
+                    // Cache result if applicable
+                    if (this.optimizationConfig.enableCaching &&
+                        executionTime < 10) {
+                        this.middlewareCache.set(cacheKey, {
+                            result: null,
+                            timestamp: Date.now(),
+                            ttl: this.optimizationConfig.defaultTTL,
+                            hits: 0,
+                            middleware: name,
+                        });
+                    }
+                    Logger.logger.debug("middleware", `Executed ${name}: ${executionTime}ms`);
+                    next();
+                });
+            }
+            catch (error) {
+                const executionTime = performance.now() - startTime;
+                Logger.logger.error("middleware", `Error in ${name}: ${error} (${executionTime}ms)`);
+                next(error);
+            }
+        };
+    }
+    /**
+     * Calculate execution order based on priority
+     */
+    calculateOrder(priority) {
+        const priorityOrder = {
+            critical: 1000,
+            high: 800,
+            normal: 500,
+            low: 200,
+        };
+        return priorityOrder[priority] + Math.random() * 100; // Add randomness for same priority
+    }
+    /**
+     * Update execution order based on priority and performance
+     */
+    updateExecutionOrder() {
+        this.executionOrder = Array.from(this.middlewareRegistry.entries())
+            .filter(([_, entry]) => entry.enabled)
+            .sort(([_, a], [__, b]) => b.order - a.order)
+            .map(([id, _]) => id);
+    }
+    /**
+     * Execute a single middleware entry
+     */
+    async executeMiddlewareEntry(entry, req, res, next) {
+        return new Promise((resolve, reject) => {
+            try {
+                entry.handler(req, res, (error) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Update middleware statistics
+     */
+    updateMiddlewareStats(entry, executionTime, hasError) {
+        entry.stats.executionCount++;
+        entry.stats.totalExecutionTime += executionTime;
+        entry.stats.averageExecutionTime =
+            entry.stats.totalExecutionTime / entry.stats.executionCount;
+        entry.stats.lastExecuted = new Date();
+        if (hasError) {
+            entry.stats.errors++;
+        }
+    }
+    /**
+     * Update performance metrics
+     */
+    updatePerformanceMetrics(executionTime, hasError) {
+        this.performanceMetrics.totalRequests++;
+        this.performanceMetrics.totalExecutionTime += executionTime;
+        this.performanceMetrics.averageExecutionTime =
+            this.performanceMetrics.totalExecutionTime /
+                this.performanceMetrics.totalRequests;
+        if (executionTime < this.performanceMetrics.fastestExecution) {
+            this.performanceMetrics.fastestExecution = executionTime;
+        }
+        if (executionTime > this.performanceMetrics.slowestExecution) {
+            this.performanceMetrics.slowestExecution = executionTime;
+        }
+        if (hasError) {
+            this.performanceMetrics.errorRate =
+                (this.performanceMetrics.errorRate *
+                    (this.performanceMetrics.totalRequests - 1) +
+                    1) /
+                    this.performanceMetrics.totalRequests;
+        }
+        // Calculate cache hit rate
+        const totalCacheAttempts = Array.from(this.middlewareCache.values()).reduce((sum, entry) => sum + entry.hits, 0);
+        this.performanceMetrics.cacheHitRate =
+            totalCacheAttempts / this.performanceMetrics.totalRequests;
+        // Calculate throughput (requests per second)
+        const now = Date.now();
+        this.performanceMetrics.throughput =
+            this.performanceMetrics.totalRequests /
+                ((now - (now - this.performanceMetrics.totalExecutionTime)) / 1000);
+    }
+    /**
+     * Convert registry entry to middleware info
+     */
+    entryToInfo(entry) {
+        return {
+            name: entry.name,
+            priority: entry.priority,
+            enabled: entry.enabled,
+            order: entry.order,
+            routes: entry.routes,
+            executionCount: entry.stats.executionCount,
+            averageExecutionTime: entry.stats.averageExecutionTime,
+            lastExecuted: entry.stats.lastExecuted,
+            cacheEnabled: entry.cacheable,
+            optimized: entry.stats.averageExecutionTime < 5, // Consider optimized if < 5ms
+        };
+    }
+    /**
+     * Generate cache key for middleware
+     */
+    generateCacheKey(req, middlewareName) {
+        return `middleware:${middlewareName}:${req.method}:${req.path}`;
+    }
+    /**
+     * Check if cache entry is valid
+     */
+    isCacheValid(entry) {
+        return Date.now() - entry.timestamp < entry.ttl;
+    }
+    /**
+     * Optimize execution order based on performance data
+     */
+    optimizeExecutionOrder() {
+        // Sort by average execution time (fastest first) within same priority
+        this.executionOrder = Array.from(this.middlewareRegistry.entries())
+            .filter(([_, entry]) => entry.enabled)
+            .sort(([_, a], [__, b]) => {
+            // First by priority
+            if (a.priority !== b.priority) {
+                return b.order - a.order;
+            }
+            // Then by performance (faster first)
+            return (a.stats.averageExecutionTime - b.stats.averageExecutionTime);
+        })
+            .map(([id, _]) => id);
+    }
+    /**
+     * Clean up expired cache entries
+     */
+    cleanupCache() {
+        const now = Date.now();
+        for (const [key, entry] of this.middlewareCache.entries()) {
+            if (now - entry.timestamp > entry.ttl) {
+                this.middlewareCache.delete(key);
+            }
+        }
+        // Limit cache size
+        if (this.middlewareCache.size > this.optimizationConfig.maxCacheSize) {
+            const entries = Array.from(this.middlewareCache.entries()).sort(([_, a], [__, b]) => a.hits - b.hits); // Remove least used first
+            const toRemove = this.middlewareCache.size -
+                this.optimizationConfig.maxCacheSize;
+            for (let i = 0; i < toRemove; i++) {
+                this.middlewareCache.delete(entries[i][0]);
+            }
+        }
+    }
+    /**
+     * Update optimization metrics
+     */
+    updateOptimizationMetrics() {
+        const totalMiddleware = this.middlewareRegistry.size;
+        const optimizedMiddleware = Array.from(this.middlewareRegistry.values()).filter((entry) => entry.stats.averageExecutionTime < 5).length;
+        this.performanceMetrics.optimizationGain =
+            totalMiddleware > 0
+                ? (optimizedMiddleware / totalMiddleware) * 100
+                : 0;
+    }
+    /**
+     * Find fastest middleware
+     */
+    findFastestMiddleware() {
+        let fastest = "";
+        let fastestTime = Infinity;
+        for (const entry of this.middlewareRegistry.values()) {
+            if (entry.stats.averageExecutionTime < fastestTime) {
+                fastestTime = entry.stats.averageExecutionTime;
+                fastest = entry.name;
+            }
+        }
+        return fastest;
+    }
+    /**
+     * Find slowest middleware
+     */
+    findSlowestMiddleware() {
+        let slowest = "";
+        let slowestTime = 0;
+        for (const entry of this.middlewareRegistry.values()) {
+            if (entry.stats.averageExecutionTime > slowestTime) {
+                slowestTime = entry.stats.averageExecutionTime;
+                slowest = entry.name;
+            }
+        }
+        return slowest;
+    }
+    /**
+     * Find most used middleware
+     */
+    findMostUsedMiddleware() {
+        let mostUsed = "";
+        let mostUsedCount = 0;
+        for (const entry of this.middlewareRegistry.values()) {
+            if (entry.stats.executionCount > mostUsedCount) {
+                mostUsedCount = entry.stats.executionCount;
+                mostUsed = entry.name;
+            }
+        }
+        return mostUsed;
+    }
+    /**
+     * Calculate cache efficiency
+     */
+    calculateCacheEfficiency() {
+        const totalCacheAttempts = Array.from(this.middlewareCache.values()).reduce((sum, entry) => sum + entry.hits, 0);
+        const totalRequests = this.performanceMetrics.totalRequests;
+        return totalRequests > 0
+            ? (totalCacheAttempts / totalRequests) * 100
+            : 0;
+    }
+}
+
+exports.MiddlewareManager = MiddlewareManager;
+//# sourceMappingURL=middlewareManager.js.map