xypriss 1.0.0 → 1.0.1

package/dist/cjs/server/optimization/RequestPreCompiler.js

@@ -0,0 +1,708 @@
+'use strict';
+
+var index = require('../../mods/toolkit/src/components/fortified-function/index.js');
+var Logger = require('../utils/Logger.js');
+
+/**
+ * Request Pre-Compiler
+ *
+ * optimization system that analyzes request patterns and pre-compiles
+ * optimized execution paths for ultra-fast request processing (<1ms overhead).
+ *
+ * Key Features:
+ * - Pattern recognition and route optimization
+ * - Pre-compiled execution paths
+ * - Intelligent caching strategies
+ * - Zero-allocation hot paths
+ * - Predictive request handling
+ */
+class RequestPreCompiler {
+    constructor(cache, config = {}) {
+        this.patterns = new Map();
+        this.compiledRoutes = new Map();
+        this.learningMode = true;
+        this.optimizationStats = {
+            totalRequests: 0,
+            optimizedRequests: 0,
+            avgOptimizationGain: 0,
+            compilationTime: 0,
+        };
+        // Library-agnostic configuration
+        this.customResponseGenerators = [];
+        this.responseTemplates = new Map();
+        // Pre-allocated objects for zero-allocation hot paths
+        this.fastPathContext = {
+            startTime: 0,
+            cacheKey: "",
+            pattern: null,
+        };
+        this.cache = cache;
+        this.config = {
+            enabled: true,
+            learningPeriod: 300000, // 5 minutes
+            optimizationThreshold: 10, // 10 requests per minute
+            maxCompiledRoutes: 1000,
+            aggressiveOptimization: false,
+            predictivePreloading: true,
+            customResponseGenerators: [],
+            responseTemplates: [],
+            systemInfo: {
+                serviceName: "FastApi.ts Service",
+                version: "1.0.0",
+                environment: process.env.NODE_ENV || "development",
+            },
+            ...config,
+        };
+        // Initialize configurable components
+        this.initializeCustomGenerators();
+        this.initializeResponseTemplates();
+        this.logger = new Logger.Logger();
+        // Start learning period
+        setTimeout(() => {
+            this.learningMode = false;
+            this.compileOptimizedRoutes();
+        }, this.config.learningPeriod);
+    }
+    /**
+     * Analyze incoming request and update patterns
+     */
+    analyzeRequest(req, res, next) {
+        const startTime = performance.now();
+        const patternKey = this.generatePatternKey(req);
+        // Update or create pattern
+        const pattern = this.patterns.get(patternKey) ||
+            this.createNewPattern(req, patternKey);
+        pattern.frequency++;
+        pattern.lastSeen = new Date();
+        // Store pattern
+        this.patterns.set(patternKey, pattern);
+        // Track response time
+        res.on("finish", () => {
+            const responseTime = performance.now() - startTime;
+            pattern.avgResponseTime =
+                (pattern.avgResponseTime + responseTime) / 2;
+            this.updateOptimizationStats(responseTime);
+        });
+        next();
+    }
+    /**
+     * Get optimized handler for request if available
+     */
+    getOptimizedHandler(req) {
+        if (!this.config.enabled || this.learningMode) {
+            return null;
+        }
+        const patternKey = this.generatePatternKey(req);
+        return this.compiledRoutes.get(patternKey) || null;
+    }
+    /**
+     * Pre-compile optimized execution paths for hot routes
+     */
+    async compileOptimizedRoutes() {
+        this.logger.debug("server", "Starting route pre-compilation...");
+        const compilationStart = performance.now();
+        // Sort patterns by optimization potential - AGGRESSIVE MODE
+        const sortedPatterns = Array.from(this.patterns.values())
+            .filter((p) => p.frequency >= this.config.optimizationThreshold)
+            .sort((a, b) => this.calculateOptimizationPotential(b) -
+            this.calculateOptimizationPotential(a))
+            .slice(0, this.config.maxCompiledRoutes);
+        // BOOST: Automatically upgrade high-potential routes to ultra optimization
+        sortedPatterns.forEach((pattern) => {
+            if (pattern.frequency >= 5 ||
+                pattern.route.includes("health") ||
+                pattern.route.includes("ping") ||
+                pattern.route.includes("status")) {
+                pattern.optimizationLevel = "ultra";
+                console.log(`ULTRA-OPTIMIZED: ${pattern.route} (freq: ${pattern.frequency})`);
+            }
+            else if (pattern.frequency >= 2) {
+                pattern.optimizationLevel = "advanced";
+                console.log(`ADVANCED-OPTIMIZED: ${pattern.route} (freq: ${pattern.frequency})`);
+            }
+            else {
+                pattern.optimizationLevel = "basic";
+            }
+        });
+        for (const pattern of sortedPatterns) {
+            await this.compileRoute(pattern);
+        }
+        const compilationTime = performance.now() - compilationStart;
+        this.optimizationStats.compilationTime = compilationTime;
+        this.logger.info("server", `✔ Pre-compiled ${sortedPatterns.length} routes in ${compilationTime.toFixed(2)}ms`);
+    }
+    /**
+     * Compile individual route for maximum performance
+     */
+    async compileRoute(pattern) {
+        const compiledRoute = {
+            pattern,
+            compiledHandler: this.createOptimizedHandler(pattern),
+            optimizedMiddleware: this.createOptimizedMiddleware(pattern),
+            cacheStrategy: this.determineCacheStrategy(pattern),
+            executionPath: this.determineExecutionPath(pattern),
+        };
+        // Pre-compute data if beneficial
+        if (pattern.optimizationLevel === "ultra") {
+            compiledRoute.precomputedData = await this.precomputeRouteData(pattern);
+        }
+        this.compiledRoutes.set(pattern.id, compiledRoute);
+    }
+    /**
+     * Create ultra-fast optimized handler
+     */
+    createOptimizedHandler(pattern) {
+        return index.func(async (req, res) => {
+            // Ultra-fast path with minimal overhead
+            this.fastPathContext.startTime = performance.now();
+            this.fastPathContext.pattern = pattern;
+            // Skip unnecessary middleware for ultra-optimized routes
+            if (pattern.optimizationLevel === "ultra") {
+                return this.handleUltraFastPath(req, res);
+            }
+            // Standard optimized path
+            return this.handleOptimizedPath(req, res);
+        }, {
+            ultraFast: "maximum",
+            memoize: true,
+            cacheTTL: 60000, // 1 minute
+            timeout: 5000,
+            errorHandling: "graceful",
+        });
+    }
+    /**
+     * Handle ultra-fast execution path (<0.5ms target)
+     */
+    async handleUltraFastPath(req, res) {
+        // Direct cache lookup with pre-computed key
+        const cacheKey = this.fastPathContext.cacheKey || this.generateFastCacheKey(req);
+        const cachedResponse = await this.cache.get(cacheKey);
+        if (cachedResponse) {
+            // Ultra-fast cache hit
+            res.json(cachedResponse);
+            return;
+        }
+        // Fallback to standard path if cache miss
+        return this.handleOptimizedPath(req, res);
+    }
+    /**
+     * Handle standard optimized path with template processing and fallback
+     */
+    async handleOptimizedPath(req, res) {
+        try {
+            // Optimized execution with reduced overhead
+            const pattern = this.fastPathContext.pattern;
+            // Use pre-computed data if available
+            const compiledRoute = this.compiledRoutes.get(pattern.id);
+            if (compiledRoute?.precomputedData) {
+                let responseData = compiledRoute.precomputedData;
+                // Handle template substitution for parameterized routes
+                if (responseData.template && req.params) {
+                    responseData = this.processTemplateData(responseData, req);
+                }
+                // Add performance headers
+                res.set("X-Precomputed", "true");
+                res.set("X-Optimization-Level", pattern.optimizationLevel);
+                res.set("X-Cache-Strategy", compiledRoute.cacheStrategy);
+                res.json(responseData);
+                return;
+            }
+            // Fallback: Generate dynamic response for known patterns
+            const dynamicResponse = await this.generateDynamicResponse(req, pattern);
+            if (dynamicResponse) {
+                res.set("X-Precomputed", "false");
+                res.set("X-Dynamic-Generation", "true");
+                res.json(dynamicResponse);
+                return;
+            }
+            // Final fallback: Let the request continue to normal route handlers
+            // This integrates with the existing FastApi.ts route system
+            console.log(`No precomputed data for ${pattern.route}, continuing to normal handler`);
+            // The request will continue through the normal middleware chain
+            // This is handled by the calling function in FastApi.ts
+        }
+        catch (error) {
+            console.error(`Optimized path handling failed for ${req.path}:`, error.message);
+            // Graceful fallback - let the request continue normally
+            // The calling function will handle the fallback to standard processing
+            throw error;
+        }
+    }
+    /**
+     * Process template data with parameter substitution
+     */
+    processTemplateData(templateData, req) {
+        try {
+            let processedData = JSON.parse(JSON.stringify(templateData));
+            // Remove template flag
+            delete processedData.template;
+            // Substitute URL parameters
+            if (req.params) {
+                const dataString = JSON.stringify(processedData);
+                let substitutedString = dataString;
+                Object.entries(req.params).forEach(([key, value]) => {
+                    const placeholder = `{{${key}}}`;
+                    const globalRegex = new RegExp(placeholder.replace(/[{}]/g, "\\$&"), "g");
+                    substitutedString = substitutedString.replace(globalRegex, value);
+                });
+                // Handle common parameter names
+                if (req.params.id) {
+                    substitutedString = substitutedString.replace(/\{\{userId\}\}/g, req.params.id);
+                }
+                processedData = JSON.parse(substitutedString);
+            }
+            // Update timestamp for freshness
+            if (processedData.timestamp) {
+                processedData.timestamp = Date.now();
+            }
+            return processedData;
+        }
+        catch (error) {
+            console.warn("Template processing failed:", error.message);
+            return templateData;
+        }
+    }
+    /**
+     * Generate dynamic response for known patterns when precomputed data is not available
+     * Library-agnostic implementation with configurable response generators
+     */
+    async generateDynamicResponse(req, pattern) {
+        try {
+            const route = pattern.route;
+            const method = pattern.method;
+            // Try custom response generators first (user-defined)
+            for (const generator of this.customResponseGenerators) {
+                try {
+                    let matches = false;
+                    if (typeof generator.pattern === "string") {
+                        matches =
+                            route === generator.pattern ||
+                                route.includes(generator.pattern);
+                    }
+                    else if (generator.pattern instanceof RegExp) {
+                        matches = generator.pattern.test(route);
+                    }
+                    if (matches) {
+                        const result = await generator.generator(req, pattern);
+                        if (result !== null && result !== undefined) {
+                            return {
+                                ...result,
+                                timestamp: Date.now(),
+                                dynamic: true,
+                                source: "custom-generator",
+                            };
+                        }
+                    }
+                }
+                catch (error) {
+                    console.warn(`Custom generator failed for pattern ${generator.pattern}:`, error.message);
+                    // Continue to next generator
+                }
+            }
+            // Universal health check - always generate fresh data
+            if ((route === "/health" || route.endsWith("/health")) &&
+                method === "GET") {
+                const systemInfo = this.config.systemInfo || {};
+                const baseResponse = {
+                    status: "ok",
+                    timestamp: Date.now(),
+                    uptime: process.uptime(),
+                    memory: process.memoryUsage(),
+                    service: systemInfo.serviceName || "FastApi.ts Service",
+                    version: systemInfo.version || "1.0.0",
+                    environment: systemInfo.environment ||
+                        process.env.NODE_ENV ||
+                        "development",
+                    dynamic: true,
+                };
+                // Add custom health data if provided
+                if (systemInfo.customHealthData &&
+                    typeof systemInfo.customHealthData === "function") {
+                    try {
+                        const customData = await systemInfo.customHealthData();
+                        return { ...baseResponse, ...customData };
+                    }
+                    catch (error) {
+                        console.warn("Custom health data generation failed:", error.message);
+                    }
+                }
+                return baseResponse;
+            }
+            // Universal ping endpoint
+            if ((route === "/ping" || route.endsWith("/ping")) &&
+                method === "GET") {
+                return {
+                    pong: true,
+                    timestamp: Date.now(),
+                    service: this.config.systemInfo?.serviceName ||
+                        "FastApi.ts Service",
+                    dynamic: true,
+                };
+            }
+            // Universal status endpoint
+            if ((route === "/status" || route.includes("status")) &&
+                method === "GET") {
+                const systemInfo = this.config.systemInfo || {};
+                const baseResponse = {
+                    status: "healthy",
+                    timestamp: Date.now(),
+                    service: systemInfo.serviceName || "FastApi.ts Service",
+                    version: systemInfo.version || "1.0.0",
+                    dynamic: true,
+                };
+                // Add custom status data if provided
+                if (systemInfo.customStatusData &&
+                    typeof systemInfo.customStatusData === "function") {
+                    try {
+                        const customData = await systemInfo.customStatusData();
+                        return { ...baseResponse, ...customData };
+                    }
+                    catch (error) {
+                        console.warn("Custom status data generation failed:", error.message);
+                    }
+                }
+                return baseResponse;
+            }
+            // No universal pattern matched and no custom generators handled it
+            // Return null to allow the application's actual route handlers to take over
+            return null;
+        }
+        catch (error) {
+            console.warn(`Dynamic response generation failed for ${pattern.route}:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Generate pattern key for request classification
+     */
+    generatePatternKey(req) {
+        return `${req.method}:${req.route?.path || req.path}:${this.hashQueryParams(req.query)}`;
+    }
+    /**
+     * Generate fast cache key with minimal overhead
+     */
+    generateFastCacheKey(req) {
+        // Pre-computed hash for ultra-fast lookup
+        return `fast:${req.method}:${req.path}`;
+    }
+    /**
+     * Hash query parameters for pattern matching
+     */
+    hashQueryParams(query) {
+        const keys = Object.keys(query).sort();
+        return keys.length > 0 ? keys.join(",") : "none";
+    }
+    /**
+     * Create new request pattern
+     */
+    createNewPattern(req, patternKey) {
+        return {
+            id: patternKey,
+            route: req.route?.path || req.path,
+            method: req.method,
+            frequency: 0,
+            avgResponseTime: 0,
+            cacheHitRate: 0,
+            complexity: this.calculateRouteComplexity(req),
+            lastSeen: new Date(),
+            optimizationLevel: "none",
+        };
+    }
+    /**
+     * Calculate optimization potential for a pattern
+     */
+    calculateOptimizationPotential(pattern) {
+        const frequencyScore = Math.min(pattern.frequency / 100, 1) * 40;
+        const responseTimeScore = Math.max(0, (100 - pattern.avgResponseTime) / 100) * 30;
+        const complexityScore = ((5 - pattern.complexity) / 5) * 20;
+        const recencyScore = this.calculateRecencyScore(pattern.lastSeen) * 10;
+        return (frequencyScore + responseTimeScore + complexityScore + recencyScore);
+    }
+    /**
+     * Calculate route complexity
+     */
+    calculateRouteComplexity(req) {
+        let complexity = 1;
+        // Add complexity for query parameters
+        complexity += Object.keys(req.query).length * 0.5;
+        // Add complexity for path parameters
+        complexity += Object.keys(req.params || {}).length * 0.3;
+        // Add complexity for headers
+        complexity += Object.keys(req.headers).length * 0.1;
+        return Math.min(complexity, 5);
+    }
+    /**
+     * Calculate recency score
+     */
+    calculateRecencyScore(lastSeen) {
+        const hoursSinceLastSeen = (Date.now() - lastSeen.getTime()) / (1000 * 60 * 60);
+        return Math.max(0, 1 - hoursSinceLastSeen / 24);
+    }
+    /**
+     * Determine optimal cache strategy
+     */
+    determineCacheStrategy(pattern) {
+        if (pattern.frequency > 50 && pattern.avgResponseTime > 10) {
+            return "hybrid";
+        }
+        else if (pattern.frequency > 20) {
+            return "memory";
+        }
+        else if (pattern.avgResponseTime > 50) {
+            return "redis";
+        }
+        return "skip";
+    }
+    /**
+     * Determine execution path
+     */
+    determineExecutionPath(pattern) {
+        if (pattern.complexity <= 2 && pattern.avgResponseTime <= 5) {
+            return "fast";
+        }
+        else if (pattern.complexity <= 4 && pattern.avgResponseTime <= 20) {
+            return "standard";
+        }
+        return "complex";
+    }
+    /**
+     * Create optimized middleware stack
+     */
+    createOptimizedMiddleware(pattern) {
+        const middleware = [];
+        // Skip unnecessary middleware for simple routes
+        if (pattern.complexity <= 2) {
+            return middleware;
+        }
+        // Add only essential middleware for complex routes
+        return middleware;
+    }
+    /**
+     * Pre-compute route data for ultra-fast responses
+     * Generates static/semi-static response data for instant serving
+     */
+    async precomputeRouteData(pattern) {
+        try {
+            const route = pattern.route;
+            const method = pattern.method;
+            // Universal health check endpoints
+            if ((route === "/health" || route.endsWith("/health")) &&
+                method === "GET") {
+                const systemInfo = this.config.systemInfo || {};
+                const baseResponse = {
+                    status: "ok",
+                    timestamp: Date.now(),
+                    uptime: process.uptime(),
+                    service: systemInfo.serviceName || "FastApi.ts Service",
+                    version: systemInfo.version || "1.0.0",
+                    environment: systemInfo.environment ||
+                        process.env.NODE_ENV ||
+                        "development",
+                    precomputed: true,
+                    responseTime: "<1ms",
+                };
+                // Add custom health data if provided
+                if (systemInfo.customHealthData &&
+                    typeof systemInfo.customHealthData === "function") {
+                    try {
+                        const customData = await systemInfo.customHealthData();
+                        return { ...baseResponse, ...customData };
+                    }
+                    catch (error) {
+                        console.warn("Custom health data generation failed:", error.message);
+                    }
+                }
+                return baseResponse;
+            }
+            // Universal ping endpoints
+            if ((route === "/ping" || route.endsWith("/ping")) &&
+                method === "GET") {
+                return {
+                    pong: true,
+                    timestamp: Date.now(),
+                    service: this.config.systemInfo?.serviceName ||
+                        "FastApi.ts Service",
+                    precomputed: true,
+                };
+            }
+            // Universal status endpoints
+            if ((route === "/status" || route.includes("status")) &&
+                method === "GET") {
+                const systemInfo = this.config.systemInfo || {};
+                const baseResponse = {
+                    status: "healthy",
+                    timestamp: Date.now(),
+                    service: systemInfo.serviceName || "FastApi.ts Service",
+                    version: systemInfo.version || "1.0.0",
+                    precomputed: true,
+                };
+                // Add custom status data if provided
+                if (systemInfo.customStatusData &&
+                    typeof systemInfo.customStatusData === "function") {
+                    try {
+                        const customData = await systemInfo.customStatusData();
+                        return { ...baseResponse, ...customData };
+                    }
+                    catch (error) {
+                        console.warn("Custom status data generation failed:", error.message);
+                    }
+                }
+                return baseResponse;
+            }
+            // Check for registered response templates first
+            const templateKey = `${method}:${route}`;
+            const template = this.responseTemplates.get(templateKey);
+            if (template) {
+                return {
+                    ...template.template,
+                    timestamp: Date.now(),
+                    precomputed: true,
+                    source: "template",
+                };
+            }
+            // Monitoring endpoints
+            if (route.includes("/XyPriss/") && method === "GET") {
+                return {
+                    service: "XyPriss-monitoring",
+                    status: "operational",
+                    timestamp: Date.now(),
+                    precomputed: true,
+                };
+            }
+            // Default fallback for other routes
+            return null;
+        }
+        catch (error) {
+            console.warn(`Failed to precompute data for ${pattern.route}:`, error.message);
+            return null;
+        }
+    }
+    /**
+     * Update optimization statistics
+     */
+    updateOptimizationStats(responseTime) {
+        this.optimizationStats.totalRequests++;
+        if (responseTime < 5) {
+            this.optimizationStats.optimizedRequests++;
+        }
+        this.optimizationStats.avgOptimizationGain =
+            (this.optimizationStats.avgOptimizationGain + responseTime) / 2;
+    }
+    /**
+     * Get optimization statistics
+     */
+    getStats() {
+        return {
+            ...this.optimizationStats,
+            patternsLearned: this.patterns.size,
+            routesCompiled: this.compiledRoutes.size,
+            optimizationRate: this.optimizationStats.optimizedRequests /
+                this.optimizationStats.totalRequests,
+            customGenerators: this.customResponseGenerators.length,
+            responseTemplates: this.responseTemplates.size,
+        };
+    }
+    /**
+     * Register a custom dynamic response generator
+     * Allows developers to extend the optimization system with their own response logic
+     */
+    registerResponseGenerator(generator) {
+        this.customResponseGenerators.push(generator);
+        // Sort by priority (higher priority first)
+        this.customResponseGenerators.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+        console.log(`Registered custom response generator for pattern: ${generator.pattern}`);
+    }
+    /**
+     * Register a response template for pre-computation
+     * Allows developers to define static response structures for their routes
+     */
+    registerResponseTemplate(template) {
+        const key = `${template.method}:${template.route}`;
+        this.responseTemplates.set(key, template);
+        console.log(`Registered response template for: ${key}`);
+    }
+    /**
+     * Remove a custom response generator
+     */
+    unregisterResponseGenerator(pattern) {
+        this.customResponseGenerators = this.customResponseGenerators.filter((gen) => gen.pattern !== pattern);
+    }
+    /**
+     * Clear all custom configurations
+     */
+    clearCustomConfigurations() {
+        this.customResponseGenerators = [];
+        this.responseTemplates.clear();
+        console.log("Cleared all custom response configurations");
+    }
+    /**
+     * Force immediate compilation of registered templates and generators
+     * Useful for testing or when you want immediate optimization without waiting for learning period
+     */
+    forceCompileTemplates() {
+        console.log(" Force compiling registered templates...");
+        // Create patterns from registered templates
+        this.responseTemplates.forEach((template, key) => {
+            const [method, route] = key.split(":");
+            const patternKey = `${method}:${route}:none`;
+            const pattern = {
+                id: patternKey,
+                route: route,
+                method: method,
+                frequency: 100, // High frequency to trigger ultra optimization
+                avgResponseTime: 0.5, // Ultra-fast response time
+                cacheHitRate: 0.9,
+                complexity: 1, // Simple route
+                lastSeen: new Date(),
+                optimizationLevel: "ultra", // Force ultra optimization
+            };
+            this.patterns.set(patternKey, pattern);
+            console.log(`📝 Created pattern for template: ${key}`);
+        });
+        // Create patterns from custom generators
+        this.customResponseGenerators.forEach((generator, index) => {
+            const patternString = generator.pattern.toString();
+            const patternKey = `GET:${patternString}:none`;
+            const pattern = {
+                id: patternKey,
+                route: patternString,
+                method: "GET",
+                frequency: 50, // High frequency
+                avgResponseTime: 1, // Fast response time
+                cacheHitRate: 0.8,
+                complexity: 2, // Slightly more complex
+                lastSeen: new Date(),
+                optimizationLevel: "advanced", // Advanced optimization
+            };
+            this.patterns.set(patternKey, pattern);
+            console.log(`📝 Created pattern for generator ${index}: ${patternString}`);
+        });
+        // Force immediate compilation
+        this.learningMode = false;
+        this.compileOptimizedRoutes();
+        console.log("✔ Force compilation completed!");
+    }
+    /**
+     * Initialize custom response generators from configuration
+     */
+    initializeCustomGenerators() {
+        if (this.config.customResponseGenerators) {
+            this.config.customResponseGenerators.forEach((generator) => {
+                this.registerResponseGenerator(generator);
+            });
+        }
+    }
+    /**
+     * Initialize response templates from configuration
+     */
+    initializeResponseTemplates() {
+        if (this.config.responseTemplates) {
+            this.config.responseTemplates.forEach((template) => {
+                this.registerResponseTemplate(template);
+            });
+        }
+    }
+}
+
+exports.RequestPreCompiler = RequestPreCompiler;
+//# sourceMappingURL=RequestPreCompiler.js.map