@ductape/sdk 0.0.4-v9 → 0.0.4-v91

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

@@ -0,0 +1,1421 @@
+"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