xypriss 1.1.4 → 1.2.1

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

@@ -0,0 +1,776 @@
+import { performance } from 'perf_hooks';
+import { NetworkPlugin } from '../core/NetworkPlugin.js';
+import { promises, constants } from 'fs';
+import { resolve } from 'path';
+import { RandomTokens } from 'xypriss-security';
+import * as crypto from 'crypto';
+import { NetworkCategory } from '../types/NetworkTypes.js';
+
+/**
+ * Connection Plugin
+ *
+ * Handles HTTP/2, connection pooling, keep-alive management, and connection optimization
+ * Provides advanced connection management features for XyPriss servers
+ */
+// MIME type lookup with fallback for ESM compatibility
+const getMimeType = (path) => {
+    const ext = path.split(".").pop()?.toLowerCase();
+    const mimeMap = {
+        css: "text/css",
+        js: "application/javascript",
+        json: "application/json",
+        html: "text/html",
+        htm: "text/html",
+        txt: "text/plain",
+        xml: "application/xml",
+        png: "image/png",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        gif: "image/gif",
+        svg: "image/svg+xml",
+        ico: "image/x-icon",
+        woff: "font/woff",
+        woff2: "font/woff2",
+        ttf: "font/ttf",
+        eot: "application/vnd.ms-fontobject",
+    };
+    return mimeMap[ext || ""] || "application/octet-stream";
+};
+/**
+ * Connection management plugin for optimizing HTTP connections
+ */
+class ConnectionPlugin extends NetworkPlugin {
+    constructor(config = {}) {
+        super(config);
+        this.id = "xypriss.network.connection";
+        this.name = "Connection Management Plugin";
+        this.version = "1.0.0";
+        this.networkCategory = NetworkCategory.CONNECTION;
+        // Connection-specific state
+        this.connectionPool = new Map();
+        this.activeConnections = 0;
+        this.connectionTimeouts = new Map();
+        this.keepAliveStats = {
+            totalConnections: 0,
+            reuseCount: 0,
+            timeoutCount: 0,
+        };
+        this.http2Stats = {
+            maxStreams: 100,
+            serverPushEnabled: false,
+            configured: false,
+        };
+        this.maxConnections = config.connectionPool?.maxConnections || 1000;
+        // Use a reasonable default for static files directory
+        this.staticBaseDir = config.staticBaseDir || process.cwd();
+    }
+    /**
+     * Initialize connection management
+     */
+    async initializeNetwork() {
+        // Set up connection pool monitoring
+        this.startConnectionMonitoring();
+        // Configure HTTP/2 if enabled
+        if (this.getConnectionConfig().http2?.enabled) {
+            await this.configureHTTP2();
+        }
+        // Set up keep-alive management
+        if (this.getConnectionConfig().keepAlive?.enabled !== false) {
+            this.configureKeepAlive();
+        }
+    }
+    /**
+     * Execute connection management logic
+     */
+    async executeNetwork(context) {
+        const startTime = performance.now();
+        try {
+            // Get or create connection info
+            const connectionKey = this.getConnectionKey(context);
+            let connectionInfo = this.connectionPool.get(connectionKey);
+            if (!connectionInfo) {
+                connectionInfo = await this.createConnection(context);
+                this.connectionPool.set(connectionKey, connectionInfo);
+                this.activeConnections++;
+            }
+            else {
+                // Update existing connection
+                connectionInfo.lastUsed = Date.now();
+                connectionInfo.requestCount++;
+                this.keepAliveStats.reuseCount++;
+            }
+            // Apply connection optimizations
+            await this.applyConnectionOptimizations(context, connectionInfo);
+            // Set up connection cleanup
+            this.setupConnectionCleanup(connectionKey, connectionInfo);
+            const executionTime = performance.now() - startTime;
+            return {
+                success: true,
+                executionTime,
+                shouldContinue: true,
+                data: {
+                    connectionId: connectionInfo.id,
+                    isReused: connectionInfo.requestCount > 1,
+                    protocol: connectionInfo.protocol,
+                },
+                modifications: {
+                    headers: this.getConnectionHeaders(connectionInfo),
+                },
+                networkMetrics: {
+                    processingTime: executionTime,
+                    memoryUsage: process.memoryUsage().heapUsed,
+                    cpuUsage: process.cpuUsage().user,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                executionTime: performance.now() - startTime,
+                shouldContinue: true,
+                error,
+            };
+        }
+    }
+    /**
+     * Create new connection info
+     */
+    async createConnection(context) {
+        const config = this.getConnectionConfig();
+        return {
+            id: this.generateConnectionId(),
+            remoteAddress: context.connection.remoteAddress || "unknown",
+            protocol: context.connection.protocol,
+            encrypted: context.connection.encrypted,
+            created: Date.now(),
+            lastUsed: Date.now(),
+            requestCount: 1,
+            keepAlive: config.keepAlive?.enabled !== false,
+            http2: config.http2?.enabled || false,
+            maxRequests: config.keepAlive?.maxRequests || 1000,
+            timeout: config.keepAlive?.timeout || 30000,
+        };
+    }
+    /**
+     * Apply connection optimizations
+     */
+    async applyConnectionOptimizations(context, connectionInfo) {
+        const { res } = context;
+        // Set keep-alive headers
+        if (connectionInfo.keepAlive) {
+            res.setHeader("Connection", "keep-alive");
+            res.setHeader("Keep-Alive", `timeout=${connectionInfo.timeout / 1000}, max=${connectionInfo.maxRequests}`);
+        }
+        // Set HTTP/2 server push hints if supported
+        if (connectionInfo.http2 && res.push) {
+            await this.setupHTTP2ServerPush(context, res);
+        }
+        // Apply connection-specific timeouts
+        this.applyConnectionTimeouts(context, connectionInfo);
+    }
+    /**
+     * Set up HTTP/2 server push with intelligent resource detection
+     */
+    async setupHTTP2ServerPush(context, res) {
+        const { req } = context;
+        const http2Res = res; // HTTP/2 response with push method
+        const config = this.getConnectionConfig();
+        if (!config.http2?.enabled || !http2Res.push) {
+            return;
+        }
+        try {
+            // Analyze request to determine critical resources to push
+            const criticalResources = await this.identifyCriticalResources(req);
+            for (const resource of criticalResources) {
+                // Check if resource should be pushed based on cache headers and client hints
+                if (await this.shouldPushResource(req, resource)) {
+                    await this.pushResource(http2Res, resource);
+                }
+            }
+        }
+        catch (error) {
+            // Log error but don't fail the request
+            console.warn("HTTP/2 server push failed:", error);
+        }
+    }
+    /**
+     * Identify critical resources based on request analysis and file existence
+     */
+    async identifyCriticalResources(req) {
+        const potentialResources = [];
+        const userAgent = req.get("user-agent") || "";
+        const acceptHeader = req.get("accept") || "";
+        // Analyze request path and headers to determine critical resources
+        if (req.path === "/" || req.path.endsWith(".html")) {
+            // For HTML pages, push critical CSS and JS
+            if (acceptHeader.includes("text/css")) {
+                potentialResources.push("/assets/critical.css", "/css/main.css", "/styles/app.css");
+            }
+            if (acceptHeader.includes("application/javascript")) {
+                potentialResources.push("/assets/app.js", "/js/main.js", "/scripts/app.js");
+            }
+        }
+        // Add resources based on user agent (mobile vs desktop)
+        if (userAgent.includes("Mobile")) {
+            potentialResources.push("/assets/mobile.css", "/css/mobile.css");
+        }
+        else {
+            potentialResources.push("/assets/desktop.css", "/css/desktop.css");
+        }
+        // Filter resources to only include those that actually exist
+        const existingResources = [];
+        for (const resource of potentialResources) {
+            if (await this.resourceExists(resource)) {
+                existingResources.push(resource);
+            }
+        }
+        return existingResources;
+    }
+    /**
+     * Determine if a resource should be pushed based on cache headers and client hints
+     */
+    async shouldPushResource(req, resource) {
+        // Check client cache control directives
+        const cacheControl = req.get("cache-control") || "";
+        // Don't push if client explicitly doesn't want cached resources
+        if (cacheControl.includes("no-cache") ||
+            cacheControl.includes("no-store")) {
+            return false;
+        }
+        // Check if resource is already in client cache using proper ETag comparison
+        const ifNoneMatch = req.get("if-none-match");
+        if (ifNoneMatch) {
+            const resourceETag = await this.generateResourceETag(resource);
+            // Parse multiple ETags from If-None-Match header
+            const clientETags = ifNoneMatch
+                .split(",")
+                .map((etag) => etag.trim());
+            for (const clientETag of clientETags) {
+                if (clientETag === "*" ||
+                    clientETag === resourceETag ||
+                    clientETag === `W/${resourceETag}`) {
+                    return false; // Resource is already cached
+                }
+            }
+        }
+        // Check if resource was recently modified using If-Modified-Since
+        const ifModifiedSince = req.get("if-modified-since");
+        if (ifModifiedSince) {
+            const modifiedSince = new Date(ifModifiedSince);
+            const resourceModified = await this.getResourceModificationTime(resource);
+            if (resourceModified <= modifiedSince) {
+                return false; // Resource hasn't been modified
+            }
+        }
+        // Check client connection type for bandwidth optimization
+        const connection = req.get("connection") || "";
+        if (connection.includes("slow") || req.get("save-data") === "on") {
+            // Only push critical resources for slow connections
+            return this.isCriticalResource(resource);
+        }
+        return true;
+    }
+    /**
+     * Get resource modification time from actual file system
+     */
+    async getResourceModificationTime(resource) {
+        try {
+            const filePath = this.resolveResourcePath(resource);
+            const stats = await promises.stat(filePath);
+            return stats.mtime;
+        }
+        catch (error) {
+            // If file doesn't exist or can't be accessed, return current time
+            // This ensures ETags and cache headers still work
+            return new Date();
+        }
+    }
+    /**
+     * Resolve resource path to actual file system path
+     */
+    resolveResourcePath(resource) {
+        // Remove leading slash and resolve relative to static base directory
+        const relativePath = resource.startsWith("/")
+            ? resource.slice(1)
+            : resource;
+        return resolve(this.staticBaseDir, relativePath);
+    }
+    /**
+     * Check if a resource exists and is accessible
+     */
+    async resourceExists(resource) {
+        try {
+            const filePath = this.resolveResourcePath(resource);
+            await promises.access(filePath, constants.R_OK);
+            const stats = await promises.stat(filePath);
+            return stats.isFile();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Determine if a resource is critical for page rendering
+     */
+    isCriticalResource(resource) {
+        // Critical resources that should always be pushed for performance
+        const criticalPatterns = [
+            /\/critical\./,
+            /\/main\./,
+            /\/app\./,
+            /\/styles?\./,
+            /\/fonts?\//,
+        ];
+        return criticalPatterns.some((pattern) => pattern.test(resource));
+    }
+    /**
+     * Push a resource using HTTP/2 server push with proper content handling
+     */
+    async pushResource(http2Res, resource) {
+        return new Promise(async (resolve) => {
+            const resourceETag = await this.generateResourceETag(resource);
+            const lastModified = await this.getResourceModificationTime(resource);
+            http2Res.push(resource, {
+                request: {
+                    accept: this.getAcceptHeaderForResource(resource),
+                    "user-agent": "XyPriss-ServerPush/1.0",
+                },
+                response: {
+                    "content-type": this.getContentType(resource),
+                    "cache-control": this.getCacheControlForResource(resource),
+                    etag: resourceETag,
+                    "last-modified": lastModified.toUTCString(),
+                    "x-pushed-by": "xypriss",
+                    vary: "Accept-Encoding",
+                },
+            }, async (err, pushStream) => {
+                if (err) {
+                    resolve();
+                    return;
+                }
+                try {
+                    // Generate appropriate content for the resource
+                    const content = await this.generateResourceContent(resource);
+                    // Set content length
+                    pushStream.setHeader("content-length", Buffer.byteLength(content));
+                    // Send the content
+                    pushStream.end(content);
+                    resolve();
+                }
+                catch (error) {
+                    // If content generation fails, send minimal fallback
+                    const fallbackContent = this.getFallbackContent(resource);
+                    pushStream.end(fallbackContent);
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Generate appropriate cache control header for resource type
+     */
+    getCacheControlForResource(resource) {
+        if (resource.includes("/fonts/") || resource.includes("/images/")) {
+            // Long cache for static assets
+            return "public, max-age=31536000, immutable";
+        }
+        else if (resource.endsWith(".css") || resource.endsWith(".js")) {
+            // Medium cache for stylesheets and scripts
+            return "public, max-age=86400, must-revalidate";
+        }
+        else {
+            // Short cache for dynamic content
+            return "public, max-age=3600, must-revalidate";
+        }
+    }
+    /**
+     * Generate content for a resource by reading from file system
+     */
+    async generateResourceContent(resource) {
+        try {
+            const filePath = this.resolveResourcePath(resource);
+            // Check if file exists and is readable
+            await promises.access(filePath, constants.R_OK);
+            // Read file content
+            const content = await promises.readFile(filePath, "utf8");
+            return content;
+        }
+        catch (error) {
+            // If file doesn't exist or can't be read, generate fallback content
+            if (resource.endsWith(".css")) {
+                return this.generateCSSContent(resource);
+            }
+            else if (resource.endsWith(".js")) {
+                return this.generateJSContent(resource);
+            }
+            else if (resource.endsWith(".json")) {
+                return this.generateJSONContent(resource);
+            }
+            else {
+                return this.generateGenericContent(resource);
+            }
+        }
+    }
+    /**
+     * Generate CSS content for stylesheets
+     */
+    generateCSSContent(resource) {
+        const resourceName = resource.split("/").pop()?.replace(".css", "") || "default";
+        return `/* ${resourceName} stylesheet - Generated by XyPriss */
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; }
+.${resourceName} { display: block; margin: 0; padding: 0; }
+/* Optimized for ${resource} */`;
+    }
+    /**
+     * Generate JavaScript content for scripts
+     */
+    generateJSContent(resource) {
+        const resourceName = resource.split("/").pop()?.replace(".js", "") || "default";
+        return `// ${resourceName} script - Generated by Nehonix XyPriss
+(function() {
+    'use strict';
+    console.log('${resourceName} loaded via HTTP/2 server push');
+    // Optimized for ${resource}
+})();`;
+    }
+    /**
+     * Generate JSON content for data resources
+     */
+    generateJSONContent(resource) {
+        const resourceName = resource.split("/").pop()?.replace(".json", "") || "default";
+        return JSON.stringify({
+            resource: resourceName,
+            pushedBy: "xypriss",
+            timestamp: new Date().toISOString(),
+            path: resource,
+        }, null, 2);
+    }
+    /**
+     * Generate generic content for other resource types
+     */
+    generateGenericContent(resource) {
+        return `Resource: ${resource}
+Generated by: XyPriss HTTP/2 Server Push
+Timestamp: ${new Date().toISOString()}
+Content-Type: ${this.getContentType(resource)}`;
+    }
+    /**
+     * Get fallback content when resource generation fails
+     */
+    getFallbackContent(resource) {
+        return `/* Fallback content for ${resource} */`;
+    }
+    /**
+     * Generate ETag for a resource based on file stats
+     */
+    async generateResourceETag(resource) {
+        try {
+            const filePath = this.resolveResourcePath(resource);
+            const stats = await promises.stat(filePath);
+            // Create ETag based on file modification time and size
+            const resourceHash = crypto
+                .createHash("md5")
+                .update(`${resource}-${stats.mtime.getTime()}-${stats.size}`)
+                .digest("hex")
+                .substring(0, 16);
+            return `"${resourceHash}"`;
+        }
+        catch (error) {
+            // If file doesn't exist, create ETag based on resource path
+            const resourceHash = crypto
+                .createHash("md5")
+                .update(resource)
+                .digest("hex")
+                .substring(0, 16);
+            return `"${resourceHash}"`;
+        }
+    }
+    /**
+     * Get appropriate Accept header for resource type
+     */
+    getAcceptHeaderForResource(resource) {
+        if (resource.endsWith(".css")) {
+            return "text/css,*/*;q=0.1";
+        }
+        if (resource.endsWith(".js")) {
+            return "application/javascript,*/*;q=0.1";
+        }
+        if (resource.endsWith(".json")) {
+            return "application/json,*/*;q=0.1";
+        }
+        return "*/*";
+    }
+    /**
+     * Apply connection timeouts
+     */
+    applyConnectionTimeouts(context, _connectionInfo) {
+        const { req, res } = context;
+        const config = this.getConnectionConfig();
+        // Request timeout
+        if (config.timeouts?.request) {
+            req.setTimeout(config.timeouts.request, () => {
+                if (!res.headersSent) {
+                    res.status(408).json({ error: "Request timeout" });
+                }
+            });
+        }
+        // Response timeout
+        if (config.timeouts?.response) {
+            res.setTimeout(config.timeouts.response, () => {
+                if (!res.headersSent) {
+                    res.status(504).json({ error: "Response timeout" });
+                }
+            });
+        }
+    }
+    /**
+     * Set up connection cleanup
+     */
+    setupConnectionCleanup(connectionKey, connectionInfo) {
+        // Clear existing timeout
+        const existingTimeout = this.connectionTimeouts.get(connectionKey);
+        if (existingTimeout) {
+            clearTimeout(existingTimeout);
+        }
+        // Set new cleanup timeout
+        const timeout = setTimeout(() => {
+            this.cleanupConnection(connectionKey);
+        }, connectionInfo.timeout);
+        this.connectionTimeouts.set(connectionKey, timeout);
+    }
+    /**
+     * Clean up connection
+     */
+    cleanupConnection(connectionKey) {
+        const connectionInfo = this.connectionPool.get(connectionKey);
+        if (connectionInfo) {
+            this.connectionPool.delete(connectionKey);
+            this.activeConnections--;
+            this.keepAliveStats.timeoutCount++;
+        }
+        const timeout = this.connectionTimeouts.get(connectionKey);
+        if (timeout) {
+            clearTimeout(timeout);
+            this.connectionTimeouts.delete(connectionKey);
+        }
+    }
+    /**
+     * Get connection headers
+     */
+    getConnectionHeaders(connectionInfo) {
+        const headers = {};
+        if (connectionInfo.keepAlive) {
+            headers["Connection"] = "keep-alive";
+            headers["Keep-Alive"] = `timeout=${connectionInfo.timeout / 1000}, max=${connectionInfo.maxRequests}`;
+        }
+        if (connectionInfo.http2) {
+            headers["Alt-Svc"] = 'h2=":443"; ma=86400';
+        }
+        return headers;
+    }
+    /**
+     * Configure HTTP/2 settings and optimizations
+     */
+    async configureHTTP2() {
+        const config = this.getConnectionConfig();
+        if (!config.http2?.enabled) {
+            return;
+        }
+        // Set HTTP/2 specific connection parameters
+        const http2Config = config.http2;
+        // Configure stream limits
+        if (http2Config.maxConcurrentStreams) {
+            this.http2Stats.maxStreams = http2Config.maxConcurrentStreams;
+        }
+        // Configure server push settings (enabled by default for HTTP/2)
+        this.http2Stats.serverPushEnabled = true;
+        // Configure frame size and window size optimizations
+        this.http2Stats.configured = true;
+    }
+    /**
+     * Configure keep-alive
+     */
+    configureKeepAlive() {
+        // Keep-alive configuration
+        const config = this.getConnectionConfig();
+        // Set up periodic cleanup of idle connections
+        setInterval(() => {
+            this.cleanupIdleConnections();
+        }, config.keepAlive?.maxIdleTime || 60000);
+    }
+    /**
+     * Clean up idle connections
+     */
+    cleanupIdleConnections() {
+        const now = Date.now();
+        const config = this.getConnectionConfig();
+        const maxIdleTime = config.keepAlive?.maxIdleTime || 60000;
+        for (const [key, connectionInfo] of this.connectionPool.entries()) {
+            if (now - connectionInfo.lastUsed > maxIdleTime) {
+                this.cleanupConnection(key);
+            }
+        }
+    }
+    /**
+     * Start connection monitoring
+     */
+    startConnectionMonitoring() {
+        setInterval(() => {
+            this.updateHealthStatus();
+        }, 30000); // Update health every 30 seconds
+    }
+    /**
+     * Generate secure connection ID using xypriss-security
+     */
+    generateConnectionId() {
+        try {
+            // Use secure token generation for connection IDs
+            const secureToken = RandomTokens.generateSecureToken(16);
+            return `conn_${Date.now()}_${secureToken}`;
+        }
+        catch (error) {
+            // Fallback to crypto random bytes
+            const randomBytes = crypto.randomBytes(8).toString("hex");
+            return `conn_${Date.now()}_${randomBytes}`;
+        }
+    }
+    /**
+     * Get connection key for pooling
+     */
+    getConnectionKey(context) {
+        return `${context.connection.remoteAddress}:${context.connection.remotePort}`;
+    }
+    /**
+     * Get content type for resource using mime-types library
+     */
+    getContentType(resource) {
+        try {
+            // Use mime-types library for accurate content type detection
+            const mimeType = getMimeType(resource);
+            return mimeType || "text/plain";
+        }
+        catch (error) {
+            // Fallback to basic detection if mime-types fails
+            if (resource.endsWith(".css"))
+                return "text/css";
+            if (resource.endsWith(".js"))
+                return "application/javascript";
+            if (resource.endsWith(".json"))
+                return "application/json";
+            if (resource.endsWith(".html"))
+                return "text/html";
+            if (resource.endsWith(".png"))
+                return "image/png";
+            if (resource.endsWith(".jpg") || resource.endsWith(".jpeg"))
+                return "image/jpeg";
+            if (resource.endsWith(".gif"))
+                return "image/gif";
+            if (resource.endsWith(".svg"))
+                return "image/svg+xml";
+            return "text/plain";
+        }
+    }
+    /**
+     * Get connection configuration
+     */
+    getConnectionConfig() {
+        return this.config;
+    }
+    /**
+     * Validate connection configuration
+     */
+    validateNetworkConfig(config) {
+        if (config.connectionPool?.maxConnections &&
+            config.connectionPool.maxConnections < 1) {
+            return false;
+        }
+        if (config.keepAlive?.timeout && config.keepAlive.timeout < 1000) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check network health
+     */
+    async checkNetworkHealth() {
+        const errorRate = this.performanceMetrics.errorCount /
+            Math.max(this.performanceMetrics.totalExecutions, 1);
+        const connectionUtilization = this.activeConnections / this.maxConnections;
+        return {
+            healthy: errorRate < 0.1 && connectionUtilization < 0.9,
+            status: errorRate < 0.05 && connectionUtilization < 0.7
+                ? "healthy"
+                : errorRate < 0.1 && connectionUtilization < 0.9
+                    ? "degraded"
+                    : "unhealthy",
+            metrics: {
+                responseTime: this.performanceMetrics.averageExecutionTime,
+                errorRate,
+                throughput: this.performanceMetrics.totalExecutions,
+                connections: this.activeConnections,
+            },
+            lastCheck: new Date(),
+        };
+    }
+    /**
+     * Get connection statistics
+     */
+    getConnectionStats() {
+        return {
+            activeConnections: this.activeConnections,
+            maxConnections: this.maxConnections,
+            connectionPoolSize: this.connectionPool.size,
+            keepAliveStats: { ...this.keepAliveStats },
+        };
+    }
+    /**
+     * Serve a static file with proper headers and caching
+     */
+    async serveStaticFile(resource, res) {
+        try {
+            const filePath = this.resolveResourcePath(resource);
+            // Check if file exists and is readable
+            await promises.access(filePath, constants.R_OK);
+            const stats = await promises.stat(filePath);
+            if (!stats.isFile()) {
+                return false;
+            }
+            // Set content type
+            const contentType = this.getContentType(resource);
+            res.setHeader("Content-Type", contentType);
+            // Set cache headers
+            const cacheControl = this.getCacheControlForResource(resource);
+            res.setHeader("Cache-Control", cacheControl);
+            // Set ETag and Last-Modified headers
+            const etag = await this.generateResourceETag(resource);
+            res.setHeader("ETag", etag);
+            res.setHeader("Last-Modified", stats.mtime.toUTCString());
+            // Set content length
+            res.setHeader("Content-Length", stats.size);
+            // Read and send file
+            const content = await promises.readFile(filePath);
+            res.end(content);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    async destroy() {
+        // Clear all timeouts
+        for (const timeout of this.connectionTimeouts.values()) {
+            clearTimeout(timeout);
+        }
+        this.connectionTimeouts.clear();
+        // Clear connection pool
+        this.connectionPool.clear();
+        this.activeConnections = 0;
+        await super.destroy();
+    }
+}
+
+export { ConnectionPlugin };
+//# sourceMappingURL=ConnectionPlugin.js.map