noormme 1.0.6 → 1.2.0

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

@@ -19,7 +19,7 @@ class ConnectionFactory {
             activeConnections: 0,
             failedCreations: 0,
             averageCreationTime: 0,
-            averageValidationTime: 0
+            averageValidationTime: 0,
         };
     }
     /**
@@ -39,7 +39,7 @@ class ConnectionFactory {
                 lastUsed: new Date(),
                 isActive: true,
                 inUse: false,
-                config
+                config,
             };
             this.connections.set(id, connection);
             this.updateStats('created', performance.now() - startTime);
@@ -63,7 +63,7 @@ class ConnectionFactory {
             this.updateStats('validated', responseTime);
             return {
                 isValid: true,
-                responseTime
+                responseTime,
             };
         }
         catch (error) {
@@ -73,7 +73,7 @@ class ConnectionFactory {
             return {
                 isValid: false,
                 error: errorMessage,
-                responseTime
+                responseTime,
             };
         }
     }
@@ -93,13 +93,13 @@ class ConnectionFactory {
      * Get active connections
      */
     getActiveConnections() {
-        return Array.from(this.connections.values()).filter(conn => conn.isActive);
+        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);
+        return Array.from(this.connections.values()).filter((conn) => conn.isActive && !conn.inUse);
     }
     /**
      * Mark connection as in use
@@ -140,7 +140,7 @@ class ConnectionFactory {
      * Destroy all connections
      */
     async destroyAllConnections() {
-        const destroyPromises = Array.from(this.connections.keys()).map(id => this.destroyConnection(id));
+        const destroyPromises = Array.from(this.connections.keys()).map((id) => this.destroyConnection(id));
         await Promise.all(destroyPromises);
         this.logger.info('Destroyed all connections');
     }
