@arcaelas/dynamite 1.0.15 → 1.0.17

package/src/utils/security-validator.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * @file security-validator.ts
+ * @description Security validation and NoSQL injection prevention
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.securityValidator = exports.SecurityValidator = exports.SecurityError = void 0;
+class SecurityValidator {
+    static { this.DEFAULT_CONFIG = {
+        maxStringLength: 10000,
+        maxArrayLength: 1000,
+        maxNestedDepth: 10,
+        allowedOperators: [
+            "=",
+            "!=",
+            "<",
+            "<=",
+            ">",
+            ">=",
+            "in",
+            "not-in",
+            "contains",
+            "begins-with",
+        ],
+        blockedPatterns: [
+            /\$\w+/g, // MongoDB operators
+            /javascript:/gi, // JavaScript injection
+            /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, // Script tags
+            /eval\s*\(/gi, // eval() calls
+            /function\s*\(/gi, // function declarations
+            /\{\s*\$\w+/g, // NoSQL operators
+            /\.\.\//g, // Path traversal
+            /union\s+select/gi, // SQL injection patterns
+            /drop\s+table/gi, // Destructive SQL
+        ],
+    }; }
+    constructor(config) {
+        this.config = { ...SecurityValidator.DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Validar nombre de atributo/tabla
+     */
+    validateAttributeName(name) {
+        if (!name || typeof name !== "string") {
+            throw new SecurityError("Nombre de atributo inválido");
+        }
+        if (name.length > 255) {
+            throw new SecurityError("Nombre de atributo muy largo");
+        }
+        // Solo permitir caracteres alfanuméricos, guiones y guiones bajos
+        if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)) {
+            throw new SecurityError("Nombre de atributo contiene caracteres inválidos");
+        }
+        // Verificar patrones bloqueados
+        for (const pattern of this.config.blockedPatterns) {
+            if (pattern.test(name)) {
+                throw new SecurityError("Nombre de atributo contiene patrones peligrosos");
+            }
+        }
+    }
+    /**
+     * Validar operador de query
+     */
+    validateOperator(operator) {
+        if (!this.config.allowedOperators.includes(operator)) {
+            throw new SecurityError(`Operador no permitido: ${operator}`);
+        }
+        return operator;
+    }
+    /**
+     * Validar valor de campo
+     */
+    validateValue(value, depth = 0) {
+        if (depth > this.config.maxNestedDepth) {
+            throw new SecurityError("Estructura de datos anidada muy profunda");
+        }
+        // Valores null/undefined son válidos
+        if (value === null || value === undefined) {
+            return value;
+        }
+        // Validar strings
+        if (typeof value === "string") {
+            if (value.length > this.config.maxStringLength) {
+                throw new SecurityError("String muy largo");
+            }
+            for (const pattern of this.config.blockedPatterns) {
+                if (pattern.test(value)) {
+                    throw new SecurityError("Valor contiene patrones peligrosos");
+                }
+            }
+            return value;
+        }
+        // Validar arrays
+        if (Array.isArray(value)) {
+            if (value.length > this.config.maxArrayLength) {
+                throw new SecurityError("Array muy largo");
+            }
+            return value.map((item) => this.validateValue(item, depth + 1));
+        }
+        // Validar objetos
+        if (typeof value === "object") {
+            const validated = {};
+            for (const [key, val] of Object.entries(value)) {
+                this.validateAttributeName(key);
+                validated[key] = this.validateValue(val, depth + 1);
+            }
+            return validated;
+        }
+        // Números, booleans son válidos
+        if (typeof value === "number" || typeof value === "boolean") {
+            return value;
+        }
+        throw new SecurityError(`Tipo de valor no permitido: ${typeof value}`);
+    }
+    /**
+     * Validar filtros de query completos
+     */
+    validateQueryFilters(filters) {
+        const validated = {};
+        for (const [key, value] of Object.entries(filters)) {
+            this.validateAttributeName(key);
+            validated[key] = this.validateValue(value);
+        }
+        return validated;
+    }
+    /**
+     * Sanitizar string para DynamoDB
+     */
+    sanitizeString(input) {
+        if (typeof input !== "string") {
+            return String(input);
+        }
+        return input
+            .replace(/[\x00-\x1F\x7F]/g, "") // Remover caracteres de control
+            .trim()
+            .slice(0, this.config.maxStringLength);
+    }
+    /**
+     * Validar tamaño de item para DynamoDB (límite 400KB)
+     */
+    validateItemSize(item) {
+        const size = JSON.stringify(item).length;
+        const maxSize = 400 * 1024; // 400KB en bytes
+        if (size > maxSize) {
+            throw new SecurityError(`Item muy grande: ${size} bytes (máximo: ${maxSize} bytes)`);
+        }
+    }
+}
+exports.SecurityValidator = SecurityValidator;
+class SecurityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SecurityError";
+    }
+}
+exports.SecurityError = SecurityError;
+// Instancia singleton
+const securityValidator = new SecurityValidator();
+exports.securityValidator = securityValidator;
+exports.default = securityValidator;
+//# sourceMappingURL=security-validator.js.map

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

@@ -0,0 +1,78 @@
+/**
+ * @file throttle-manager.ts
+ * @description AWS DynamoDB throttling and retry management
+ * @author Miguel Alejandro
+ * @fecha 2025-08-31
+ */
+interface RetryConfig {
+    maxRetries: number;
+    baseDelay: number;
+    maxDelay: number;
+    backoffMultiplier: number;
+    jitterFactor: number;
+}
+interface ThrottleStats {
+    totalRequests: number;
+    throttledRequests: number;
+    retriedRequests: number;
+    averageLatency: number;
+}
+declare class ThrottleManager {
+    private static readonly DEFAULT_CONFIG;
+    private config;
+    private stats;
+    private requestQueue;
+    private isProcessingQueue;
+    private concurrentRequests;
+    private maxConcurrentRequests;
+    constructor(config?: Partial<RetryConfig>);
+    /**
+     * Ejecutar operación con retry automático
+     */
+    executeWithRetry<T>(operation: () => Promise<T>, operationName?: string): Promise<T>;
+    /**
+     * Verificar si el error es reintentable
+     */
+    private isRetryableError;
+    /**
+     * Calcular delay con exponential backoff + jitter
+     */
+    private calculateDelay;
+    /**
+     * Controlar concurrencia de requests
+     */
+    private acquireConcurrencySlot;
+    private releaseConcurrencySlot;
+    /**
+     * Queue para operaciones batch con rate limiting
+     */
+    queueOperation<T>(operation: () => Promise<T>): Promise<T>;
+    private processQueue;
+    /**
+     * Obtener estadísticas de throttling
+     */
+    getStats(): ThrottleStats;
+    /**
+     * Resetear estadísticas
+     */
+    resetStats(): void;
+    private updateLatencyStats;
+    private sleep;
+    /**
+     * Configurar límites de concurrencia dinámicamente
+     */
+    setConcurrencyLimit(limit: number): void;
+    /**
+     * Obtener métricas de salud del throttling
+     */
+    getHealthMetrics(): {
+        throttleRate: number;
+        retryRate: number;
+        avgLatency: number;
+        concurrentRequests: number;
+        queueSize: number;
+    };
+}
+declare const throttleManager: ThrottleManager;
+export { RetryConfig, ThrottleManager, ThrottleStats, throttleManager };
+export default throttleManager;

package/src/utils/throttle-manager.js

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

@@ -0,0 +1,88 @@
+/**
+ * @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, };