noormme 1.0.6 → 1.2.0

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

@@ -7,7 +7,7 @@ const mockKysely = {
     selectFrom: jest.fn(),
     select: jest.fn(),
     where: jest.fn(),
-    execute: jest.fn()
+    execute: jest.fn(),
 };
 // Mock DiscoveryFactory
 const mockFactory = {
@@ -20,7 +20,7 @@ const mockFactory = {
     createDiscoveryServices: jest.fn(),
     getDialectCapabilities: jest.fn(),
     isDialectSupported: jest.fn(),
-    getSupportedDialects: jest.fn()
+    getSupportedDialects: jest.fn(),
 };
 // Mock SQLite coordinator
 const mockSQLiteCoordinator = {
@@ -33,7 +33,7 @@ const mockSQLiteCoordinator = {
     viewDiscovery: {},
     indexDiscovery: {},
     constraintDiscovery: {},
-    enhanceTablesWithSQLiteMetadata: jest.fn()
+    enhanceTablesWithSQLiteMetadata: jest.fn(),
 };
 (0, globals_1.describe)('SchemaDiscoveryCoordinator', () => {
     let coordinator;
@@ -48,7 +48,7 @@ const mockSQLiteCoordinator = {
             relationshipDiscovery: {},
             viewDiscovery: {},
             indexDiscovery: {},
-            constraintDiscovery: {}
+            constraintDiscovery: {},
         });
         mockFactory.getDialectCapabilities.mockReturnValue({
             supportsViews: true,
@@ -56,7 +56,7 @@ const mockSQLiteCoordinator = {
             supportsConstraints: true,
             supportsForeignKeys: true,
             supportsCheckConstraints: true,
-            supportsDeferredConstraints: false
+            supportsDeferredConstraints: false,
         });
         mockFactory.isDialectSupported.mockReturnValue(true);
         coordinator = schema_discovery_coordinator_js_1.SchemaDiscoveryCoordinator.getInstance();
@@ -79,7 +79,7 @@ const mockSQLiteCoordinator = {
                 views: [],
                 indexes: [],
                 constraints: [],
-                relationships: []
+                relationships: [],
             };
             mockSQLiteCoordinator.discoverSchema.mockResolvedValue(mockSchemaInfo);
             const result = await coordinator.discoverSchema(mockKysely, {}, 'sqlite');
@@ -113,7 +113,7 @@ const mockSQLiteCoordinator = {
                 supportsConstraints: true,
                 supportsForeignKeys: true,
                 supportsCheckConstraints: true,
-                supportsDeferredConstraints: false
+                supportsDeferredConstraints: false,
             });
         });
     });
