@ductape/sdk 0.1.7 → 0.1.8

package/dist/database/migrations/migration-engine.js

@@ -1,1421 +0,0 @@
-"use strict";
-/**
- * Migration Engine
- *
- * Manages database migrations including running migrations,
- * rolling back, tracking migration history, and status checking.
- *
- * Executes platform-independent migration operations by translating
- * them to database-specific commands via the adapter.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MigrationHelpers = exports.MigrationEngine = void 0;
-const crypto = __importStar(require("crypto"));
-const enums_1 = require("../types/enums");
-const database_error_1 = require("../utils/database-error");
-/**
- * Migration tracking table/collection name
- */
-const MIGRATION_COLLECTION = '_ductape_migrations';
-/**
- * Migration Engine for managing database migrations
- */
-class MigrationEngine {
-    constructor(adapter) {
-        this.adapter = adapter;
-        this.databaseType = adapter.getDatabaseType();
-    }
-    /**
-     * Execute a raw query using the adapter's raw() method
-     * This is a convenience wrapper that handles different query types
-     */
-    async rawQuery(query, params) {
-        try {
-            const result = await this.adapter.raw({
-                table: MIGRATION_COLLECTION,
-                query: query,
-                params: params,
-            });
-            return result;
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-    // ==================== INITIALIZATION ====================
-    /**
-     * Initialize migration tracking collection if it doesn't exist
-     */
-    async initialize() {
-        const exists = await this.adapter.tableExists(MIGRATION_COLLECTION);
-        if (exists)
-            return;
-        // Create migration tracking collection using raw operations
-        await this.createMigrationTrackingCollection();
-    }
-    async createMigrationTrackingCollection() {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                await this.createSQLMigrationTable();
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                await this.createMongoMigrationCollection();
-                break;
-            case enums_1.DatabaseType.DYNAMODB:
-                await this.createDynamoMigrationTable();
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                await this.createCassandraMigrationTable();
-                break;
-        }
-    }
-    async createSQLMigrationTable() {
-        const escapedTable = this.escapeIdentifier(MIGRATION_COLLECTION);
-        const sql = `
-      CREATE TABLE IF NOT EXISTS ${escapedTable} (
-        id ${this.databaseType === enums_1.DatabaseType.POSTGRESQL ? 'SERIAL' : 'INT AUTO_INCREMENT'} PRIMARY KEY,
-        tag VARCHAR(255) NOT NULL UNIQUE,
-        name VARCHAR(255) NOT NULL,
-        applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        applied_by VARCHAR(255),
-        checksum VARCHAR(64),
-        execution_time INT
-      )
-    `;
-        await this.rawQuery(sql);
-    }
-    async createMongoMigrationCollection() {
-        // MongoDB will auto-create the collection on first insert
-        // But we can create it explicitly with validation
-        try {
-            await this.rawQuery({
-                create: MIGRATION_COLLECTION,
-                validator: {
-                    $jsonSchema: {
-                        bsonType: 'object',
-                        required: ['tag', 'name', 'applied_at'],
-                        properties: {
-                            tag: { bsonType: 'string' },
-                            name: { bsonType: 'string' },
-                            applied_at: { bsonType: 'date' },
-                            applied_by: { bsonType: 'string' },
-                            checksum: { bsonType: 'string' },
-                            execution_time: { bsonType: 'int' },
-                        },
-                    },
-                },
-            });
-            // Create unique index on tag
-            await this.rawQuery({
-                createIndexes: MIGRATION_COLLECTION,
-                indexes: [{ key: { tag: 1 }, unique: true, name: 'tag_unique' }],
-            });
-        }
-        catch (error) {
-            // Collection might already exist
-        }
-    }
-    async createDynamoMigrationTable() {
-        await this.rawQuery({
-            operation: 'CreateTable',
-            params: {
-                TableName: MIGRATION_COLLECTION,
-                KeySchema: [{ AttributeName: 'tag', KeyType: 'HASH' }],
-                AttributeDefinitions: [{ AttributeName: 'tag', AttributeType: 'S' }],
-                BillingMode: 'PAY_PER_REQUEST',
-            },
-        });
-    }
-    async createCassandraMigrationTable() {
-        const sql = `
-      CREATE TABLE IF NOT EXISTS ${MIGRATION_COLLECTION} (
-        tag text PRIMARY KEY,
-        name text,
-        applied_at timestamp,
-        applied_by text,
-        checksum text,
-        execution_time int
-      )
-    `;
-        await this.rawQuery(sql);
-    }
-    // ==================== MIGRATION EXECUTION ====================
-    /**
-     * Run all pending migrations
-     */
-    async migrate(migrations, options) {
-        await this.initialize();
-        const results = new Map();
-        const pending = await this.getPendingMigrations(migrations);
-        const sorted = this.sortByDependencies(pending);
-        for (const migration of sorted) {
-            if (options === null || options === void 0 ? void 0 : options.dryRun) {
-                results.set(migration.tag, {
-                    success: true,
-                    operations: migration.up.map(op => this.getOperationDescription(op)),
-                    executionTime: 0,
-                });
-                continue;
-            }
-            const result = await this.runMigration(migration, 'up', options === null || options === void 0 ? void 0 : options.appliedBy);
-            results.set(migration.tag, result);
-            if (!result.success) {
-                break;
-            }
-        }
-        return results;
-    }
-    /**
-     * Run a single migration
-     */
-    async runMigration(migration, direction, appliedBy) {
-        const startTime = Date.now();
-        const operations = [];
-        try {
-            const ops = direction === 'up' ? migration.up : migration.down;
-            for (const operation of ops) {
-                const description = this.getOperationDescription(operation);
-                operations.push(description);
-                await this.executeOperation(operation);
-            }
-            const executionTime = Date.now() - startTime;
-            if (direction === 'up') {
-                await this.recordMigration(migration, appliedBy, executionTime);
-            }
-            else {
-                await this.removeMigrationRecord(migration.tag);
-            }
-            return { success: true, operations, executionTime };
-        }
-        catch (error) {
-            return {
-                success: false,
-                operations,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
-        }
-    }
-    /**
-     * Rollback the last N migrations
-     */
-    async rollback(migrations, count = 1) {
-        await this.initialize();
-        const results = new Map();
-        const applied = await this.getAppliedMigrations();
-        const toRollback = applied.slice(-count);
-        for (const history of toRollback.reverse()) {
-            const migration = migrations.find(m => m.tag === history.tag);
-            if (!migration) {
-                results.set(history.tag, {
-                    success: false,
-                    operations: [],
-                    error: `Migration definition not found for tag: ${history.tag}`,
-                });
-                continue;
-            }
-            const result = await this.runMigration(migration, 'down');
-            results.set(history.tag, result);
-            if (!result.success)
-                break;
-        }
-        return results;
-    }
-    /**
-     * Rollback all migrations
-     */
-    async rollbackAll(migrations) {
-        const applied = await this.getAppliedMigrations();
-        return this.rollback(migrations, applied.length);
-    }
-    /**
-     * Reset database (rollback all and re-run all migrations)
-     */
-    async reset(migrations) {
-        const rollbackResults = await this.rollbackAll(migrations);
-        const migrateResults = await this.migrate(migrations);
-        return { rollback: rollbackResults, migrate: migrateResults };
-    }
-    // ==================== STATUS & HISTORY ====================
-    async getStatus(migrations) {
-        await this.initialize();
-        const applied = await this.getAppliedMigrations();
-        const appliedTags = new Set(applied.map(m => m.tag));
-        const pendingMigrations = migrations.filter(m => !appliedTags.has(m.tag)).map(m => m.tag);
-        return {
-            total: migrations.length,
-            completed: applied.length,
-            pending: pendingMigrations.length,
-            lastApplied: applied[applied.length - 1] || undefined,
-            pendingMigrations,
-            appliedMigrations: applied.map(m => m.tag),
-        };
-    }
-    async getAppliedMigrations() {
-        await this.initialize();
-        try {
-            const result = await this.adapter.query({
-                options: {
-                    table: MIGRATION_COLLECTION,
-                    orderBy: { column: 'applied_at', order: 'ASC' },
-                },
-            });
-            return (result.data || []).map((row) => ({
-                tag: row.tag,
-                name: row.name,
-                appliedAt: new Date(row.applied_at || row.appliedAt),
-                appliedBy: row.applied_by || row.appliedBy,
-                checksum: row.checksum,
-                executionTime: row.execution_time || row.executionTime,
-            }));
-        }
-        catch (error) {
-            return [];
-        }
-    }
-    async getPendingMigrations(migrations) {
-        const applied = await this.getAppliedMigrations();
-        const appliedTags = new Set(applied.map(m => m.tag));
-        const pendingMigrations = [];
-        for (const migration of migrations) {
-            // If migration was never applied, it's pending
-            if (!appliedTags.has(migration.tag)) {
-                pendingMigrations.push(migration);
-                continue;
-            }
-            // For createCollection migrations, verify the table actually exists
-            // If it doesn't exist (e.g., was manually dropped), re-apply the migration
-            const createOp = migration.up.find(op => op.type === 'createCollection');
-            if (createOp) {
-                try {
-                    const tableExists = await this.tableExists(createOp.name);
-                    if (!tableExists) {
-                        // Table doesn't exist but migration was marked as applied
-                        // Remove the stale migration record and mark as pending
-                        await this.removeMigrationRecord(migration.tag);
-                        pendingMigrations.push(migration);
-                    }
-                }
-                catch (_a) {
-                    // If we can't check, assume it needs to be re-applied
-                    await this.removeMigrationRecord(migration.tag);
-                    pendingMigrations.push(migration);
-                }
-            }
-        }
-        return pendingMigrations;
-    }
-    /**
-     * Check if a table exists in the database
-     */
-    async tableExists(tableName) {
-        var _a, _b, _c;
-        try {
-            switch (this.databaseType) {
-                case enums_1.DatabaseType.POSTGRESQL:
-                    const pgResult = await this.rawQuery(`SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = '${tableName}')`);
-                    return ((_a = pgResult === null || pgResult === void 0 ? void 0 : pgResult[0]) === null || _a === void 0 ? void 0 : _a.exists) === true;
-                case enums_1.DatabaseType.MYSQL:
-                case enums_1.DatabaseType.MARIADB:
-                    const mysqlResult = await this.rawQuery(`SHOW TABLES LIKE '${tableName}'`);
-                    return Array.isArray(mysqlResult) && mysqlResult.length > 0;
-                case enums_1.DatabaseType.MONGODB:
-                    const collections = await this.rawQuery({ listCollections: 1, nameOnly: true });
-                    return ((_c = (_b = collections === null || collections === void 0 ? void 0 : collections.cursor) === null || _b === void 0 ? void 0 : _b.firstBatch) === null || _c === void 0 ? void 0 : _c.some((c) => c.name === tableName)) || false;
-                default:
-                    return true; // Assume exists for other databases
-            }
-        }
-        catch (_d) {
-            return true; // On error, assume exists to avoid accidental re-creation
-        }
-    }
-    async isMigrationApplied(tag) {
-        await this.initialize();
-        const applied = await this.getAppliedMigrations();
-        return applied.some(m => m.tag === tag);
-    }
-    // ==================== OPERATION EXECUTION ====================
-    async executeOperation(operation) {
-        switch (operation.type) {
-            // Common operations
-            case 'createCollection':
-                await this.executeCreateCollection(operation);
-                break;
-            case 'dropCollection':
-                await this.executeDropCollection(operation);
-                break;
-            case 'createIndex':
-                await this.executeCreateIndex(operation);
-                break;
-            case 'dropIndex':
-                await this.executeDropIndex(operation);
-                break;
-            case 'addField':
-                await this.executeAddField(operation);
-                break;
-            case 'dropField':
-                await this.executeDropField(operation);
-                break;
-            case 'renameField':
-                await this.executeRenameField(operation);
-                break;
-            case 'modifyField':
-                await this.executeModifyField(operation);
-                break;
-            // SQL-specific
-            case 'addConstraint':
-                await this.executeAddConstraint(operation);
-                break;
-            case 'dropConstraint':
-                await this.executeDropConstraint(operation);
-                break;
-            // MongoDB-specific
-            case 'createMongoValidation':
-                await this.executeCreateMongoValidation(operation);
-                break;
-            case 'dropMongoValidation':
-                await this.executeDropMongoValidation(operation);
-                break;
-            case 'shardCollection':
-                await this.executeShardCollection(operation);
-                break;
-            // DynamoDB-specific
-            case 'createDynamoTable':
-                await this.executeCreateDynamoTable(operation);
-                break;
-            case 'updateDynamoThroughput':
-                await this.executeUpdateDynamoThroughput(operation);
-                break;
-            case 'addDynamoGSI':
-                await this.executeAddDynamoGSI(operation);
-                break;
-            case 'removeDynamoGSI':
-                await this.executeRemoveDynamoGSI(operation);
-                break;
-            case 'enableDynamoStream':
-                await this.executeEnableDynamoStream(operation);
-                break;
-            case 'enableDynamoTTL':
-                await this.executeEnableDynamoTTL(operation);
-                break;
-            // Cassandra-specific
-            case 'alterCassandraTable':
-                await this.executeAlterCassandraTable(operation);
-                break;
-            case 'createCassandraMaterializedView':
-                await this.executeCreateCassandraMaterializedView(operation);
-                break;
-            case 'dropCassandraMaterializedView':
-                await this.executeDropCassandraMaterializedView(operation);
-                break;
-            // Raw operations
-            case 'raw':
-                await this.executeRawOperation(operation);
-                break;
-            default:
-                throw database_error_1.DatabaseError.migrationError(`Unknown migration operation type: ${operation.type}`);
-        }
-    }
-    // ==================== COMMON OPERATION EXECUTORS ====================
-    async executeCreateCollection(op) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                await this.createSQLTable(op);
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                await this.createMongoCollection(op);
-                break;
-            case enums_1.DatabaseType.DYNAMODB:
-                await this.createDynamoTable(op);
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                await this.createCassandraTable(op);
-                break;
-        }
-    }
-    async executeDropCollection(op) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                let sql = 'DROP TABLE';
-                if (op.ifExists)
-                    sql += ' IF EXISTS';
-                sql += ` ${this.escapeIdentifier(op.name)}`;
-                if (op.cascade)
-                    sql += ' CASCADE';
-                await this.rawQuery(sql);
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                await this.rawQuery({ drop: op.name });
-                break;
-            case enums_1.DatabaseType.DYNAMODB:
-                await this.rawQuery({
-                    operation: 'DeleteTable',
-                    params: { TableName: op.name },
-                });
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                await this.rawQuery(`DROP TABLE ${op.ifExists ? 'IF EXISTS ' : ''}${op.name}`);
-                break;
-        }
-    }
-    async executeCreateIndex(op) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                await this.createSQLIndex(op);
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                await this.createMongoIndex(op);
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                await this.createCassandraIndex(op);
-                break;
-            case enums_1.DatabaseType.DYNAMODB:
-                // DynamoDB indexes are created with the table or via GSI
-                break;
-        }
-    }
-    async executeDropIndex(op) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-                let pgSql = 'DROP INDEX';
-                if (op.ifExists)
-                    pgSql += ' IF EXISTS';
-                if (op.concurrent)
-                    pgSql += ' CONCURRENTLY';
-                pgSql += ` ${this.escapeIdentifier(op.name)}`;
-                await this.rawQuery(pgSql);
-                break;
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                await this.rawQuery(`DROP INDEX ${this.escapeIdentifier(op.name)} ON ${this.escapeIdentifier(op.collection)}`);
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                await this.rawQuery({
-                    dropIndexes: op.collection,
-                    index: op.name,
-                });
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                await this.rawQuery(`DROP INDEX ${op.ifExists ? 'IF EXISTS ' : ''}${op.name}`);
-                break;
-        }
-    }
-    async executeAddField(op) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                const colDef = this.buildColumnDefinition(op.field);
-                await this.rawQuery(`ALTER TABLE ${this.escapeIdentifier(op.collection)} ADD COLUMN ${colDef}`);
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                // MongoDB is schemaless - fields are added on write
-                // Optionally update validator
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                const cassDef = this.buildCassandraColumnDefinition(op.field);
-                await this.rawQuery(`ALTER TABLE ${op.collection} ADD ${cassDef}`);
-                break;
-            case enums_1.DatabaseType.DYNAMODB:
-                // DynamoDB is schemaless - fields are added on write
-                break;
-        }
-    }
-    async executeDropField(op) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                let sql = `ALTER TABLE ${this.escapeIdentifier(op.collection)} DROP COLUMN ${this.escapeIdentifier(op.fieldName)}`;
-                if (op.cascade)
-                    sql += ' CASCADE';
-                await this.rawQuery(sql);
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                // Use $unset to remove field from all documents
-                await this.rawQuery({
-                    update: op.collection,
-                    updates: [{ q: {}, u: { $unset: { [op.fieldName]: '' } }, multi: true }],
-                });
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                await this.rawQuery(`ALTER TABLE ${op.collection} DROP ${op.fieldName}`);
-                break;
-        }
-    }
-    async executeRenameField(op) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-                await this.rawQuery(`ALTER TABLE ${this.escapeIdentifier(op.collection)} RENAME COLUMN ${this.escapeIdentifier(op.oldName)} TO ${this.escapeIdentifier(op.newName)}`);
-                break;
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                await this.rawQuery(`ALTER TABLE ${this.escapeIdentifier(op.collection)} RENAME COLUMN ${this.escapeIdentifier(op.oldName)} TO ${this.escapeIdentifier(op.newName)}`);
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                await this.rawQuery({
-                    update: op.collection,
-                    updates: [{ q: {}, u: { $rename: { [op.oldName]: op.newName } }, multi: true }],
-                });
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                await this.rawQuery(`ALTER TABLE ${op.collection} RENAME ${op.oldName} TO ${op.newName}`);
-                break;
-        }
-    }
-    async executeModifyField(op) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL:
-                if (op.changes.type) {
-                    const pgType = this.mapFieldTypeToSQL(op.changes.type, op.changes);
-                    await this.rawQuery(`ALTER TABLE ${this.escapeIdentifier(op.collection)} ALTER COLUMN ${this.escapeIdentifier(op.fieldName)} TYPE ${pgType}`);
-                }
-                if (op.changes.nullable === false) {
-                    await this.rawQuery(`ALTER TABLE ${this.escapeIdentifier(op.collection)} ALTER COLUMN ${this.escapeIdentifier(op.fieldName)} SET NOT NULL`);
-                }
-                else if (op.changes.nullable === true) {
-                    await this.rawQuery(`ALTER TABLE ${this.escapeIdentifier(op.collection)} ALTER COLUMN ${this.escapeIdentifier(op.fieldName)} DROP NOT NULL`);
-                }
-                if (op.changes.defaultValue !== undefined) {
-                    await this.rawQuery(`ALTER TABLE ${this.escapeIdentifier(op.collection)} ALTER COLUMN ${this.escapeIdentifier(op.fieldName)} SET DEFAULT ${this.formatValue(op.changes.defaultValue)}`);
-                }
-                break;
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB:
-                // MySQL requires full column definition for MODIFY
-                const mysqlType = this.mapFieldTypeToSQL(op.changes.type || 'string', op.changes);
-                await this.rawQuery(`ALTER TABLE ${this.escapeIdentifier(op.collection)} MODIFY COLUMN ${this.escapeIdentifier(op.fieldName)} ${mysqlType}`);
-                break;
-            case enums_1.DatabaseType.MONGODB:
-                // MongoDB doesn't have schema modification - data is flexible
-                break;
-            case enums_1.DatabaseType.CASSANDRA:
-                if (op.changes.type) {
-                    const cassType = this.mapFieldTypeToCassandra(op.changes.type);
-                    await this.rawQuery(`ALTER TABLE ${op.collection} ALTER ${op.fieldName} TYPE ${cassType}`);
-                }
-                break;
-        }
-    }
-    // ==================== SQL-SPECIFIC EXECUTORS ====================
-    async executeAddConstraint(op) {
-        if (!this.isSQLDatabase()) {
-            throw database_error_1.DatabaseError.migrationError('addConstraint is only supported for SQL databases');
-        }
-        const constraint = op.constraint;
-        let sql = `ALTER TABLE ${this.escapeIdentifier(op.collection)} ADD CONSTRAINT ${this.escapeIdentifier(constraint.name)}`;
-        switch (constraint.type) {
-            case 'primaryKey':
-                sql += ` PRIMARY KEY (${constraint.columns.map(c => this.escapeIdentifier(c)).join(', ')})`;
-                break;
-            case 'foreignKey':
-                sql += ` FOREIGN KEY (${constraint.columns.map(c => this.escapeIdentifier(c)).join(', ')})`;
-                if (constraint.references) {
-                    sql += ` REFERENCES ${this.escapeIdentifier(constraint.references.table)} (${constraint.references.columns.map(c => this.escapeIdentifier(c)).join(', ')})`;
-                    if (constraint.references.onDelete)
-                        sql += ` ON DELETE ${constraint.references.onDelete}`;
-                    if (constraint.references.onUpdate)
-                        sql += ` ON UPDATE ${constraint.references.onUpdate}`;
-                }
-                break;
-            case 'unique':
-                sql += ` UNIQUE (${constraint.columns.map(c => this.escapeIdentifier(c)).join(', ')})`;
-                break;
-            case 'check':
-                sql += ` CHECK (${constraint.expression})`;
-                break;
-        }
-        await this.rawQuery(sql);
-    }
-    async executeDropConstraint(op) {
-        if (!this.isSQLDatabase()) {
-            throw database_error_1.DatabaseError.migrationError('dropConstraint is only supported for SQL databases');
-        }
-        let sql = `ALTER TABLE ${this.escapeIdentifier(op.collection)} DROP CONSTRAINT ${this.escapeIdentifier(op.constraintName)}`;
-        if (op.cascade)
-            sql += ' CASCADE';
-        await this.rawQuery(sql);
-    }
-    // ==================== MONGODB-SPECIFIC EXECUTORS ====================
-    async executeCreateMongoValidation(op) {
-        if (this.databaseType !== enums_1.DatabaseType.MONGODB) {
-            throw database_error_1.DatabaseError.migrationError('createMongoValidation is only supported for MongoDB');
-        }
-        await this.rawQuery({
-            collMod: op.collection,
-            validator: op.validator,
-            validationLevel: op.validationLevel || 'strict',
-            validationAction: op.validationAction || 'error',
-        });
-    }
-    async executeDropMongoValidation(op) {
-        if (this.databaseType !== enums_1.DatabaseType.MONGODB) {
-            throw database_error_1.DatabaseError.migrationError('dropMongoValidation is only supported for MongoDB');
-        }
-        await this.rawQuery({
-            collMod: op.collection,
-            validator: {},
-            validationLevel: 'off',
-        });
-    }
-    async executeShardCollection(op) {
-        if (this.databaseType !== enums_1.DatabaseType.MONGODB) {
-            throw database_error_1.DatabaseError.migrationError('shardCollection is only supported for MongoDB');
-        }
-        await this.rawQuery({
-            shardCollection: op.collection,
-            key: op.shardKey,
-            unique: op.unique,
-        });
-    }
-    // ==================== DYNAMODB-SPECIFIC EXECUTORS ====================
-    async executeCreateDynamoTable(op) {
-        if (this.databaseType !== enums_1.DatabaseType.DYNAMODB) {
-            throw database_error_1.DatabaseError.migrationError('createDynamoTable is only supported for DynamoDB');
-        }
-        const params = {
-            TableName: op.name,
-            KeySchema: [{ AttributeName: op.partitionKey.name, KeyType: 'HASH' }],
-            AttributeDefinitions: [{ AttributeName: op.partitionKey.name, AttributeType: op.partitionKey.type }],
-            BillingMode: op.billingMode || 'PAY_PER_REQUEST',
-        };
-        if (op.sortKey) {
-            params.KeySchema.push({ AttributeName: op.sortKey.name, KeyType: 'RANGE' });
-            params.AttributeDefinitions.push({ AttributeName: op.sortKey.name, AttributeType: op.sortKey.type });
-        }
-        if (op.billingMode === 'PROVISIONED') {
-            params.ProvisionedThroughput = {
-                ReadCapacityUnits: op.readCapacity || 5,
-                WriteCapacityUnits: op.writeCapacity || 5,
-            };
-        }
-        if (op.globalSecondaryIndexes) {
-            params.GlobalSecondaryIndexes = op.globalSecondaryIndexes.map(gsi => this.buildDynamoGSI(gsi, op.billingMode));
-            // Add attribute definitions for GSI keys
-            for (const gsi of op.globalSecondaryIndexes) {
-                if (!params.AttributeDefinitions.find((a) => a.AttributeName === gsi.partitionKey.name)) {
-                    params.AttributeDefinitions.push({ AttributeName: gsi.partitionKey.name, AttributeType: gsi.partitionKey.type });
-                }
-                if (gsi.sortKey && !params.AttributeDefinitions.find((a) => a.AttributeName === gsi.sortKey.name)) {
-                    params.AttributeDefinitions.push({ AttributeName: gsi.sortKey.name, AttributeType: gsi.sortKey.type });
-                }
-            }
-        }
-        if (op.localSecondaryIndexes) {
-            params.LocalSecondaryIndexes = op.localSecondaryIndexes.map(lsi => ({
-                IndexName: lsi.name,
-                KeySchema: [
-                    { AttributeName: op.partitionKey.name, KeyType: 'HASH' },
-                    { AttributeName: lsi.sortKey.name, KeyType: 'RANGE' },
-                ],
-                Projection: this.buildDynamoProjection(lsi.projection),
-            }));
-            // Add attribute definitions for LSI sort keys
-            for (const lsi of op.localSecondaryIndexes) {
-                if (!params.AttributeDefinitions.find((a) => a.AttributeName === lsi.sortKey.name)) {
-                    params.AttributeDefinitions.push({ AttributeName: lsi.sortKey.name, AttributeType: lsi.sortKey.type });
-                }
-            }
-        }
-        if (op.streamEnabled) {
-            params.StreamSpecification = {
-                StreamEnabled: true,
-                StreamViewType: op.streamViewType || 'NEW_AND_OLD_IMAGES',
-            };
-        }
-        await this.rawQuery({ operation: 'CreateTable', params });
-    }
-    async executeUpdateDynamoThroughput(op) {
-        if (this.databaseType !== enums_1.DatabaseType.DYNAMODB) {
-            throw database_error_1.DatabaseError.migrationError('updateDynamoThroughput is only supported for DynamoDB');
-        }
-        const params = { TableName: op.name };
-        if (op.billingMode) {
-            params.BillingMode = op.billingMode;
-        }
-        if (op.billingMode === 'PROVISIONED' && (op.readCapacity || op.writeCapacity)) {
-            params.ProvisionedThroughput = {
-                ReadCapacityUnits: op.readCapacity || 5,
-                WriteCapacityUnits: op.writeCapacity || 5,
-            };
-        }
-        await this.rawQuery({ operation: 'UpdateTable', params });
-    }
-    async executeAddDynamoGSI(op) {
-        if (this.databaseType !== enums_1.DatabaseType.DYNAMODB) {
-            throw database_error_1.DatabaseError.migrationError('addDynamoGSI is only supported for DynamoDB');
-        }
-        const params = {
-            TableName: op.tableName,
-            AttributeDefinitions: [
-                { AttributeName: op.gsi.partitionKey.name, AttributeType: op.gsi.partitionKey.type },
-            ],
-            GlobalSecondaryIndexUpdates: [{
-                    Create: this.buildDynamoGSI(op.gsi),
-                }],
-        };
-        if (op.gsi.sortKey) {
-            params.AttributeDefinitions.push({ AttributeName: op.gsi.sortKey.name, AttributeType: op.gsi.sortKey.type });
-        }
-        await this.rawQuery({ operation: 'UpdateTable', params });
-    }
-    async executeRemoveDynamoGSI(op) {
-        if (this.databaseType !== enums_1.DatabaseType.DYNAMODB) {
-            throw database_error_1.DatabaseError.migrationError('removeDynamoGSI is only supported for DynamoDB');
-        }
-        await this.rawQuery({
-            operation: 'UpdateTable',
-            params: {
-                TableName: op.tableName,
-                GlobalSecondaryIndexUpdates: [{ Delete: { IndexName: op.gsiName } }],
-            },
-        });
-    }
-    async executeEnableDynamoStream(op) {
-        if (this.databaseType !== enums_1.DatabaseType.DYNAMODB) {
-            throw database_error_1.DatabaseError.migrationError('enableDynamoStream is only supported for DynamoDB');
-        }
-        await this.rawQuery({
-            operation: 'UpdateTable',
-            params: {
-                TableName: op.tableName,
-                StreamSpecification: {
-                    StreamEnabled: true,
-                    StreamViewType: op.streamViewType,
-                },
-            },
-        });
-    }
-    async executeEnableDynamoTTL(op) {
-        if (this.databaseType !== enums_1.DatabaseType.DYNAMODB) {
-            throw database_error_1.DatabaseError.migrationError('enableDynamoTTL is only supported for DynamoDB');
-        }
-        await this.rawQuery({
-            operation: 'UpdateTimeToLive',
-            params: {
-                TableName: op.tableName,
-                TimeToLiveSpecification: {
-                    AttributeName: op.attributeName,
-                    Enabled: op.enabled,
-                },
-            },
-        });
-    }
-    // ==================== CASSANDRA-SPECIFIC EXECUTORS ====================
-    async executeAlterCassandraTable(op) {
-        if (this.databaseType !== enums_1.DatabaseType.CASSANDRA) {
-            throw database_error_1.DatabaseError.migrationError('alterCassandraTable is only supported for Cassandra');
-        }
-        const options = [];
-        if (op.options.defaultTTL !== undefined)
-            options.push(`default_time_to_live = ${op.options.defaultTTL}`);
-        if (op.options.gcGraceSeconds !== undefined)
-            options.push(`gc_grace_seconds = ${op.options.gcGraceSeconds}`);
-        if (op.options.compaction)
-            options.push(`compaction = ${JSON.stringify(op.options.compaction)}`);
-        if (op.options.compression)
-            options.push(`compression = ${JSON.stringify(op.options.compression)}`);
-        if (op.options.caching)
-            options.push(`caching = ${JSON.stringify(op.options.caching)}`);
-        if (options.length > 0) {
-            await this.rawQuery(`ALTER TABLE ${op.name} WITH ${options.join(' AND ')}`);
-        }
-    }
-    async executeCreateCassandraMaterializedView(op) {
-        if (this.databaseType !== enums_1.DatabaseType.CASSANDRA) {
-            throw database_error_1.DatabaseError.migrationError('createCassandraMaterializedView is only supported for Cassandra');
-        }
-        const pk = op.partitionKey.join(', ');
-        const clustering = op.clusteringColumns ? `, ${op.clusteringColumns.join(', ')}` : '';
-        await this.rawQuery(`
-      CREATE MATERIALIZED VIEW ${op.name} AS
-        SELECT ${op.columns.join(', ')}
-        FROM ${op.baseTable}
-        WHERE ${op.where}
-        PRIMARY KEY ((${pk})${clustering})
-    `);
-    }
-    async executeDropCassandraMaterializedView(op) {
-        if (this.databaseType !== enums_1.DatabaseType.CASSANDRA) {
-            throw database_error_1.DatabaseError.migrationError('dropCassandraMaterializedView is only supported for Cassandra');
-        }
-        await this.rawQuery(`DROP MATERIALIZED VIEW ${op.ifExists ? 'IF EXISTS ' : ''}${op.name}`);
-    }
-    // ==================== RAW OPERATION EXECUTOR ====================
-    async executeRawOperation(op) {
-        const dbType = this.databaseType.toLowerCase();
-        const dbOp = op.operations[dbType];
-        if (!dbOp) {
-            if (op.databases && !op.databases.includes(dbType)) {
-                // Skip if database not in target list
-                return;
-            }
-            throw database_error_1.DatabaseError.migrationError(`No raw operation defined for database type: ${dbType}`);
-        }
-        if ('sql' in dbOp) {
-            await this.rawQuery(dbOp.sql, dbOp.params);
-        }
-        else if ('cql' in dbOp) {
-            await this.rawQuery(dbOp.cql, dbOp.params);
-        }
-        else if ('command' in dbOp) {
-            await this.rawQuery(dbOp.command);
-        }
-        else if ('operation' in dbOp) {
-            await this.rawQuery(dbOp);
-        }
-    }
-    // ==================== HELPER METHODS ====================
-    async createSQLTable(op) {
-        var _a, _b, _c, _d;
-        const columns = op.fields.map(f => this.buildColumnDefinition(f));
-        const constraints = [];
-        // Handle composite primary key
-        const pkFields = op.fields.filter(f => f.primaryKey);
-        if (pkFields.length > 1) {
-            const pkNames = pkFields.map(f => this.escapeIdentifier(f.name)).join(', ');
-            constraints.push(`PRIMARY KEY (${pkNames})`);
-        }
-        else if ((_a = op.sqlOptions) === null || _a === void 0 ? void 0 : _a.primaryKey) {
-            constraints.push(`PRIMARY KEY (${op.sqlOptions.primaryKey.map(c => this.escapeIdentifier(c)).join(', ')})`);
-        }
-        // Add constraints from options
-        if ((_b = op.sqlOptions) === null || _b === void 0 ? void 0 : _b.constraints) {
-            for (const c of op.sqlOptions.constraints) {
-                const constraintSQL = this.buildConstraintSQL(c);
-                constraints.push(constraintSQL);
-            }
-        }
-        let sql = 'CREATE';
-        if ((_c = op.sqlOptions) === null || _c === void 0 ? void 0 : _c.temporary)
-            sql += ' TEMPORARY';
-        if (((_d = op.sqlOptions) === null || _d === void 0 ? void 0 : _d.unlogged) && this.databaseType === enums_1.DatabaseType.POSTGRESQL)
-            sql += ' UNLOGGED';
-        sql += ' TABLE';
-        if (op.ifNotExists)
-            sql += ' IF NOT EXISTS';
-        sql += ` ${this.escapeIdentifier(op.name)} (${[...columns, ...constraints].join(', ')})`;
-        await this.rawQuery(sql);
-    }
-    async createMongoCollection(op) {
-        var _a, _b;
-        const createCmd = { create: op.name };
-        if ((_a = op.mongoOptions) === null || _a === void 0 ? void 0 : _a.capped) {
-            createCmd.capped = true;
-            if (op.mongoOptions.size)
-                createCmd.size = op.mongoOptions.size;
-            if (op.mongoOptions.max)
-                createCmd.max = op.mongoOptions.max;
-        }
-        if ((_b = op.mongoOptions) === null || _b === void 0 ? void 0 : _b.validator) {
-            createCmd.validator = op.mongoOptions.validator;
-            if (op.mongoOptions.validationLevel)
-                createCmd.validationLevel = op.mongoOptions.validationLevel;
-        }
-        try {
-            await this.rawQuery(createCmd);
-        }
-        catch (error) {
-            // Collection might already exist
-            if (!error.message.includes('already exists'))
-                throw error;
-        }
-        // Process fields: create unique indexes and register auto-increment fields
-        if (op.fields) {
-            for (const field of op.fields) {
-                // Create unique index for fields marked as unique (excluding _id which is already unique)
-                if (field.unique && field.name !== '_id') {
-                    await this.createMongoUniqueIndex(op.name, field.name);
-                }
-                // Register auto-increment fields in the _ductape_counters collection
-                if (field.autoGenerate) {
-                    await this.registerMongoAutoIncrementField(op.name, field.name);
-                }
-            }
-        }
-        // Store schema metadata for default values and other app-level features
-        if (op.fields && op.fields.length > 0) {
-            await this.storeMongoSchemaMetadata(op.name, op.fields);
-        }
-    }
-    /**
-     * Create a unique index on a MongoDB collection field.
-     */
-    async createMongoUniqueIndex(collectionName, fieldName) {
-        try {
-            await this.rawQuery({
-                createIndexes: collectionName,
-                indexes: [{
-                        key: { [fieldName]: 1 },
-                        name: `${collectionName}_${fieldName}_unique`,
-                        unique: true
-                    }]
-            });
-        }
-        catch (error) {
-            // Index might already exist - ignore this error
-            const errMsg = error.message || '';
-            if (!errMsg.includes('already exists') && !errMsg.includes('duplicate key')) {
-                throw error;
-            }
-        }
-    }
-    /**
-     * Register an auto-increment field in the MongoDB counters collection.
-     * Uses atomic operations to ensure thread safety.
-     */
-    async registerMongoAutoIncrementField(collectionName, fieldName) {
-        await this.rawQuery({
-            findAndModify: '_ductape_counters',
-            query: { _id: `${collectionName}.${fieldName}` },
-            update: {
-                $setOnInsert: {
-                    collection: collectionName,
-                    field: fieldName,
-                    currentValue: 0
-                }
-            },
-            upsert: true
-        });
-    }
-    /**
-     * Store schema metadata for MongoDB collections.
-     * This enables application-level features like default values.
-     */
-    async storeMongoSchemaMetadata(collectionName, fields) {
-        await this.rawQuery({
-            findAndModify: '_ductape_schema',
-            query: { _id: collectionName },
-            update: {
-                $set: {
-                    collection: collectionName,
-                    columns: fields.map(f => ({
-                        name: f.name,
-                        type: f.type,
-                        defaultValue: f.defaultValue,
-                        nullable: f.nullable,
-                        unique: f.unique,
-                        primaryKey: f.primaryKey,
-                        autoIncrement: f.autoGenerate,
-                    })),
-                    updatedAt: new Date()
-                }
-            },
-            upsert: true
-        });
-    }
-    async createDynamoTable(op) {
-        if (!op.dynamoOptions) {
-            throw database_error_1.DatabaseError.migrationError('DynamoDB requires dynamoOptions with partitionKey');
-        }
-        // Convert to ICreateDynamoTableMigration format
-        await this.executeCreateDynamoTable(Object.assign({ type: 'createDynamoTable', name: op.name }, op.dynamoOptions));
-    }
-    async createCassandraTable(op) {
-        if (!op.cassandraOptions) {
-            throw database_error_1.DatabaseError.migrationError('Cassandra requires cassandraOptions with partitionKey');
-        }
-        const columns = op.fields.map(f => this.buildCassandraColumnDefinition(f));
-        const pk = op.cassandraOptions.partitionKey.join(', ');
-        const clustering = op.cassandraOptions.clusteringColumns
-            ? `, ${op.cassandraOptions.clusteringColumns.join(', ')}`
-            : '';
-        let sql = `CREATE TABLE ${op.ifNotExists ? 'IF NOT EXISTS ' : ''}${op.name} (${columns.join(', ')}, PRIMARY KEY ((${pk})${clustering}))`;
-        const withClauses = [];
-        if (op.cassandraOptions.clusteringOrder) {
-            const order = op.cassandraOptions.clusteringOrder.map(o => `${o.column} ${o.order}`).join(', ');
-            withClauses.push(`CLUSTERING ORDER BY (${order})`);
-        }
-        if (op.cassandraOptions.defaultTTL) {
-            withClauses.push(`default_time_to_live = ${op.cassandraOptions.defaultTTL}`);
-        }
-        if (withClauses.length > 0) {
-            sql += ` WITH ${withClauses.join(' AND ')}`;
-        }
-        await this.rawQuery(sql);
-    }
-    async createSQLIndex(op) {
-        var _a, _b, _c, _d;
-        let sql = 'CREATE';
-        if (op.unique)
-            sql += ' UNIQUE';
-        sql += ' INDEX';
-        if (op.ifNotExists && this.databaseType === enums_1.DatabaseType.POSTGRESQL)
-            sql += ' IF NOT EXISTS';
-        if (((_a = op.sqlOptions) === null || _a === void 0 ? void 0 : _a.concurrent) && this.databaseType === enums_1.DatabaseType.POSTGRESQL)
-            sql += ' CONCURRENTLY';
-        sql += ` ${this.escapeIdentifier(op.name)} ON ${this.escapeIdentifier(op.collection)}`;
-        if (((_b = op.sqlOptions) === null || _b === void 0 ? void 0 : _b.method) && this.databaseType === enums_1.DatabaseType.POSTGRESQL) {
-            sql += ` USING ${op.sqlOptions.method}`;
-        }
-        sql += ` (${op.fields.map(f => `${this.escapeIdentifier(f.name)}${f.order ? ' ' + f.order.toUpperCase() : ''}`).join(', ')})`;
-        if (((_c = op.sqlOptions) === null || _c === void 0 ? void 0 : _c.include) && this.databaseType === enums_1.DatabaseType.POSTGRESQL) {
-            sql += ` INCLUDE (${op.sqlOptions.include.map(c => this.escapeIdentifier(c)).join(', ')})`;
-        }
-        if (((_d = op.sqlOptions) === null || _d === void 0 ? void 0 : _d.where) && this.databaseType === enums_1.DatabaseType.POSTGRESQL) {
-            sql += ` WHERE ${op.sqlOptions.where}`;
-        }
-        await this.rawQuery(sql);
-    }
-    async createMongoIndex(op) {
-        var _a, _b, _c;
-        const keys = {};
-        for (const f of op.fields) {
-            keys[f.name] = f.type === 'text' ? 'text' : (f.order === 'desc' ? -1 : 1);
-        }
-        const indexOptions = { name: op.name };
-        if (op.unique)
-            indexOptions.unique = true;
-        if (op.sparse)
-            indexOptions.sparse = true;
-        if ((_a = op.mongoOptions) === null || _a === void 0 ? void 0 : _a.background)
-            indexOptions.background = true;
-        if (((_b = op.mongoOptions) === null || _b === void 0 ? void 0 : _b.expireAfterSeconds) !== undefined) {
-            indexOptions.expireAfterSeconds = op.mongoOptions.expireAfterSeconds;
-        }
-        if ((_c = op.mongoOptions) === null || _c === void 0 ? void 0 : _c.weights)
-            indexOptions.weights = op.mongoOptions.weights;
-        await this.rawQuery({
-            createIndexes: op.collection,
-            indexes: [Object.assign({ key: keys }, indexOptions)],
-        });
-    }
-    async createCassandraIndex(op) {
-        var _a;
-        const field = op.fields[0]; // Cassandra secondary indexes are single-column
-        let sql = `CREATE INDEX ${op.ifNotExists ? 'IF NOT EXISTS ' : ''}${op.name} ON ${op.collection} (${field.name})`;
-        if ((_a = op.cassandraOptions) === null || _a === void 0 ? void 0 : _a.sasiOptions) {
-            const opts = op.cassandraOptions.sasiOptions;
-            const using = [];
-            if (opts.mode)
-                using.push(`'mode': '${opts.mode}'`);
-            if (opts.analyzerClass)
-                using.push(`'analyzer_class': '${opts.analyzerClass}'`);
-            if (opts.caseSensitive !== undefined)
-                using.push(`'case_sensitive': '${opts.caseSensitive}'`);
-            sql += ` USING 'org.apache.cassandra.index.sasi.SASIIndex' WITH OPTIONS = {${using.join(', ')}}`;
-        }
-        await this.rawQuery(sql);
-    }
-    buildColumnDefinition(field) {
-        const parts = [this.escapeIdentifier(field.name)];
-        parts.push(this.mapFieldTypeToSQL(field.type, field));
-        if (field.primaryKey && !field.autoGenerate)
-            parts.push('PRIMARY KEY');
-        if (field.autoGenerate) {
-            if (this.databaseType === enums_1.DatabaseType.POSTGRESQL) {
-                // Already handled in type mapping (SERIAL)
-            }
-            else {
-                parts.push('AUTO_INCREMENT');
-                if (field.primaryKey)
-                    parts.push('PRIMARY KEY');
-            }
-        }
-        if (field.nullable === false && !field.primaryKey)
-            parts.push('NOT NULL');
-        if (field.unique && !field.primaryKey)
-            parts.push('UNIQUE');
-        if (field.defaultValue !== undefined)
-            parts.push(`DEFAULT ${this.formatValue(field.defaultValue)}`);
-        return parts.join(' ');
-    }
-    buildCassandraColumnDefinition(field) {
-        return `${field.name} ${this.mapFieldTypeToCassandra(field.type)}`;
-    }
-    buildConstraintSQL(constraint) {
-        let sql = `CONSTRAINT ${this.escapeIdentifier(constraint.name)}`;
-        switch (constraint.type) {
-            case 'primaryKey':
-                sql += ` PRIMARY KEY (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
-                break;
-            case 'unique':
-                sql += ` UNIQUE (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
-                break;
-            case 'foreignKey':
-                sql += ` FOREIGN KEY (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
-                if (constraint.references) {
-                    sql += ` REFERENCES ${this.escapeIdentifier(constraint.references.table)} (${constraint.references.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
-                }
-                break;
-            case 'check':
-                sql += ` CHECK (${constraint.expression})`;
-                break;
-        }
-        return sql;
-    }
-    buildDynamoGSI(gsi, billingMode) {
-        const result = {
-            IndexName: gsi.name,
-            KeySchema: [{ AttributeName: gsi.partitionKey.name, KeyType: 'HASH' }],
-            Projection: this.buildDynamoProjection(gsi.projection),
-        };
-        if (gsi.sortKey) {
-            result.KeySchema.push({ AttributeName: gsi.sortKey.name, KeyType: 'RANGE' });
-        }
-        if (billingMode === 'PROVISIONED') {
-            result.ProvisionedThroughput = {
-                ReadCapacityUnits: gsi.readCapacity || 5,
-                WriteCapacityUnits: gsi.writeCapacity || 5,
-            };
-        }
-        return result;
-    }
-    buildDynamoProjection(projection) {
-        if (projection === 'ALL')
-            return { ProjectionType: 'ALL' };
-        if (projection === 'KEYS_ONLY')
-            return { ProjectionType: 'KEYS_ONLY' };
-        if (typeof projection === 'object' && projection.type === 'INCLUDE') {
-            return { ProjectionType: 'INCLUDE', NonKeyAttributes: projection.attributes };
-        }
-        return { ProjectionType: 'ALL' };
-    }
-    mapFieldTypeToSQL(type, options) {
-        const isPG = this.databaseType === enums_1.DatabaseType.POSTGRESQL;
-        switch (type) {
-            case 'integer':
-                if ((options === null || options === void 0 ? void 0 : options.autoGenerate) && isPG)
-                    return 'SERIAL';
-                return 'INTEGER';
-            case 'bigint':
-                if ((options === null || options === void 0 ? void 0 : options.autoGenerate) && isPG)
-                    return 'BIGSERIAL';
-                return 'BIGINT';
-            case 'smallint': return 'SMALLINT';
-            case 'decimal': return `DECIMAL(${(options === null || options === void 0 ? void 0 : options.precision) || 10}, ${(options === null || options === void 0 ? void 0 : options.scale) || 2})`;
-            case 'float': return 'REAL';
-            case 'double': return 'DOUBLE PRECISION';
-            case 'string': return `VARCHAR(${(options === null || options === void 0 ? void 0 : options.maxLength) || 255})`;
-            case 'text': return 'TEXT';
-            case 'uuid': return isPG ? 'UUID' : 'CHAR(36)';
-            case 'boolean': return 'BOOLEAN';
-            case 'date': return 'DATE';
-            case 'time': return 'TIME';
-            case 'datetime': return isPG ? 'TIMESTAMP' : 'DATETIME';
-            case 'timestamp': return isPG ? 'TIMESTAMPTZ' : 'TIMESTAMP';
-            case 'binary': return 'BYTEA';
-            case 'blob': return isPG ? 'BYTEA' : 'BLOB';
-            case 'json': return isPG ? 'JSONB' : 'JSON';
-            case 'object': return isPG ? 'JSONB' : 'JSON';
-            case 'array': return isPG ? `${this.mapFieldTypeToSQL((options === null || options === void 0 ? void 0 : options.arrayElementType) || 'string', {})}[]` : 'JSON';
-            case 'enum': return (options === null || options === void 0 ? void 0 : options.enumValues) ? `ENUM(${options.enumValues.map(v => `'${v}'`).join(', ')})` : 'VARCHAR(255)';
-            default: return 'VARCHAR(255)';
-        }
-    }
-    mapFieldTypeToCassandra(type) {
-        switch (type) {
-            case 'integer': return 'int';
-            case 'bigint': return 'bigint';
-            case 'smallint': return 'smallint';
-            case 'decimal': return 'decimal';
-            case 'float': return 'float';
-            case 'double': return 'double';
-            case 'string': return 'text';
-            case 'text': return 'text';
-            case 'uuid': return 'uuid';
-            case 'boolean': return 'boolean';
-            case 'date': return 'date';
-            case 'time': return 'time';
-            case 'datetime': return 'timestamp';
-            case 'timestamp': return 'timestamp';
-            case 'binary': return 'blob';
-            case 'blob': return 'blob';
-            case 'json': return 'text';
-            case 'object': return 'text';
-            default: return 'text';
-        }
-    }
-    isSQLDatabase() {
-        return [enums_1.DatabaseType.POSTGRESQL, enums_1.DatabaseType.MYSQL, enums_1.DatabaseType.MARIADB].includes(this.databaseType);
-    }
-    async recordMigration(migration, appliedBy, executionTime) {
-        const checksum = this.calculateChecksum(migration);
-        await this.adapter.insert({
-            table: MIGRATION_COLLECTION,
-            data: {
-                tag: migration.tag,
-                name: migration.name,
-                applied_at: new Date(),
-                applied_by: appliedBy || null,
-                checksum,
-                execution_time: executionTime || null,
-            },
-        });
-    }
-    async removeMigrationRecord(tag) {
-        await this.adapter.delete({
-            table: MIGRATION_COLLECTION,
-            where: { tag },
-        });
-    }
-    calculateChecksum(migration) {
-        const content = JSON.stringify({ tag: migration.tag, name: migration.name, up: migration.up, down: migration.down });
-        return crypto.createHash('sha256').update(content).digest('hex').substring(0, 64);
-    }
-    sortByDependencies(migrations) {
-        const sorted = [];
-        const visited = new Set();
-        const visiting = new Set();
-        const visit = (migration) => {
-            if (visited.has(migration.tag))
-                return;
-            if (visiting.has(migration.tag)) {
-                throw database_error_1.DatabaseError.migrationError(`Circular dependency detected in migration: ${migration.tag}`);
-            }
-            visiting.add(migration.tag);
-            if (migration.dependencies) {
-                for (const depTag of migration.dependencies) {
-                    const dep = migrations.find(m => m.tag === depTag);
-                    if (dep)
-                        visit(dep);
-                }
-            }
-            visiting.delete(migration.tag);
-            visited.add(migration.tag);
-            sorted.push(migration);
-        };
-        for (const migration of migrations)
-            visit(migration);
-        return sorted;
-    }
-    getOperationDescription(operation) {
-        switch (operation.type) {
-            case 'createCollection': return `Create collection: ${operation.name}`;
-            case 'dropCollection': return `Drop collection: ${operation.name}`;
-            case 'createIndex': return `Create index: ${operation.name} on ${operation.collection}`;
-            case 'dropIndex': return `Drop index: ${operation.name} from ${operation.collection}`;
-            case 'addField': return `Add field: ${operation.field.name} to ${operation.collection}`;
-            case 'dropField': return `Drop field: ${operation.fieldName} from ${operation.collection}`;
-            case 'renameField': return `Rename field: ${operation.oldName} to ${operation.newName} in ${operation.collection}`;
-            case 'modifyField': return `Modify field: ${operation.fieldName} in ${operation.collection}`;
-            case 'addConstraint': return `Add constraint: ${operation.constraint.name} to ${operation.collection}`;
-            case 'dropConstraint': return `Drop constraint: ${operation.constraintName} from ${operation.collection}`;
-            case 'createMongoValidation': return `Create validation on: ${operation.collection}`;
-            case 'dropMongoValidation': return `Drop validation from: ${operation.collection}`;
-            case 'shardCollection': return `Shard collection: ${operation.collection}`;
-            case 'createDynamoTable': return `Create DynamoDB table: ${operation.name}`;
-            case 'updateDynamoThroughput': return `Update DynamoDB throughput: ${operation.name}`;
-            case 'addDynamoGSI': return `Add GSI to: ${operation.tableName}`;
-            case 'removeDynamoGSI': return `Remove GSI from: ${operation.tableName}`;
-            case 'enableDynamoStream': return `Enable stream on: ${operation.tableName}`;
-            case 'enableDynamoTTL': return `Enable TTL on: ${operation.tableName}`;
-            case 'alterCassandraTable': return `Alter Cassandra table: ${operation.name}`;
-            case 'createCassandraMaterializedView': return `Create materialized view: ${operation.name}`;
-            case 'dropCassandraMaterializedView': return `Drop materialized view: ${operation.name}`;
-            case 'raw': return 'Execute raw operation';
-            default: return 'Unknown operation';
-        }
-    }
-    escapeIdentifier(identifier) {
-        switch (this.databaseType) {
-            case enums_1.DatabaseType.POSTGRESQL: return `"${identifier.replace(/"/g, '""')}"`;
-            case enums_1.DatabaseType.MYSQL:
-            case enums_1.DatabaseType.MARIADB: return `\`${identifier.replace(/`/g, '``')}\``;
-            case enums_1.DatabaseType.CASSANDRA:
-                if (/[^a-zA-Z0-9_]/.test(identifier))
-                    return `"${identifier.replace(/"/g, '""')}"`;
-                return identifier;
-            default: return identifier;
-        }
-    }
-    formatValue(value) {
-        if (value === null)
-            return 'NULL';
-        if (typeof value === 'boolean')
-            return value ? 'TRUE' : 'FALSE';
-        if (typeof value === 'number')
-            return String(value);
-        if (typeof value === 'string') {
-            const upperValue = value.toUpperCase();
-            // Handle special datetime functions
-            if (upperValue.startsWith('CURRENT_') || upperValue === 'NOW()')
-                return value;
-            // Handle 'now' as CURRENT_TIMESTAMP for datetime defaults
-            if (upperValue === 'NOW')
-                return 'CURRENT_TIMESTAMP';
-            return `'${value.replace(/'/g, "''")}'`;
-        }
-        if (value instanceof Date)
-            return `'${value.toISOString()}'`;
-        return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
-    }
-}
-exports.MigrationEngine = MigrationEngine;
-/**
- * Migration Helpers for creating common migrations
- */
-exports.MigrationHelpers = {
-    generateMigrationTag(name) {
-        const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, '').substring(0, 14);
-        const sanitizedName = name.toLowerCase().replace(/[^a-z0-9]/g, '_');
-        return `${timestamp}_${sanitizedName}`;
-    },
-    createCollectionMigration(tag, name, fields) {
-        return {
-            tag,
-            name: `Create collection ${name}`,
-            up: [{ type: 'createCollection', name, fields }],
-            down: [{ type: 'dropCollection', name, ifExists: true }],
-        };
-    },
-    addFieldMigration(tag, collection, field) {
-        return {
-            tag,
-            name: `Add field ${field.name} to ${collection}`,
-            up: [{ type: 'addField', collection, field }],
-            down: [{ type: 'dropField', collection, fieldName: field.name }],
-        };
-    },
-    addIndexMigration(tag, collection, indexName, fields, unique) {
-        return {
-            tag,
-            name: `Add index ${indexName} on ${collection}`,
-            up: [{ type: 'createIndex', collection, name: indexName, fields: fields.map(f => ({ name: f })), unique }],
-            down: [{ type: 'dropIndex', collection, name: indexName, ifExists: true }],
-        };
-    },
-};
-//# sourceMappingURL=migration-engine.js.map