noormme 1.1.0 → 1.2.0

package/dist/esm/schema/core/utils/type-mapper.js

@@ -5,31 +5,31 @@
 export class TypeMapper {
     static typeMapping = {
         // SQLite types
-        'text': 'string',
-        'varchar': 'string',
-        'char': 'string',
-        'integer': 'number',
-        'real': 'number',
-        'numeric': 'number',
-        'boolean': 'boolean',
-        'date': 'Date',
-        'datetime': 'Date',
-        'blob': 'Buffer',
+        text: 'string',
+        varchar: 'string',
+        char: 'string',
+        integer: 'number',
+        real: 'number',
+        numeric: 'number',
+        boolean: 'boolean',
+        date: 'Date',
+        datetime: 'Date',
+        blob: 'Buffer',
         // PostgreSQL types
-        'bigint': 'number',
-        'smallint': 'number',
-        'decimal': 'number',
+        bigint: 'number',
+        smallint: 'number',
+        decimal: 'number',
         'double precision': 'number',
-        'timestamp': 'Date',
-        'timestamptz': 'Date',
-        'time': 'Date',
-        'timetz': 'Date',
-        'json': 'Record<string, unknown>',
-        'jsonb': 'Record<string, unknown>',
-        'uuid': 'string',
-        'tsvector': 'string',
-        'tsquery': 'string',
-        'bytea': 'Buffer',
+        timestamp: 'Date',
+        timestamptz: 'Date',
+        time: 'Date',
+        timetz: 'Date',
+        json: 'Record<string, unknown>',
+        jsonb: 'Record<string, unknown>',
+        uuid: 'string',
+        tsvector: 'string',
+        tsquery: 'string',
+        bytea: 'Buffer',
     };
     /**
      * Map database column info to our ColumnInfo interface
@@ -44,7 +44,7 @@ export class TypeMapper {
             isAutoIncrement: dbColumn.isAutoIncrement ?? false,
             maxLength: dbColumn.maxLength,
             precision: dbColumn.precision,
-            scale: dbColumn.scale
+            scale: dbColumn.scale,
         };
     }
     /**

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

@@ -31,7 +31,7 @@ export class PostgresDiscoveryCoordinator {
         const discoveryConfig = {
             excludeTables: config.excludeTables,
             includeViews: config.includeViews,
-            customTypeMappings: config.customTypeMappings
+            customTypeMappings: config.customTypeMappings,
         };
         // Discover tables
         let tables = [];
@@ -45,7 +45,8 @@ export 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);
@@ -56,11 +57,11 @@ export 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) {
@@ -71,7 +72,7 @@ export class PostgresDiscoveryCoordinator {
         return {
             tables,
             relationships,
-            views
+            views,
         };
     }
     /**
@@ -95,7 +96,7 @@ export class PostgresDiscoveryCoordinator {
             supportsAutoIncrement: true, // via serial or identity
             supportsRowId: false,
             supportsTriggers: true,
-            supportsFullTextSearch: true
+            supportsFullTextSearch: true,
         };
     }
     /**
@@ -107,7 +108,7 @@ export 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/esm/schema/dialects/sqlite/discovery/sqlite-constraint-discovery.js

@@ -42,7 +42,7 @@ export 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')) {
@@ -52,7 +52,7 @@ export class SQLiteConstraintDiscovery {
                         name: `${tableName}_pk`,
                         type: 'p',
                         columns: [pkMatch[1]],
-                        definition: definition
+                        definition: definition,
                     });
                 }
             }
@@ -66,7 +66,7 @@ export class SQLiteConstraintDiscovery {
                         column: fkMatch[1],
                         referencedTable: fkMatch[2],
                         referencedColumn: fkMatch[3],
-                        definition: definition
+                        definition: definition,
                     });
                 }
             }
@@ -78,7 +78,7 @@ export class SQLiteConstraintDiscovery {
                         name: `${tableName}_check_${constraints.length + 1}`,
                         type: 'c',
                         definition: checkMatch[1],
-                        fullDefinition: definition
+                        fullDefinition: definition,
                     });
                 }
             }
@@ -89,8 +89,8 @@ export 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,
                     });
                 }
             }
@@ -102,7 +102,7 @@ export class SQLiteConstraintDiscovery {
                         name: `${tableName}_nn_${notNullMatch[1]}`,
                         type: 'n',
                         column: notNullMatch[1],
-                        definition: definition
+                        definition: definition,
                     });
                 }
             }
@@ -123,7 +123,7 @@ export 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) {
@@ -175,7 +175,7 @@ export class SQLiteConstraintDiscovery {
         }
         return {
             isValid: issues.length === 0,
-            issues
+            issues,
         };
     }
     /**
@@ -203,7 +203,7 @@ export class SQLiteConstraintDiscovery {
         }
         return {
             recommendations,
-            compatibilityIssues
+            compatibilityIssues,
         };
     }
     /**
@@ -260,7 +260,7 @@ export class SQLiteConstraintDiscovery {
                 issues,
                 recommendations,
                 orphanedRecords,
-                performanceImpact
+                performanceImpact,
             };
         }
         catch (error) {
@@ -270,7 +270,7 @@ export class SQLiteConstraintDiscovery {
                 issues,
                 recommendations: ['Check database connection and permissions'],
                 orphanedRecords: [],
-                performanceImpact: 'high'
+                performanceImpact: 'high',
             };
         }
     }
@@ -437,7 +437,7 @@ export class SQLiteConstraintDiscovery {
                 indexRecommendations,
                 constraintRecommendations,
                 cleanupRecommendations,
-                performanceRecommendations
+                performanceRecommendations,
             };
         }
         catch (error) {
@@ -445,7 +445,9 @@ export class SQLiteConstraintDiscovery {
                 indexRecommendations: [],
                 constraintRecommendations: [],
                 cleanupRecommendations: [],
-                performanceRecommendations: [`Error generating recommendations: ${error}`]
+                performanceRecommendations: [
+                    `Error generating recommendations: ${error}`,
+                ],
             };
         }
     }
@@ -453,7 +455,7 @@ export 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/esm/schema/dialects/sqlite/discovery/sqlite-index-discovery.js

@@ -22,7 +22,7 @@ export class SQLiteIndexDiscovery {
                 'name',
                 'sql as definition',
                 sql `type = 'index'`.as('isIndex'),
-                sql `sql LIKE '%UNIQUE%'`.as('unique')
+                sql `sql LIKE '%UNIQUE%'`.as('unique'),
             ])
                 .where('type', '=', 'index')
                 .where('tbl_name', '=', tableName)
@@ -32,7 +32,7 @@ export 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;
         }
@@ -53,8 +53,8 @@ export 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 [];
     }
@@ -80,12 +80,12 @@ export 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)`);
         }
@@ -107,7 +107,7 @@ export class SQLiteIndexDiscovery {
         return {
             recommendations,
             missingIndexes,
-            redundantIndexes
+            redundantIndexes,
         };
     }
     /**
@@ -119,7 +119,7 @@ export 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/esm/schema/dialects/sqlite/introspection/sqlite-schema-introspector.js

@@ -15,13 +15,7 @@ export class SQLiteSchemaIntrospector extends DatabaseIntrospector {
         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 = [];
@@ -39,7 +33,7 @@ export class SQLiteSchemaIntrospector extends DatabaseIntrospector {
                         hasTriggers: false, // Will be determined separately
                         tableType: 'table',
                         lastAnalyzed: null,
-                        lastAutoAnalyzed: null
+                        lastAutoAnalyzed: null,
                     });
                 }
                 catch (error) {
@@ -71,7 +65,7 @@ export class SQLiteSchemaIntrospector extends DatabaseIntrospector {
                 'synchronous',
                 'journal_mode',
                 'auto_vacuum',
-                'integrity_check'
+                'integrity_check',
             ];
             for (const pragma of pragmas) {
                 try {
@@ -98,7 +92,7 @@ export class SQLiteSchemaIntrospector extends DatabaseIntrospector {
                 pageSize: stats.page_size,
                 journalMode: stats.journal_mode,
                 autoVacuum: stats.auto_vacuum,
-                synchronous: stats.synchronous
+                synchronous: stats.synchronous,
             };
         }
         catch (error) {
@@ -117,7 +111,8 @@ export class SQLiteSchemaIntrospector extends DatabaseIntrospector {
             info.version = versionResult.rows?.[0]?.version;
             // Get compile options
             const compileOptionsResult = await 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 sql `PRAGMA foreign_keys`.execute(this.db);
             info.foreignKeysEnabled = fkResult.rows?.[0]?.foreign_keys === 1;

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

@@ -36,7 +36,7 @@ export 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;
@@ -62,7 +62,8 @@ export 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);
@@ -80,16 +81,16 @@ export 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,
         };
     }
     /**
@@ -111,23 +112,23 @@ export 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) {
@@ -137,7 +138,7 @@ export class SQLiteDiscoveryCoordinator {
                     indexes: [],
                     constraints: [],
                     foreignKeys: [],
-                    tableSize: undefined
+                    tableSize: undefined,
                 });
             }
         }
@@ -164,7 +165,7 @@ export class SQLiteDiscoveryCoordinator {
             supportsAutoIncrement: true,
             supportsRowId: true,
             supportsTriggers: true,
-            supportsFullTextSearch: true
+            supportsFullTextSearch: true,
         };
     }
     /**
@@ -213,7 +214,7 @@ export 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/esm/schema/test/basic-schema-test.js

@@ -54,7 +54,7 @@ class SimpleTest {
                         console.log(`❌ Expected error containing "${expectedError}", got: ${errorMessage}`);
                     }
                 }
-            }
+            },
         };
     }
     async run() {
@@ -88,7 +88,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);
@@ -100,7 +100,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);
@@ -112,7 +112,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);
@@ -124,7 +124,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);
@@ -137,9 +137,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)');
@@ -148,7 +150,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);
@@ -162,7 +164,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/esm/schema/test/dialect-capabilities.test.js

@@ -23,7 +23,7 @@ describe('Dialect Capabilities', () => {
                     supportsConstraints: true,
                     supportsForeignKeys: true,
                     supportsCheckConstraints: true,
-                    supportsDeferredConstraints: false
+                    supportsDeferredConstraints: false,
                 });
             });
             it('should handle case insensitive dialect names', () => {
@@ -34,7 +34,7 @@ describe('Dialect Capabilities', () => {
                     supportsConstraints: true,
                     supportsForeignKeys: true,
                     supportsCheckConstraints: true,
-                    supportsDeferredConstraints: false
+                    supportsDeferredConstraints: false,
                 });
             });
         });
@@ -46,7 +46,7 @@ describe('Dialect Capabilities', () => {
                 supportsConstraints: false,
                 supportsForeignKeys: false,
                 supportsCheckConstraints: false,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
         it('should handle dialect name with whitespace', () => {
@@ -57,7 +57,7 @@ describe('Dialect Capabilities', () => {
                 supportsConstraints: true,
                 supportsForeignKeys: true,
                 supportsCheckConstraints: true,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
         it('should handle mixed case dialect names', () => {
@@ -68,7 +68,7 @@ describe('Dialect Capabilities', () => {
                 supportsConstraints: true,
                 supportsForeignKeys: true,
                 supportsCheckConstraints: true,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
     });
@@ -93,7 +93,7 @@ describe('Dialect Capabilities', () => {
                     supportsAutoIncrement: true,
                     supportsRowId: true,
                     supportsTriggers: true,
-                    supportsFullTextSearch: true
+                    supportsFullTextSearch: true,
                 });
             });
             it('should support all SQLite features', () => {

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

@@ -132,7 +132,7 @@ describe('DiscoveryFactory', () => {
                 supportsConstraints: true,
                 supportsForeignKeys: true,
                 supportsCheckConstraints: true,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
         it('should return false capabilities for unsupported dialects', () => {
@@ -143,7 +143,7 @@ describe('DiscoveryFactory', () => {
                 supportsConstraints: false,
                 supportsForeignKeys: false,
                 supportsCheckConstraints: false,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
     });

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

@@ -77,7 +77,7 @@ describe('Error Handling', () => {
             getPlugin: jest.fn(),
             withPlugin: jest.fn(),
             withoutPlugins: jest.fn(),
-            freeze: jest.fn()
+            freeze: jest.fn(),
         };
         it('should handle table discovery service errors', async () => {
             // The coordinator handles errors gracefully by returning empty results
@@ -89,11 +89,13 @@ describe('Error Handling', () => {
                         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, {});
@@ -108,9 +110,9 @@ describe('Error Handling', () => {
                     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, {});
@@ -140,7 +142,7 @@ describe('Error Handling', () => {
                 }),
                 // Add minimal required properties
                 schema: null,
-                dynamic: null
+                dynamic: null,
             };
             // Should return empty result instead of throwing
             const result = await sqliteCoordinator.discoverSchema(mockKyselyWithError, {});