@@ -122,14 +122,14 @@ const mockSQLiteCoordinator = {
             const config = {
                 excludeTables: ['migrations'],
                 includeViews: true,
-                customTypeMappings: { 'jsonb': 'Record<string, any>' }
+                customTypeMappings: { jsonb: 'Record<string, any>' },
             };
             const mockSchemaInfo = {
                 tables: [],
                 views: [],
                 indexes: [],
                 constraints: [],
-                relationships: []
+                relationships: [],
             };
             mockSQLiteCoordinator.discoverSchema.mockResolvedValue(mockSchemaInfo);
             await coordinator.discoverSchema(mockKysely, config, 'sqlite');

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

@@ -8,52 +8,52 @@ describe('Schema Strategy - Basic Tests', () => {
     test('should verify DiscoveryFactory exists', () => {
         // Test that we can import the DiscoveryFactory
         expect(() => {
-            const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+            const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
             return DiscoveryFactory;
         }).not.toThrow();
     });
     test('should verify SchemaDiscoveryCoordinator exists', () => {
         // Test that we can import the SchemaDiscoveryCoordinator
         expect(() => {
-            const { SchemaDiscoveryCoordinator } = require('../core/coordinators/schema-discovery.coordinator.js');
+            const { SchemaDiscoveryCoordinator, } = require('../core/coordinators/schema-discovery.coordinator.js');
             return SchemaDiscoveryCoordinator;
         }).not.toThrow();
     });
     test('should verify SQLite coordinator exists', () => {
         // Test that we can import the SQLite coordinator
         expect(() => {
-            const { SQLiteDiscoveryCoordinator } = require('../dialects/sqlite/sqlite-discovery.coordinator.js');
+            const { SQLiteDiscoveryCoordinator, } = require('../dialects/sqlite/sqlite-discovery.coordinator.js');
             return SQLiteDiscoveryCoordinator;
         }).not.toThrow();
     });
     test('should verify singleton pattern works for DiscoveryFactory', () => {
-        const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+        const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
         const instance1 = DiscoveryFactory.getInstance();
         const instance2 = DiscoveryFactory.getInstance();
         expect(instance1).toBe(instance2);
     });
     test('should verify singleton pattern works for SchemaDiscoveryCoordinator', () => {
-        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();
         expect(instance1).toBe(instance2);
     });
     test('should verify dialect support', () => {
-        const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+        const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
         const factory = DiscoveryFactory.getInstance();
         expect(factory.isDialectSupported('postgresql')).toBe(true);
         expect(factory.isDialectSupported('sqlite')).toBe(true);
         expect(factory.isDialectSupported('mysql')).toBe(false);
     });
     test('should verify error handling for unsupported dialects', () => {
-        const { DiscoveryFactory } = require('../core/factories/discovery-factory.js');
+        const { DiscoveryFactory, } = require('../core/factories/discovery-factory.js');
         const factory = DiscoveryFactory.getInstance();
         expect(() => {
             factory.createIndexDiscovery('oracle');
         }).toThrow('Unsupported dialect');
     });
     test('should verify PostgreSQL capabilities', () => {
-        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');
         expect(capabilities.supportsViews).toBe(true);
@@ -64,7 +64,7 @@ describe('Schema Strategy - Basic Tests', () => {
         expect(capabilities.supportsDeferredConstraints).toBe(true);
     });
     test('should verify SQLite capabilities', () => {
-        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');
         expect(capabilities.supportsViews).toBe(true);

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

@@ -11,15 +11,15 @@ const sqlite_constraint_discovery_js_1 = require("../dialects/sqlite/discovery/s
 const mockKysely = {
     selectFrom: jest.fn(),
     select: jest.fn(),
-    execute: jest.fn()
+    execute: jest.fn(),
 };
 // Mock DatabaseIntrospector
 jest.mock('../../dialect/database-introspector.js', () => ({
     DatabaseIntrospector: jest.fn().mockImplementation(() => ({
         getTables: jest.fn(),
         getTableMetadata: jest.fn(),
-        getViews: jest.fn()
-    }))
+        getViews: jest.fn(),
+    })),
 }));
 const mockTableData = [
     {
@@ -27,19 +27,19 @@ const mockTableData = [
         columns: [
             { name: 'id', type: 'INTEGER', isPrimaryKey: true, isNullable: false },
             { name: 'email', type: 'TEXT', isNullable: false },
-            { name: 'created_at', type: 'DATETIME', isNullable: false }
+            { name: 'created_at', type: 'DATETIME', isNullable: false },
         ],
-        primaryKey: ['id']
+        primaryKey: ['id'],
     },
     {
         name: 'posts',
         columns: [
             { name: 'id', type: 'INTEGER', isPrimaryKey: true, isNullable: false },
             { name: 'user_id', type: 'INTEGER', isNullable: false },
-            { name: 'title', type: 'TEXT', isNullable: false }
+            { name: 'title', type: 'TEXT', isNullable: false },
         ],
-        primaryKey: ['id']
-    }
+        primaryKey: ['id'],
+    },
 ];
 const mockIndexData = [
     {
@@ -47,23 +47,23 @@ const mockIndexData = [
         columns: ['email'],
         unique: true,
         isPrimary: false,
-        definition: 'CREATE UNIQUE INDEX users_email_idx ON users(email)'
+        definition: 'CREATE UNIQUE INDEX users_email_idx ON users(email)',
     },
     {
         name: 'posts_user_id_idx',
         columns: ['user_id'],
         unique: false,
         isPrimary: false,
-        definition: 'CREATE INDEX posts_user_id_idx ON posts(user_id)'
-    }
+        definition: 'CREATE INDEX posts_user_id_idx ON posts(user_id)',
+    },
 ];
 const mockConstraintData = [
     {
         name: 'users_email_check',
         type: 'CHECK',
         definition: "email LIKE '%@%'",
-        valid: true
-    }
+        valid: true,
+    },
 ];
 const mockForeignKeyData = [
     {
@@ -72,8 +72,8 @@ const mockForeignKeyData = [
         referencedTable: 'users',
         referencedColumn: 'id',
         onDelete: 'CASCADE',
-        onUpdate: 'NO ACTION'
-    }
+        onUpdate: 'NO ACTION',
+    },
 ];
 const mockViewData = [
     {
@@ -81,9 +81,9 @@ const mockViewData = [
         definition: 'SELECT u.email, p.title FROM users u JOIN posts p ON u.id = p.user_id',
         columns: [
             { name: 'email', type: 'TEXT' },
-            { name: 'title', type: 'TEXT' }
-        ]
-    }
+            { name: 'title', type: 'TEXT' },
+        ],
+    },
 ];
 const mockRelationshipData = [
     {
@@ -91,13 +91,13 @@ const mockRelationshipData = [
         fromColumn: 'user_id',
         toTable: 'users',
         toColumn: 'id',
-        type: 'many-to-one'
-    }
+        type: 'many-to-one',
+    },
 ];
 const mockTableSize = {
     pages: 10,
     size: 40960,
-    estimatedRows: 100
+    estimatedRows: 100,
 };
 (0, globals_1.describe)('SQLiteDiscoveryCoordinator', () => {
     let coordinator;
@@ -112,35 +112,45 @@ const mockTableSize = {
         sqlite_discovery_coordinator_js_1.SQLiteDiscoveryCoordinator.instance = undefined;
         // Create mocks
         mockTableDiscovery = {
-            discoverTables: jest.fn().mockResolvedValue(mockTableData)
+            discoverTables: jest.fn().mockResolvedValue(mockTableData),
         };
         mockRelationshipDiscovery = {
-            discoverRelationships: jest.fn().mockResolvedValue(mockRelationshipData)
+            discoverRelationships: jest.fn().mockResolvedValue(mockRelationshipData),
         };
         mockViewDiscovery = {
-            discoverViews: jest.fn().mockResolvedValue(mockViewData)
+            discoverViews: jest.fn().mockResolvedValue(mockViewData),
         };
         mockIndexDiscovery = {
             discoverTableIndexes: jest.fn().mockResolvedValue(mockIndexData),
             getTableSize: jest.fn().mockResolvedValue(mockTableSize),
             analyzeIndexEfficiency: jest.fn().mockReturnValue({
-                recommendations: ['Consider using covering indexes for better performance']
-            })
+                recommendations: [
+                    'Consider using covering indexes for better performance',
+                ],
+            }),
         };
         mockConstraintDiscovery = {
             isForeignKeySupportEnabled: jest.fn().mockResolvedValue(true),
             discoverTableConstraints: jest.fn().mockResolvedValue(mockConstraintData),
             getForeignKeyInfo: jest.fn().mockResolvedValue(mockForeignKeyData),
             analyzeConstraintCompatibility: jest.fn().mockReturnValue({
-                recommendations: ['Consider optimizing constraint definitions']
-            })
+                recommendations: ['Consider optimizing constraint definitions'],
+            }),
         };
         // Mock static methods
-        jest.spyOn(table_metadata_discovery_js_1.TableMetadataDiscovery, 'getInstance').mockReturnValue(mockTableDiscovery);
-        jest.spyOn(relationship_discovery_js_1.RelationshipDiscovery, 'getInstance').mockReturnValue(mockRelationshipDiscovery);
+        jest
+            .spyOn(table_metadata_discovery_js_1.TableMetadataDiscovery, 'getInstance')
+            .mockReturnValue(mockTableDiscovery);
+        jest
+            .spyOn(relationship_discovery_js_1.RelationshipDiscovery, 'getInstance')
+            .mockReturnValue(mockRelationshipDiscovery);
         jest.spyOn(view_discovery_js_1.ViewDiscovery, 'getInstance').mockReturnValue(mockViewDiscovery);
-        jest.spyOn(sqlite_index_discovery_js_1.SQLiteIndexDiscovery, 'getInstance').mockReturnValue(mockIndexDiscovery);
-        jest.spyOn(sqlite_constraint_discovery_js_1.SQLiteConstraintDiscovery, 'getInstance').mockReturnValue(mockConstraintDiscovery);
+        jest
+            .spyOn(sqlite_index_discovery_js_1.SQLiteIndexDiscovery, 'getInstance')
+            .mockReturnValue(mockIndexDiscovery);
+        jest
+            .spyOn(sqlite_constraint_discovery_js_1.SQLiteConstraintDiscovery, 'getInstance')
+            .mockReturnValue(mockConstraintDiscovery);
         coordinator = sqlite_discovery_coordinator_js_1.SQLiteDiscoveryCoordinator.getInstance();
     });
     (0, globals_1.afterEach)(() => {
@@ -190,8 +200,8 @@ const mockTableSize = {
                         name: 'users_email_idx',
                         columns: ['email'],
                         unique: true,
-                        definition: 'CREATE UNIQUE INDEX users_email_idx ON users(email)'
-                    })
+                        definition: 'CREATE UNIQUE INDEX users_email_idx ON users(email)',
+                    }),
                 ]),
                 constraints: mockConstraintData,
                 foreignKeys: globals_1.expect.arrayContaining([
@@ -200,10 +210,10 @@ const mockTableSize = {
                         column: 'user_id',
                         referencedTable: 'users',
                         referencedColumn: 'id',
-                        onDelete: 'CASCADE'
-                    })
+                        onDelete: 'CASCADE',
+                    }),
                 ]),
