noormme 1.0.0 → 1.0.2

package/dist/cjs/noormme.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NOORMME = void 0;
+const kysely_js_1 = require("./kysely.js");
 const schema_discovery_js_1 = require("./schema/schema-discovery.js");
 const type_generator_js_1 = require("./types/type-generator.js");
 const repository_factory_js_1 = require("./repository/repository-factory.js");
@@ -10,9 +14,12 @@ const logger_js_1 = require("./logging/logger.js");
 const NoormError_js_1 = require("./errors/NoormError.js");
 const dotenv_1 = require("dotenv");
 const schema_watcher_js_1 = require("./watch/schema-watcher.js");
-const query_analyzer_js_1 = require("./performance/query-analyzer.js");
+const metrics_collector_js_1 = require("./performance/services/metrics-collector.js");
 const sqlite_auto_optimizer_js_1 = require("./dialect/sqlite/sqlite-auto-optimizer.js");
 const sqlite_auto_indexer_js_1 = require("./dialect/sqlite/sqlite-auto-indexer.js");
+const sqlite_dialect_js_1 = require("./dialect/sqlite/sqlite-dialect.js");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const compiled_query_js_1 = require("./query-compiler/compiled-query.js");
 // Global initialization lock to prevent concurrent initialization
 const globalInitLock = new Map();
 /**
@@ -30,12 +37,13 @@ class NOORMME {
     cacheManager;
     logger;
     schemaWatcher = null;
-    queryAnalyzer = null;
+    metricsCollector = null;
     sqliteAutoOptimizer = null;
     sqliteAutoIndexer = null;
     initialized = false;
     repositories = new Map();
     instanceId;
+    schemaChangeCallbacks = [];
     constructor(configOrConnectionString) {
         // Load .env if it exists
         (0, dotenv_1.config)({ path: '.env' });
@@ -65,7 +73,7 @@ class NOORMME {
         this.instanceId = `${this.config.dialect}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
         // Initialize Kysely with the provided dialect
         this.dialect = this.createDialect();
-        this.db = new (require('./kysely.js').Kysely)({
+        this.db = new kysely_js_1.Kysely({
             dialect: this.dialect,
             log: this.config.logging?.enabled ? this.logger.createKyselyLogger() : undefined
         });
@@ -110,34 +118,80 @@ class NOORMME {
             this.logger.info('Initializing NOORMME...');
             // Test database connection using the dialect-specific introspector
             const introspector = this.dialect.createIntrospector(this.db);
-            await introspector.getTables();
-            this.logger.info('Database connection successful');
-            // Discover schema
+            let tables = [];
+            try {
+                tables = await introspector.getTables();
+                this.logger.info('Database connection successful');
+            }
+            catch (error) {
+                this.logger.warn('Database connection test failed, but continuing with initialization:', error);
+                // Continue with empty schema if connection test fails
+            }
+            // Discover schema - handle empty databases gracefully
             this.logger.info('Discovering database schema...');
-            const schemaInfo = await this.schemaDiscovery.discoverSchema();
-            this.logger.info(`Discovered ${schemaInfo.tables.length} tables`);
-            // Generate types
+            let schemaInfo;
+            try {
+                schemaInfo = await this.schemaDiscovery.discoverSchema();
+                this.logger.info(`Discovered ${schemaInfo.tables.length} tables`);
+            }
+            catch (error) {
+                // In test mode, throw the error instead of silently continuing
+                if (process.env.NODE_ENV === 'test') {
+                    this.logger.error('Schema discovery failed in test mode:', error);
+                    throw new Error(`Schema discovery failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+                this.logger.warn('Schema discovery failed, using empty schema:', error);
+                // Create empty schema info if discovery fails
+                schemaInfo = {
+                    tables: [],
+                    relationships: [],
+                    views: []
+                };
+            }
+            // Generate types - handle empty schema gracefully
             this.logger.info('Generating TypeScript types...');
-            const generatedTypes = this.typeGenerator.generateTypes(schemaInfo);
-            this.logger.info(`Generated types for ${generatedTypes.entities.length} entities`);
-            // Cache schema and types
-            await this.cacheManager.set('schema', schemaInfo);
-            await this.cacheManager.set('types', generatedTypes);
-            // Initialize relationship engine
-            this.relationshipEngine.initialize(schemaInfo.relationships);
-            // Initialize query analyzer for development mode
-            this.queryAnalyzer = new query_analyzer_js_1.QueryAnalyzer(this.db, this.logger, schemaInfo, {
-                enabled: this.config.performance?.enableQueryOptimization ?? true,
+            let generatedTypes;
+            try {
+                generatedTypes = this.typeGenerator.generateTypes(schemaInfo);
+                this.logger.info(`Generated types for ${generatedTypes.entities.length} entities`);
+            }
+            catch (error) {
+                this.logger.warn('Type generation failed, using empty types:', error);
+                // Create empty type info if generation fails
+                generatedTypes = {
+                    entities: [],
+                    relationships: [],
+                    types: {}
+                };
+            }
+            // Cache schema and types - handle caching errors gracefully
+            try {
+                await this.cacheManager.set('schema', schemaInfo);
+                await this.cacheManager.set('types', generatedTypes);
+            }
+            catch (error) {
+                this.logger.warn('Failed to cache schema/types, continuing without cache:', error);
+            }
+            // Initialize relationship engine - handle empty relationships
+            try {
+                this.relationshipEngine.initialize(schemaInfo.relationships);
+            }
+            catch (error) {
+                this.logger.warn('Failed to initialize relationship engine:', error);
+            }
+            // Initialize metrics collector for development mode
+            this.metricsCollector = new metrics_collector_js_1.MetricsCollector({
+                enabled: process.env.NODE_ENV === 'development',
                 slowQueryThreshold: 1000,
-                missingIndexDetection: true,
-                largeResultSetThreshold: 1000
-            });
+                nPlusOneDetection: true,
+                missingIndexDetection: true
+            }, this.logger);
             // Initialize SQLite-specific auto-optimization features
             if (this.config.dialect === 'sqlite') {
                 this.sqliteAutoOptimizer = sqlite_auto_optimizer_js_1.SQLiteAutoOptimizer.getInstance(this.logger);
                 this.sqliteAutoIndexer = sqlite_auto_indexer_js_1.SQLiteAutoIndexer.getInstance(this.logger);
                 // Apply automatic optimizations if enabled (default: true)
-                const enableAutoOptimization = this.config.performance?.enableAutoOptimization !== false;
+                const enableAutoOptimization = this.config.automation?.enableAutoOptimization !== false;
                 if (enableAutoOptimization) {
                     await this.applySQLiteAutoOptimizations();
                 }
@@ -209,8 +263,8 @@ class NOORMME {
         if (this.config.dialect === 'sqlite' && this.sqliteAutoIndexer) {
             this.sqliteAutoIndexer.recordQuery(query, executionTime, table);
         }
-        if (this.queryAnalyzer) {
-            this.queryAnalyzer.recordQuery(query, executionTime, undefined, table);
+        if (this.metricsCollector) {
+            this.metricsCollector.recordQuery(query, executionTime, { table });
         }
     }
     /**
@@ -247,7 +301,8 @@ class NOORMME {
         }
         const table = schemaInfo.tables.find(t => t.name === tableName);
         if (!table) {
-            throw new Error(`Table '${tableName}' not found in schema. Available tables: ${schemaInfo.tables.map(t => t.name).join(', ')}`);
+            const availableTables = schemaInfo.tables.map(t => t.name);
+            throw new NoormError_js_1.TableNotFoundError(tableName, availableTables);
         }
         const repository = this.repositoryFactory.createRepository(table, schemaInfo.relationships);
         this.repositories.set(tableName, repository);
@@ -301,28 +356,34 @@ class NOORMME {
     /**
      * Start monitoring schema changes in development mode
      */
