noormme 1.0.0

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

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteMigrationManager = void 0;
+const sql_js_1 = require("../raw-builder/sql.js");
+const logger_js_1 = require("../logging/logger.js");
+const sqlite_auto_optimizer_js_1 = require("../dialect/sqlite/sqlite-auto-optimizer.js");
+const sqlite_auto_indexer_js_1 = require("../dialect/sqlite/sqlite-auto-indexer.js");
+/**
+ * SQLite Migration Manager - Focused on SQLite automation and optimization
+ * Integrates with existing SQLite auto-optimization features
+ */
+class SQLiteMigrationManager {
+    static instance = null;
+    db;
+    config;
+    logger;
+    optimizer;
+    indexer;
+    isInitialized = false;
+    constructor(db, config = {}, logger) {
+        this.db = db;
+        this.logger = logger;
+        this.config = {
+            enableAutoOptimization: true,
+            enableIndexRecommendations: true,
+            enableConstraintValidation: true,
+            enablePerformanceMonitoring: true,
+            migrationDirectory: './migrations',
+            backupBeforeMigration: true,
+            dryRun: false,
+            ...config
+        };
+        this.optimizer = sqlite_auto_optimizer_js_1.SQLiteAutoOptimizer.getInstance(logger);
+        this.indexer = sqlite_auto_indexer_js_1.SQLiteAutoIndexer.getInstance(logger);
+    }
+    static getInstance(db, config, logger) {
+        if (!SQLiteMigrationManager.instance) {
+            if (!logger) {
+                logger = new logger_js_1.Logger({ level: 'info', enabled: true });
+            }
+            SQLiteMigrationManager.instance = new SQLiteMigrationManager(db, config, logger);
+        }
+        return SQLiteMigrationManager.instance;
+    }
+    /**
+     * Initialize the SQLite migration system
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            return;
+        }
+        this.logger.info('🚀 Initializing SQLite Migration Manager...');
+        try {
+            // Create migrations table if it doesn't exist
+            await this.createMigrationsTable();
+            // Apply initial SQLite optimizations
+            if (this.config.enableAutoOptimization) {
+                await this.applyInitialOptimizations();
+            }
+            this.isInitialized = true;
+            this.logger.info('✅ SQLite Migration Manager initialized successfully');
+        }
+        catch (error) {
+            this.logger.error('❌ Failed to initialize SQLite Migration Manager:', error);
+            throw error;
+        }
+    }
+    /**
+     * Create the migrations tracking table
+     */
+    async createMigrationsTable() {
+        await (0, sql_js_1.sql) `
+      CREATE TABLE IF NOT EXISTS sqlite_migrations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT NOT NULL UNIQUE,
+        applied_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        checksum TEXT,
+        optimization_applied BOOLEAN DEFAULT FALSE,
+        index_recommendations TEXT,
+        performance_impact TEXT
+      )
+    `.execute(this.db);
+        // Create index for faster lookups
+        await (0, sql_js_1.sql) `
+      CREATE INDEX IF NOT EXISTS idx_sqlite_migrations_name 
+      ON sqlite_migrations(name)
+    `.execute(this.db);
+    }
+    /**
+     * Apply initial SQLite optimizations
+     */
+    async applyInitialOptimizations() {
+        this.logger.info('🔧 Applying initial SQLite optimizations...');
+        try {
+            const optimizations = await this.optimizer.optimizeDatabase(this.db, {
+                enableAutoPragma: true,
+                enableAutoIndexing: false, // We'll handle indexing separately
+                enablePerformanceTuning: true,
+                enableBackupRecommendations: false,
+                slowQueryThreshold: 1000,
+                autoVacuumMode: 'INCREMENTAL',
+                journalMode: 'WAL',
+                synchronous: 'NORMAL',
+                cacheSize: -64000, // 64MB
+                tempStore: 'MEMORY'
+            });
+            this.logger.info(`✅ Applied ${optimizations.appliedOptimizations.length} optimizations`);
+            if (optimizations.warnings.length > 0) {
+                this.logger.warn(`⚠️ ${optimizations.warnings.length} warnings:`, optimizations.warnings);
+            }
+        }
+        catch (error) {
+            this.logger.error('❌ Failed to apply initial optimizations:', error);
+            throw error;
+        }
+    }
+    /**
+     * Plan SQLite migrations with optimization recommendations
+     */
+    async planMigrations() {
+        this.logger.info('📋 Planning SQLite migrations...');
+        try {
+            // Get pending migrations
+            const pendingMigrations = await this.getPendingMigrations();
+            // Get optimization recommendations
+            const optimizationRecs = await this.optimizer.optimizeDatabase(this.db);
+            // Get index recommendations
+            const indexRecs = await this.indexer.analyzeAndRecommend(this.db, {
+                minFrequency: 3,
+                slowQueryThreshold: 1000,
+                maxRecommendations: 10
+            });
+            const plan = {
+                migrations: pendingMigrations,
+                optimizations: optimizationRecs.recommendations || [],
+                indexRecommendations: indexRecs.recommendations.map(r => r.sql),
+                estimatedImpact: this.calculateImpact(pendingMigrations.length, optimizationRecs.recommendations?.length || 0),
+                dryRun: this.config.dryRun
+            };
+            this.logger.info(`📊 Migration plan: ${plan.migrations.length} migrations, ${plan.optimizations.length} optimizations, ${plan.indexRecommendations.length} index recommendations`);
+            return plan;
+        }
+        catch (error) {
+            this.logger.error('❌ Failed to plan migrations:', error);
+            throw error;
+        }
+    }
+    /**
+     * Execute SQLite migrations with automatic optimization
+     */
+    async executeMigrations() {
+        const startTime = Date.now();
+        this.logger.info('🔄 Executing SQLite migrations...');
+        try {
+            const plan = await this.planMigrations();
+            if (plan.migrations.length === 0) {
+                this.logger.info('✅ No pending migrations');
+                return {
+                    success: true,
+                    migrationsApplied: 0,
+                    optimizationsApplied: [],
+                    indexRecommendations: [],
+                    performanceImpact: 'low',
+                    duration: Date.now() - startTime,
+                    warnings: []
+                };
+            }
+            const result = {
+                success: false,
+                migrationsApplied: 0,
+                optimizationsApplied: [],
+                indexRecommendations: [],
+                performanceImpact: 'low',
+                duration: 0,
+                warnings: []
+            };
+            // Execute migrations in transaction
+            await this.db.transaction().execute(async (trx) => {
+                for (const migration of plan.migrations) {
+                    await this.executeMigration(trx, migration);
+                    result.migrationsApplied++;
+                }
+                // Apply optimizations after migrations
+                if (this.config.enableAutoOptimization && plan.optimizations.length > 0) {
+                    const optimizationResult = await this.optimizer.optimizeDatabase(trx, {
+                        enableAutoPragma: true,
+                        enableAutoIndexing: false,
+                        enablePerformanceTuning: true,
+                        enableBackupRecommendations: false,
+                        slowQueryThreshold: 1000,
+                        autoVacuumMode: 'INCREMENTAL',
+                        journalMode: 'WAL',
+                        synchronous: 'NORMAL',
+                        cacheSize: -64000,
+                        tempStore: 'MEMORY'
+                    });
+                    result.optimizationsApplied = optimizationResult.appliedOptimizations;
+                    result.warnings.push(...optimizationResult.warnings);
+                }
+                // Record index recommendations
+                if (this.config.enableIndexRecommendations) {
+                    result.indexRecommendations = plan.indexRecommendations;
+                }
+            });
+            result.success = true;
+            result.performanceImpact = plan.estimatedImpact;
+            result.duration = Date.now() - startTime;
+            this.logger.info(`✅ Migration completed: ${result.migrationsApplied} migrations applied in ${result.duration}ms`);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            this.logger.error('❌ Migration failed:', error);
+            return {
+                success: false,
+                migrationsApplied: 0,
+                optimizationsApplied: [],
+                indexRecommendations: [],
+                performanceImpact: 'low',
+                duration,
+                warnings: [error instanceof Error ? error.message : 'Unknown error']
+            };
+        }
+    }
+    /**
+     * Execute a single migration
+     */
+    async executeMigration(trx, migrationName) {
+        this.logger.info(`📝 Executing migration: ${migrationName}`);
+        // For now, this is a placeholder - in a real implementation,
+        // you would load and execute the actual migration SQL
+        const migrationSQL = `-- Migration: ${migrationName}\n-- This would contain the actual migration SQL`;
+        // Record the migration
+        await trx
+            .insertInto('sqlite_migrations')
+            .values({
+            name: migrationName,
+            applied_at: new Date(),
+            checksum: this.calculateChecksum(migrationSQL),
+            optimization_applied: true,
+            performance_impact: 'medium'
+        })
+            .execute();
+        this.logger.info(`✅ Migration ${migrationName} applied successfully`);
+    }
+    /**
+     * Get pending migrations
+     */
+    async getPendingMigrations() {
+        // This is a simplified implementation
+        // In a real scenario, you would scan the migration directory
+        // and compare with the database records
+        const appliedMigrations = await this.db
+            .selectFrom('sqlite_migrations')
+            .select('name')
+            .execute();
+        const appliedNames = new Set(appliedMigrations.map(m => m.name));
+        // Placeholder - return some example migrations
+        const allMigrations = [
+            '20240101000000_create_users_table',
+            '20240102000000_add_email_index',
+            '20240103000000_create_posts_table'
+        ];
+        return allMigrations.filter(name => !appliedNames.has(name));
+    }
+    /**
+     * Calculate performance impact
+     */
+    calculateImpact(migrationCount, optimizationCount) {
+        const total = migrationCount + optimizationCount;
+        if (total === 0)
+            return 'low';
+        if (total <= 3)
+            return 'medium';
+        return 'high';
+    }
+    /**
+     * Calculate checksum for migration content
+     */
+    calculateChecksum(content) {
+        // Simple checksum implementation
+        let hash = 0;
+        for (let i = 0; i < content.length; i++) {
+            const char = content.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return hash.toString(16);
+    }
+    /**
+     * Get migration status
+     */
+    async getStatus() {
+        const migrations = await this.db
+            .selectFrom('sqlite_migrations')
+            .selectAll()
+            .orderBy('applied_at', 'desc')
+            .execute();
+        const pending = await this.getPendingMigrations();
+        return {
+            totalMigrations: migrations.length + pending.length,
+            appliedMigrations: migrations.length,
+            pendingMigrations: pending.length,
+            lastMigration: migrations[0]?.name,
+            lastAppliedAt: migrations[0]?.applied_at
+        };
+    }
+    /**
+     * Record query for performance analysis
+     */
+    recordQuery(query, executionTime, table) {
+        if (this.config.enablePerformanceMonitoring) {
+            this.indexer.recordQuery(query, executionTime, table);
+        }
+    }
+    /**
+     * Get performance metrics
+     */
+    async getPerformanceMetrics() {
+        return await this.optimizer.analyzeDatabase(this.db);
+    }
+    /**
+     * Get index recommendations
+     */
+    async getIndexRecommendations() {
+        return await this.indexer.analyzeAndRecommend(this.db);
+    }
+    /**
+     * Get optimization recommendations
+     */
+    async getOptimizationRecommendations() {
+        return await this.optimizer.optimizeDatabase(this.db);
+    }
+}
+exports.SQLiteMigrationManager = SQLiteMigrationManager;

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

@@ -0,0 +1,77 @@
+import { Logger } from '../logging/logger.js';
+export interface SQLiteMigrationFile {
+    name: string;
+    content: string;
+    checksum: string;
+    timestamp: Date;
+}
+export interface SQLiteMigrationProviderConfig {
+    migrationDirectory: string;
+    fileExtensions: string[];
+    encoding: BufferEncoding;
+}
+/**
+ * SQLite Migration Provider - Handles migration file discovery and loading
+ * Focused on SQLite-specific migration patterns and optimizations
+ */
+export declare class SQLiteMigrationProvider {
+    private static instance;
+    private config;
+    private logger;
+    private migrationCache;
+    private constructor();
+    static getInstance(config?: Partial<SQLiteMigrationProviderConfig>, logger?: Logger): SQLiteMigrationProvider;
+    /**
+     * Discover all migration files
+     */
+    discoverMigrations(): Promise<SQLiteMigrationFile[]>;
+    /**
+     * Get a specific migration by name
+     */
+    getMigration(name: string): Promise<SQLiteMigrationFile | null>;
+    /**
+     * Validate migration file
+     */
+    validateMigration(migration: SQLiteMigrationFile): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Generate SQLite-optimized migration content
+     */
+    generateOptimizedMigration(operation: 'create_table' | 'add_column' | 'add_index' | 'modify_column', tableName: string, options?: any): string;
+    /**
+     * Generate create table migration with SQLite optimizations
+     */
+    private generateCreateTableMigration;
+    /**
+     * Generate add column migration
+     */
+    private generateAddColumnMigration;
+    /**
+     * Generate add index migration
+     */
+    private generateAddIndexMigration;
+    /**
+     * Generate modify column migration
+     */
+    private generateModifyColumnMigration;
+    /**
+     * Map common types to SQLite types
+     */
+    private mapToSQLiteType;
+    /**
+     * Format default value for SQLite
+     */
+    private formatDefaultValue;
+    /**
+     * Calculate checksum for content
+     */
+    private calculateChecksum;
+    /**
+     * Generate example migrations for demonstration
+     */
+    private generateUsersTableMigration;
+    private generateEmailIndexMigration;
+    private generatePostsTableMigration;
+}