noormme 1.0.0 → 1.0.2

package/dist/cjs/performance/services/connection-factory.js

@@ -0,0 +1,498 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionPoolManager = exports.ConnectionFactory = void 0;
+exports.createConnectionPool = createConnectionPool;
+const noormme_1 = require("../../noormme");
+const logger_js_1 = require("../../logging/logger.js");
+/**
+ * Factory for creating and managing database connections
+ */
+class ConnectionFactory {
+    connections = new Map();
+    stats;
+    logger;
+    constructor(logger) {
+        this.logger = logger || new logger_js_1.Logger('ConnectionFactory');
+        this.stats = {
+            totalCreated: 0,
+            totalDestroyed: 0,
+            activeConnections: 0,
+            failedCreations: 0,
+            averageCreationTime: 0,
+            averageValidationTime: 0
+        };
+    }
+    /**
+     * Create a new database connection
+     */
+    async createConnection(config) {
+        const startTime = performance.now();
+        const id = config.id || this.generateConnectionId();
+        try {
+            this.logger.debug(`Creating connection ${id}`);
+            const db = new noormme_1.NOORMME(config);
+            await db.initialize();
+            const connection = {
+                id,
+                db,
+                createdAt: new Date(),
+                lastUsed: new Date(),
+                isActive: true,
+                inUse: false,
+                config
+            };
+            this.connections.set(id, connection);
+            this.updateStats('created', performance.now() - startTime);
+            this.logger.debug(`Created connection ${id} successfully`);
+            return connection;
+        }
+        catch (error) {
+            this.updateStats('failed', performance.now() - startTime);
+            this.logger.error(`Failed to create connection ${id}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Validate a connection
+     */
+    async validateConnection(connection) {
+        const startTime = performance.now();
+        try {
+            await connection.db.execute('SELECT 1');
+            const responseTime = performance.now() - startTime;
+            this.updateStats('validated', responseTime);
+            return {
+                isValid: true,
+                responseTime
+            };
+        }
+        catch (error) {
+            const responseTime = performance.now() - startTime;
+            this.updateStats('validated', responseTime);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                isValid: false,
+                error: errorMessage,
+                responseTime
+            };
+        }
+    }
+    /**
+     * Get connection by ID
+     */
+    getConnection(id) {
+        return this.connections.get(id) || null;
+    }
+    /**
+     * Get all connections
+     */
+    getAllConnections() {
+        return Array.from(this.connections.values());
+    }
+    /**
+     * Get active connections
+     */
+    getActiveConnections() {
+        return Array.from(this.connections.values()).filter(conn => conn.isActive);
+    }
+    /**
+     * Get idle connections
+     */
+    getIdleConnections() {
+        return Array.from(this.connections.values()).filter(conn => conn.isActive && !conn.inUse);
+    }
+    /**
+     * Mark connection as in use
+     */
+    markInUse(connection) {
+        connection.inUse = true;
+        connection.lastUsed = new Date();
+    }
+    /**
+     * Mark connection as idle
+     */
+    markIdle(connection) {
+        connection.inUse = false;
+        connection.lastUsed = new Date();
+    }
+    /**
+     * Destroy a connection
+     */
+    async destroyConnection(id) {
+        const connection = this.connections.get(id);
+        if (!connection) {
+            return false;
+        }
+        try {
+            await connection.db.destroy();
+            connection.isActive = false;
+            this.connections.delete(id);
+            this.updateStats('destroyed', 0);
+            this.logger.debug(`Destroyed connection ${id}`);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Failed to destroy connection ${id}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Destroy all connections
+     */
+    async destroyAllConnections() {
+        const destroyPromises = Array.from(this.connections.keys()).map(id => this.destroyConnection(id));
+        await Promise.all(destroyPromises);
+        this.logger.info('Destroyed all connections');
+    }
+    /**
+     * Cleanup inactive connections
+     */
+    async cleanupInactiveConnections(maxAge = 300000) {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [id, connection] of this.connections.entries()) {
+            if (!connection.inUse &&
+                now - connection.lastUsed.getTime() > maxAge) {
+                if (await this.destroyConnection(id)) {
+                    cleaned++;
+                }
+            }
+        }
+        if (cleaned > 0) {
+            this.logger.info(`Cleaned up ${cleaned} inactive connections`);
+        }
+        return cleaned;
+    }
+    /**
+     * Validate all connections
+     */
+    async validateAllConnections() {
+        const validationPromises = Array.from(this.connections.values()).map(async (connection) => {
+            const result = await this.validateConnection(connection);
+            return {
+                id: connection.id,
+                isValid: result.isValid,
+                error: result.error,
+                responseTime: result.responseTime
+            };
+        });
+        return Promise.all(validationPromises);
+    }
+    /**
+     * Get connection statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get connection health status
+     */
+    async getHealthStatus() {
+        const connections = this.getAllConnections();
+        const activeConnections = this.getActiveConnections();
+        const idleConnections = this.getIdleConnections();
+        const inUseConnections = connections.filter(c => c.inUse);
+        const issues = [];
+        // Check for failed creations
+        if (this.stats.failedCreations > 0) {
+            issues.push(`${this.stats.failedCreations} connection creation failures`);
+        }
+        // Check for slow validation times
+        if (this.stats.averageValidationTime > 1000) {
+            issues.push(`Slow connection validation: ${this.stats.averageValidationTime.toFixed(2)}ms average`);
+        }
+        // Check for high connection count
+        if (connections.length > 50) {
+            issues.push(`High connection count: ${connections.length}`);
+        }
+        let status = 'healthy';
+        if (issues.length > 0) {
+            status = issues.some(issue => issue.includes('failures')) ? 'critical' : 'warning';
+        }
+        return {
+            status,
+            issues,
+            connections: {
+                total: connections.length,
+                active: activeConnections.length,
+                idle: idleConnections.length,
+                inUse: inUseConnections.length
+            }
+        };
+    }
+    /**
+     * Generate unique connection ID
+     */
+    generateConnectionId() {
+        return `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Update statistics
+     */
+    updateStats(operation, time) {
+        switch (operation) {
+            case 'created':
+                this.stats.totalCreated++;
+                this.stats.activeConnections++;
+                this.updateAverageTime('creation', time);
+                break;
+            case 'destroyed':
+                this.stats.totalDestroyed++;
+                this.stats.activeConnections = Math.max(0, this.stats.activeConnections - 1);
+                break;
+            case 'failed':
+                this.stats.failedCreations++;
+                break;
+            case 'validated':
+                this.updateAverageTime('validation', time);
+                break;
+        }
+    }
+    /**
+     * Update average time for operations
+     */
+    updateAverageTime(operation, time) {
+        if (operation === 'creation') {
+            const total = this.stats.totalCreated;
+            this.stats.averageCreationTime =
+                (this.stats.averageCreationTime * (total - 1) + time) / total;
+        }
+        else if (operation === 'validation') {
+            // This is a simplified approach - in practice you'd track validation count separately
+            this.stats.averageValidationTime =
+                (this.stats.averageValidationTime + time) / 2;
+        }
+    }
+}
+exports.ConnectionFactory = ConnectionFactory;
+/**
+ * Connection pool manager using the factory
+ */
+class ConnectionPoolManager {
+    factory;
+    config;
+    poolConfig;
+    waitingQueue = [];
+    validationTimer;
+    isShuttingDown = false;
+    logger;
+    constructor(config, poolConfig = {}, logger) {
+        this.config = config;
+        this.logger = logger || new logger_js_1.Logger('ConnectionPoolManager');
+        this.factory = new ConnectionFactory(this.logger);
+        this.poolConfig = {
+            minConnections: 2,
+            maxConnections: 10,
+            acquireTimeout: 30000,
+            idleTimeout: 300000,
+            validationInterval: 60000,
+            ...poolConfig
+        };
+        this.startValidationTimer();
+    }
+    /**
+     * Initialize the connection pool
+     */
+    async initialize() {
+        this.logger.info(`Initializing connection pool with ${this.poolConfig.minConnections} minimum connections`);
+        const initPromises = Array.from({ length: this.poolConfig.minConnections }, (_, i) => this.factory.createConnection({
+            ...this.config,
+            id: `pool_conn_${i}`
+        }));
+        try {
+            await Promise.all(initPromises);
+            this.logger.info(`Connection pool initialized with ${this.factory.getAllConnections().length} connections`);
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize connection pool:', error);
+            throw error;
+        }
+    }
+    /**
+     * Acquire a connection from the pool
+     */
+    async acquire() {
+        if (this.isShuttingDown) {
+            throw new Error('Connection pool is shutting down');
+        }
+        const startTime = performance.now();
+        try {
+            // Try to get an idle connection
+            const idleConnection = this.getIdleConnection();
+            if (idleConnection) {
+                this.factory.markInUse(idleConnection);
+                this.logger.debug(`Acquired connection ${idleConnection.id} from pool`);
+                return idleConnection;
+            }
+            // Try to create a new connection if under max limit
+            const currentConnections = this.factory.getAllConnections();
+            if (currentConnections.length < this.poolConfig.maxConnections) {
+                const newConnection = await this.factory.createConnection({
+                    ...this.config,
+                    id: `pool_conn_${Date.now()}`
+                });
+                this.factory.markInUse(newConnection);
+                this.logger.debug(`Created and acquired new connection ${newConnection.id}`);
+                return newConnection;
+            }
+            // Wait for a connection to become available
+            return this.waitForConnection(startTime);
+        }
+        catch (error) {
+            this.logger.error('Failed to acquire connection:', error);
+            throw error;
+        }
+    }
+    /**
+     * Release a connection back to the pool
+     */
+    async release(connection) {
+        try {
+            // Validate connection before returning to pool
+            const validation = await this.factory.validateConnection(connection);
+            if (!validation.isValid) {
+                this.logger.warn(`Connection ${connection.id} failed validation, removing from pool`);
+                await this.factory.destroyConnection(connection.id);
+                return;
+            }
+            this.factory.markIdle(connection);
+            this.processWaitingQueue();
+            this.logger.debug(`Released connection ${connection.id} back to pool`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to release connection ${connection.id}:`, error);
+        }
+    }
+    /**
+     * Execute a function with a pooled connection
+     */
+    async withConnection(fn) {
+        const connection = await this.acquire();
+        try {
+            return await fn(connection.db);
+        }
+        finally {
+            await this.release(connection);
+        }
+    }
+    /**
+     * Get pool statistics
+     */
+    getStats() {
+        const factoryStats = this.factory.getStats();
+        const connections = this.factory.getAllConnections();
+        return {
+            ...factoryStats,
+            poolSize: connections.length,
+            idleConnections: this.factory.getIdleConnections().length,
+            inUseConnections: connections.filter(c => c.inUse).length,
+            waitingQueue: this.waitingQueue.length
+        };
+    }
+    /**
+     * Shutdown the connection pool
+     */
+    async shutdown() {
+        this.logger.info('Shutting down connection pool...');
+        this.isShuttingDown = true;
+        // Stop validation timer
+        if (this.validationTimer) {
+            clearInterval(this.validationTimer);
+        }
+        // Reject all waiting requests
+        this.waitingQueue.forEach(({ reject }) => {
+            reject(new Error('Connection pool is shutting down'));
+        });
+        this.waitingQueue = [];
+        // Destroy all connections
+        await this.factory.destroyAllConnections();
+        this.logger.info('Connection pool shutdown complete');
+    }
+    /**
+     * Get idle connection from pool
+     */
+    getIdleConnection() {
+        const idleConnections = this.factory.getIdleConnections();
+        return idleConnections.length > 0 ? idleConnections[0] : null;
+    }
+    /**
+     * Wait for a connection to become available
+     */
+    async waitForConnection(startTime) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                const index = this.waitingQueue.findIndex(item => item.reject === reject);
+                if (index !== -1) {
+                    this.waitingQueue.splice(index, 1);
+                }
+                reject(new Error(`Connection acquisition timeout after ${this.poolConfig.acquireTimeout}ms`));
+            }, this.poolConfig.acquireTimeout);
+            this.waitingQueue.push({
+                resolve: (connection) => {
+                    clearTimeout(timeout);
+                    resolve(connection);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                },
+                timestamp: Date.now()
+            });
+        });
+    }
+    /**
+     * Process waiting queue when connections become available
+     */
+    processWaitingQueue() {
+        while (this.waitingQueue.length > 0) {
+            const idleConnection = this.getIdleConnection();
+            if (!idleConnection)
+                break;
+            const waiter = this.waitingQueue.shift();
+            this.factory.markInUse(idleConnection);
+            waiter.resolve(idleConnection);
+        }
+    }
+    /**
+     * Start validation timer
+     */
+    startValidationTimer() {
+        this.validationTimer = setInterval(async () => {
+            await this.validateConnections();
+            await this.cleanupIdleConnections();
+        }, this.poolConfig.validationInterval);
+    }
+    /**
+     * Validate all connections in the pool
+     */
+    async validateConnections() {
+        const validationPromises = this.factory.getIdleConnections().map(async (connection) => {
+            const validation = await this.factory.validateConnection(connection);
+            if (!validation.isValid) {
+                await this.factory.destroyConnection(connection.id);
+            }
+        });
+        await Promise.all(validationPromises);
+    }
+    /**
+     * Cleanup idle connections that exceed the idle timeout
+     */
+    async cleanupIdleConnections() {
+        const now = Date.now();
+        const idleConnections = this.factory.getIdleConnections();
+        const excessConnections = idleConnections.filter(conn => now - conn.lastUsed.getTime() > this.poolConfig.idleTimeout).slice(this.poolConfig.minConnections);
+        for (const connection of excessConnections) {
+            await this.factory.destroyConnection(connection.id);
+        }
+        if (excessConnections.length > 0) {
+            this.logger.debug(`Cleaned up ${excessConnections.length} idle connections`);
+        }
+    }
+}
+exports.ConnectionPoolManager = ConnectionPoolManager;
+/**
+ * Factory function to create connection pool manager
+ */
+function createConnectionPool(config, poolConfig, logger) {
+    return new ConnectionPoolManager(config, poolConfig, logger);
+}

package/dist/cjs/performance/services/metrics-collector.d.ts

@@ -0,0 +1,162 @@
+import { Logger } from '../../logging/logger.js';
+export interface QueryMetrics {
+    query: string;
+    executionTime: number;
+    timestamp: number;
+    table?: string;
+    operation?: string;
+    resultCount?: number;
+    error?: string;
+}
+export interface PerformanceWarning {
+    type: 'n_plus_one' | 'missing_index' | 'slow_query' | 'full_table_scan' | 'large_result_set';
+    message: string;
+    suggestion: string;
+    query?: string;
+    table?: string;
+    severity: 'low' | 'medium' | 'high';
+    timestamp: number;
+}
+export interface MetricsConfig {
+    enabled: boolean;
+    slowQueryThreshold: number;
+    nPlusOneDetection: boolean;
+    missingIndexDetection: boolean;
+    largeResultSetThreshold: number;
+    maxHistorySize: number;
+    warningRetentionDays: number;
+}
+export interface PerformanceStats {
+    totalQueries: number;
+    averageExecutionTime: number;
+    slowQueries: number;
+    errorRate: number;
+    warningCount: {
+        [key: string]: number;
+    };
+    topSlowQueries: Array<{
+        query: string;
+        averageTime: number;
+        count: number;
+    }>;
+    queryPatterns: Array<{
+        pattern: string;
+        frequency: number;
+        averageTime: number;
+    }>;
+}
+/**
+ * Service for collecting and analyzing performance metrics
+ */
+export declare class MetricsCollector {
+    private queryHistory;
+    private warnings;
+    private recentQueries;
+    private config;
+    private logger;
+    private cleanupTimer?;
+    constructor(config?: Partial<MetricsConfig>, logger?: Logger);
+    /**
+     * Record a query execution
+     */
+    recordQuery(query: string, executionTime: number, options?: {
+        table?: string;
+        operation?: string;
+        resultCount?: number;
+        error?: string;
+    }): void;
+    /**
+     * Get performance statistics
+     */
+    getPerformanceStats(): PerformanceStats;
+    /**
+     * Get recent warnings
+     */
+    getRecentWarnings(limit?: number): PerformanceWarning[];
+    /**
+     * Get warnings by type
+     */
+    getWarningsByType(type: PerformanceWarning['type']): PerformanceWarning[];
+    /**
+     * Get query history
+     */
+    getQueryHistory(limit?: number): QueryMetrics[];
+    /**
+     * Get slow queries
+     */
+    getSlowQueries(threshold?: number): QueryMetrics[];
+    /**
+     * Get N+1 query patterns
+     */
+    getNPlusOnePatterns(): Array<{
+        pattern: string;
+        count: number;
+        timeWindow: number;
+        severity: 'low' | 'medium' | 'high';
+    }>;
+    /**
+     * Clear all metrics
+     */
+    clear(): void;
+    /**
+     * Export metrics data
+     */
+    exportMetrics(): {
+        config: MetricsConfig;
+        stats: PerformanceStats;
+        warnings: PerformanceWarning[];
+        queries: QueryMetrics[];
+    };
+    /**
+     * Shutdown metrics collector
+     */
+    shutdown(): void;
+    /**
+     * Track recent query for pattern detection
+     */
+    private trackRecentQuery;
+    /**
+     * Analyze query for performance issues
+     */
+    private analyzeQuery;
+    /**
+     * Detect N+1 query patterns
+     */
+    private detectNPlusOne;
+    /**
+     * Add warning to collection
+     */
+    private addWarning;
+    /**
+     * Log performance warning
+     */
+    private logWarning;
+    /**
+     * Get emoji for warning type
+     */
+    private getWarningEmoji;
+    /**
+     * Normalize query for comparison
+     */
+    private normalizeQuery;
+    /**
+     * Get top slow queries
+     */
+    private getTopSlowQueries;
+    /**
+     * Get query patterns
+     */
+    private getQueryPatterns;
+    /**
+     * Start cleanup timer
+     */
+    private startCleanupTimer;
+    /**
+     * Cleanup old data
+     */
+    private cleanup;
+}
+/**
+ * Factory function to create metrics collector
+ */
+export declare function createMetricsCollector(config?: Partial<MetricsConfig>, logger?: Logger): MetricsCollector;