@arcaelas/dynamite 1.0.15 → 1.0.17

package/src/utils/transaction-manager.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * @file transaction-manager.ts
+ * @description Transaction simulation and rollback system for DynamoDB
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionManager = exports.TransactionError = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const security_validator_1 = __importDefault(require("./security-validator"));
+const throttle_manager_1 = __importDefault(require("./throttle-manager"));
+class TransactionManager {
+    static { this.DEFAULT_CONFIG = {
+        maxOperationsPerTransaction: 25, // DynamoDB limit
+        snapshotTTL: 3600000, // 1 hour
+        enableOptimisticLocking: true,
+        maxRetries: 3,
+    }; }
+    constructor(client, config) {
+        this.activeTransactions = new Map();
+        this.snapshots = new Map();
+        this.client = client;
+        this.config = { ...TransactionManager.DEFAULT_CONFIG, ...config };
+        // Cleanup expired snapshots
+        setInterval(() => this.cleanupExpiredSnapshots(), 300000); // 5 minutes
+    }
+    /**
+     * Iniciar nueva transacción
+     */
+    async beginTransaction(operations) {
+        const transactionId = this.generateTransactionId();
+        // Validar operaciones
+        this.validateOperations(operations);
+        // Crear snapshot del estado actual para rollback
+        const snapshot = await this.createSnapshot(transactionId, operations);
+        this.activeTransactions.set(transactionId, snapshot);
+        this.snapshots.set(transactionId, snapshot);
+        return transactionId;
+    }
+    /**
+     * Ejecutar transacción usando DynamoDB TransactWrite
+     */
+    async commitTransaction(transactionId) {
+        const snapshot = this.activeTransactions.get(transactionId);
+        if (!snapshot) {
+            throw new TransactionError(`Transaction ${transactionId} not found`);
+        }
+        try {
+            snapshot.status = "pending";
+            // Agrupar operaciones en lotes de 25 (límite DynamoDB)
+            const batches = this.splitIntoBatches(snapshot.operations);
+            for (const batch of batches) {
+                await this.executeBatch(batch);
+            }
+            snapshot.status = "committed";
+            this.activeTransactions.delete(transactionId);
+        }
+        catch (error) {
+            snapshot.status = "failed";
+            // Intentar rollback automático
+            try {
+                await this.rollbackTransaction(transactionId);
+            }
+            catch (rollbackError) {
+                console.error("Rollback failed after commit error:", rollbackError);
+            }
+            throw new TransactionError(`Transaction commit failed: ${error.message}`);
+        }
+    }
+    /**
+     * Rollback manual de transacción
+     */
+    async rollbackTransaction(transactionId) {
+        const snapshot = this.snapshots.get(transactionId);
+        if (!snapshot) {
+            throw new TransactionError(`Transaction snapshot ${transactionId} not found`);
+        }
+        try {
+            // Crear operaciones inversas para rollback
+            const rollbackOps = this.createRollbackOperations(snapshot.operations);
+            if (rollbackOps.length > 0) {
+                const batches = this.splitIntoBatches(rollbackOps);
+                for (const batch of batches) {
+                    await this.executeBatch(batch);
+                }
+            }
+            snapshot.status = "rolled_back";
+            this.activeTransactions.delete(transactionId);
+        }
+        catch (error) {
+            throw new TransactionError(`Rollback failed: ${error.message}`);
+        }
+    }
+    /**
+     * Crear snapshot del estado actual para rollback
+     */
+    async createSnapshot(transactionId, operations) {
+        const snapshot = {
+            id: transactionId,
+            operations: [],
+            timestamp: Date.now(),
+            status: "pending",
+        };
+        // Para cada operación, guardar el estado actual del item
+        for (const op of operations) {
+            try {
+                const currentItem = await this.getCurrentItemState(op.tableName, op.key);
+                const snapshotOp = {
+                    ...op,
+                    rollbackData: currentItem || undefined, // Estado actual para rollback
+                };
+                snapshot.operations.push(snapshotOp);
+            }
+            catch (error) {
+                if (error.name !== "ResourceNotFoundException") {
+                    throw error;
+                }
+                // Item no existe, sin datos de rollback necesarios
+                snapshot.operations.push(op);
+            }
+        }
+        return snapshot;
+    }
+    /**
+     * Obtener estado actual de un item
+     */
+    async getCurrentItemState(tableName, key) {
+        const params = {
+            TransactItems: [
+                {
+                    Get: {
+                        TableName: tableName,
+                        Key: (0, util_dynamodb_1.marshall)(key),
+                    },
+                },
+            ],
+        };
+        const result = await throttle_manager_1.default.executeWithRetry(() => this.client.send(new client_dynamodb_1.TransactGetItemsCommand(params)), `GetItem-${tableName}`);
+        return result.Responses?.[0]?.Item
+            ? (0, util_dynamodb_1.unmarshall)(result.Responses[0].Item)
+            : null;
+    }
+    /**
+     * Crear operaciones inversas para rollback
+     */
+    createRollbackOperations(operations) {
+        const rollbackOps = [];
+        // Procesar en orden inverso
+        for (let i = operations.length - 1; i >= 0; i--) {
+            const op = operations[i];
+            switch (op.type) {
+                case "create":
+                    // Para rollback de create: delete el item
+                    rollbackOps.push({
+                        type: "delete",
+                        tableName: op.tableName,
+                        key: op.key,
+                    });
+                    break;
+                case "update":
+                    if (op.rollbackData) {
+                        // Para rollback de update: restore estado anterior
+                        rollbackOps.push({
+                            type: "update",
+                            tableName: op.tableName,
+                            key: op.key,
+                            item: op.rollbackData,
+                        });
+                    }
+                    break;
+                case "delete":
+                    if (op.rollbackData) {
+                        // Para rollback de delete: recrear el item
+                        rollbackOps.push({
+                            type: "create",
+                            tableName: op.tableName,
+                            key: op.key,
+                            item: op.rollbackData,
+                        });
+                    }
+                    break;
+            }
+        }
+        return rollbackOps;
+    }
+    /**
+     * Ejecutar lote de operaciones usando TransactWrite
+     */
+    async executeBatch(operations) {
+        const transactItems = operations.map((op) => {
+            security_validator_1.default.validateItemSize(op.item || op.key);
+            switch (op.type) {
+                case "create":
+                case "update":
+                    return {
+                        Put: {
+                            TableName: op.tableName,
+                            Item: (0, util_dynamodb_1.marshall)(op.item, { removeUndefinedValues: true }),
+                            ConditionExpression: op.conditionExpression,
+                        },
+                    };
+                case "delete":
+                    return {
+                        Delete: {
+                            TableName: op.tableName,
+                            Key: (0, util_dynamodb_1.marshall)(op.key),
+                            ConditionExpression: op.conditionExpression,
+                        },
+                    };
+                default:
+                    throw new TransactionError(`Unknown operation type: ${op.type}`);
+            }
+        });
+        const command = new client_dynamodb_1.TransactWriteItemsCommand({
+            TransactItems: transactItems,
+        });
+        await throttle_manager_1.default.executeWithRetry(() => this.client.send(command), "TransactWrite");
+    }
+    /**
+     * Dividir operaciones en lotes según límites DynamoDB
+     */
+    splitIntoBatches(operations) {
+        const batches = [];
+        const batchSize = this.config.maxOperationsPerTransaction;
+        for (let i = 0; i < operations.length; i += batchSize) {
+            batches.push(operations.slice(i, i + batchSize));
+        }
+        return batches;
+    }
+    /**
+     * Validar operaciones antes de transacción
+     */
+    validateOperations(operations) {
+        if (operations.length === 0) {
+            throw new TransactionError("Transaction must contain at least one operation");
+        }
+        if (operations.length > this.config.maxOperationsPerTransaction * 10) {
+            throw new TransactionError(`Too many operations: ${operations.length}`);
+        }
+        for (const op of operations) {
+            // Validar estructura de la operación
+            if (!op.tableName || !op.key) {
+                throw new TransactionError("Invalid operation: missing tableName or key");
+            }
+            // Validar datos de seguridad
+            security_validator_1.default.validateQueryFilters(op.key);
+            if (op.item) {
+                security_validator_1.default.validateValue(op.item);
+            }
+        }
+    }
+    /**
+     * Limpiar snapshots expirados
+     */
+    cleanupExpiredSnapshots() {
+        const now = Date.now();
+        const expired = [];
+        for (const [id, snapshot] of this.snapshots.entries()) {
+            if (now - snapshot.timestamp > this.config.snapshotTTL) {
+                expired.push(id);
+            }
+        }
+        expired.forEach((id) => {
+            this.snapshots.delete(id);
+            this.activeTransactions.delete(id);
+        });
+        if (expired.length > 0) {
+            console.log(`Cleaned up ${expired.length} expired transaction snapshots`);
+        }
+    }
+    /**
+     * Obtener estado de transacción
+     */
+    getTransactionStatus(transactionId) {
+        return this.snapshots.get(transactionId) || null;
+    }
+    /**
+     * Listar transacciones activas
+     */
+    getActiveTransactions() {
+        return Array.from(this.activeTransactions.values());
+    }
+    generateTransactionId() {
+        return `txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.TransactionManager = TransactionManager;
+class TransactionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TransactionError";
+    }
+}
+exports.TransactionError = TransactionError;
+//# sourceMappingURL=transaction-manager.js.map