-                tableSize: mockTableSize
+                tableSize: mockTableSize,
             });
         });
         (0, globals_1.it)('should skip views when includeViews is false', async () => {
@@ -219,7 +229,7 @@ const mockTableSize = {
                 name: 'users',
                 indexes: [],
                 foreignKeys: [],
-                tableSize: undefined
+                tableSize: undefined,
             });
         });
         (0, globals_1.it)('should handle constraint discovery errors gracefully', async () => {
@@ -249,7 +259,7 @@ const mockTableSize = {
                 supportsAutoIncrement: true,
                 supportsRowId: true,
                 supportsTriggers: true,
-                supportsFullTextSearch: true
+                supportsFullTextSearch: true,
             });
         });
     });
@@ -258,7 +268,7 @@ const mockTableSize = {
             mockConstraintDiscovery.isForeignKeySupportEnabled.mockResolvedValue(false);
             const tables = [
                 { name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] },
-                { name: 'posts', primaryKey: ['id'], indexes: [], foreignKeys: [] }
+                { name: 'posts', primaryKey: ['id'], indexes: [], foreignKeys: [] },
             ];
             const recommendations = await coordinator.getRecommendations(mockKysely, tables);
             (0, globals_1.expect)(mockConstraintDiscovery.isForeignKeySupportEnabled).toHaveBeenCalled();
