noormme 1.1.0 → 1.2.0

package/dist/cjs/migration/database_migration_manager.js

@@ -90,7 +90,7 @@ class DatabaseMigrationManager {
             this.logger.info('\n✅ Step 4: Verifying migration...');
             const verificationResult = await this.verifyMigration(filteredSourceSchema);
             result.warnings.push(...verificationResult.warnings);
-            result.success = result.errors.filter(e => e.fatal).length === 0;
+            result.success = result.errors.filter((e) => e.fatal).length === 0;
             result.duration = Date.now() - startTime;
             this.logger.info('\n🎉 Migration completed!');
             this.logger.info(`   Duration: ${(result.duration / 1000).toFixed(2)}s`);
@@ -146,14 +146,14 @@ class DatabaseMigrationManager {
         this.logger.info(`   Generated ${sqlStatements.length} SQL statements`);
         if (options.generateSQL) {
             this.logger.info('\nSQL Statements:');
-            sqlStatements.forEach(stmt => this.logger.info(stmt));
+            sqlStatements.forEach((stmt) => this.logger.info(stmt));
         }
         if (options.apply) {
             const result = await (0, schema_differ_js_1.applySchemaSyncronization)(this.targetDb, sqlStatements, options);
             this.logger.info(`   Applied ${result.appliedStatements} changes`);
             if (result.errors.length > 0) {
                 this.logger.error(`   Errors: ${result.errors.length}`);
-                result.errors.forEach(err => {
+                result.errors.forEach((err) => {
                     this.logger.error(`     ${err.sql}`);
                     this.logger.error(`     ${err.error.message}`);
                 });
@@ -199,11 +199,13 @@ class DatabaseMigrationManager {
      */
     filterTables(tables) {
         let filtered = tables;
-        if (this.config.options?.includeTables && this.config.options.includeTables.length > 0) {
-            filtered = filtered.filter(t => this.config.options.includeTables.includes(t.name));
+        if (this.config.options?.includeTables &&
+            this.config.options.includeTables.length > 0) {
+            filtered = filtered.filter((t) => this.config.options.includeTables.includes(t.name));
         }
-        if (this.config.options?.excludeTables && this.config.options.excludeTables.length > 0) {
-            filtered = filtered.filter(t => !this.config.options.excludeTables.includes(t.name));
+        if (this.config.options?.excludeTables &&
+            this.config.options.excludeTables.length > 0) {
+            filtered = filtered.filter((t) => !this.config.options.excludeTables.includes(t.name));
         }
         return filtered;
     }
@@ -219,9 +221,11 @@ class DatabaseMigrationManager {
         if (this.config.options?.dropTables) {
             this.logger.info('   Dropping existing tables...');
             for (const table of targetSchema) {
-                if (sourceSchema.find(t => t.name === table.name)) {
+                if (sourceSchema.find((t) => t.name === table.name)) {
                     try {
-                        await sql_js_1.sql.raw(`DROP TABLE IF EXISTS "${table.name}" CASCADE`).execute(this.targetDb);
+                        await sql_js_1.sql
+                            .raw(`DROP TABLE IF EXISTS "${table.name}" CASCADE`)
+                            .execute(this.targetDb);
                         this.logger.info(`     Dropped: ${table.name}`);
                     }
                     catch (error) {
@@ -233,7 +237,7 @@ class DatabaseMigrationManager {
         // Create tables
         for (const sourceTable of sourceSchema) {
             try {
-                const targetTable = targetSchema.find(t => t.name === sourceTable.name);
+                const targetTable = targetSchema.find((t) => t.name === sourceTable.name);
                 if (!targetTable || this.config.options?.dropTables) {
                     // Create table
                     await this.createTable(sourceTable);
@@ -292,8 +296,8 @@ class DatabaseMigrationManager {
         createSQL += columnDefs.join(',\n');
         // Add foreign keys
         for (const fk of sourceTable.foreignKeys) {
-            const fkCols = fk.columns.map(c => `"${c}"`).join(', ');
-            const refCols = fk.referencedColumns.map(c => `"${c}"`).join(', ');
+            const fkCols = fk.columns.map((c) => `"${c}"`).join(', ');
+            const refCols = fk.referencedColumns.map((c) => `"${c}"`).join(', ');
             createSQL += `,\n  FOREIGN KEY (${fkCols}) REFERENCES "${fk.referencedTable}" (${refCols})`;
             if (fk.onDelete) {
                 createSQL += ` ON DELETE ${fk.onDelete}`;
@@ -332,7 +336,7 @@ class DatabaseMigrationManager {
         const results = await (0, data_migrator_js_1.migrateAllTablesData)(this.sourceDb, this.targetDb, sourceSchema, targetSchema, this.config.source.dialect, this.config.target.dialect, options);
         const tablesProcessed = results.length;
         const rowsMigrated = results.reduce((sum, r) => sum + r.rowsMigrated, 0);
-        const errors = results.flatMap(r => r.errors);
+        const errors = results.flatMap((r) => r.errors);
         const warnings = [];
         for (const result of results) {
             if (result.errors.length > 0) {

package/dist/cjs/migration/schema_differ.js

@@ -13,8 +13,8 @@ const type_mapper_js_1 = require("./type_mapper.js");
  */
 function compareSchemas(sourceSchema, targetSchema, sourceDialect, targetDialect) {
     const differences = [];
-    const sourceTableMap = new Map(sourceSchema.map(t => [t.name, t]));
-    const targetTableMap = new Map(targetSchema.map(t => [t.name, t]));
+    const sourceTableMap = new Map(sourceSchema.map((t) => [t.name, t]));
+    const targetTableMap = new Map(targetSchema.map((t) => [t.name, t]));
     // Find added and modified tables
     for (const sourceTable of sourceSchema) {
         const targetTable = targetTableMap.get(sourceTable.name);
@@ -55,11 +55,17 @@ function compareSchemas(sourceSchema, targetSchema, sourceDialect, targetDialect
         }
     }
     // Calculate summary
-    const tablesAdded = differences.filter(d => d.type === 'table_added').length;
-    const tablesRemoved = differences.filter(d => d.type === 'table_removed').length;
+    const tablesAdded = differences.filter((d) => d.type === 'table_added').length;
+    const tablesRemoved = differences.filter((d) => d.type === 'table_removed').length;
     const tablesModified = new Set(differences
-        .filter(d => ['column_added', 'column_removed', 'column_modified', 'index_added', 'index_removed'].includes(d.type))
-        .map(d => d.table)).size;
+        .filter((d) => [
+        'column_added',
+        'column_removed',
+        'column_modified',
+        'index_added',
+        'index_removed',
+    ].includes(d.type))
+        .map((d) => d.table)).size;
     return {
         differences,
         sourceSchema,
@@ -75,8 +81,8 @@ function compareSchemas(sourceSchema, targetSchema, sourceDialect, targetDialect
 }
 function compareColumns(sourceTable, targetTable, sourceDialect, targetDialect) {
     const differences = [];
-    const sourceColumnMap = new Map(sourceTable.columns.map(c => [c.name, c]));
-    const targetColumnMap = new Map(targetTable.columns.map(c => [c.name, c]));
+    const sourceColumnMap = new Map(sourceTable.columns.map((c) => [c.name, c]));
+    const targetColumnMap = new Map(targetTable.columns.map((c) => [c.name, c]));
     // Check for added and modified columns
     for (const sourceColumn of sourceTable.columns) {
         const targetColumn = targetColumnMap.get(sourceColumn.name);
@@ -140,8 +146,8 @@ function compareColumns(sourceTable, targetTable, sourceDialect, targetDialect)
 }
 function compareIndexes(sourceTable, targetTable) {
     const differences = [];
-    const sourceIndexMap = new Map(sourceTable.indexes.map(i => [i.name, i]));
-    const targetIndexMap = new Map(targetTable.indexes.map(i => [i.name, i]));
+    const sourceIndexMap = new Map(sourceTable.indexes.map((i) => [i.name, i]));
+    const targetIndexMap = new Map(targetTable.indexes.map((i) => [i.name, i]));
     // Check for added indexes
     for (const sourceIndex of sourceTable.indexes) {
         const targetIndex = targetIndexMap.get(sourceIndex.name);
@@ -231,7 +237,8 @@ function generateSyncSQL(comparison, targetDialect) {
     return sqlStatements;
 }
 function generateCreateTableSQL(table, targetDialect) {
-    const columns = table.columns.map(col => {
+    const columns = table.columns
+        .map((col) => {
         let colDef = `"${col.name}" ${col.type}`;
         if (col.primaryKey) {
             colDef += ' PRIMARY KEY';
@@ -249,13 +256,14 @@ function generateCreateTableSQL(table, targetDialect) {
             colDef += ` DEFAULT ${col.defaultValue}`;
         }
         return colDef;
-    }).join(',\n  ');
+    })
+        .join(',\n  ');
     let sql = `CREATE TABLE "${table.name}" (\n  ${columns}`;
     // Add foreign keys
     if (table.foreignKeys.length > 0) {
         for (const fk of table.foreignKeys) {
-            const fkCols = fk.columns.map(c => `"${c}"`).join(', ');
-            const refCols = fk.referencedColumns.map(c => `"${c}"`).join(', ');
+            const fkCols = fk.columns.map((c) => `"${c}"`).join(', ');
+            const refCols = fk.referencedColumns.map((c) => `"${c}"`).join(', ');
             sql += `,\n  FOREIGN KEY (${fkCols}) REFERENCES "${fk.referencedTable}" (${refCols})`;
             if (fk.onDelete) {
                 sql += ` ON DELETE ${fk.onDelete}`;

package/dist/cjs/migration/schema_introspector.js

@@ -34,8 +34,8 @@ async function introspectSQLiteSchema(db) {
         const rowCount = countResult.rows[0]?.count || 0;
         // Get primary key
         const primaryKey = columns
-            .filter(col => col.primaryKey)
-            .map(col => col.name);
+            .filter((col) => col.primaryKey)
+            .map((col) => col.name);
         tables.push({
             name: tableName,
             columns,
@@ -120,9 +120,9 @@ async function introspectSQLiteForeignKeys(db, tableName) {
     for (const rows of fkMap.values()) {
         const first = rows[0];
         foreignKeys.push({
-            columns: rows.map(r => r.from),
+            columns: rows.map((r) => r.from),
             referencedTable: first.table,
-            referencedColumns: rows.map(r => r.to),
+            referencedColumns: rows.map((r) => r.to),
             onDelete: first.on_delete,
             onUpdate: first.on_update,
         });
@@ -177,8 +177,8 @@ async function introspectPostgreSQLSchema(db) {
         const rowCount = parseInt(countResult.rows[0]?.count || '0', 10);
         // Get primary key
         const primaryKey = columns
-            .filter(col => col.primaryKey)
-            .map(col => col.name);
+            .filter((col) => col.primaryKey)
+            .map((col) => col.name);
         tables.push({
             name: tableName,
             columns,
@@ -315,9 +315,9 @@ async function introspectPostgreSQLForeignKeys(db, tableName) {
         const first = rows[0];
         foreignKeys.push({
             name: constraintName,
-            columns: rows.map(r => r.column_name),
+            columns: rows.map((r) => r.column_name),
             referencedTable: first.foreign_table_name,
-            referencedColumns: rows.map(r => r.foreign_column_name),
+            referencedColumns: rows.map((r) => r.foreign_column_name),
             onDelete: first.delete_rule?.toUpperCase(),
             onUpdate: first.update_rule?.toUpperCase(),
         });

package/dist/cjs/migration/type_mapper.js

@@ -12,99 +12,99 @@ exports.areTypesCompatible = areTypesCompatible;
  */
 exports.SQLITE_TO_POSTGRES_TYPES = {
     // Integer types
-    'INTEGER': 'INTEGER',
-    'INT': 'INTEGER',
-    'TINYINT': 'SMALLINT',
-    'SMALLINT': 'SMALLINT',
-    'MEDIUMINT': 'INTEGER',
-    'BIGINT': 'BIGINT',
+    INTEGER: 'INTEGER',
+    INT: 'INTEGER',
+    TINYINT: 'SMALLINT',
+    SMALLINT: 'SMALLINT',
+    MEDIUMINT: 'INTEGER',
+    BIGINT: 'BIGINT',
     // Real/Float types
-    'REAL': 'REAL',
-    'DOUBLE': 'DOUBLE PRECISION',
+    REAL: 'REAL',
+    DOUBLE: 'DOUBLE PRECISION',
     'DOUBLE PRECISION': 'DOUBLE PRECISION',
-    'FLOAT': 'REAL',
+    FLOAT: 'REAL',
     // Numeric/Decimal
-    'NUMERIC': 'NUMERIC',
-    'DECIMAL': 'DECIMAL',
+    NUMERIC: 'NUMERIC',
+    DECIMAL: 'DECIMAL',
     // Text types
-    'TEXT': 'TEXT',
-    'CHARACTER': 'VARCHAR',
-    'VARCHAR': 'VARCHAR',
+    TEXT: 'TEXT',
+    CHARACTER: 'VARCHAR',
+    VARCHAR: 'VARCHAR',
     'VARYING CHARACTER': 'VARCHAR',
-    'NCHAR': 'VARCHAR',
+    NCHAR: 'VARCHAR',
     'NATIVE CHARACTER': 'VARCHAR',
-    'NVARCHAR': 'VARCHAR',
-    'CLOB': 'TEXT',
+    NVARCHAR: 'VARCHAR',
+    CLOB: 'TEXT',
     // Binary types
-    'BLOB': 'BYTEA',
+    BLOB: 'BYTEA',
     // Boolean
-    'BOOLEAN': 'BOOLEAN',
+    BOOLEAN: 'BOOLEAN',
     // Date/Time types (SQLite stores as text/integer)
-    'DATE': 'DATE',
-    'DATETIME': 'TIMESTAMP',
-    'TIMESTAMP': 'TIMESTAMP',
-    'TIME': 'TIME',
+    DATE: 'DATE',
+    DATETIME: 'TIMESTAMP',
+    TIMESTAMP: 'TIMESTAMP',
+    TIME: 'TIME',
 };
 /**
  * Map PostgreSQL types to SQLite types
  */
 exports.POSTGRES_TO_SQLITE_TYPES = {
     // Integer types
-    'INTEGER': 'INTEGER',
-    'INT': 'INTEGER',
-    'INT4': 'INTEGER',
-    'SMALLINT': 'INTEGER',
-    'INT2': 'INTEGER',
-    'BIGINT': 'INTEGER',
-    'INT8': 'INTEGER',
-    'SERIAL': 'INTEGER',
-    'BIGSERIAL': 'INTEGER',
-    'SMALLSERIAL': 'INTEGER',
+    INTEGER: 'INTEGER',
+    INT: 'INTEGER',
+    INT4: 'INTEGER',
+    SMALLINT: 'INTEGER',
+    INT2: 'INTEGER',
+    BIGINT: 'INTEGER',
+    INT8: 'INTEGER',
+    SERIAL: 'INTEGER',
+    BIGSERIAL: 'INTEGER',
+    SMALLSERIAL: 'INTEGER',
     // Float types
-    'REAL': 'REAL',
-    'FLOAT4': 'REAL',
+    REAL: 'REAL',
+    FLOAT4: 'REAL',
     'DOUBLE PRECISION': 'REAL',
-    'FLOAT8': 'REAL',
+    FLOAT8: 'REAL',
     // Numeric
-    'NUMERIC': 'NUMERIC',
-    'DECIMAL': 'NUMERIC',
+    NUMERIC: 'NUMERIC',
+    DECIMAL: 'NUMERIC',
     // Text types
-    'TEXT': 'TEXT',
-    'VARCHAR': 'TEXT',
+    TEXT: 'TEXT',
+    VARCHAR: 'TEXT',
     'CHARACTER VARYING': 'TEXT',
-    'CHAR': 'TEXT',
-    'CHARACTER': 'TEXT',
-    'BPCHAR': 'TEXT',
+    CHAR: 'TEXT',
+    CHARACTER: 'TEXT',
+    BPCHAR: 'TEXT',
     // Binary
-    'BYTEA': 'BLOB',
+    BYTEA: 'BLOB',
     // Boolean
-    'BOOLEAN': 'INTEGER',
-    'BOOL': 'INTEGER',
+    BOOLEAN: 'INTEGER',
+    BOOL: 'INTEGER',
     // Date/Time
-    'DATE': 'TEXT',
-    'TIME': 'TEXT',
-    'TIMESTAMP': 'TEXT',
-    'TIMESTAMPTZ': 'TEXT',
+    DATE: 'TEXT',
+    TIME: 'TEXT',
+    TIMESTAMP: 'TEXT',
+    TIMESTAMPTZ: 'TEXT',
     'TIMESTAMP WITH TIME ZONE': 'TEXT',
     'TIMESTAMP WITHOUT TIME ZONE': 'TEXT',
-    'INTERVAL': 'TEXT',
+    INTERVAL: 'TEXT',
     // JSON
-    'JSON': 'TEXT',
-    'JSONB': 'TEXT',
+    JSON: 'TEXT',
+    JSONB: 'TEXT',
     // UUID
-    'UUID': 'TEXT',
+    UUID: 'TEXT',
     // Network types
-    'INET': 'TEXT',
-    'CIDR': 'TEXT',
-    'MACADDR': 'TEXT',
+    INET: 'TEXT',
+    CIDR: 'TEXT',
+    MACADDR: 'TEXT',
     // Geometric types (simplified)
-    'POINT': 'TEXT',
-    'LINE': 'TEXT',
-    'LSEG': 'TEXT',
-    'BOX': 'TEXT',
-    'PATH': 'TEXT',
-    'POLYGON': 'TEXT',
-    'CIRCLE': 'TEXT',
+    POINT: 'TEXT',
+    LINE: 'TEXT',
+    LSEG: 'TEXT',
+    BOX: 'TEXT',
+    PATH: 'TEXT',
+    POLYGON: 'TEXT',
+    CIRCLE: 'TEXT',
     // Array types - convert to TEXT in SQLite
     'TEXT[]': 'TEXT',
     'INTEGER[]': 'TEXT',
@@ -116,8 +116,8 @@ exports.POSTGRES_TO_SQLITE_TYPES = {
     'JSON[]': 'TEXT',
     'JSONB[]': 'TEXT',
     // Full-text search
-    'TSVECTOR': 'TEXT',
-    'TSQUERY': 'TEXT',
+    TSVECTOR: 'TEXT',
+    TSQUERY: 'TEXT',
 };
 /**
  * Map type from source dialect to target dialect
@@ -259,5 +259,6 @@ function areTypesCompatible(sourceType, targetType, sourceDialect, targetDialect
         return sourceType.toUpperCase() === targetType.toUpperCase();
     }
     const mapped = mapType(sourceType, sourceDialect, targetDialect);
-    return mapped.toUpperCase().split('(')[0] === targetType.toUpperCase().split('(')[0];
+    return (mapped.toUpperCase().split('(')[0] ===
+        targetType.toUpperCase().split('(')[0]);
 }

package/dist/cjs/noormme.js

@@ -86,7 +86,9 @@ class NOORMME {
         this.dialect = this.createDialect();
         this.db = new kysely_js_1.Kysely({
             dialect: this.dialect,
-            log: this.config.logging?.enabled ? this.logger.createKyselyLogger() : undefined
+            log: this.config.logging?.enabled
+                ? this.logger.createKyselyLogger()
+                : undefined,
         });
         // Initialize core components
         this.schemaDiscovery = new schema_discovery_js_1.SchemaDiscovery(this.db, this.config.introspection, this.dialect);
@@ -100,7 +102,7 @@ class NOORMME {
                 : null,
             schema: new agent_schema_js_1.AgentSchemaHelper(this.db, agenticConfig),
             cortex: new Cortex_js_1.Cortex(this.db, this.config),
-            evolution: new schema_evolution_js_1.SchemaEvolutionHelper(this.db)
+            evolution: new schema_evolution_js_1.SchemaEvolutionHelper(this.db),
         };
         this.repositoryFactory = new repository_factory_js_1.RepositoryFactory(this.db, this.config.performance, this.agent.cortex);
         this.relationshipEngine = new relationship_engine_js_1.RelationshipEngine(this.db, this.config.performance);
@@ -167,7 +169,7 @@ class NOORMME {
                 schemaInfo = {
                     tables: [],
                     relationships: [],
-                    views: []
+                    views: [],
                 };
             }
             // Generate types - handle empty schema gracefully
@@ -183,7 +185,7 @@ class NOORMME {
                 generatedTypes = {
                     entities: [],
                     relationships: [],
-                    types: {}
+                    types: {},
                 };
             }
             // Cache schema and types - handle caching errors gracefully
@@ -207,7 +209,7 @@ class NOORMME {
                 slowQueryThreshold: 1000,
                 nPlusOneDetection: true,
                 missingIndexDetection: true,
-                persistPath: process.env.NOORMME_METRICS_PATH || '.noormme/metrics.json'
+                persistPath: process.env.NOORMME_METRICS_PATH || '.noormme/metrics.json',
             }, this.logger);
             // Initialize SQLite-specific auto-optimization features
             if (this.config.dialect === 'sqlite') {
@@ -245,15 +247,15 @@ class NOORMME {
             const result = await this.sqliteAutoOptimizer.optimizeDatabase(this.db, config);
             if (result.appliedOptimizations.length > 0) {
                 this.logger.info(`Applied ${result.appliedOptimizations.length} SQLite optimizations`);
-                result.appliedOptimizations.forEach(opt => this.logger.debug(`  ✓ ${opt}`));
+                result.appliedOptimizations.forEach((opt) => this.logger.debug(`  ✓ ${opt}`));
             }
             if (result.recommendations.length > 0) {
                 this.logger.info(`Generated ${result.recommendations.length} recommendations`);
-                result.recommendations.forEach(rec => this.logger.debug(`  💡 ${rec}`));
+                result.recommendations.forEach((rec) => this.logger.debug(`  💡 ${rec}`));
             }
             if (result.warnings.length > 0) {
                 this.logger.warn(`Found ${result.warnings.length} warnings`);
-                result.warnings.forEach(warning => this.logger.warn(`  ⚠️ ${warning}`));
+                result.warnings.forEach((warning) => this.logger.warn(`  ⚠️ ${warning}`));
             }
         }
         catch (error) {
@@ -338,9 +340,9 @@ class NOORMME {
         if (!schemaInfo) {
             throw new Error('Schema not found. Please reinitialize NOORMME.');
         }
-        const table = schemaInfo.tables.find(t => t.name === tableName);
+        const table = schemaInfo.tables.find((t) => t.name === tableName);
         if (!table) {
-            const availableTables = schemaInfo.tables.map(t => t.name);
+            const availableTables = schemaInfo.tables.map((t) => t.name);
             throw new NoormError_js_1.TableNotFoundError(tableName, availableTables);
         }
         const repository = this.repositoryFactory.createRepository(table, schemaInfo.relationships);
@@ -411,7 +413,7 @@ class NOORMME {
         // Auto-refresh schema when changes detected
         this.schemaWatcher.onSchemaChange(async (changes) => {
             this.logger.info(`Schema changes detected: ${changes.length} changes`);
-            changes.forEach(change => {
+            changes.forEach((change) => {
                 this.logger.info(`  - ${change.type}: ${change.table}`);
             });
             try {
@@ -452,12 +454,12 @@ class NOORMME {
             queryCount: this.logger.getQueryCount(),
             averageQueryTime: this.logger.getAverageQueryTime(),
             cacheHitRate: this.cacheManager.getHitRate(),
-            repositoryCount: this.repositories.size
+            repositoryCount: this.repositories.size,
         };
         if (this.metricsCollector) {
             return {
                 ...baseMetrics,
-                ...this.metricsCollector.getPerformanceStats()
+                ...this.metricsCollector.getPerformanceStats(),
             };
         }
         return baseMetrics;
@@ -477,7 +479,7 @@ class NOORMME {
             enabled: true,
             slowQueryThreshold: options?.slowQueryThreshold || 1000,
             nPlusOneDetection: true,
-            missingIndexDetection: true
+            missingIndexDetection: true,
         }, this.logger);
         this.logger.info('Query performance monitoring enabled');
     }
@@ -537,27 +539,27 @@ class NOORMME {
                 includeViews: false,
                 excludeTables: [],
                 customTypeMappings: {},
-                ...config.introspection
+                ...config.introspection,
             },
             cache: {
                 ttl: 300000, // 5 minutes
                 maxSize: 1000,
                 strategy: 'lru',
-                ...config.cache
+                ...config.cache,
             },
             logging: {
                 level: 'info',
                 enabled: true,
-                ...config.logging
+                ...config.logging,
             },
             performance: {
                 enableQueryOptimization: true,
                 enableBatchLoading: true,
                 maxBatchSize: 100,
-                ...config.performance
+                ...config.performance,
             },
             agentic: config.agentic,
-            automation: config.automation
+            automation: config.automation,
         };
     }
     /**
@@ -581,7 +583,7 @@ class NOORMME {
                 default:
                     throw new NoormError_js_1.NoormError(`Unsupported database protocol: ${url.protocol}`, {
                         operation: 'connection_string_parsing',
-                        suggestion: 'Supported protocols: sqlite, postgresql, postgres, mysql'
+                        suggestion: 'Supported protocols: sqlite, postgresql, postgres, mysql',
                     });
             }
             if (dialect === 'sqlite') {
@@ -592,8 +594,8 @@ class NOORMME {
                         host: '',
                         port: 0,
                         username: '',
-                        password: ''
-                    }
+                        password: '',
+                    },
                 };
             }
             if (dialect === 'postgresql' || dialect === 'mysql') {
@@ -610,23 +612,31 @@ class NOORMME {
                     }
                     else {
                         // For other SSL modes, we'll need more configuration
-                        ssl = { rejectUnauthorized: sslParam !== 'allow' && sslParam !== 'prefer' };
+                        ssl = {
+                            rejectUnauthorized: sslParam !== 'allow' && sslParam !== 'prefer',
+                        };
                     }
                 }
                 return {
                     dialect,
                     connection: {
                         host: url.hostname || 'localhost',
-                        port: url.port ? parseInt(url.port, 10) : this.getDefaultPort(dialect),
+                        port: url.port
+                            ? parseInt(url.port, 10)
+                            : this.getDefaultPort(dialect),
                         database: url.pathname.replace(/^\//, ''),
                         username: url.username || undefined,
                         password: url.password || undefined,
                         ssl,
                         pool: {
-                            max: searchParams.get('pool_max') ? parseInt(searchParams.get('pool_max'), 10) : 10,
-                            min: searchParams.get('pool_min') ? parseInt(searchParams.get('pool_min'), 10) : 0,
-                        }
-                    }
+                            max: searchParams.get('pool_max')
+                                ? parseInt(searchParams.get('pool_max'), 10)
+                                : 10,
+                            min: searchParams.get('pool_min')
+                                ? parseInt(searchParams.get('pool_min'), 10)
+                                : 0,
+                        },
+                    },
                 };
             }
             return {
@@ -637,14 +647,15 @@ class NOORMME {
                     database: url.pathname.slice(1), // Remove leading slash
                     username: url.username || '',
                     password: url.password || '',
-                    ssl: url.searchParams.get('ssl') === 'true' || url.searchParams.get('sslmode') === 'require'
-                }
+                    ssl: url.searchParams.get('ssl') === 'true' ||
+                        url.searchParams.get('sslmode') === 'require',
+                },
             };
         }
         catch (error) {
             throw new NoormError_js_1.NoormError(`Failed to parse connection string: ${error instanceof Error ? error.message : String(error)}`, {
                 operation: 'connection_string_parsing',
-                suggestion: 'Ensure connection string format is: protocol://username:password@host:port/database'
+                suggestion: 'Ensure connection string format is: protocol://username:password@host:port/database',
             });
         }
     }
@@ -653,10 +664,14 @@ class NOORMME {
      */
     getDefaultPort(dialect) {
         switch (dialect) {
-            case 'sqlite': return 0;
-            case 'postgresql': return 5432;
-            case 'mysql': return 3306;
-            default: return 0;
+            case 'sqlite':
+                return 0;
+            case 'postgresql':
+                return 5432;
+            case 'mysql':
+                return 3306;
+            default:
+                return 0;
         }
     }
     createDialect() {
@@ -664,7 +679,7 @@ class NOORMME {
         switch (dialect) {
             case 'sqlite':
                 return new sqlite_dialect_js_1.SqliteDialect({
-                    database: new better_sqlite3_1.default(connection.database)
+                    database: new better_sqlite3_1.default(connection.database),
                 });
             case 'postgresql':
                 return new postgresql_dialect_js_1.PostgresDialect({
@@ -678,7 +693,7 @@ class NOORMME {
                         max: connection.pool?.max ?? 10,
                         min: connection.pool?.min ?? 0,
                         idleTimeoutMillis: connection.pool?.idleTimeoutMillis ?? 10000,
-                    }
+                    },
                 });
             default:
                 throw new Error(`Unsupported dialect: ${dialect}`);