@arcaelas/dynamite 1.0.17 → 1.0.19

package/src/utils/throttle-manager.js

@@ -1,201 +0,0 @@
-"use strict";
-/**
- * @file throttle-manager.ts
- * @description AWS DynamoDB throttling and retry management
- * @author Miguel Alejandro
- * @fecha 2025-08-31
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.throttleManager = exports.ThrottleManager = void 0;
-class ThrottleManager {
-    static { this.DEFAULT_CONFIG = {
-        maxRetries: 10,
-        baseDelay: 100, // 100ms base delay
-        maxDelay: 30000, // 30s max delay
-        backoffMultiplier: 2, // Exponential backoff
-        jitterFactor: 0.1, // 10% jitter
-    }; }
-    constructor(config) {
-        this.requestQueue = [];
-        this.isProcessingQueue = false;
-        this.concurrentRequests = 0;
-        this.maxConcurrentRequests = 25; // DynamoDB default
-        this.config = { ...ThrottleManager.DEFAULT_CONFIG, ...config };
-        this.stats = {
-            totalRequests: 0,
-            throttledRequests: 0,
-            retriedRequests: 0,
-            averageLatency: 0,
-        };
-    }
-    /**
-     * Ejecutar operación con retry automático
-     */
-    async executeWithRetry(operation, operationName = "DynamoDB Operation") {
-        const startTime = Date.now();
-        let lastError = null;
-        this.stats.totalRequests++;
-        for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
-            try {
-                // Control de concurrencia
-                await this.acquireConcurrencySlot();
-                const result = await operation();
-                this.releaseConcurrencySlot();
-                this.updateLatencyStats(Date.now() - startTime);
-                if (attempt > 0) {
-                    console.log(`✅ ${operationName} succeeded after ${attempt} retries`);
-                }
-                return result;
-            }
-            catch (error) {
-                this.releaseConcurrencySlot();
-                lastError = error;
-                // Verificar si es un error que podemos reintentar
-                if (!this.isRetryableError(error)) {
-                    throw error;
-                }
-                this.stats.throttledRequests++;
-                if (attempt === this.config.maxRetries) {
-                    console.error(`❌ ${operationName} failed after ${this.config.maxRetries} retries:`, error.message);
-                    throw new Error(`Max retries exceeded for ${operationName}: ${error.message}`);
-                }
-                this.stats.retriedRequests++;
-                const delay = this.calculateDelay(attempt);
-                console.warn(`⚠️  ${operationName} throttled, retrying in ${delay}ms (attempt ${attempt + 1}/${this.config.maxRetries})`);
-                await this.sleep(delay);
-            }
-        }
-        throw lastError;
-    }
-    /**
-     * Verificar si el error es reintentable
-     */
-    isRetryableError(error) {
-        if (!error.name)
-            return false;
-        const retryableErrors = [
-            "ProvisionedThroughputExceededException",
-            "ThrottlingException",
-            "RequestLimitExceeded",
-            "ServiceUnavailableException",
-            "InternalServerError",
-            "NetworkingError",
-            "TimeoutError",
-        ];
-        return retryableErrors.includes(error.name) || error.retryable === true;
-    }
-    /**
-     * Calcular delay con exponential backoff + jitter
-     */
-    calculateDelay(attempt) {
-        const exponentialDelay = this.config.baseDelay * Math.pow(this.config.backoffMultiplier, attempt);
-        const cappedDelay = Math.min(exponentialDelay, this.config.maxDelay);
-        // Agregar jitter para evitar "thundering herd"
-        const jitter = cappedDelay * this.config.jitterFactor * Math.random();
-        return Math.floor(cappedDelay + jitter);
-    }
-    /**
-     * Controlar concurrencia de requests
-     */
-    async acquireConcurrencySlot() {
-        while (this.concurrentRequests >= this.maxConcurrentRequests) {
-            await this.sleep(10); // Esperar 10ms
-        }
-        this.concurrentRequests++;
-    }
-    releaseConcurrencySlot() {
-        this.concurrentRequests = Math.max(0, this.concurrentRequests - 1);
-    }
-    /**
-     * Queue para operaciones batch con rate limiting
-     */
-    async queueOperation(operation) {
-        return new Promise((resolve, reject) => {
-            this.requestQueue.push(async () => {
-                try {
-                    const result = await this.executeWithRetry(operation);
-                    resolve(result);
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-            this.processQueue();
-        });
-    }
-    async processQueue() {
-        if (this.isProcessingQueue || this.requestQueue.length === 0) {
-            return;
-        }
-        this.isProcessingQueue = true;
-        while (this.requestQueue.length > 0) {
-            const operation = this.requestQueue.shift();
-            try {
-                await operation();
-            }
-            catch (error) {
-                console.error("Queue operation failed:", error);
-            }
-            // Rate limiting: pequeña pausa entre operaciones
-            if (this.requestQueue.length > 0) {
-                await this.sleep(50); // 50ms entre requests
-            }
-        }
-        this.isProcessingQueue = false;
-    }
-    /**
-     * Obtener estadísticas de throttling
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Resetear estadísticas
-     */
-    resetStats() {
-        this.stats = {
-            totalRequests: 0,
-            throttledRequests: 0,
-            retriedRequests: 0,
-            averageLatency: 0,
-        };
-    }
-    updateLatencyStats(latency) {
-        const totalRequests = this.stats.totalRequests;
-        this.stats.averageLatency =
-            (this.stats.averageLatency * (totalRequests - 1) + latency) /
-                totalRequests;
-    }
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    /**
-     * Configurar límites de concurrencia dinámicamente
-     */
-    setConcurrencyLimit(limit) {
-        this.maxConcurrentRequests = Math.max(1, Math.min(limit, 100));
-    }
-    /**
-     * Obtener métricas de salud del throttling
-     */
-    getHealthMetrics() {
-        const stats = this.getStats();
-        return {
-            throttleRate: stats.totalRequests > 0
-                ? stats.throttledRequests / stats.totalRequests
-                : 0,
-            retryRate: stats.totalRequests > 0
-                ? stats.retriedRequests / stats.totalRequests
-                : 0,
-            avgLatency: stats.averageLatency,
-            concurrentRequests: this.concurrentRequests,
-            queueSize: this.requestQueue.length,
-        };
-    }
-}
-exports.ThrottleManager = ThrottleManager;
-// Instancia singleton
-const throttleManager = new ThrottleManager();
-exports.throttleManager = throttleManager;
-exports.default = throttleManager;
-//# sourceMappingURL=throttle-manager.js.map

package/src/utils/transaction-manager.d.ts

@@ -1,88 +0,0 @@
-/**
- * @file transaction-manager.ts
- * @description Transaction simulation and rollback system for DynamoDB
- * @author Miguel Alejandro
- * @fecha 2025-08-31
- */
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-interface TransactionOperation {
-    type: "create" | "update" | "delete";
-    tableName: string;
-    key: Record<string, any>;
-    item?: Record<string, any>;
-    conditionExpression?: string;
-    rollbackData?: Record<string, any>;
-}
-interface TransactionSnapshot {
-    id: string;
-    operations: TransactionOperation[];
-    timestamp: number;
-    status: "pending" | "committed" | "rolled_back" | "failed";
-}
-interface TransactionConfig {
-    maxOperationsPerTransaction: number;
-    snapshotTTL: number;
-    enableOptimisticLocking: boolean;
-    maxRetries: number;
-}
-declare class TransactionManager {
-    private static readonly DEFAULT_CONFIG;
-    private client;
-    private config;
-    private activeTransactions;
-    private snapshots;
-    constructor(client: DynamoDBClient, config?: Partial<TransactionConfig>);
-    /**
-     * Iniciar nueva transacción
-     */
-    beginTransaction(operations: TransactionOperation[]): Promise<string>;
-    /**
-     * Ejecutar transacción usando DynamoDB TransactWrite
-     */
-    commitTransaction(transactionId: string): Promise<void>;
-    /**
-     * Rollback manual de transacción
-     */
-    rollbackTransaction(transactionId: string): Promise<void>;
-    /**
-     * Crear snapshot del estado actual para rollback
-     */
-    private createSnapshot;
-    /**
-     * Obtener estado actual de un item
-     */
-    private getCurrentItemState;
-    /**
-     * Crear operaciones inversas para rollback
-     */
-    private createRollbackOperations;
-    /**
-     * Ejecutar lote de operaciones usando TransactWrite
-     */
-    private executeBatch;
-    /**
-     * Dividir operaciones en lotes según límites DynamoDB
-     */
-    private splitIntoBatches;
-    /**
-     * Validar operaciones antes de transacción
-     */
-    private validateOperations;
-    /**
-     * Limpiar snapshots expirados
-     */
-    private cleanupExpiredSnapshots;
-    /**
-     * Obtener estado de transacción
-     */
-    getTransactionStatus(transactionId: string): TransactionSnapshot | null;
-    /**
-     * Listar transacciones activas
-     */
-    getActiveTransactions(): TransactionSnapshot[];
-    private generateTransactionId;
-}
-declare class TransactionError extends Error {
-    constructor(message: string);
-}
-export { TransactionConfig, TransactionError, TransactionManager, TransactionOperation, TransactionSnapshot, };

package/src/utils/transaction-manager.js

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