@@ -272,14 +282,16 @@ const mockTableSize = {
         });
         (0, globals_1.it)('should recommend enabling foreign keys when disabled', async () => {
             mockConstraintDiscovery.isForeignKeySupportEnabled.mockResolvedValue(false);
-            const tables = [{ name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] }];
+            const tables = [
+                { name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] },
+            ];
             const recommendations = await coordinator.getRecommendations(mockKysely, tables);
             (0, globals_1.expect)(recommendations).toContain('Consider enabling foreign key support with PRAGMA foreign_keys = ON for better data integrity');
         });
         (0, globals_1.it)('should recommend primary key for tables without one', async () => {
             const tables = [
                 { name: 'users', primaryKey: [], indexes: [], foreignKeys: [] },
-                { name: 'posts', primaryKey: ['id'], indexes: [], foreignKeys: [] }
+                { name: 'posts', primaryKey: ['id'], indexes: [], foreignKeys: [] },
             ];
             const recommendations = await coordinator.getRecommendations(mockKysely, tables);
             (0, globals_1.expect)(recommendations).toContain('Table users should have a primary key for better performance');
@@ -287,9 +299,13 @@ const mockTableSize = {
         (0, globals_1.it)('should handle recommendation errors gracefully', async () => {
             mockConstraintDiscovery.isForeignKeySupportEnabled.mockResolvedValue(false);
             mockIndexDiscovery.discoverTableIndexes.mockRejectedValue(new Error('Index analysis failed'));
-            const tables = [{ name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] }];
+            const tables = [
+                { name: 'users', primaryKey: ['id'], indexes: [], foreignKeys: [] },
+            ];
             const recommendations = await coordinator.getRecommendations(mockKysely, tables);
-            (0, globals_1.expect)(recommendations).toEqual(['Consider enabling foreign key support with PRAGMA foreign_keys = ON for better data integrity']);
+            (0, globals_1.expect)(recommendations).toEqual([
+                'Consider enabling foreign key support with PRAGMA foreign_keys = ON for better data integrity',
+            ]);
         });
         (0, globals_1.it)('should handle empty tables array', async () => {
             const recommendations = await coordinator.getRecommendations(mockKysely, []);
@@ -305,7 +321,7 @@ const mockTableSize = {
                 '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',
             ]);
         });
     });
