noormme 1.0.6 → 1.2.0

package/dist/cjs/schema/dialects/postgresql/postgresql-discovery.coordinator.js

@@ -33,7 +33,7 @@ class PostgresDiscoveryCoordinator {
         const discoveryConfig = {
             excludeTables: config.excludeTables,
             includeViews: config.includeViews,
-            customTypeMappings: config.customTypeMappings
+            customTypeMappings: config.customTypeMappings,
         };
         // Discover tables
         let tables = [];
@@ -47,7 +47,8 @@ class PostgresDiscoveryCoordinator {
         // Discover relationships
         let relationships = [];
         try {
-            relationships = await this.relationshipDiscovery.discoverRelationships(tables);
+            relationships =
+                await this.relationshipDiscovery.discoverRelationships(tables);
         }
         catch (error) {
             console.warn('PostgreSQL relationship discovery failed:', error);
@@ -58,11 +59,11 @@ class PostgresDiscoveryCoordinator {
         if (discoveryConfig.includeViews) {
             try {
                 const viewMetadata = await this.viewDiscovery.discoverViews(introspector);
-                views = viewMetadata.map(view => ({
+                views = viewMetadata.map((view) => ({
                     name: view.name,
                     schema: view.schema,
                     definition: view.definition || '',
-                    columns: view.columns || []
+                    columns: view.columns || [],
                 }));
             }
             catch (error) {
@@ -73,7 +74,7 @@ class PostgresDiscoveryCoordinator {
         return {
             tables,
             relationships,
-            views
+            views,
         };
     }
     /**
@@ -97,7 +98,7 @@ class PostgresDiscoveryCoordinator {
             supportsAutoIncrement: true, // via serial or identity
             supportsRowId: false,
             supportsTriggers: true,
-            supportsFullTextSearch: true
+            supportsFullTextSearch: true,
         };
     }
     /**
@@ -109,7 +110,7 @@ class PostgresDiscoveryCoordinator {
             'Enable SSL for secure database connections',
             'Consider using JSONB for unstructured data',
             'Use appropriate isolation levels for transactions',
-            'Monitor slow queries using pg_stat_statements'
+            'Monitor slow queries using pg_stat_statements',
         ];
     }
 }

package/dist/cjs/schema/dialects/sqlite/discovery/sqlite-constraint-discovery.js

@@ -44,7 +44,7 @@ class SQLiteConstraintDiscovery {
         const columnMatches = sql.match(/CREATE TABLE[^(]*\(([^)]+)\)/i);
         if (!columnMatches)
             return constraints;
-        const definitions = columnMatches[1].split(',').map(def => def.trim());
+        const definitions = columnMatches[1].split(',').map((def) => def.trim());
         for (const definition of definitions) {
             // Primary key constraints
             if (definition.toUpperCase().includes('PRIMARY KEY')) {
@@ -54,7 +54,7 @@ class SQLiteConstraintDiscovery {
                         name: `${tableName}_pk`,
                         type: 'p',
                         columns: [pkMatch[1]],
-                        definition: definition
+                        definition: definition,
                     });
                 }
             }
@@ -68,7 +68,7 @@ class SQLiteConstraintDiscovery {
                         column: fkMatch[1],
                         referencedTable: fkMatch[2],
                         referencedColumn: fkMatch[3],
-                        definition: definition
+                        definition: definition,
                     });
                 }
             }
@@ -80,7 +80,7 @@ class SQLiteConstraintDiscovery {
                         name: `${tableName}_check_${constraints.length + 1}`,
                         type: 'c',
                         definition: checkMatch[1],
-                        fullDefinition: definition
+                        fullDefinition: definition,
                     });
                 }
             }
@@ -91,8 +91,8 @@ class SQLiteConstraintDiscovery {
                     constraints.push({
                         name: `${tableName}_unique_${constraints.length + 1}`,
                         type: 'u',
-                        columns: uniqueMatch[1].split(',').map(col => col.trim()),
-                        definition: definition
+                        columns: uniqueMatch[1].split(',').map((col) => col.trim()),
+                        definition: definition,
                     });
                 }
             }
@@ -104,7 +104,7 @@ class SQLiteConstraintDiscovery {
                         name: `${tableName}_nn_${notNullMatch[1]}`,
                         type: 'n',
                         column: notNullMatch[1],
-                        definition: definition
+                        definition: definition,
                     });
                 }
             }
@@ -125,7 +125,7 @@ class SQLiteConstraintDiscovery {
                 // If 'to' is null/undefined, the FK references the primary key (default to 'id')
                 referencedColumn: row.to || 'id',
                 onDelete: row.on_delete || 'NO ACTION',
-                onUpdate: row.on_update || 'NO ACTION'
+                onUpdate: row.on_update || 'NO ACTION',
             }));
         }
         catch (error) {
@@ -177,7 +177,7 @@ class SQLiteConstraintDiscovery {
         }
         return {
             isValid: issues.length === 0,
-            issues
+            issues,
         };
     }
     /**
@@ -205,7 +205,7 @@ class SQLiteConstraintDiscovery {
         }
         return {
             recommendations,
-            compatibilityIssues
+            compatibilityIssues,
         };
     }
     /**
@@ -262,7 +262,7 @@ class SQLiteConstraintDiscovery {
                 issues,
                 recommendations,
                 orphanedRecords,
-                performanceImpact
+                performanceImpact,
             };
         }
         catch (error) {
@@ -272,7 +272,7 @@ class SQLiteConstraintDiscovery {
                 issues,
                 recommendations: ['Check database connection and permissions'],
                 orphanedRecords: [],
-                performanceImpact: 'high'
+                performanceImpact: 'high',
             };
         }
     }
@@ -439,7 +439,7 @@ class SQLiteConstraintDiscovery {
                 indexRecommendations,
                 constraintRecommendations,
                 cleanupRecommendations,
-                performanceRecommendations
+                performanceRecommendations,
             };
         }
         catch (error) {
@@ -447,7 +447,9 @@ class SQLiteConstraintDiscovery {
                 indexRecommendations: [],
                 constraintRecommendations: [],
                 cleanupRecommendations: [],
-                performanceRecommendations: [`Error generating recommendations: ${error}`]
+                performanceRecommendations: [
+                    `Error generating recommendations: ${error}`,
+                ],
             };
         }
     }
@@ -455,7 +457,7 @@ class SQLiteConstraintDiscovery {
      * Auto-fix common foreign key issues
      */
     async autoFixForeignKeyIssues(db, options = {}) {
-        const { createMissingIndexes = true, enableForeignKeys = true, cleanupOrphanedRecords = false, dryRun = true } = options;
+        const { createMissingIndexes = true, enableForeignKeys = true, cleanupOrphanedRecords = false, dryRun = true, } = options;
         const applied = [];
         const failed = [];
         const skipped = [];

package/dist/cjs/schema/dialects/sqlite/discovery/sqlite-index-discovery.js

@@ -24,7 +24,7 @@ class SQLiteIndexDiscovery {
                 'name',
                 'sql as definition',
                 (0, sql_js_1.sql) `type = 'index'`.as('isIndex'),
-                (0, sql_js_1.sql) `sql LIKE '%UNIQUE%'`.as('unique')
+                (0, sql_js_1.sql) `sql LIKE '%UNIQUE%'`.as('unique'),
             ])
                 .where('type', '=', 'index')
                 .where('tbl_name', '=', tableName)
@@ -34,7 +34,7 @@ class SQLiteIndexDiscovery {
                 ...index,
                 columns: this.extractColumnsFromSQL(index.definition),
                 isPrimary: index.name.includes('sqlite_autoindex'),
-                comment: null // SQLite doesn't support index comments
+                comment: null, // SQLite doesn't support index comments
             }));
             return processedIndexes;
         }
@@ -55,8 +55,8 @@ class SQLiteIndexDiscovery {
         if (match) {
             return match[1]
                 .split(',')
-                .map(col => col.trim().replace(/^\s*["']?|["']?\s*$/g, ''))
-                .filter(col => col.length > 0);
+                .map((col) => col.trim().replace(/^\s*["']?|["']?\s*$/g, ''))
+                .filter((col) => col.length > 0);
         }
         return [];
     }
@@ -82,12 +82,12 @@ class SQLiteIndexDiscovery {
         const missingIndexes = [];
         const redundantIndexes = [];
         // Check for auto-generated indexes that might be redundant
-        const autoIndexes = indexes.filter(idx => idx.isPrimary);
+        const autoIndexes = indexes.filter((idx) => idx.isPrimary);
         if (autoIndexes.length > 1) {
             recommendations.push('Multiple auto-generated indexes found - review table structure');
         }
         // Check for indexes with no columns (invalid)
-        const invalidIndexes = indexes.filter(idx => !idx.columns || idx.columns.length === 0);
+        const invalidIndexes = indexes.filter((idx) => !idx.columns || idx.columns.length === 0);
         for (const idx of invalidIndexes) {
             recommendations.push(`Invalid index found: ${idx.name} (no columns)`);
         }
@@ -109,7 +109,7 @@ class SQLiteIndexDiscovery {
         return {
             recommendations,
             missingIndexes,
-            redundantIndexes
+            redundantIndexes,
         };
     }
     /**
@@ -121,7 +121,7 @@ class SQLiteIndexDiscovery {
             return {
                 rowCount: result.rows?.[0]?.rowCount || 0,
                 size: 0, // SQLite doesn't provide direct size info
-                lastModified: new Date()
+                lastModified: new Date(),
             };
         }
         catch (error) {

package/dist/cjs/schema/dialects/sqlite/introspection/sqlite-schema-introspector.js

@@ -17,13 +17,7 @@ class SQLiteSchemaIntrospector extends database_introspector_js_1.DatabaseIntros
         try {
             const tables = await this.db
                 .selectFrom('sqlite_master')
-                .select([
-                'name',
-                'type',
-                'tbl_name',
-                'rootpage',
-                'sql'
-            ])
+                .select(['name', 'type', 'tbl_name', 'rootpage', 'sql'])
                 .where('type', '=', 'table')
                 .execute();
             const enhancedTables = [];
@@ -41,7 +35,7 @@ class SQLiteSchemaIntrospector extends database_introspector_js_1.DatabaseIntros
                         hasTriggers: false, // Will be determined separately
                         tableType: 'table',
                         lastAnalyzed: null,
-                        lastAutoAnalyzed: null
+                        lastAutoAnalyzed: null,
                     });
                 }
                 catch (error) {
@@ -73,7 +67,7 @@ class SQLiteSchemaIntrospector extends database_introspector_js_1.DatabaseIntros
                 'synchronous',
                 'journal_mode',
                 'auto_vacuum',
-                'integrity_check'
+                'integrity_check',
             ];
             for (const pragma of pragmas) {
                 try {
@@ -100,7 +94,7 @@ class SQLiteSchemaIntrospector extends database_introspector_js_1.DatabaseIntros
                 pageSize: stats.page_size,
                 journalMode: stats.journal_mode,
                 autoVacuum: stats.auto_vacuum,
-                synchronous: stats.synchronous
+                synchronous: stats.synchronous,
             };
         }
         catch (error) {
@@ -119,7 +113,8 @@ class SQLiteSchemaIntrospector extends database_introspector_js_1.DatabaseIntros
             info.version = versionResult.rows?.[0]?.version;
             // Get compile options
             const compileOptionsResult = await (0, sql_js_1.sql) `PRAGMA compile_options`.execute(this.db);
-            info.compileOptions = compileOptionsResult.rows?.map((row) => row.compile_options) || [];
+            info.compileOptions =
+                compileOptionsResult.rows?.map((row) => row.compile_options) || [];
             // Get foreign key status
             const fkResult = await (0, sql_js_1.sql) `PRAGMA foreign_keys`.execute(this.db);
             info.foreignKeysEnabled = fkResult.rows?.[0]?.foreign_keys === 1;

package/dist/cjs/schema/dialects/sqlite/sqlite-discovery.coordinator.js

@@ -38,7 +38,7 @@ class SQLiteDiscoveryCoordinator {
         const discoveryConfig = {
             excludeTables: config.excludeTables,
             includeViews: config.includeViews,
-            customTypeMappings: config.customTypeMappings
+            customTypeMappings: config.customTypeMappings,
         };
         // Check if foreign keys are enabled
         let fkEnabled = false;
@@ -64,7 +64,8 @@ class SQLiteDiscoveryCoordinator {
         let relationships = [];
         if (fkEnabled) {
             try {
-                relationships = await this.relationshipDiscovery.discoverRelationships(enhancedTables);
+                relationships =
+                    await this.relationshipDiscovery.discoverRelationships(enhancedTables);
             }
             catch (error) {
                 console.warn('Relationship discovery failed:', error);
@@ -82,16 +83,16 @@ class SQLiteDiscoveryCoordinator {
                 viewMetadata = [];
             }
         }
-        const views = viewMetadata.map(view => ({
+        const views = viewMetadata.map((view) => ({
             name: view.name,
             schema: view.schema,
             definition: view.definition || '',
-            columns: view.columns || []
+            columns: view.columns || [],
         }));
         return {
             tables: enhancedTables,
             relationships,
-            views
+            views,
         };
     }
     /**
@@ -113,23 +114,23 @@ class SQLiteDiscoveryCoordinator {
                 const tableSize = await this.indexDiscovery.getTableSize(db, table.name);
                 enhancedTables.push({
                     ...table,
-                    indexes: indexes.map(idx => ({
+                    indexes: indexes.map((idx) => ({
                         name: idx.name,
                         columns: idx.columns,
                         unique: idx.unique,
                         isPrimary: idx.isPrimary,
-                        definition: idx.definition
+                        definition: idx.definition,
                     })),
                     constraints: constraints,
-                    foreignKeys: foreignKeys.map(fk => ({
+                    foreignKeys: foreignKeys.map((fk) => ({
                         name: fk.name,
                         column: fk.column,
                         referencedTable: fk.referencedTable,
                         referencedColumn: fk.referencedColumn,
                         onDelete: fk.onDelete,
-                        onUpdate: fk.onUpdate
+                        onUpdate: fk.onUpdate,
                     })),
-                    tableSize: tableSize
+                    tableSize: tableSize,
                 });
             }
             catch (error) {
@@ -139,7 +140,7 @@ class SQLiteDiscoveryCoordinator {
                     indexes: [],
                     constraints: [],
                     foreignKeys: [],
-                    tableSize: undefined
+                    tableSize: undefined,
                 });
             }
         }
@@ -166,7 +167,7 @@ class SQLiteDiscoveryCoordinator {
             supportsAutoIncrement: true,
             supportsRowId: true,
             supportsTriggers: true,
-            supportsFullTextSearch: true
+            supportsFullTextSearch: true,
         };
     }
     /**
@@ -215,7 +216,7 @@ class SQLiteDiscoveryCoordinator {
             'Use WAL mode for better concurrency: PRAGMA journal_mode = WAL',
             'Set appropriate cache size: PRAGMA cache_size = -64000',
             'Enable query optimization: PRAGMA optimize',
-            'Consider using prepared statements for better performance'
+            'Consider using prepared statements for better performance',
         ];
     }
 }

package/dist/cjs/schema/test/basic-schema-test.js

@@ -56,7 +56,7 @@ class SimpleTest {
                         console.log(`❌ Expected error containing "${expectedError}", got: ${errorMessage}`);
                     }
                 }
-            }
+            },
         };
     }
     async run() {
@@ -90,7 +90,7 @@ async function runTests() {
     // Test 1: DiscoveryFactory Singleton
     test.test('DiscoveryFactory should be a singleton', () => {
         try {
-            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
             const instance1 = DiscoveryFactory.getInstance();
             const instance2 = DiscoveryFactory.getInstance();
             test.expect(instance1).toBe(instance2);
@@ -102,7 +102,7 @@ async function runTests() {
     // Test 2: SchemaDiscoveryCoordinator Singleton
     test.test('SchemaDiscoveryCoordinator should be a singleton', () => {
         try {
-            const { SchemaDiscoveryCoordinator } = require('../core/coordinators/schema-discovery.coordinator.js');
+            const { SchemaDiscoveryCoordinator, } = require('../core/coordinators/schema-discovery.coordinator.js');
             const instance1 = SchemaDiscoveryCoordinator.getInstance();
             const instance2 = SchemaDiscoveryCoordinator.getInstance();
             test.expect(instance1).toBe(instance2);
@@ -114,7 +114,7 @@ async function runTests() {
     // Test 4: SQLite Coordinator Singleton
     test.test('SQLiteDiscoveryCoordinator should be a singleton', () => {
         try {
-            const { SQLiteDiscoveryCoordinator } = require('../dialects/sqlite/sqlite-discovery.coordinator.js');
+            const { SQLiteDiscoveryCoordinator, } = require('../dialects/sqlite/sqlite-discovery.coordinator.js');
             const instance1 = SQLiteDiscoveryCoordinator.getInstance();
             const instance2 = SQLiteDiscoveryCoordinator.getInstance();
             test.expect(instance1).toBe(instance2);
@@ -126,7 +126,7 @@ async function runTests() {
     // Test 5: Factory Dialect Support
     test.test('DiscoveryFactory should support PostgreSQL and SQLite', () => {
         try {
-            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
             const factory = DiscoveryFactory.getInstance();
             test.expect(factory.isDialectSupported('postgresql')).toBe(true);
             test.expect(factory.isDialectSupported('sqlite')).toBe(true);
@@ -139,9 +139,11 @@ async function runTests() {
     // Test 6: Error Handling
     test.test('DiscoveryFactory should throw error for unsupported dialects', () => {
         try {
-            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
             const factory = DiscoveryFactory.getInstance();
-            test.expect(() => factory.createIndexDiscovery('oracle')).toThrow('Unsupported dialect');
+            test
+                .expect(() => factory.createIndexDiscovery('oracle'))
+                .toThrow('Unsupported dialect');
         }
         catch (error) {
             console.log('⚠️  Error handling test skipped (module not available)');
@@ -150,7 +152,7 @@ async function runTests() {
     // Test 7: Capabilities
     test.test('PostgreSQL should have correct capabilities', () => {
         try {
-            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
             const factory = DiscoveryFactory.getInstance();
             const capabilities = factory.getDialectCapabilities('postgresql');
             test.expect(capabilities.supportsViews).toBe(true);
@@ -164,7 +166,7 @@ async function runTests() {
     // Test 8: SQLite Capabilities
     test.test('SQLite should have correct capabilities', () => {
         try {
-            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
             const factory = DiscoveryFactory.getInstance();
             const capabilities = factory.getDialectCapabilities('sqlite');
             test.expect(capabilities.supportsViews).toBe(true);

package/dist/cjs/schema/test/dialect-capabilities.test.js

@@ -24,7 +24,7 @@ const sqlite_discovery_coordinator_js_1 = require("../dialects/sqlite/sqlite-dis
                     supportsConstraints: true,
                     supportsForeignKeys: true,
                     supportsCheckConstraints: true,
-                    supportsDeferredConstraints: false
+                    supportsDeferredConstraints: false,
                 });
             });
             (0, globals_1.it)('should handle case insensitive dialect names', () => {
@@ -35,7 +35,7 @@ const sqlite_discovery_coordinator_js_1 = require("../dialects/sqlite/sqlite-dis
                     supportsConstraints: true,
                     supportsForeignKeys: true,
                     supportsCheckConstraints: true,
-                    supportsDeferredConstraints: false
+                    supportsDeferredConstraints: false,
                 });
             });
         });
@@ -47,7 +47,7 @@ const sqlite_discovery_coordinator_js_1 = require("../dialects/sqlite/sqlite-dis
                 supportsConstraints: false,
                 supportsForeignKeys: false,
                 supportsCheckConstraints: false,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
         (0, globals_1.it)('should handle dialect name with whitespace', () => {
@@ -58,7 +58,7 @@ const sqlite_discovery_coordinator_js_1 = require("../dialects/sqlite/sqlite-dis
                 supportsConstraints: true,
                 supportsForeignKeys: true,
                 supportsCheckConstraints: true,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
         (0, globals_1.it)('should handle mixed case dialect names', () => {
@@ -69,7 +69,7 @@ const sqlite_discovery_coordinator_js_1 = require("../dialects/sqlite/sqlite-dis
                 supportsConstraints: true,
                 supportsForeignKeys: true,
                 supportsCheckConstraints: true,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
     });
@@ -94,7 +94,7 @@ const sqlite_discovery_coordinator_js_1 = require("../dialects/sqlite/sqlite-dis
                     supportsAutoIncrement: true,
                     supportsRowId: true,
                     supportsTriggers: true,
-                    supportsFullTextSearch: true
+                    supportsFullTextSearch: true,
                 });
             });
             (0, globals_1.it)('should support all SQLite features', () => {

package/dist/cjs/schema/test/discovery-factory.test.js

@@ -133,7 +133,7 @@ const view_discovery_js_1 = require("../core/discovery/view-discovery.js");
                 supportsConstraints: true,
                 supportsForeignKeys: true,
                 supportsCheckConstraints: true,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
         (0, globals_1.it)('should return false capabilities for unsupported dialects', () => {
@@ -144,7 +144,7 @@ const view_discovery_js_1 = require("../core/discovery/view-discovery.js");
                 supportsConstraints: false,
                 supportsForeignKeys: false,
                 supportsCheckConstraints: false,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
     });

package/dist/cjs/schema/test/error-handling.test.js

@@ -78,7 +78,7 @@ const mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => { }
             getPlugin: jest.fn(),
             withPlugin: jest.fn(),
             withoutPlugins: jest.fn(),
-            freeze: jest.fn()
+            freeze: jest.fn(),
         };
         (0, globals_1.it)('should handle table discovery service errors', async () => {
             // The coordinator handles errors gracefully by returning empty results
@@ -90,11 +90,13 @@ const mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => { }
                         return {
                             select: jest.fn().mockReturnThis(),
                             where: jest.fn().mockReturnThis(),
-                            execute: jest.fn().mockRejectedValue(new Error('Table discovery service failed'))
+                            execute: jest
+                                .fn()
+                                .mockRejectedValue(new Error('Table discovery service failed')),
                         };
                     }
                     return mockKysely.selectFrom(table);
-                })
+                }),
             };
             // Should return empty result instead of throwing
             const result = await sqliteCoordinator.discoverSchema(failingMockKysely, {});
@@ -109,9 +111,9 @@ const mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => { }
                     return {
                         select: jest.fn().mockReturnThis(),
                         where: jest.fn().mockReturnThis(),
-                        execute: jest.fn().mockResolvedValue([])
+                        execute: jest.fn().mockResolvedValue([]),
                     };
-                })
+                }),
             };
             // This test validates the coordinator can handle errors gracefully
             const result = await sqliteCoordinator.discoverSchema(failingMockKysely, {});
@@ -141,7 +143,7 @@ const mockConsoleWarn = jest.spyOn(console, 'warn').mockImplementation(() => { }
                 }),
                 // Add minimal required properties
                 schema: null,
-                dynamic: null
+                dynamic: null,
             };
             // Should return empty result instead of throwing
             const result = await sqliteCoordinator.discoverSchema(mockKyselyWithError, {});

package/dist/cjs/schema/test/integration.test.js

@@ -42,39 +42,43 @@ const mockKysely = {
     selectFrom: jest.fn().mockReturnThis(),
     select: jest.fn().mockReturnThis(),
     where: jest.fn().mockReturnThis(),
-    execute: jest.fn().mockResolvedValue([])
+    execute: jest.fn().mockResolvedValue([]),
 };
 // Mock discovery services
 jest.mock('../core/discovery/table-metadata-discovery.js', () => ({
     TableMetadataDiscovery: {
         getInstance: jest.fn().mockReturnValue({
-            discoverTables: jest.fn().mockResolvedValue([])
-        })
-    }
+            discoverTables: jest.fn().mockResolvedValue([]),
+        }),
+    },
 }));
 jest.mock('../core/discovery/relationship-discovery.js', () => ({
     RelationshipDiscovery: {
         getInstance: jest.fn().mockReturnValue({
-            discoverRelationships: jest.fn().mockResolvedValue([])
-        })
-    }
+            discoverRelationships: jest.fn().mockResolvedValue([]),
+        }),
+    },
 }));
 jest.mock('../core/discovery/view-discovery.js', () => ({
     ViewDiscovery: {
         getInstance: jest.fn().mockReturnValue({
-            discoverViews: jest.fn().mockResolvedValue([])
-        })
-    }
+            discoverViews: jest.fn().mockResolvedValue([]),
+        }),
+    },
 }));
 jest.mock('../dialects/sqlite/discovery/sqlite-index-discovery.js', () => ({
     SQLiteIndexDiscovery: {
         getInstance: jest.fn().mockReturnValue({
             discoverIndexes: jest.fn().mockResolvedValue([]),
             discoverTableIndexes: jest.fn().mockResolvedValue([]),
-            getTableSize: jest.fn().mockResolvedValue({ pages: 0, size: 0, estimatedRows: 0 }),
-            analyzeIndexEfficiency: jest.fn().mockReturnValue({ recommendations: [] })
-        })
-    }
+            getTableSize: jest
+                .fn()
+                .mockResolvedValue({ pages: 0, size: 0, estimatedRows: 0 }),
+            analyzeIndexEfficiency: jest
+                .fn()
+                .mockReturnValue({ recommendations: [] }),
+        }),
+    },
 }));
 jest.mock('../dialects/sqlite/discovery/sqlite-constraint-discovery.js', () => ({
     SQLiteConstraintDiscovery: {
@@ -83,9 +87,11 @@ jest.mock('../dialects/sqlite/discovery/sqlite-constraint-discovery.js', () => (
             isForeignKeySupportEnabled: jest.fn().mockResolvedValue(true),
             getForeignKeyInfo: jest.fn().mockResolvedValue([]),
             discoverTableConstraints: jest.fn().mockResolvedValue([]),
-            analyzeConstraintCompatibility: jest.fn().mockReturnValue({ recommendations: [], compatibilityIssues: [] })
-        })
-    }
+            analyzeConstraintCompatibility: jest
+                .fn()
+                .mockReturnValue({ recommendations: [], compatibilityIssues: [] }),
+        }),
+    },
 }));
 (0, globals_1.describe)('Schema Strategy Integration Tests', () => {
     let coordinator;
@@ -173,7 +179,7 @@ jest.mock('../dialects/sqlite/discovery/sqlite-constraint-discovery.js', () => (
                 selectFrom: jest.fn().mockReturnThis(),
                 select: jest.fn().mockReturnThis(),
                 where: jest.fn().mockReturnThis(),
-                execute: jest.fn().mockResolvedValue([])
+                execute: jest.fn().mockResolvedValue([]),
             };
             const result = await coordinator.discoverSchema(mockKyselyWithError, {}, 'sqlite');
             (0, globals_1.expect)(result).toBeDefined();