noormme 1.1.0 → 1.2.0

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

@@ -16,7 +16,7 @@ export class ConnectionFactory {
             activeConnections: 0,
             failedCreations: 0,
             averageCreationTime: 0,
-            averageValidationTime: 0
+            averageValidationTime: 0,
         };
     }
     /**
@@ -36,7 +36,7 @@ export class ConnectionFactory {
                 lastUsed: new Date(),
                 isActive: true,
                 inUse: false,
-                config
+                config,
             };
             this.connections.set(id, connection);
             this.updateStats('created', performance.now() - startTime);
@@ -60,7 +60,7 @@ export class ConnectionFactory {
             this.updateStats('validated', responseTime);
             return {
                 isValid: true,
-                responseTime
+                responseTime,
             };
         }
         catch (error) {
@@ -70,7 +70,7 @@ export class ConnectionFactory {
             return {
                 isValid: false,
                 error: errorMessage,
-                responseTime
+                responseTime,
             };
         }
     }
@@ -90,13 +90,13 @@ export 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
@@ -137,7 +137,7 @@ export 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');
     }
@@ -148,8 +148,7 @@ export 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++;
                 }
@@ -170,7 +169,7 @@ export class ConnectionFactory {
                 id: connection.id,
                 isValid: result.isValid,
                 error: result.error,
-                responseTime: result.responseTime
+                responseTime: result.responseTime,
             };
         });
         return Promise.all(validationPromises);
@@ -188,7 +187,7 @@ export 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) {
@@ -204,7 +203,9 @@ export 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,
@@ -213,8 +214,8 @@ export class ConnectionFactory {
                 total: connections.length,
                 active: activeConnections.length,
                 idle: idleConnections.length,
-                inUse: inUseConnections.length
-            }
+                inUse: inUseConnections.length,
+            },
         };
     }
     /**
@@ -282,7 +283,7 @@ export class ConnectionPoolManager {
             acquireTimeout: 30000,
             idleTimeout: 300000,
             validationInterval: 60000,
-            ...poolConfig
+            ...poolConfig,
         };
         this.startValidationTimer();
     }
@@ -293,7 +294,7 @@ export 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);
@@ -325,7 +326,7 @@ export 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}`);
@@ -381,8 +382,8 @@ export 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,
         };
     }
     /**
@@ -417,7 +418,7 @@ export 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);
                 }
@@ -432,7 +433,7 @@ export class ConnectionPoolManager {
                     clearTimeout(timeout);
                     reject(error);
                 },
-                timestamp: Date.now()
+                timestamp: Date.now(),
             });
         });
     }
@@ -462,7 +463,9 @@ export 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);
@@ -476,7 +479,9 @@ export 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/esm/performance/services/metrics-collector.js

@@ -23,11 +23,11 @@ export 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
@@ -65,7 +65,7 @@ export 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}`);
@@ -87,7 +87,7 @@ export 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
@@ -104,12 +104,13 @@ export 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) {
@@ -124,7 +125,7 @@ export class MetricsCollector {
             errorRate,
             warningCount,
             topSlowQueries,
-            queryPatterns
+            queryPatterns,
         };
     }
     /**
@@ -139,14 +140,13 @@ export 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;
     }
     /**
@@ -155,7 +155,7 @@ export 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);
     }
     /**
@@ -180,7 +180,7 @@ export 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) {
@@ -193,7 +193,7 @@ export class MetricsCollector {
                         pattern,
                         count: maxCountInWindow,
                         timeWindow: windowMs,
-                        severity
+                        severity,
                     });
                     break;
                 }
@@ -219,7 +219,7 @@ export class MetricsCollector {
             config: this.config,
             stats: this.getPerformanceStats(),
             warnings: this.warnings,
-            queries: this.queryHistory
+            queries: this.queryHistory,
         };
     }
     /**
@@ -244,7 +244,7 @@ export 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);
             }
@@ -266,8 +266,10 @@ export 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
@@ -278,15 +280,18 @@ export 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
@@ -302,7 +307,7 @@ export 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',
@@ -311,7 +316,7 @@ export class MetricsCollector {
                     query: metrics.query,
                     table: metrics.table,
                     severity: 'high',
-                    timestamp: Date.now()
+                    timestamp: Date.now(),
                 };
             }
         }
@@ -351,11 +356,11 @@ export 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] || '⚠️';
     }
@@ -389,7 +394,7 @@ export class MetricsCollector {
             .map(([query, { totalTime, count }]) => ({
             query,
             averageTime: totalTime / count,
-            count
+            count,
         }))
             .sort((a, b) => b.averageTime - a.averageTime)
             .slice(0, 10);
@@ -411,7 +416,7 @@ export 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);
@@ -422,22 +427,22 @@ export 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/esm/performance/utils/query-parser.js

@@ -21,7 +21,7 @@ export class QueryParser {
             groupByColumns: this.extractGroupByColumns(normalized),
             hasLimit: lowerQuery.includes('limit'),
             hasAggregates: this.hasAggregates(normalized),
-            isComplex: this.isComplexQuery(normalized)
+            isComplex: this.isComplexQuery(normalized),
         };
     }
     /**
@@ -58,7 +58,7 @@ export 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);
@@ -67,7 +67,7 @@ export 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);
@@ -85,7 +85,7 @@ export 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)
             : [];
     }
     /**
@@ -114,7 +114,7 @@ export class QueryParser {
             return [];
         return orderByMatch[1]
             .split(',')
-            .map(col => col.trim().split(/\s+/)[0])
+            .map((col) => col.trim().split(/\s+/)[0])
             .filter(Boolean);
     }
     /**
@@ -126,7 +126,7 @@ export class QueryParser {
             return [];
         return groupByMatch[1]
             .split(',')
-            .map(col => col.trim())
+            .map((col) => col.trim())
             .filter(Boolean);
     }
     /**
@@ -134,25 +134,25 @@ export 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
@@ -191,7 +191,7 @@ export 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}`;
     }
     /**
@@ -237,12 +237,11 @@ export 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
@@ -268,7 +267,7 @@ export 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) {
@@ -281,7 +280,7 @@ export class QueryParser {
                         pattern,
                         count: maxCountInWindow,
                         timeWindow: windowMs,
-                        severity
+                        severity,
                     });
                     break; // Only report the most severe pattern
                 }

package/dist/esm/raw-builder/sql.js

@@ -8,7 +8,7 @@ import { parseTable } from '../parser/table-parser.js';
 import { parseValueExpression } from '../parser/value-parser.js';
 import { createQueryId } from '../util/query-id.js';
 import { createRawBuilder } from './raw-builder.js';
-import { validateColumnReference, validateTableReference, validateIdentifier } from '../util/security-validator.js';
+import { validateColumnReference, validateTableReference, validateIdentifier, } from '../util/security-validator.js';
 export const sql = Object.assign((sqlFragments, ...parameters) => {
     return createRawBuilder({
         queryId: createQueryId(),

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

@@ -39,7 +39,7 @@ export 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);
@@ -50,7 +50,7 @@ export 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);
@@ -83,6 +83,7 @@ export class RelationshipEngine {
                 relatedData = await this.loadManyToManyRelationship(entity, relationship);
                 break;
         }
+        ;
         entity[relationship.name] = relatedData;
     }
     /**
@@ -90,8 +91,8 @@ export 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;
@@ -136,6 +137,7 @@ export class RelationshipEngine {
                 else {
                     entityRelatedData = groupedData.get(entityValue) || [];
                 }
+                ;
                 entity[relationship.name] = entityRelatedData;
             }
         }
@@ -165,8 +167,8 @@ export 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
@@ -180,7 +182,7 @@ export 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
@@ -198,6 +200,6 @@ export 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);
     }
 }