@@ -351,14 +367,14 @@ const mockTableSize = {
             const config = {
                 excludeTables: ['temp_*'],
                 includeViews: true,
-                customTypeMappings: { 'INTEGER': 'number' }
+                customTypeMappings: { INTEGER: 'number' },
             };
             await coordinator.discoverSchema(mockKysely, config);
             (0, globals_1.expect)(mockTableDiscovery.discoverTables).toHaveBeenCalledWith(globals_1.expect.any(Object), // DatabaseIntrospector
             {
                 excludeTables: ['temp_*'],
                 includeViews: true,
-                customTypeMappings: { 'INTEGER': 'number' }
+                customTypeMappings: { INTEGER: 'number' },
             });
         });
         (0, globals_1.it)('should use default configuration when none provided', async () => {
@@ -366,7 +382,7 @@ const mockTableSize = {
             (0, globals_1.expect)(mockTableDiscovery.discoverTables).toHaveBeenCalledWith(globals_1.expect.any(Object), {
                 excludeTables: undefined,
                 includeViews: undefined,
-                customTypeMappings: undefined
+                customTypeMappings: undefined,
             });
         });
     });

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

@@ -77,7 +77,7 @@ exports.default = {
         'sqlite-discovery-coordinator.test.ts',
         'dialect-capabilities.test.ts',
         'error-handling.test.ts',
-        'integration.test.ts'
+        'integration.test.ts',
     ],
     coverage: {
         factory: '100%',
@@ -85,6 +85,6 @@ exports.default = {
         sqlite: '100%',
         capabilities: '100%',
         errorHandling: '100%',
-        integration: '100%'
-    }
+        integration: '100%',
+    },
 };

package/dist/cjs/sqlite-migration/index.d.ts

@@ -1,6 +1,6 @@
 export { SQLiteMigrationManager } from './sqlite-migration-manager.js';
 export { SQLiteMigrationProvider } from './sqlite-migration-provider.js';
-export type { SQLiteMigrationConfig, SQLiteMigrationResult, SQLiteMigrationPlan } from './sqlite-migration-manager.js';
-export type { SQLiteMigrationFile, SQLiteMigrationProviderConfig } from './sqlite-migration-provider.js';
+export type { SQLiteMigrationConfig, SQLiteMigrationResult, SQLiteMigrationPlan, } from './sqlite-migration-manager.js';
+export type { SQLiteMigrationFile, SQLiteMigrationProviderConfig, } from './sqlite-migration-provider.js';
 export declare function createSQLiteMigrationManager(db: any, config?: Partial<import('./sqlite-migration-manager.js').SQLiteMigrationConfig>, logger?: import('../logging/logger.js').Logger): Promise<import('./sqlite-migration-manager.js').SQLiteMigrationManager>;
 export declare function createSQLiteMigrationProvider(config?: Partial<import('./sqlite-migration-provider.js').SQLiteMigrationProviderConfig>, logger?: import('../logging/logger.js').Logger): Promise<import('./sqlite-migration-provider.js').SQLiteMigrationProvider>;

package/dist/cjs/sqlite-migration/sqlite-migration-manager.js

