noormme 1.1.0 → 1.2.0

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;