@@ -151,8 +151,7 @@ class ConnectionFactory {
         const now = Date.now();
         let cleaned = 0;
         for (const [id, connection] of this.connections.entries()) {
-            if (!connection.inUse &&
-                now - connection.lastUsed.getTime() > maxAge) {
+            if (!connection.inUse && now - connection.lastUsed.getTime() > maxAge) {
                 if (await this.destroyConnection(id)) {
                     cleaned++;
                 }
@@ -173,7 +172,7 @@ class ConnectionFactory {
                 id: connection.id,
                 isValid: result.isValid,
                 error: result.error,
-                responseTime: result.responseTime
+                responseTime: result.responseTime,
             };
         });
         return Promise.all(validationPromises);
@@ -191,7 +190,7 @@ class ConnectionFactory {
         const connections = this.getAllConnections();
         const activeConnections = this.getActiveConnections();
         const idleConnections = this.getIdleConnections();
-        const inUseConnections = connections.filter(c => c.inUse);
+        const inUseConnections = connections.filter((c) => c.inUse);
         const issues = [];
         // Check for failed creations
         if (this.stats.failedCreations > 0) {
@@ -207,7 +206,9 @@ class ConnectionFactory {
         }
         let status = 'healthy';
         if (issues.length > 0) {
-            status = issues.some(issue => issue.includes('failures')) ? 'critical' : 'warning';
+            status = issues.some((issue) => issue.includes('failures'))
+                ? 'critical'
+                : 'warning';
         }
         return {
             status,
@@ -216,8 +217,8 @@ class ConnectionFactory {
                 total: connections.length,
                 active: activeConnections.length,
                 idle: idleConnections.length,
-                inUse: inUseConnections.length
-            }
+                inUse: inUseConnections.length,
+            },
         };
     }
     /**
@@ -286,7 +287,7 @@ class ConnectionPoolManager {
             acquireTimeout: 30000,
             idleTimeout: 300000,
             validationInterval: 60000,
-            ...poolConfig
+            ...poolConfig,
         };
         this.startValidationTimer();
     }
@@ -297,7 +298,7 @@ class ConnectionPoolManager {
         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}`
+            id: `pool_conn_${i}`,
         }));
         try {
             await Promise.all(initPromises);
@@ -329,7 +330,7 @@ class ConnectionPoolManager {
             if (currentConnections.length < this.poolConfig.maxConnections) {
                 const newConnection = await this.factory.createConnection({
                     ...this.config,
-                    id: `pool_conn_${Date.now()}`
+                    id: `pool_conn_${Date.now()}`,
                 });
                 this.factory.markInUse(newConnection);
                 this.logger.debug(`Created and acquired new connection ${newConnection.id}`);
@@ -385,8 +386,8 @@ class ConnectionPoolManager {
             ...factoryStats,
             poolSize: connections.length,
             idleConnections: this.factory.getIdleConnections().length,
-            inUseConnections: connections.filter(c => c.inUse).length,
-            waitingQueue: this.waitingQueue.length
+            inUseConnections: connections.filter((c) => c.inUse).length,
+            waitingQueue: this.waitingQueue.length,
         };
     }
     /**
@@ -421,7 +422,7 @@ class ConnectionPoolManager {
     async waitForConnection(startTime) {
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                const index = this.waitingQueue.findIndex(item => item.reject === reject);
+                const index = this.waitingQueue.findIndex((item) => item.reject === reject);
                 if (index !== -1) {
                     this.waitingQueue.splice(index, 1);
                 }
@@ -436,7 +437,7 @@ class ConnectionPoolManager {
                     clearTimeout(timeout);
                     reject(error);
                 },
-                timestamp: Date.now()
+                timestamp: Date.now(),
             });
         });
     }
@@ -466,7 +467,9 @@ class ConnectionPoolManager {
      * Validate all connections in the pool
      */
     async validateConnections() {
-        const validationPromises = this.factory.getIdleConnections().map(async (connection) => {
+        const validationPromises = this.factory
+            .getIdleConnections()
+            .map(async (connection) => {
             const validation = await this.factory.validateConnection(connection);
             if (!validation.isValid) {
                 await this.factory.destroyConnection(connection.id);
@@ -480,7 +483,9 @@ class ConnectionPoolManager {
     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);
+        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);
         }

package/dist/cjs/performance/services/metrics-collector.js

@@ -59,11 +59,11 @@ class MetricsCollector {
             maxHistorySize: 10000,
             warningRetentionDays: 7,
             persistPath: config.persistPath,
-            ...config
+            ...config,
         };
         this.startCleanupTimer();
         // Attempt to load metrics on startup (fire and forget)
-        this.load().catch(err => this.logger.warn('Failed to load metrics:', err));
+        this.load().catch((err) => this.logger.warn('Failed to load metrics:', err));
     }
     /**
      * Load metrics from disk
@@ -101,7 +101,7 @@ class MetricsCollector {
             const data = JSON.stringify({
                 queryHistory: this.queryHistory,
                 warnings: this.warnings,
-                savedAt: Date.now()
+                savedAt: Date.now(),
             }, null, 2);
             await fs.writeFile(this.config.persistPath, data, 'utf-8');
             this.logger.debug(`Saved metrics to ${this.config.persistPath}`);
@@ -123,7 +123,7 @@ class MetricsCollector {
             table: options.table,
             operation: options.operation,
             resultCount: options.resultCount,
-            error: options.error
+            error: options.error,
         };
         this.queryHistory.push(metrics);
         // Keep history size under control
@@ -140,12 +140,13 @@ class MetricsCollector {
      */
     getPerformanceStats() {
         const totalQueries = this.queryHistory.length;
-        const slowQueries = this.queryHistory.filter(q => q.executionTime > this.config.slowQueryThreshold).length;
+        const slowQueries = this.queryHistory.filter((q) => q.executionTime > this.config.slowQueryThreshold).length;
         const averageExecutionTime = totalQueries > 0
-            ? this.queryHistory.reduce((sum, q) => sum + q.executionTime, 0) / totalQueries
+            ? this.queryHistory.reduce((sum, q) => sum + q.executionTime, 0) /
+                totalQueries
             : 0;
         const errorRate = totalQueries > 0
-            ? this.queryHistory.filter(q => q.error).length / totalQueries
+            ? this.queryHistory.filter((q) => q.error).length / totalQueries
             : 0;
         const warningCount = {};
         for (const warning of this.warnings) {
@@ -160,7 +161,7 @@ class MetricsCollector {
             errorRate,
             warningCount,
             topSlowQueries,
-            queryPatterns
+            queryPatterns,
         };
     }
     /**
@@ -175,14 +176,13 @@ class MetricsCollector {
      * Get warnings by type
      */
     getWarningsByType(type) {
-        return this.warnings.filter(w => w.type === type);
+        return this.warnings.filter((w) => w.type === type);
     }
     /**
      * Get query history
      */
     getQueryHistory(limit) {
-        const history = this.queryHistory
-            .sort((a, b) => b.timestamp - a.timestamp);
+        const history = this.queryHistory.sort((a, b) => b.timestamp - a.timestamp);
         return limit ? history.slice(0, limit) : history;
     }
     /**
@@ -191,7 +191,7 @@ class MetricsCollector {
     getSlowQueries(threshold) {
         const actualThreshold = threshold || this.config.slowQueryThreshold;
         return this.queryHistory
-            .filter(q => q.executionTime > actualThreshold)
+            .filter((q) => q.executionTime > actualThreshold)
             .sort((a, b) => b.executionTime - a.executionTime);
     }
     /**
@@ -216,7 +216,7 @@ class MetricsCollector {
                 let maxCountInWindow = 0;
                 for (const query of queries) {
                     const windowStart = query.timestamp - windowMs;
-                    const countInWindow = queries.filter(q => q.timestamp >= windowStart && q.timestamp <= query.timestamp).length;
+                    const countInWindow = queries.filter((q) => q.timestamp >= windowStart && q.timestamp <= query.timestamp).length;
                     maxCountInWindow = Math.max(maxCountInWindow, countInWindow);
                 }
                 if (maxCountInWindow >= 5) {
@@ -229,7 +229,7 @@ class MetricsCollector {
                         pattern,
                         count: maxCountInWindow,
                         timeWindow: windowMs,
-                        severity
+                        severity,
                     });
                     break;
                 }
@@ -255,7 +255,7 @@ class MetricsCollector {
             config: this.config,
             stats: this.getPerformanceStats(),
             warnings: this.warnings,
-            queries: this.queryHistory
+            queries: this.queryHistory,
         };
     }
     /**
@@ -280,7 +280,7 @@ class MetricsCollector {
         // Clean up old recent queries (keep last 10 seconds)
         const cutoff = Date.now() - 10000;
         for (const [query, queries] of this.recentQueries.entries()) {
-            const recent = queries.filter(q => q.timestamp >= cutoff);
+            const recent = queries.filter((q) => q.timestamp >= cutoff);
             if (recent.length === 0) {
                 this.recentQueries.delete(query);
             }
@@ -302,8 +302,10 @@ class MetricsCollector {
                 suggestion: 'Consider adding indexes or optimizing the query',
                 query: metrics.query,
                 table: metrics.table,
-                severity: metrics.executionTime > this.config.slowQueryThreshold * 3 ? 'high' : 'medium',
-                timestamp: Date.now()
+                severity: metrics.executionTime > this.config.slowQueryThreshold * 3
+                    ? 'high'
+                    : 'medium',
+                timestamp: Date.now(),
             });
         }
         // Check for N+1 queries
@@ -314,15 +316,18 @@ class MetricsCollector {
             }
         }
         // Check for large result sets
-        if (metrics.resultCount && metrics.resultCount > this.config.largeResultSetThreshold) {
+        if (metrics.resultCount &&
+            metrics.resultCount > this.config.largeResultSetThreshold) {
             warnings.push({
                 type: 'large_result_set',
                 message: `Large result set: ${metrics.resultCount} rows returned`,
                 suggestion: 'Consider using pagination or filtering to reduce result size',
                 query: metrics.query,
                 table: metrics.table,
-                severity: metrics.resultCount > this.config.largeResultSetThreshold * 5 ? 'high' : 'medium',
-                timestamp: Date.now()
+                severity: metrics.resultCount > this.config.largeResultSetThreshold * 5
+                    ? 'high'
+                    : 'medium',
+                timestamp: Date.now(),
             });
         }
         // Log warnings
@@ -338,7 +343,7 @@ class MetricsCollector {
         // Look for the same query executed multiple times in quick succession
         if (recentQueries.length >= 5) {
             const timeWindow = 5000; // 5 seconds
-            const recentInWindow = recentQueries.filter(q => Date.now() - q.timestamp < timeWindow);
+            const recentInWindow = recentQueries.filter((q) => Date.now() - q.timestamp < timeWindow);
             if (recentInWindow.length >= 5) {
                 return {
                     type: 'n_plus_one',
@@ -347,7 +352,7 @@ class MetricsCollector {
                     query: metrics.query,
                     table: metrics.table,
                     severity: 'high',
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 };
             }
         }
@@ -387,11 +392,11 @@ class MetricsCollector {
      */
     getWarningEmoji(type) {
         const emojis = {
-            'n_plus_one': '🔄',
-            'missing_index': '📇',
-            'slow_query': '🐌',
-            'full_table_scan': '🔍',
-            'large_result_set': '📊'
+            n_plus_one: '🔄',
+            missing_index: '📇',
+            slow_query: '🐌',
+            full_table_scan: '🔍',
+            large_result_set: '📊',
         };
         return emojis[type] || '⚠️';
     }
@@ -425,7 +430,7 @@ class MetricsCollector {
             .map(([query, { totalTime, count }]) => ({
             query,
             averageTime: totalTime / count,
-            count
+            count,
         }))
             .sort((a, b) => b.averageTime - a.averageTime)
             .slice(0, 10);
@@ -447,7 +452,7 @@ class MetricsCollector {
             .map(([pattern, { totalTime, count }]) => ({
             pattern,
             frequency: count,
-            averageTime: totalTime / count
+            averageTime: totalTime / count,
         }))
             .sort((a, b) => b.frequency - a.frequency)
             .slice(0, 20);
@@ -458,22 +463,22 @@ class MetricsCollector {
     startCleanupTimer() {
         this.cleanupTimer = setInterval(() => {
             this.cleanup();
-            this.save().catch(err => this.logger.warn('Failed to auto-save metrics:', err));
+            this.save().catch((err) => this.logger.warn('Failed to auto-save metrics:', err));
         }, 60000); // Cleanup and save every minute
     }
     /**
      * Cleanup old data
      */
     cleanup() {
-        const cutoffTime = Date.now() - (this.config.warningRetentionDays * 24 * 60 * 60 * 1000);
+        const cutoffTime = Date.now() - this.config.warningRetentionDays * 24 * 60 * 60 * 1000;
         // Remove old warnings
-        this.warnings = this.warnings.filter(w => w.timestamp > cutoffTime);
+        this.warnings = this.warnings.filter((w) => w.timestamp > cutoffTime);
         // Remove old queries (keep last 24 hours)
-        const queryCutoff = Date.now() - (24 * 60 * 60 * 1000);
-        this.queryHistory = this.queryHistory.filter(q => q.timestamp > queryCutoff);
+        const queryCutoff = Date.now() - 24 * 60 * 60 * 1000;
+        this.queryHistory = this.queryHistory.filter((q) => q.timestamp > queryCutoff);
         // Clean up recent queries
         for (const [query, queries] of this.recentQueries.entries()) {
-            const recent = queries.filter(q => q.timestamp > queryCutoff);
+            const recent = queries.filter((q) => q.timestamp > queryCutoff);
             if (recent.length === 0) {
                 this.recentQueries.delete(query);
             }

package/dist/cjs/performance/utils/query-parser.js

@@ -23,7 +23,7 @@ class QueryParser {
             groupByColumns: this.extractGroupByColumns(normalized),
             hasLimit: lowerQuery.includes('limit'),
             hasAggregates: this.hasAggregates(normalized),
-            isComplex: this.isComplexQuery(normalized)
+            isComplex: this.isComplexQuery(normalized),
         };
     }
     /**
@@ -60,7 +60,7 @@ class QueryParser {
         // FROM clause
         const fromMatches = query.match(/from\s+(\w+)/gi);
         if (fromMatches) {
-            fromMatches.forEach(match => {
+            fromMatches.forEach((match) => {
                 const table = match.split(/\s+/)[1];
                 if (table)
                     tables.add(table);
@@ -69,7 +69,7 @@ class QueryParser {
         // JOIN clauses
         const joinMatches = query.match(/join\s+(\w+)/gi);
         if (joinMatches) {
-            joinMatches.forEach(match => {
+            joinMatches.forEach((match) => {
                 const table = match.split(/\s+/)[1];
                 if (table)
                     tables.add(table);
@@ -87,7 +87,7 @@ class QueryParser {
         const whereClause = whereMatch[1];
         const columnMatches = whereClause.match(/(\w+)\s*[=<>!]/g);
         return columnMatches
-            ? columnMatches.map(match => match.split(/\s+/)[0]).filter(Boolean)
+            ? columnMatches.map((match) => match.split(/\s+/)[0]).filter(Boolean)
             : [];
     }
     /**
@@ -116,7 +116,7 @@ class QueryParser {
             return [];
         return orderByMatch[1]
             .split(',')
-            .map(col => col.trim().split(/\s+/)[0])
+            .map((col) => col.trim().split(/\s+/)[0])
             .filter(Boolean);
     }
     /**
@@ -128,7 +128,7 @@ class QueryParser {
             return [];
         return groupByMatch[1]
             .split(',')
-            .map(col => col.trim())
+            .map((col) => col.trim())
             .filter(Boolean);
     }
     /**
@@ -136,25 +136,25 @@ class QueryParser {
      */
     static hasAggregates(query) {
         const lowerQuery = query.toLowerCase();
-        return lowerQuery.includes('group by') ||
+        return (lowerQuery.includes('group by') ||
             lowerQuery.includes('having') ||
             lowerQuery.includes('count(') ||
             lowerQuery.includes('sum(') ||
             lowerQuery.includes('avg(') ||
             lowerQuery.includes('max(') ||
-            lowerQuery.includes('min(');
+            lowerQuery.includes('min('));
     }
     /**
      * Check if query is complex (joins, subqueries, etc.)
      */
     static isComplexQuery(query) {
         const lowerQuery = query.toLowerCase();
-        return lowerQuery.includes('join') ||
+        return (lowerQuery.includes('join') ||
             lowerQuery.includes('subquery') ||
             lowerQuery.includes('union') ||
             lowerQuery.includes('except') ||
             lowerQuery.includes('intersect') ||
-            (lowerQuery.includes('select') && lowerQuery.includes('('));
+            (lowerQuery.includes('select') && lowerQuery.includes('(')));
     }
     /**
      * Check if query could return many rows
@@ -193,7 +193,7 @@ class QueryParser {
      */
     static generateCacheKey(query, params = []) {
         const normalized = this.normalizeQuery(query);
-        const paramsKey = params.map(p => String(p)).join('|');
+        const paramsKey = params.map((p) => String(p)).join('|');
         return `${normalized}:${paramsKey}`;
     }
     /**
@@ -239,12 +239,11 @@ class QueryParser {
                     original: query,
                     frequency: 1,
                     averageTime: executionTime,
-                    tables: parsed.tables
+                    tables: parsed.tables,
                 });
             }
         }
-        return Array.from(patternMap.values())
-            .sort((a, b) => b.frequency - a.frequency);
+        return Array.from(patternMap.values()).sort((a, b) => b.frequency - a.frequency);
     }
     /**
      * Detect potential N+1 query patterns
@@ -270,7 +269,7 @@ class QueryParser {
                 let maxCountInWindow = 0;
                 for (const query of queries) {
                     const windowStart = query.timestamp - windowMs;
-                    const countInWindow = queries.filter(q => q.timestamp >= windowStart && q.timestamp <= query.timestamp).length;
+                    const countInWindow = queries.filter((q) => q.timestamp >= windowStart && q.timestamp <= query.timestamp).length;
                     maxCountInWindow = Math.max(maxCountInWindow, countInWindow);
                 }
                 if (maxCountInWindow >= 5) {
@@ -283,7 +282,7 @@ class QueryParser {
                         pattern,
                         count: maxCountInWindow,
                         timeWindow: windowMs,
-                        severity
+                        severity,
                     });
                     break; // Only report the most severe pattern
                 }

package/dist/cjs/relationships/relationship-engine.js

@@ -41,7 +41,7 @@ class RelationshipEngine {
      */
     async loadEntityRelationships(entity, relations) {
         for (const relationName of relations) {
-            const relationship = this.relationships.find(r => r.name === relationName);
+            const relationship = this.relationships.find((r) => r.name === relationName);
             if (!relationship)
                 continue;
             await this.loadSingleRelationship(entity, relationship);
@@ -52,7 +52,7 @@ class RelationshipEngine {
      */
     async batchLoadRelationships(entities, relations) {
         for (const relationName of relations) {
-            const relationship = this.relationships.find(r => r.name === relationName);
+            const relationship = this.relationships.find((r) => r.name === relationName);
             if (!relationship)
                 continue;
             await this.batchLoadSingleRelationship(entities, relationship);
@@ -85,6 +85,7 @@ class RelationshipEngine {
                 relatedData = await this.loadManyToManyRelationship(entity, relationship);
                 break;
         }
+        ;
         entity[relationship.name] = relatedData;
     }
     /**
@@ -92,8 +93,8 @@ class RelationshipEngine {
      */
     async batchLoadSingleRelationship(entities, relationship) {
         const entityValues = entities
-            .map(e => e[relationship.fromColumn])
-            .filter(v => v !== undefined && v !== null);
+            .map((e) => e[relationship.fromColumn])
+            .filter((v) => v !== undefined && v !== null);
         if (entityValues.length === 0)
             return;
         let relatedData;
@@ -138,6 +139,7 @@ class RelationshipEngine {
                 else {
                     entityRelatedData = groupedData.get(entityValue) || [];
                 }
+                ;
                 entity[relationship.name] = entityRelatedData;
             }
         }
@@ -167,8 +169,8 @@ class RelationshipEngine {
             throw new Error('Many-to-many relationship requires throughTable');
         }
         const entityValues = entities
-            .map(e => e[relationship.fromColumn])
-            .filter(v => v !== undefined && v !== null);
+            .map((e) => e[relationship.fromColumn])
+            .filter((v) => v !== undefined && v !== null);
         if (entityValues.length === 0)
             return [];
         return await this.db
@@ -182,7 +184,7 @@ class RelationshipEngine {
      * Get relationships for a specific table
      */
     getRelationshipsForTable(tableName) {
-        return this.relationships.filter(r => r.fromTable === tableName);
+        return this.relationships.filter((r) => r.fromTable === tableName);
     }
     /**
      * Get all relationships
@@ -200,7 +202,7 @@ class RelationshipEngine {
      * Remove a relationship
      */
     removeRelationship(relationshipName) {
-        this.relationships = this.relationships.filter(r => r.name !== relationshipName);
+        this.relationships = this.relationships.filter((r) => r.name !== relationshipName);
     }
 }
 exports.RelationshipEngine = RelationshipEngine;