@@ -66,12 +66,12 @@ class SQLiteMigrationManager {
             migrationDirectory: './migrations',
             backupBeforeMigration: true,
             dryRun: false,
-            ...config
+            ...config,
         };
         this.optimizer = sqlite_auto_optimizer_js_1.SQLiteAutoOptimizer.getInstance(logger);
         this.indexer = sqlite_auto_indexer_js_1.SQLiteAutoIndexer.getInstance(logger);
         this.provider = sqlite_migration_provider_js_1.SQLiteMigrationProvider.getInstance({
-            migrationDirectory: this.config.migrationDirectory
+            migrationDirectory: this.config.migrationDirectory,
         }, logger);
     }
     static getInstance(db, config, logger) {
@@ -143,7 +143,7 @@ class SQLiteMigrationManager {
                 journalMode: 'WAL',
                 synchronous: 'NORMAL',
                 cacheSize: -64000, // 64MB
-                tempStore: 'MEMORY'
+                tempStore: 'MEMORY',
             });
             this.logger.info(`✅ Applied ${optimizations.appliedOptimizations.length} optimizations`);
             if (optimizations.warnings.length > 0) {
@@ -169,14 +169,14 @@ class SQLiteMigrationManager {
             const indexRecs = await this.indexer.analyzeAndRecommend(this.db, {
                 minFrequency: 3,
                 slowQueryThreshold: 1000,
-                maxRecommendations: 10
+                maxRecommendations: 10,
             });
             const plan = {
                 migrations: pendingMigrations,
                 optimizations: optimizationRecs.recommendations || [],
-                indexRecommendations: indexRecs.recommendations.map(r => r.sql),
+                indexRecommendations: indexRecs.recommendations.map((r) => r.sql),
                 estimatedImpact: this.calculateImpact(pendingMigrations.length, optimizationRecs.recommendations?.length || 0),
-                dryRun: this.config.dryRun
+                dryRun: this.config.dryRun,
             };
             this.logger.info(`📊 Migration plan: ${plan.migrations.length} migrations, ${plan.optimizations.length} optimizations, ${plan.indexRecommendations.length} index recommendations`);
             return plan;
@@ -203,7 +203,7 @@ class SQLiteMigrationManager {
                     indexRecommendations: [],
                     performanceImpact: 'low',
                     duration: Date.now() - startTime,
-                    warnings: []
+                    warnings: [],
                 };
             }
             const result = {
@@ -213,7 +213,7 @@ class SQLiteMigrationManager {
                 indexRecommendations: [],
                 performanceImpact: 'low',
                 duration: 0,
-                warnings: []
+                warnings: [],
             };
             // Execute migrations in transaction
             await this.db.transaction().execute(async (trx) => {
@@ -222,7 +222,8 @@ class SQLiteMigrationManager {
                     result.migrationsApplied++;
                 }
                 // Apply optimizations after migrations
-                if (this.config.enableAutoOptimization && plan.optimizations.length > 0) {
+                if (this.config.enableAutoOptimization &&
+                    plan.optimizations.length > 0) {
                     const optimizationResult = await this.optimizer.optimizeDatabase(trx, {
                         enableAutoPragma: true,
                         enableAutoIndexing: false,
@@ -233,7 +234,7 @@ class SQLiteMigrationManager {
                         journalMode: 'WAL',
                         synchronous: 'NORMAL',
                         cacheSize: -64000,
-                        tempStore: 'MEMORY'
+                        tempStore: 'MEMORY',
                     });
                     result.optimizationsApplied = optimizationResult.appliedOptimizations;
                     result.warnings.push(...optimizationResult.warnings);
@@ -259,7 +260,7 @@ class SQLiteMigrationManager {
                 indexRecommendations: [],
                 performanceImpact: 'low',
                 duration,
-                warnings: [error instanceof Error ? error.message : 'Unknown error']
+                warnings: [error instanceof Error ? error.message : 'Unknown error'],
             };
         }
     }
@@ -283,7 +284,7 @@ class SQLiteMigrationManager {
                 applied_at: new Date(),
                 checksum: migration.checksum,
                 optimization_applied: true,
-                performance_impact: 'medium'
+                performance_impact: 'medium',
             })
                 .execute();
             this.logger.info(`✅ Migration ${migrationName} applied successfully`);
@@ -304,17 +305,20 @@ class SQLiteMigrationManager {
             .selectFrom('sqlite_migrations')
             .select('name')
             .execute();
-        const appliedNames = new Set(appliedMigrations.map(m => m.name));
+        const appliedNames = new Set(appliedMigrations.map((m) => m.name));
         // Filter out applied migrations
         return availableMigrations
-            .filter(m => !appliedNames.has(m.name))
-            .map(m => m.name);
+            .filter((m) => !appliedNames.has(m.name))
+            .map((m) => m.name);
     }
     /**
      * Generate a new migration file
      */
     async generateMigration(description, operation = 'create_table', options = {}) {
-        const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+        const timestamp = new Date()
+            .toISOString()
+            .replace(/[-:T]/g, '')
+            .slice(0, 14);
         const fileName = `${timestamp}_${description.toLowerCase().replace(/\s+/g, '_')}.sql`;
         const filePath = path.join(this.config.migrationDirectory, fileName);
         const content = this.provider.generateOptimizedMigration(operation, options.tableName || 'new_table', options);
@@ -376,7 +380,7 @@ class SQLiteMigrationManager {
             pendingMigrations: pending.length,
             lastMigration: migrations[0]?.name,
             lastAppliedAt: migrations[0]?.applied_at,
-            appliedList: migrations
+            appliedList: migrations,
         };
     }
     /**