xypriss 1.1.4 → 1.2.1

package/dist/esm/src/plugins/modules/index.js

@@ -0,0 +1,275 @@
+import { JWTAuthPlugin } from './builtin/JWTAuthPlugin.js';
+import { ResponseTimePlugin } from './builtin/ResponseTimePlugin.js';
+import { SmartCachePlugin } from './builtin/SmartCachePlugin.js';
+import { PluginEngine } from './PluginEngine.js';
+import { PluginRegistry } from './PluginRegistry.js';
+import { PluginPriority } from './types/PluginTypes.js';
+export { PluginEventType, PluginType } from './types/PluginTypes.js';
+export { SecurityPlugin as SecurityPluginBase } from './core/SecurityPlugin.js';
+import '../../../mods/security/src/components/fortified-function/core/fortified-function-core.js';
+import '../../../mods/security/src/components/fortified-function/core/fortified-config.js';
+import '../../../mods/security/src/components/fortified-function/core/fortified-logger.js';
+import 'events';
+import '../../../mods/security/src/components/fortified-function/serializer/safe-serializer.js';
+import 'nehoid';
+import '../../../mods/security/src/utils/memory/index.js';
+import 'crypto';
+import '../../../mods/security/src/types/secure-memory.js';
+import '../../../mods/security/src/components/secure-string/advanced/entropy-analyzer.js';
+import '../../../mods/security/src/components/secure-string/advanced/quantum-safe.js';
+import '../../../mods/security/src/components/secure-string/advanced/performance-monitor.js';
+import '../../../mods/security/src/core/hash/hash-core.js';
+import '../../../mods/security/src/core/hash/hash-types.js';
+import '../../../mods/security/src/core/hash/hash-security.js';
+import '../../../mods/security/src/core/hash/hash-advanced.js';
+import '../../../mods/security/src/algorithms/hash-algorithms.js';
+import '../../../mods/security/src/core/random/random-types.js';
+import '../../../mods/security/src/core/random/random-sources.js';
+import 'nehonix-uri-processor';
+import '../../../mods/security/src/types.js';
+import '../../../mods/security/src/components/secure-array/utils/id-generator.js';
+import '../../../mods/security/src/index.js';
+import '../../../shared/logger/Logger.js';
+import '../../../mods/security/src/components/fortified-function/UFA/ultra-fast-allocator.js';
+import 'argon2';
+import 'child_process';
+import 'https';
+import '../../../mods/security/src/components/runtime-verification.js';
+import '../../../mods/security/src/components/tamper-evident-logging.js';
+import '../../../mods/security/src/core/keys/keys-types.js';
+import '../../../mods/security/src/core/keys/keys-logger.js';
+import '../../../mods/security/src/core/keys/keys-utils.js';
+import '../../../mods/security/src/core/keys/algorithms/mods/PBKDF2Algo.js';
+import '../../../mods/security/src/core/password/index.js';
+import 'systeminformation';
+import 'pidusage';
+import 'node-os-utils';
+import '../../../mods/security/src/components/cache/index.js';
+import 'perf_hooks';
+export { NetworkCategory } from './network/types/NetworkTypes.js';
+import 'fs';
+import 'path';
+import 'xypriss-security';
+import 'zlib';
+import 'compression';
+import 'http-proxy-middleware';
+import 'express-rate-limit';
+import 'ioredis';
+import 'util';
+import '../../encryption/EncryptionService.js';
+
+/**
+ * XyPrissJS Ultra-Fast Plugin System
+ *
+ * Comprehensive plugin system exports for ultra-fast performance
+ * with <1ms execution overhead and enterprise-grade security.
+ */
+/**
+ * Plugin system version and metadata
+ */
+const PLUGIN_SYSTEM_VERSION = "1.0.0";
+const PLUGIN_SYSTEM_NAME = "XyPrissJS Ultra-Fast Plugin System";
+/**
+ * Performance targets achieved by the plugin system
+ */
+const PERFORMANCE_TARGETS = {
+    PLUGIN_EXECUTION_OVERHEAD: "<1ms",
+    SECURITY_PLUGIN_EXECUTION: "<2ms",
+    CACHE_PLUGIN_EXECUTION: "<0.5ms",
+    PERFORMANCE_PLUGIN_EXECUTION: "<0.3ms",
+    PLUGIN_REGISTRATION: "<0.1ms",
+};
+/**
+ * Default plugin configurations
+ */
+const DEFAULT_PLUGIN_CONFIG = {
+    maxExecutionTime: 1000, // 1 second default timeout
+    enableProfiling: true,
+    enableCaching: true,
+    enableEncryption: false,
+    enableAuditLogging: false,
+    securityLevel: "basic",
+    customSettings: {},
+};
+/**
+ * Plugin system utilities
+ */
+class PluginSystemUtils {
+    /**
+     * Validate plugin configuration
+     */
+    static validatePluginConfig(config) {
+        if (!config.id || typeof config.id !== "string") {
+            return false;
+        }
+        if (!config.name || typeof config.name !== "string") {
+            return false;
+        }
+        if (!config.version || typeof config.version !== "string") {
+            return false;
+        }
+        if (typeof config.execute !== "function") {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Create plugin performance summary
+     */
+    static createPerformanceSummary(stats) {
+        if (!stats || stats.length === 0) {
+            return {
+                totalPlugins: 0,
+                averageExecutionTime: 0,
+                totalExecutions: 0,
+                successRate: 100,
+            };
+        }
+        const totalExecutions = stats.reduce((sum, stat) => sum + stat.executionCount, 0);
+        const totalExecutionTime = stats.reduce((sum, stat) => sum + stat.totalExecutionTime, 0);
+        const totalErrors = stats.reduce((sum, stat) => sum + stat.errorCount, 0);
+        return {
+            totalPlugins: stats.length,
+            averageExecutionTime: totalExecutions > 0 ? totalExecutionTime / totalExecutions : 0,
+            totalExecutions,
+            successRate: totalExecutions > 0
+                ? ((totalExecutions - totalErrors) / totalExecutions) * 100
+                : 100,
+        };
+    }
+    /**
+     * Generate plugin health report
+     */
+    static generateHealthReport(registryStats, engineStats) {
+        const isHealthy = registryStats.totalPlugins > 0 &&
+            registryStats.averageExecutionTime < 10 && // 10ms threshold
+            engineStats.circuitBreakersOpen === 0;
+        return {
+            status: isHealthy ? "healthy" : "degraded",
+            timestamp: new Date().toISOString(),
+            metrics: {
+                totalPlugins: registryStats.totalPlugins,
+                averageExecutionTime: registryStats.averageExecutionTime,
+                circuitBreakersOpen: engineStats.circuitBreakersOpen,
+                contextPoolSize: engineStats.contextPoolSize,
+                warmedUpPlugins: engineStats.warmedUpPlugins,
+            },
+            recommendations: this.generateRecommendations(registryStats, engineStats),
+        };
+    }
+    /**
+     * Generate performance recommendations
+     */
+    static generateRecommendations(registryStats, engineStats) {
+        const recommendations = [];
+        if (registryStats.averageExecutionTime > 5) {
+            recommendations.push("Consider optimizing slow plugins or increasing timeout values");
+        }
+        if (engineStats.circuitBreakersOpen > 0) {
+            recommendations.push("Review and fix failing plugins to restore full functionality");
+        }
+        if (engineStats.contextPoolSize < 10) {
+            recommendations.push("Consider increasing context pool size for better performance");
+        }
+        if (registryStats.totalPlugins === 0) {
+            recommendations.push("Initialize built-in plugins to enable enhanced functionality");
+        }
+        if (recommendations.length === 0) {
+            recommendations.push("Plugin system is performing optimally");
+        }
+        return recommendations;
+    }
+}
+/**
+ * Plugin system factory for easy initialization
+ */
+class PluginSystemFactory {
+    /**
+     * Create a pre-configured plugin registry
+     */
+    static createRegistry(cache, cluster, config) {
+        return new PluginRegistry(cache, cluster, config);
+    }
+    /**
+     * Create a pre-configured plugin engine
+     */
+    static createEngine(registry, cache, cluster) {
+        return new PluginEngine(registry, cache, cluster);
+    }
+    /**
+     * Create all built-in plugins
+     */
+    static createBuiltinPlugins() {
+        return [
+            new JWTAuthPlugin(),
+            new ResponseTimePlugin(),
+            new SmartCachePlugin(),
+        ];
+    }
+    /**
+     * Initialize complete plugin system
+     */
+    static async initializeSystem(cache, cluster, config) {
+        const registry = this.createRegistry(cache, cluster, config);
+        const engine = this.createEngine(registry, cache, cluster);
+        const plugins = this.createBuiltinPlugins();
+        // Register all built-in plugins
+        for (const plugin of plugins) {
+            await registry.register(plugin);
+        }
+        return { registry, engine, plugins };
+    }
+}
+/**
+ * Plugin development helpers
+ */
+class PluginDevelopmentHelpers {
+    /**
+     * Create a basic plugin template
+     */
+    static createPluginTemplate(id, name, type, priority = PluginPriority.NORMAL) {
+        return {
+            id,
+            name,
+            version: "1.0.0",
+            type,
+            priority,
+            isAsync: true,
+            isCacheable: false,
+            maxExecutionTime: 1000,
+            execute: async (context) => {
+                // Plugin implementation goes here
+                return {
+                    success: true,
+                    executionTime: 0,
+                    shouldContinue: true,
+                };
+            },
+        };
+    }
+    /**
+     * Validate plugin implementation
+     */
+    static validatePlugin(plugin) {
+        const errors = [];
+        if (!plugin.id)
+            errors.push("Plugin must have an id");
+        if (!plugin.name)
+            errors.push("Plugin must have a name");
+        if (!plugin.version)
+            errors.push("Plugin must have a version");
+        if (!plugin.type)
+            errors.push("Plugin must have a type");
+        if (!plugin.execute)
+            errors.push("Plugin must have an execute method");
+        if (typeof plugin.execute !== "function")
+            errors.push("Plugin execute must be a function");
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+
+export { DEFAULT_PLUGIN_CONFIG, JWTAuthPlugin, PERFORMANCE_TARGETS, PLUGIN_SYSTEM_NAME, PLUGIN_SYSTEM_VERSION, PluginDevelopmentHelpers, PluginEngine, PluginPriority, PluginRegistry, PluginSystemFactory, PluginSystemUtils, ResponseTimePlugin, SmartCachePlugin };
+//# sourceMappingURL=index.js.map

package/dist/esm/src/plugins/modules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../src/plugins/modules/index.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/esm/src/plugins/modules/network/builtin/CompressionPlugin.js

@@ -0,0 +1,389 @@
+import { performance } from 'perf_hooks';
+import * as zlib from 'zlib';
+import compression from 'compression';
+import { NetworkPlugin } from '../core/NetworkPlugin.js';
+import { NetworkCategory } from '../types/NetworkTypes.js';
+
+/**
+ * Compression Plugin
+ *
+ * Handles response compression with multiple algorithms (Gzip, Brotli, Deflate)
+ * Provides smart compression based on content type and size optimization
+ */
+/**
+ * Response compression plugin for optimizing bandwidth usage
+ */
+class CompressionPlugin extends NetworkPlugin {
+    constructor(config = {
+        enabled: true,
+        algorithms: ["gzip", "deflate"],
+        level: 6,
+        threshold: 1024,
+        contentTypes: ["text/*", "application/json"],
+    }) {
+        super(config);
+        this.id = "xypriss.network.compression";
+        this.name = "Response Compression Plugin";
+        this.version = "1.0.0";
+        this.networkCategory = NetworkCategory.COMPRESSION;
+        // Compression-specific state
+        this.compressionStats = {
+            totalRequests: 0,
+            compressedRequests: 0,
+            totalBytesOriginal: 0,
+            totalBytesCompressed: 0,
+            averageCompressionRatio: 0,
+            algorithmUsage: new Map(),
+        };
+        this.supportedAlgorithms = [];
+        this.initializeSupportedAlgorithms();
+        this.createCompressionMiddleware();
+    }
+    /**
+     * Initialize compression algorithms based on availability
+     */
+    initializeSupportedAlgorithms() {
+        const config = this.getCompressionConfig();
+        const requestedAlgorithms = config.algorithms || ["gzip", "deflate"];
+        // Check which algorithms are available
+        for (const algorithm of requestedAlgorithms) {
+            if (this.isAlgorithmSupported(algorithm)) {
+                this.supportedAlgorithms.push(algorithm);
+                this.compressionStats.algorithmUsage.set(algorithm, 0);
+            }
+        }
+        // Ensure at least gzip is available as fallback
+        if (this.supportedAlgorithms.length === 0) {
+            this.supportedAlgorithms.push("gzip");
+            this.compressionStats.algorithmUsage.set("gzip", 0);
+        }
+    }
+    /**
+     * Create compression middleware using the compression library
+     */
+    createCompressionMiddleware() {
+        const config = this.getCompressionConfig();
+        this.compressionMiddleware = compression({
+            level: config.level || 6,
+            threshold: config.threshold || 1024,
+            filter: (req, res) => {
+                // Use our custom filter logic
+                return this.shouldCompress(req, res);
+            },
+        });
+    }
+    /**
+     * Check if compression algorithm is supported
+     */
+    isAlgorithmSupported(algorithm) {
+        switch (algorithm) {
+            case "gzip":
+            case "deflate":
+                return true; // Always available in Node.js
+            case "brotli":
+                return typeof zlib.createBrotliCompress === "function";
+            default:
+                return false;
+        }
+    }
+    /**
+     * Execute compression logic
+     */
+    async executeNetwork(context) {
+        const startTime = performance.now();
+        const { req, res } = context;
+        try {
+            // Apply compression using the middleware
+            await new Promise((resolve, reject) => {
+                this.compressionMiddleware(req, res, (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+            // Update statistics
+            this.compressionStats.totalRequests++;
+            const wasCompressed = !!res.getHeader("content-encoding");
+            if (wasCompressed) {
+                this.compressionStats.compressedRequests++;
+                const algorithm = res.getHeader("content-encoding");
+                const currentUsage = this.compressionStats.algorithmUsage.get(algorithm) || 0;
+                this.compressionStats.algorithmUsage.set(algorithm, currentUsage + 1);
+            }
+            const executionTime = performance.now() - startTime;
+            return {
+                success: true,
+                executionTime,
+                shouldContinue: true,
+                data: {
+                    compressed: wasCompressed,
+                    algorithm: res.getHeader("content-encoding") || "none",
+                    originalSize: context.networkMetrics.bytesReceived,
+                    compressedSize: context.networkMetrics.bytesSent,
+                },
+                modifications: wasCompressed
+                    ? {
+                        headers: {
+                            "Content-Encoding": res.getHeader("content-encoding"),
+                            Vary: "Accept-Encoding",
+                        },
+                        compressed: true,
+                    }
+                    : undefined,
+                networkMetrics: {
+                    processingTime: executionTime,
+                    memoryUsage: process.memoryUsage().heapUsed,
+                    cpuUsage: process.cpuUsage().user,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                executionTime: performance.now() - startTime,
+                shouldContinue: true,
+                error,
+            };
+        }
+    }
+    /**
+     * Check if response should be compressed
+     */
+    shouldCompress(req, res) {
+        const config = this.getCompressionConfig();
+        // Check if compression is enabled
+        if (!config.enabled) {
+            return false;
+        }
+        // Check if client accepts compression
+        const acceptEncoding = req.get("Accept-Encoding") || "";
+        if (!this.clientSupportsCompression(acceptEncoding)) {
+            return false;
+        }
+        // Check content type
+        const contentType = res.get("Content-Type") || "";
+        if (!this.shouldCompressContentType(contentType)) {
+            return false;
+        }
+        // Check if already compressed
+        if (res.get("Content-Encoding")) {
+            return false;
+        }
+        // Check content length threshold
+        const contentLength = parseInt(res.get("Content-Length") || "0");
+        if (contentLength > 0 && contentLength < (config.threshold || 1024)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if client supports compression
+     */
+    clientSupportsCompression(acceptEncoding) {
+        return this.supportedAlgorithms.some((algorithm) => acceptEncoding.toLowerCase().includes(algorithm));
+    }
+    /**
+     * Check if content type should be compressed
+     */
+    shouldCompressContentType(contentType) {
+        const config = this.getCompressionConfig();
+        const contentTypes = config.contentTypes || [
+            "text/*",
+            "application/json",
+            "application/javascript",
+            "application/xml",
+            "application/rss+xml",
+            "application/atom+xml",
+        ];
+        // Check exclude list first
+        if (config.excludeContentTypes) {
+            for (const excludeType of config.excludeContentTypes) {
+                if (this.matchesContentType(contentType, excludeType)) {
+                    return false;
+                }
+            }
+        }
+        // Check include list
+        return contentTypes.some((type) => this.matchesContentType(contentType, type));
+    }
+    /**
+     * Match content type with pattern (supports wildcards)
+     */
+    matchesContentType(contentType, pattern) {
+        if (pattern.includes("*")) {
+            const regex = new RegExp(pattern.replace("*", ".*"), "i");
+            return regex.test(contentType);
+        }
+        return contentType.toLowerCase().includes(pattern.toLowerCase());
+    }
+    /**
+     * Select best compression algorithm based on client support and preferences
+     */
+    selectCompressionAlgorithm(req) {
+        const acceptEncoding = req.get("Accept-Encoding") || "";
+        const encodings = acceptEncoding.toLowerCase();
+        // Priority order: brotli > gzip > deflate
+        const priorityOrder = [
+            "brotli",
+            "gzip",
+            "deflate",
+        ];
+        for (const algorithm of priorityOrder) {
+            if (this.supportedAlgorithms.includes(algorithm) &&
+                encodings.includes(algorithm)) {
+                return algorithm;
+            }
+        }
+        return null;
+    }
+    /**
+     * Apply compression to response
+     */
+    async applyCompression(context, algorithm) {
+        const { res } = context;
+        const config = this.getCompressionConfig();
+        // Set compression headers
+        res.setHeader("Content-Encoding", algorithm);
+        res.setHeader("Vary", "Accept-Encoding");
+        // Remove content-length header as it will change
+        res.removeHeader("Content-Length");
+        // Create compression stream
+        const compressionStream = this.createCompressionStream(algorithm, config.level || 6);
+        // Intercept response write/end methods
+        this.interceptResponse(res, compressionStream, context);
+    }
+    /**
+     * Create compression stream for algorithm
+     */
+    createCompressionStream(algorithm, level) {
+        switch (algorithm) {
+            case "gzip":
+                return zlib.createGzip({ level });
+            case "deflate":
+                return zlib.createDeflate({ level });
+            case "brotli":
+                return zlib.createBrotliCompress({
+                    params: {
+                        [zlib.constants.BROTLI_PARAM_QUALITY]: level,
+                    },
+                });
+            default:
+                throw new Error(`Unsupported compression algorithm: ${algorithm}`);
+        }
+    }
+    /**
+     * Intercept response to apply compression
+     */
+    interceptResponse(res, compressionStream, context) {
+        res.write.bind(res);
+        res.end.bind(res);
+        let originalSize = 0;
+        let compressedSize = 0;
+        // Track compressed data
+        compressionStream.on("data", (chunk) => {
+            compressedSize += chunk.length;
+        });
+        // Override write method
+        res.write = function (chunk, encoding, callback) {
+            if (chunk) {
+                originalSize += Buffer.isBuffer(chunk)
+                    ? chunk.length
+                    : Buffer.byteLength(chunk, encoding);
+                return compressionStream.write(chunk, encoding, callback);
+            }
+            return true;
+        };
+        // Override end method
+        res.end = function (chunk, encoding, callback) {
+            if (chunk) {
+                originalSize += Buffer.isBuffer(chunk)
+                    ? chunk.length
+                    : Buffer.byteLength(chunk, encoding);
+            }
+            compressionStream.end(chunk, encoding, () => {
+                // Update metrics
+                context.networkMetrics.bytesSent = compressedSize;
+                context.networkMetrics.compressionRatio =
+                    originalSize > 0 ? compressedSize / originalSize : 1;
+                if (callback)
+                    callback();
+            });
+            return this;
+        };
+        // Pipe compression stream to response
+        compressionStream.pipe(res, { end: false });
+    }
+    /**
+     * Update compression statistics
+     */
+    updateCompressionStats(algorithm) {
+        this.compressionStats.totalRequests++;
+        this.compressionStats.compressedRequests++;
+        const currentUsage = this.compressionStats.algorithmUsage.get(algorithm) || 0;
+        this.compressionStats.algorithmUsage.set(algorithm, currentUsage + 1);
+    }
+    /**
+     * Get compression configuration
+     */
+    getCompressionConfig() {
+        return this.config;
+    }
+    /**
+     * Validate compression configuration
+     */
+    validateNetworkConfig(config) {
+        if (config.level && (config.level < 1 || config.level > 9)) {
+            return false;
+        }
+        if (config.threshold && config.threshold < 0) {
+            return false;
+        }
+        if (config.algorithms && config.algorithms.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check network health
+     */
+    async checkNetworkHealth() {
+        const errorRate = this.performanceMetrics.errorCount /
+            Math.max(this.performanceMetrics.totalExecutions, 1);
+        this.compressionStats.compressedRequests /
+            Math.max(this.compressionStats.totalRequests, 1);
+        return {
+            healthy: errorRate < 0.1 &&
+                this.performanceMetrics.averageExecutionTime <
+                    this.maxExecutionTime,
+            status: errorRate < 0.05
+                ? "healthy"
+                : errorRate < 0.1
+                    ? "degraded"
+                    : "unhealthy",
+            metrics: {
+                responseTime: this.performanceMetrics.averageExecutionTime,
+                errorRate,
+                throughput: this.performanceMetrics.totalExecutions,
+                connections: 0, // Not applicable for compression
+            },
+            lastCheck: new Date(),
+        };
+    }
+    /**
+     * Get compression statistics
+     */
+    getCompressionStats() {
+        return {
+            ...this.compressionStats,
+            supportedAlgorithms: [...this.supportedAlgorithms],
+            averageCompressionRatio: this.compressionStats.totalBytesOriginal > 0
+                ? this.compressionStats.totalBytesCompressed /
+                    this.compressionStats.totalBytesOriginal
+                : 0,
+        };
+    }
+}
+
+export { CompressionPlugin };
+//# sourceMappingURL=CompressionPlugin.js.map