-    startSchemaWatching(options) {
+    async startSchemaWatching(options) {
         if (!this.initialized) {
             throw new NoormError_js_1.NoormError('NOORMME must be initialized before starting schema watching');
         }
-        if (!this.schemaWatcher) {
-            this.schemaWatcher = new schema_watcher_js_1.SchemaWatcher(this.db, this.schemaDiscovery, this.logger, options);
-            // Auto-refresh schema when changes detected
-            this.schemaWatcher.onSchemaChange(async (changes) => {
-                this.logger.info(`Schema changes detected: ${changes.length} changes`);
-                changes.forEach(change => {
-                    this.logger.info(`  - ${change.type}: ${change.table}`);
-                });
-                try {
-                    await this.refreshSchema();
-                    this.logger.info('Schema refreshed successfully');
-                }
-                catch (error) {
-                    this.logger.error('Failed to refresh schema:', error);
-                }
-            });
+        // If watcher already exists (e.g., from onSchemaChange), recreate it with new options
+        if (this.schemaWatcher) {
+            this.schemaWatcher.stopWatching();
+        }
+        this.schemaWatcher = new schema_watcher_js_1.SchemaWatcher(this.db, this.schemaDiscovery, this.logger, options);
+        // Register all previously registered callbacks
+        for (const callback of this.schemaChangeCallbacks) {
+            this.schemaWatcher.onSchemaChange(callback);
         }
-        this.schemaWatcher.startWatching();
+        // Auto-refresh schema when changes detected
+        this.schemaWatcher.onSchemaChange(async (changes) => {
+            this.logger.info(`Schema changes detected: ${changes.length} changes`);
+            changes.forEach(change => {
+                this.logger.info(`  - ${change.type}: ${change.table}`);
+            });
+            try {
+                await this.refreshSchema();
+                this.logger.info('Schema refreshed successfully');
+            }
+            catch (error) {
+                this.logger.error('Failed to refresh schema:', error);
+            }
+        });
+        await this.schemaWatcher.startWatching();
     }
     /**
      * Stop monitoring schema changes
@@ -330,16 +391,19 @@ class NOORMME {
     stopSchemaWatching() {
         if (this.schemaWatcher) {
             this.schemaWatcher.stopWatching();
+            // Don't set to null - keep watcher instance for potential restart
         }
     }
     /**
      * Register callback for schema changes
      */
     onSchemaChange(callback) {
-        if (!this.schemaWatcher) {
-            this.schemaWatcher = new schema_watcher_js_1.SchemaWatcher(this.db, this.schemaDiscovery, this.logger);
+        // Store callback so it can be re-registered if watcher is recreated
+        this.schemaChangeCallbacks.push(callback);
+        // If watcher already exists, register callback immediately
+        if (this.schemaWatcher) {
+            this.schemaWatcher.onSchemaChange(callback);
         }
-        this.schemaWatcher.onSchemaChange(callback);
     }
     /**
      * Get performance metrics
@@ -351,10 +415,10 @@ class NOORMME {
             cacheHitRate: this.cacheManager.getHitRate(),
             repositoryCount: this.repositories.size
         };
-        if (this.queryAnalyzer) {
+        if (this.metricsCollector) {
             return {
                 ...baseMetrics,
-                ...this.queryAnalyzer.getPerformanceStats()
+                ...this.metricsCollector.getPerformanceStats()
             };
         }
         return baseMetrics;
@@ -370,16 +434,21 @@ class NOORMME {
         if (!schemaInfo) {
             throw new NoormError_js_1.NoormError('Schema not found. Please reinitialize NOORMME.');
         }
-        this.queryAnalyzer = new query_analyzer_js_1.QueryAnalyzer(this.db, this.logger, schemaInfo, options);
+        this.metricsCollector = new metrics_collector_js_1.MetricsCollector({
+            enabled: true,
+            slowQueryThreshold: options?.slowQueryThreshold || 1000,
+            nPlusOneDetection: true,
+            missingIndexDetection: true
+        }, this.logger);
         this.logger.info('Query performance monitoring enabled');
     }
     /**
      * Disable query performance monitoring
      */
     disablePerformanceMonitoring() {
-        if (this.queryAnalyzer) {
-            this.queryAnalyzer.clearHistory();
-            this.queryAnalyzer = null;
+        if (this.metricsCollector) {
+            this.metricsCollector.clear();
+            this.metricsCollector = null;
             this.logger.info('Query performance monitoring disabled');
         }
     }
@@ -396,6 +465,12 @@ class NOORMME {
         this.repositories.clear();
         this.logger.info('NOORMME closed');
     }
+    /**
+     * Alias for close() - for backward compatibility
+     */
+    async destroy() {
+        return this.close();
+    }
     /**
      * Get the underlying Kysely instance for custom queries
      */
@@ -411,11 +486,9 @@ class NOORMME {
     /**
      * Execute raw SQL
      */
-    async execute(sql, parameters) {
-        return await this.db.executeQuery({
-            sql,
-            parameters: parameters || []
-        });
+    async execute(sqlString, parameters) {
+        const compiledQuery = compiled_query_js_1.CompiledQuery.raw(sqlString, parameters || []);
+        return await this.db.executeQuery(compiledQuery);
     }
     mergeConfig(config) {
         return {
@@ -507,9 +580,8 @@ class NOORMME {
         const { dialect, connection } = this.config;
         switch (dialect) {
             case 'sqlite':
-                const Database = require('better-sqlite3');
-                return new (require('./dialect/sqlite/sqlite-dialect').SqliteDialect)({
-                    database: new Database(connection.database)
+                return new sqlite_dialect_js_1.SqliteDialect({
+                    database: new better_sqlite3_1.default(connection.database)
                 });
             default:
                 throw new Error(`Unsupported dialect: ${dialect}`);

package/dist/cjs/operation-node/column-node.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ColumnNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const identifier_node_js_1 = require("./identifier-node.js");
+const security_validator_js_1 = require("../util/security-validator.js");
 /**
  * @internal
  */
@@ -11,6 +12,9 @@ exports.ColumnNode = (0, object_utils_js_1.freeze)({
         return node.kind === 'ColumnNode';
     },
     create(column) {
+        // SECURITY: Validate column name to prevent SQL injection
+        // Even though IdentifierNode will validate, we validate here too for defense in depth
+        (0, security_validator_js_1.validateIdentifier)(column, 'column name');
         return (0, object_utils_js_1.freeze)({
             kind: 'ColumnNode',
             column: identifier_node_js_1.IdentifierNode.create(column),

package/dist/cjs/operation-node/identifier-node.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IdentifierNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const security_validator_js_1 = require("../util/security-validator.js");
 /**
  * @internal
  */
@@ -10,6 +11,9 @@ exports.IdentifierNode = (0, object_utils_js_1.freeze)({
         return node.kind === 'IdentifierNode';
     },
     create(name) {
+        // SECURITY: Validate identifier to prevent SQL injection at the lowest level
+        // This ensures ALL identifiers are validated, even when parsers are called directly
+        (0, security_validator_js_1.validateIdentifier)(name, 'identifier');
         return (0, object_utils_js_1.freeze)({
             kind: 'IdentifierNode',
             name,

package/dist/cjs/operation-node/table-node.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TableNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const schemable_identifier_node_js_1 = require("./schemable-identifier-node.js");
+const security_validator_js_1 = require("../util/security-validator.js");
 /**
  * @internal
  */
@@ -11,12 +12,18 @@ exports.TableNode = (0, object_utils_js_1.freeze)({
         return node.kind === 'TableNode';
     },
     create(table) {
+        // SECURITY: Validate table name to prevent SQL injection
+        // Even though SchemableIdentifierNode will validate, we validate here too for defense in depth
+        (0, security_validator_js_1.validateIdentifier)(table, 'table name');
         return (0, object_utils_js_1.freeze)({
             kind: 'TableNode',
             table: schemable_identifier_node_js_1.SchemableIdentifierNode.create(table),
         });
     },
     createWithSchema(schema, table) {
+        // SECURITY: Validate both schema and table names
+        (0, security_validator_js_1.validateIdentifier)(schema, 'schema name');
+        (0, security_validator_js_1.validateIdentifier)(table, 'table name');
         return (0, object_utils_js_1.freeze)({
             kind: 'TableNode',
             table: schemable_identifier_node_js_1.SchemableIdentifierNode.createWithSchema(schema, table),

package/dist/cjs/parser/reference-parser.js

@@ -54,13 +54,16 @@ function parseJSONReference(ref, op) {
 function parseStringReference(ref) {
     const COLUMN_SEPARATOR = '.';
     if (!ref.includes(COLUMN_SEPARATOR)) {
+        // SECURITY: ColumnNode.create will validate the column name
         return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(ref));
     }
     const parts = ref.split(COLUMN_SEPARATOR).map(trim);
     if (parts.length === 3) {
+        // SECURITY: parseStringReferenceWithTableAndSchema uses ColumnNode and TableNode which validate
         return parseStringReferenceWithTableAndSchema(parts);
     }
     if (parts.length === 2) {
+        // SECURITY: parseStringReferenceWithTable uses ColumnNode and TableNode which validate
         return parseStringReferenceWithTable(parts);
     }
     throw new Error(`invalid column reference ${ref}`);
@@ -93,10 +96,12 @@ function parseOrderedColumnName(column) {
 }
 function parseStringReferenceWithTableAndSchema(parts) {
     const [schema, table, column] = parts;
+    // SECURITY: Both ColumnNode.create and TableNode.createWithSchema validate their inputs
     return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(column), table_node_js_1.TableNode.createWithSchema(schema, table));
 }
 function parseStringReferenceWithTable(parts) {
     const [table, column] = parts;
+    // SECURITY: Both ColumnNode.create and TableNode.create validate their inputs
     return reference_node_js_1.ReferenceNode.create(column_node_js_1.ColumnNode.create(column), table_node_js_1.TableNode.create(table));
 }
 function trim(str) {

package/dist/cjs/parser/table-parser.js

@@ -43,9 +43,11 @@ function parseTable(from) {
     const SCHEMA_SEPARATOR = '.';
     if (from.includes(SCHEMA_SEPARATOR)) {
         const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
+        // SECURITY: TableNode.createWithSchema will validate both parts
         return table_node_js_1.TableNode.createWithSchema(schema, table);
     }
     else {
+        // SECURITY: TableNode.create will validate the table name
         return table_node_js_1.TableNode.create(from);
     }
 }

package/dist/cjs/performance/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Performance module exports
+ * Clean, focused services, utilities, and classes
+ */
+export * from './utils/query-parser';
+export * from './services/cache-service';
+export * from './services/metrics-collector';
+export * from './services/connection-factory';
+export * from './query-optimizer';
+/**
+ * Default performance configuration
+ */
+export declare const defaultPerformanceConfig: {
+    cache: {
+        maxSize: number;
+        defaultTtl: number;
+        cleanupInterval: number;
+        enableMetrics: boolean;
+    };
+    metrics: {
+        enabled: boolean;
+        slowQueryThreshold: number;
+        nPlusOneDetection: boolean;
+        missingIndexDetection: boolean;
+        largeResultSetThreshold: number;
+        maxHistorySize: number;
+        warningRetentionDays: number;
+    };
+    connectionPool: {
+        minConnections: number;
+        maxConnections: number;
+        acquireTimeout: number;
+        idleTimeout: number;
+        validationInterval: number;
+    };
+    optimizer: {
+        enableQueryCache: boolean;
+        enableIndexRecommendations: boolean;
+        enableQueryRewriting: boolean;
+        slowQueryThreshold: number;
+        cacheSize: number;
+        maxCacheAge: number;
+    };
+};

package/dist/cjs/performance/index.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Performance module exports
+ * Clean, focused services, utilities, and classes
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultPerformanceConfig = void 0;
+// Utilities
+__exportStar(require("./utils/query-parser"), exports);
+// Services
+__exportStar(require("./services/cache-service"), exports);
+__exportStar(require("./services/metrics-collector"), exports);
+__exportStar(require("./services/connection-factory"), exports);
+// Main optimizer
+__exportStar(require("./query-optimizer"), exports);
+/**
+ * Default performance configuration
+ */
+exports.defaultPerformanceConfig = {
+    cache: {
+        maxSize: 1000,
+        defaultTtl: 300000, // 5 minutes
+        cleanupInterval: 60000, // 1 minute
+        enableMetrics: true
+    },
+    metrics: {
+        enabled: true,
+        slowQueryThreshold: 1000,
+        nPlusOneDetection: true,
+        missingIndexDetection: true,
+        largeResultSetThreshold: 1000,
+        maxHistorySize: 10000,
+        warningRetentionDays: 7
+    },
+    connectionPool: {
+        minConnections: 2,
+        maxConnections: 10,
+        acquireTimeout: 30000,
+        idleTimeout: 300000,
+        validationInterval: 60000
+    },
+    optimizer: {
+        enableQueryCache: true,
+        enableIndexRecommendations: true,
+        enableQueryRewriting: true,
+        slowQueryThreshold: 1000,
+        cacheSize: 1000,
+        maxCacheAge: 300000
+    }
+};

package/dist/cjs/performance/query-optimizer.d.ts

@@ -0,0 +1,134 @@
+import { Kysely } from '../kysely';
+import { Logger } from '../logging/logger.js';
+import { SchemaInfo } from '../types';
+export interface QueryOptimizationOptions {
+    enableQueryCache: boolean;
+    enableIndexRecommendations: boolean;
+    enableQueryRewriting: boolean;
+    slowQueryThreshold: number;
+    cacheSize: number;
+    maxCacheAge: number;
+}
+export interface QueryOptimizationResult {
+    originalQuery: string;
+    optimizedQuery: string;
+    optimizationType: 'index_hint' | 'query_rewrite' | 'cache_hit' | 'no_optimization';
+    executionTime: number;
+    improvement: number;
+    suggestions: string[];
+    result?: any;
+}
+export interface IndexRecommendation {
+    table: string;
+    columns: string[];
+    type: 'btree' | 'hash' | 'unique';
+    reason: string;
+    estimatedImprovement: number;
+    priority: 'low' | 'medium' | 'high';
+}
+/**
+ * Refactored query optimizer using focused services
+ */
+export declare class QueryOptimizer {
+    private db;
+    private cacheService;
+    private metricsCollector;
+    private options;
+    private logger;
+    private schemaInfo;
+    constructor(db: Kysely<any>, schemaInfo: SchemaInfo, options?: Partial<QueryOptimizationOptions>, logger?: Logger);
+    /**
+     * Optimize and execute a query
+     */
+    optimizeQuery<T>(query: string, params?: any[], context?: {
+        table?: string;
+        operation?: string;
+    }): Promise<QueryOptimizationResult & {
+        result: T;
+    }>;
+    /**
+     * Get index recommendations
+     */
+    getIndexRecommendations(): Promise<IndexRecommendation[]>;
+    /**
+     * Get query performance statistics
+     */
+    getQueryStats(): {
+        cache: import("./services/cache-service").CacheStats;
+        indexRecommendations: number;
+        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;
+        }>;
+    };
+    /**
+     * Clear query cache
+     */
+    clearCache(): void;
+    /**
+     * Clear metrics
+     */
+    clearMetrics(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): import("./services/cache-service").CacheStats;
+    /**
+     * Get performance warnings
+     */
+    getPerformanceWarnings(): import("./services/metrics-collector").PerformanceWarning[];
+    /**
+     * Shutdown optimizer
+     */
+    shutdown(): void;
+    /**
+     * Analyze query for optimization opportunities
+     */
+    private analyzeQuery;
+    /**
+     * Optimize SELECT queries
+     */
+    private optimizeSelectQuery;
+    /**
+     * Optimize complex queries (joins, aggregates)
+     */
+    private optimizeComplexQuery;
+    /**
+     * Analyze query for index recommendations
+     */
+    private analyzeQueryForIndexes;
+    /**
+     * Deduplicate index recommendations
+     */
+    private deduplicateRecommendations;
+    /**
+     * Generate optimization suggestions
+     */
+    private generateSuggestions;
+    /**
+     * Execute a query with error handling
+     * Note: This creates a proper SQL query with parameters
+     */
+    private executeQuery;
+    /**
+     * Check if column has an index
+     */
+    private hasIndexOnColumn;
+}
+/**
+ * Factory function to create query optimizer
+ */
+export declare function createQueryOptimizer(db: Kysely<any>, schemaInfo: SchemaInfo, options?: Partial<QueryOptimizationOptions>, logger?: Logger): QueryOptimizer;