xypriss 1.3.8 → 2.1.0

package/dist/esm/src/server/core/XyprissApp.js

@@ -0,0 +1,677 @@
+import '../../../shared/logger/Logger.js';
+import { XyPrissHttpServer } from './HttpServer.js';
+import { XyPrissMiddleware } from '../../middleware/XyPrissMiddlewareAPI.js';
+import { XyPrissRouter } from '../routing/Router.js';
+
+/**
+ * XyprissApp - Express-free UltraFastApp implementation
+ *
+ * This module provides a complete UltraFastApp implementation that doesn't
+ * depend on Express, using our XyPrisHttpServer for maximum performance.
+ */
+/**
+ * UltraFastApp implementation without Express dependency
+ */
+class XyprissApp {
+    constructor(logger) {
+        this.isStarted = false;
+        // App properties
+        this.locals = {};
+        this.mountpath = "/";
+        this.settings = {};
+        // ===== MISSING ULTRAFASTAPP METHODS (STUB IMPLEMENTATIONS) =====
+        this.invalidateCache = async (pattern) => {
+            if (this.cache) {
+                try {
+                    // Get all cache keys and filter by pattern
+                    const stats = await this.cache.getStats();
+                    let invalidatedCount = 0;
+                    // For pattern-based invalidation, we need to implement a key scanning approach
+                    // Since the cache doesn't expose all keys directly, we'll use tags if available
+                    if (pattern.includes("*")) {
+                        // Convert glob pattern to regex
+                        const regexPattern = pattern
+                            .replace(/\*/g, ".*")
+                            .replace(/\?/g, ".");
+                        const regex = new RegExp(`^${regexPattern}$`);
+                        // For now, we'll clear all cache if it's a wildcard pattern
+                        // In a production system, you'd want to implement key scanning
+                        if (pattern === "*" || pattern === "**") {
+                            await this.cache.clear();
+                            invalidatedCount = stats.memory.size || 0;
+                        }
+                        else {
+                            // For specific patterns, we'd need to implement key enumeration
+                            // This is a limitation of the current cache implementation
+                            this.logger.warn("server", `Pattern-based cache invalidation not fully supported: ${pattern}`);
+                        }
+                    }
+                    else {
+                        // Direct key deletion
+                        const deleted = await this.cache.delete(pattern);
+                        invalidatedCount = deleted ? 1 : 0;
+                    }
+                    this.logger.debug("server", `Cache invalidation completed for pattern: ${pattern}, invalidated: ${invalidatedCount} entries`);
+                }
+                catch (error) {
+                    this.logger.error("server", `Cache invalidation failed for pattern ${pattern}: ${error}`);
+                    throw error;
+                }
+            }
+        };
+        this.getCacheStats = async () => {
+            if (this.cache) {
+                try {
+                    const stats = await this.cache.getStats();
+                    // Transform cache stats to a more user-friendly format
+                    return {
+                        memory: {
+                            hitRate: stats.memory.hitRate || 0,
+                            missRate: 1 - (stats.memory.hitRate || 0),
+                            size: stats.memory.size || 0,
+                            hits: stats.memory.hits || 0,
+                            misses: stats.memory.misses || 0,
+                            totalOperations: (stats.memory.hits || 0) +
+                                (stats.memory.misses || 0),
+                            memoryUsage: stats.memory.memoryUsage || 0,
+                            evictions: stats.memory.evictions || 0,
+                        },
+                        redis: stats.redis
+                            ? {
+                                connected: stats.redis.connected,
+                                hitRate: stats.redis.hitRate || 0,
+                                hits: stats.redis.hits || 0,
+                                misses: stats.redis.misses || 0,
+                                keys: stats.redis.keys || 0,
+                                memoryUsage: stats.redis.memoryUsage,
+                                uptime: stats.redis.uptime || 0,
+                            }
+                            : null,
+                        performance: stats.performance
+                            ? {
+                                totalOperations: stats.performance.totalOperations || 0,
+                                averageResponseTime: stats.performance.averageResponseTime || 0,
+                                compressionRatio: stats.performance.compressionRatio || 0,
+                            }
+                            : null,
+                        security: stats.security
+                            ? {
+                                encryptedEntries: stats.security.encryptedEntries || 0,
+                                keyRotations: stats.security.keyRotations || 0,
+                            }
+                            : null,
+                        timestamp: Date.now(),
+                    };
+                }
+                catch (error) {
+                    this.logger.error("server", `Failed to get cache stats: ${error}`);
+                    return { error: "Failed to retrieve cache statistics" };
+                }
+            }
+            return null;
+        };
+        this.warmUpCache = async (data) => {
+            if (this.cache && data && data.length > 0) {
+                try {
+                    this.logger.debug("server", `Starting cache warmup for ${data.length} entries`);
+                    let successCount = 0;
+                    let errorCount = 0;
+                    const batchSize = 10; // Process in batches to avoid overwhelming the cache
+                    // Process entries in batches
+                    for (let i = 0; i < data.length; i += batchSize) {
+                        const batch = data.slice(i, i + batchSize);
+                        const batchPromises = batch.map(async (entry) => {
+                            try {
+                                const options = entry.ttl
+                                    ? { ttl: entry.ttl }
+                                    : undefined;
+                                await this.cache.set(entry.key, entry.value, options);
+                                successCount++;
+                            }
+                            catch (error) {
+                                errorCount++;
+                                this.logger.warn("server", `Failed to warm up cache entry ${entry.key}: ${error}`);
+                            }
+                        });
+                        // Wait for batch to complete
+                        await Promise.allSettled(batchPromises);
+                        // Small delay between batches to prevent overwhelming the system
+                        if (i + batchSize < data.length) {
+                            await new Promise((resolve) => setTimeout(resolve, 10));
+                        }
+                    }
+                    this.logger.debug("server", `Cache warmup completed: ${successCount} successful, ${errorCount} failed`);
+                }
+                catch (error) {
+                    this.logger.error("server", `Cache warmup failed: ${error}`);
+                    throw error;
+                }
+            }
+        };
+        this.getRequestPreCompiler = () => {
+            // RequestPreCompiler is not implemented in the current architecture
+            // This would be a component for pre-compiling request handlers for performance
+            this.logger.debug("server", "RequestPreCompiler not implemented");
+            return {
+                compile: (routes) => {
+                    this.logger.debug("server", `Pre-compiling ${routes.length} routes`);
+                    return routes; // Pass-through for now
+                },
+                isEnabled: () => false,
+                getStats: () => ({ compiledRoutes: 0, compilationTime: 0 }),
+            };
+        };
+        this.getConsoleInterceptor = () => null;
+        this.enableConsoleInterception = () => { };
+        this.disableConsoleInterception = () => { };
+        this.getConsoleStats = () => null;
+        this.resetConsoleStats = () => { };
+        this.getFileWatcherStatus = () => null;
+        this.getFileWatcherStats = () => null;
+        this.stopFileWatcher = async () => { };
+        this.getFileWatcherManager = () => null;
+        this.checkTypeScript = async (files) => null;
+        this.getTypeScriptStatus = () => null;
+        this.enableTypeScriptChecking = () => { };
+        this.disableTypeScriptChecking = () => { };
+        this.ultraGet = (path, options, handler) => {
+            return this.get(path, handler);
+        };
+        this.ultraPost = (path, options, handler) => {
+            return this.post(path, handler);
+        };
+        this.ultraPut = (path, options, handler) => {
+            return this.put(path, handler);
+        };
+        this.ultraDelete = (path, options, handler) => {
+            return this.delete(path, handler);
+        };
+        this.ultraRoutes = (routes) => {
+            if (!routes || !Array.isArray(routes)) {
+                this.logger.warn("server", "Invalid routes array provided to ultraRoutes");
+                return this;
+            }
+            try {
+                this.logger.debug("server", `Bulk registering ${routes.length} routes`);
+                let successCount = 0;
+                let errorCount = 0;
+                routes.forEach((route, index) => {
+                    try {
+                        const { method, path, handler } = route;
+                        if (!method || !path || !handler) {
+                            throw new Error(`Invalid route at index ${index}: missing method, path, or handler`);
+                        }
+                        // Register route based on method
+                        switch (method.toUpperCase()) {
+                            case "GET":
+                                this.get(path, handler);
+                                break;
+                            case "POST":
+                                this.post(path, handler);
+                                break;
+                            case "PUT":
+                                this.put(path, handler);
+                                break;
+                            case "DELETE":
+                                this.delete(path, handler);
+                                break;
+                            case "PATCH":
+                                this.patch(path, handler);
+                                break;
+                            case "OPTIONS":
+                                this.options(path, handler);
+                                break;
+                            case "HEAD":
+                                this.head(path, handler);
+                                break;
+                            default:
+                                throw new Error(`Unsupported HTTP method: ${method}`);
+                        }
+                        successCount++;
+                    }
+                    catch (error) {
+                        errorCount++;
+                        this.logger.error("server", `Failed to register route at index ${index}: ${error}`);
+                    }
+                });
+                this.logger.debug("server", `Bulk route registration completed: ${successCount} successful, ${errorCount} failed`);
+                return this;
+            }
+            catch (error) {
+                this.logger.error("server", `Bulk route registration failed: ${error}`);
+                return this;
+            }
+        };
+        this.getRouterStats = () => null;
+        this.getRouterInfo = () => null;
+        this.warmUpRoutes = async () => { };
+        this.resetRouterStats = () => { };
+        this.useCached = (middleware, ttl) => {
+            if (!this.cache) {
+                this.logger.warn("server", "Cache not available, using middleware without caching");
+                return this.use(middleware);
+            }
+            // Create a caching wrapper for the middleware
+            const cachedMiddleware = async (req, res, next) => {
+                try {
+                    // Generate cache key based on request
+                    const cacheKey = `middleware:${req.method}:${req.path}:${JSON.stringify(req.query)}`;
+                    // Check if response is cached
+                    const cachedResponse = await this.cache.get(cacheKey);
+                    if (cachedResponse) {
+                        this.logger.debug("server", `Serving cached middleware response for ${cacheKey}`);
+                        res.json(cachedResponse);
+                        return;
+                    }
+                    // Intercept response to cache it
+                    const originalJson = res.json;
+                    const self = this;
+                    res.json = function (data) {
+                        // Cache the response
+                        if (ttl && self.cache) {
+                            self.cache
+                                .set(cacheKey, data, { ttl })
+                                .catch((error) => {
+                                self.logger.warn("server", `Failed to cache middleware response: ${error}`);
+                            });
+                        }
+                        return originalJson.call(this, data);
+                    };
+                    // Execute original middleware
+                    middleware(req, res, next);
+                }
+                catch (error) {
+                    this.logger.error("server", `Cached middleware error: ${error}`);
+                    middleware(req, res, next);
+                }
+            };
+            return this.use(cachedMiddleware);
+        };
+        this.removeMiddleware = (name) => {
+            try {
+                // Middleware removal is complex in the current architecture
+                // This would require tracking middleware by name and rebuilding the middleware stack
+                this.logger.warn("server", `Middleware removal not fully implemented for: ${name}`);
+                // For now, we can only disable middleware through the middleware API
+                if (this.middlewareAPI) {
+                    const disabled = this.middlewareAPI.disable(name);
+                    if (disabled) {
+                        this.logger.debug("server", `Disabled middleware: ${name}`);
+                        return true;
+                    }
+                }
+                return false;
+            }
+            catch (error) {
+                this.logger.error("server", `Failed to remove middleware ${name}: ${error}`);
+                return false;
+            }
+        };
+        this.enableSecurity = (options) => {
+            try {
+                this.logger.debug("server", "Enabling security middleware");
+                if (this.middlewareAPI) {
+                    // Enable all security middleware
+                    const securityMiddleware = [
+                        "helmet",
+                        "cors",
+                        "rateLimit",
+                        "csrf",
+                        "compression",
+                        "hpp",
+                        "mongoSanitize",
+                        "xss",
+                    ];
+                    securityMiddleware.forEach((middleware) => {
+                        try {
+                            this.middlewareAPI.enable(middleware);
+                            this.logger.debug("server", `Enabled security middleware: ${middleware}`);
+                        }
+                        catch (error) {
+                            this.logger.warn("server", `Failed to enable ${middleware}: ${error}`);
+                        }
+                    });
+                    // Apply custom security options if provided
+                    if (options) {
+                        if (options.helmet) {
+                            this.middlewareAPI.helmet(options.helmet);
+                        }
+                        if (options.cors) {
+                            this.middlewareAPI.cors(options.cors);
+                        }
+                        if (options.rateLimit) {
+                            this.middlewareAPI.rateLimit(options.rateLimit);
+                        }
+                    }
+                    this.logger.debug("server", "Security middleware enabled successfully");
+                }
+                else {
+                    this.logger.warn("server", "Middleware API not available, cannot enable security");
+                }
+                return this;
+            }
+            catch (error) {
+                this.logger.error("server", `Failed to enable security middleware: ${error}`);
+                return this;
+            }
+        };
+        // More missing methods
+        this.enableConsoleEncryption = () => { };
+        this.disableConsoleEncryption = () => { };
+        this.encrypt = (data) => data;
+        this.setConsoleEncryptionKey = (key) => { };
+        this.enableCors = (options) => this;
+        this.enableCompression = (options) => this;
+        this.enableRateLimit = (options) => this;
+        this.getWithCache = (path, options, handler) => this.get(path, handler);
+        this.postWithCache = (path, options, handler) => this.post(path, handler);
+        this.putWithCache = (path, options, handler) => this.put(path, handler);
+        this.deleteWithCache = (path, options, handler) => this.delete(path, handler);
+        this.patchWithCache = (path, options, handler) => this.patch(path, handler);
+        this.optionsWithCache = (path, options, handler) => this.options(path, handler);
+        this.headWithCache = (path, options, handler) => this.head(path, handler);
+        // Final missing methods
+        this.setConsoleEncryptionDisplayMode = (_mode) => { };
+        this.getEncryptedLogs = () => [];
+        this.restoreConsoleFromEncrypted = async (_encryptedData, _key) => [];
+        this.isConsoleEncryptionEnabled = () => false;
+        this.getConsoleEncryptionKey = () => "";
+        this.clearEncryptedLogs = () => { };
+        this.exportEncryptedLogs = (_format) => null;
+        this.importEncryptedLogs = (_data) => { };
+        this.getConsoleEncryptionStats = () => null;
+        this.getConsoleEncryptionStatus = () => null;
+        this.useSecure = (_options) => this;
+        this.usePerformance = (_options) => this;
+        this.getMiddleware = () => null;
+        this.getMiddlewareStats = () => null;
+        this.logger = logger;
+        this.httpServer = new XyPrissHttpServer(logger);
+        this.middlewareAPI = new XyPrissMiddleware(this);
+        this.setupDefaultSettings();
+        this.logger.debug("routing", "XyprissApp created with new XyPrisHttpServer");
+    }
+    /**
+     * Setup default Express-like settings
+     */
+    setupDefaultSettings() {
+        this.settings = {
+            "x-powered-by": false,
+            etag: "weak",
+            env: process.env.NODE_ENV || "development",
+            "subdomain offset": 2,
+            "trust proxy": false,
+            "view cache": true,
+            "view engine": false,
+            views: process.cwd() + "/views",
+        };
+    }
+    // ===== HTTP METHOD IMPLEMENTATIONS =====
+    get(path, ...handlers) {
+        this.logger.debug("server", `Registering GET route: ${path}`);
+        this.httpServer.get(path, ...this.convertHandlers(handlers));
+    }
+    post(path, ...handlers) {
+        this.httpServer.post(path, ...this.convertHandlers(handlers));
+    }
+    put(path, ...handlers) {
+        this.httpServer.put(path, ...this.convertHandlers(handlers));
+    }
+    delete(path, ...handlers) {
+        this.httpServer.delete(path, ...this.convertHandlers(handlers));
+    }
+    patch(path, ...handlers) {
+        this.httpServer.patch(path, ...this.convertHandlers(handlers));
+    }
+    options(path, ...handlers) {
+        this.httpServer.options(path, ...this.convertHandlers(handlers));
+    }
+    head(path, ...handlers) {
+        this.httpServer.head(path, ...this.convertHandlers(handlers));
+    }
+    all(path, ...handlers) {
+        // Implement all HTTP methods
+        const convertedHandlers = this.convertHandlers(handlers);
+        this.httpServer.get(path, ...convertedHandlers);
+        this.httpServer.post(path, ...convertedHandlers);
+        this.httpServer.put(path, ...convertedHandlers);
+        this.httpServer.delete(path, ...convertedHandlers);
+        this.httpServer.patch(path, ...convertedHandlers);
+        this.httpServer.options(path, ...convertedHandlers);
+        this.httpServer.head(path, ...convertedHandlers);
+    }
+    // ===== MIDDLEWARE METHODS =====
+    use(pathOrRouter, router) {
+        if (typeof pathOrRouter === "string" &&
+            router instanceof XyPrissRouter) {
+            // app.use('/api', router)
+            this.mountRouter(pathOrRouter, router);
+        }
+        else if (pathOrRouter instanceof XyPrissRouter) {
+            // app.use(router)
+            this.mountRouter("/", pathOrRouter);
+        }
+        else if (typeof pathOrRouter === "function") {
+            // app.use(middleware)
+            this.httpServer.use(pathOrRouter);
+        }
+        else if (typeof pathOrRouter === "string" &&
+            typeof router === "function") {
+            // app.use(path, middleware)
+            this.httpServer.use(pathOrRouter, router);
+        }
+        return this;
+    }
+    listen(port, hostnameOrCallback, callback) {
+        let hostname = "localhost";
+        let cb = callback;
+        if (typeof hostnameOrCallback === "string") {
+            hostname = hostnameOrCallback;
+        }
+        else if (typeof hostnameOrCallback === "function") {
+            cb = hostnameOrCallback;
+        }
+        this.logger.debug("server", `listen() called: ${hostname}:${port}`);
+        const server = this.httpServer.listen(port, hostname, cb);
+        this.logger.debug("server", `listen() returning server: ${typeof server}, has 'on': ${typeof server?.on}`);
+        return server;
+    }
+    set(setting, val) {
+        this.settings[setting] = val;
+    }
+    getSetting(setting) {
+        return this.settings[setting];
+    }
+    enabled(setting) {
+        return Boolean(this.settings[setting]);
+    }
+    disabled(setting) {
+        return !this.settings[setting];
+    }
+    enable(setting) {
+        this.settings[setting] = true;
+    }
+    disable(setting) {
+        this.settings[setting] = false;
+    }
+    engine(ext, fn) {
+        // Template engine support - basic implementation
+        this.settings[`engine:${ext}`] = fn;
+        return this;
+    }
+    param(name, handler) {
+        // Parameter preprocessing - basic implementation
+        this.settings[`param:${name}`] = handler;
+    }
+    path() {
+        return this.mountpath;
+    }
+    render(_view, _options, callback) {
+        // Template rendering - basic implementation
+        if (callback) {
+            callback(new Error("Template rendering not implemented"));
+        }
+    }
+    route(path) {
+        // Route creation - basic implementation
+        return {
+            get: (handler) => this.get(path, handler),
+            post: (handler) => this.post(path, handler),
+            put: (handler) => this.put(path, handler),
+            delete: (handler) => this.delete(path, handler),
+            patch: (handler) => this.patch(path, handler),
+            options: (handler) => this.options(path, handler),
+            head: (handler) => this.head(path, handler),
+            all: (handler) => this.all(path, handler),
+        };
+    }
+    // ===== CACHE METHODS =====
+    setCache(cache) {
+        this.cache = cache;
+    }
+    getCache() {
+        return this.cache;
+    }
+    /**
+     * Access the middleware management API
+     */
+    middleware(config) {
+        return this.middlewareAPI;
+    }
+    /**
+     * Mount a router at a specific path
+     */
+    mountRouter(basePath, router) {
+        const routes = router.getRoutes();
+        const middleware = router.getMiddleware();
+        this.logger.debug("server", `🔧 Mounting router at ${basePath} with ${routes.length} routes`);
+        routes.forEach((route) => {
+            this.logger.debug("server", `🔧 Router route: ${route.method} ${route.path} (has pattern: ${!!route.pattern})`);
+        });
+        // Register router middleware first
+        middleware.forEach((mw) => {
+            this.httpServer.use(mw);
+        });
+        // Register all routes from the router
+        routes.forEach((route) => {
+            const fullPath = this.joinPaths(basePath, route.path);
+            // Register route-specific middleware
+            route.middleware.forEach((mw) => {
+                this.httpServer.use(mw);
+            });
+            // If the route has a compiled pattern, we need to create a new pattern
+            // that includes the base path
+            let routePath = fullPath;
+            if (route.pattern && basePath !== "/") {
+                // Create a new pattern that includes the base path
+                const originalPattern = route.pattern.source;
+                const flags = route.pattern.flags;
+                // Remove the ^ and $ anchors from the original pattern
+                const cleanPattern = originalPattern
+                    .replace(/^\^/, "")
+                    .replace(/\$$/, "");
+                // Create new pattern with base path
+                const basePathEscaped = basePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const newPatternSource = `^${basePathEscaped}${cleanPattern}$`;
+                routePath = new RegExp(newPatternSource, flags);
+                this.logger.debug("server", `🔧 Registering route: ${route.method} ${fullPath} (compiled pattern with base path)`);
+            }
+            else if (route.pattern) {
+                // Use the original pattern if no base path
+                routePath = route.pattern;
+                this.logger.debug("server", `🔧 Registering route: ${route.method} ${fullPath} (original compiled pattern)`);
+            }
+            else {
+                this.logger.debug("server", `🔧 Registering route: ${route.method} ${fullPath} (string path)`);
+            }
+            // Register the route using the appropriate HTTP method
+            const allHandlers = [...route.middleware, route.handler];
+            // For RegExp routes, we need to manually add the route with parameter names
+            if (routePath instanceof RegExp && route.paramNames) {
+                // Manually add route to HTTP server with parameter names
+                this.httpServer.addRouteWithParams(route.method.toUpperCase(), routePath, route.paramNames, allHandlers);
+            }
+            else {
+                // Use standard HTTP method registration
+                switch (route.method.toUpperCase()) {
+                    case "GET":
+                        this.httpServer.get(routePath, ...allHandlers);
+                        break;
+                    case "POST":
+                        this.httpServer.post(routePath, ...allHandlers);
+                        break;
+                    case "PUT":
+                        this.httpServer.put(routePath, ...allHandlers);
+                        break;
+                    case "DELETE":
+                        this.httpServer.delete(routePath, ...allHandlers);
+                        break;
+                    case "PATCH":
+                        this.httpServer.patch(routePath, ...allHandlers);
+                        break;
+                    case "OPTIONS":
+                        this.httpServer.options(routePath, ...allHandlers);
+                        break;
+                    case "HEAD":
+                        this.httpServer.head(routePath, ...allHandlers);
+                        break;
+                    default:
+                        this.logger.warn("server", `Unsupported HTTP method: ${route.method}`);
+                        break;
+                }
+            }
+            this.logger.debug("server", `Mounted route: ${route.method} ${fullPath}`);
+        });
+        this.logger.debug("server", `Mounted router at ${basePath} with ${routes.length} routes`);
+    }
+    /**
+     * Join two paths correctly
+     */
+    joinPaths(basePath, subPath) {
+        const normalizedBase = basePath.endsWith("/")
+            ? basePath.slice(0, -1)
+            : basePath;
+        const normalizedSub = subPath.startsWith("/") ? subPath : "/" + subPath;
+        if (normalizedBase === "" || normalizedBase === "/") {
+            return normalizedSub;
+        }
+        return normalizedBase + normalizedSub;
+    }
+    // ===== HELPER METHODS =====
+    /**
+     * Convert Express RequestHandler to XyPrisHttpServer handler
+     */
+    convertHandler(handler) {
+        return (req, res, next) => {
+            // Type assertion to make it compatible
+            return handler(req, res, next);
+        };
+    }
+    /**
+     * Convert array of Express RequestHandlers to XyPrisHttpServer handlers
+     */
+    convertHandlers(handlers) {
+        return handlers.map((handler) => this.convertHandler(handler));
+    }
+    /**
+     * Get the underlying HTTP server
+     */
+    getHttpServer() {
+        return this.httpServer;
+    }
+    /**
+     * Close the server
+     */
+    close(callback) {
+        this.httpServer.close(callback);
+    }
+    /**
+     * Get server address
+     */
+    address() {
+        return this.httpServer.address();
+    }
+}
+
+export { XyprissApp };
+//# sourceMappingURL=XyprissApp.js.map