@arcaelas/dynamite 1.0.17 → 1.0.19

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

@@ -1,42 +0,0 @@
-/**
- * @file memory-manager.ts
- * @description Memory management and leak prevention
- * @author Miguel Alejandro
- * @fecha 2025-08-31
- */
-declare class MemoryManager {
-    private static instance;
-    private cleanupTasks;
-    private maxCacheSize;
-    private maxCacheAge;
-    static getInstance(): MemoryManager;
-    /**
-     * Registrar una tarea de limpieza
-     */
-    registerCleanup(id: string, cleanup: () => void, intervalMs?: number): void;
-    /**
-     * Desregistrar y limpiar tarea
-     */
-    unregisterCleanup(id: string): void;
-    /**
-     * Limpiar cache con límites de tamaño y edad
-     */
-    cleanCache<T>(cache: Map<string, {
-        data: T;
-        expires: number;
-        created: number;
-    }>, maxSize?: number): void;
-    /**
-     * Monitorear uso de memoria
-     */
-    getMemoryUsage(): NodeJS.MemoryUsage;
-    /**
-     * Forzar garbage collection si está disponible
-     */
-    forceGC(): void;
-    /**
-     * Cleanup completo al shutdown
-     */
-    shutdown(): void;
-}
-export default MemoryManager;

package/src/utils/memory-manager.js

@@ -1,107 +0,0 @@
-"use strict";
-/**
- * @file memory-manager.ts
- * @description Memory management and leak prevention
- * @author Miguel Alejandro
- * @fecha 2025-08-31
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-class MemoryManager {
-    constructor() {
-        this.cleanupTasks = new Map();
-        this.maxCacheSize = 1000;
-        this.maxCacheAge = 300000; // 5 minutos
-    }
-    static getInstance() {
-        if (!MemoryManager.instance) {
-            MemoryManager.instance = new MemoryManager();
-        }
-        return MemoryManager.instance;
-    }
-    /**
-     * Registrar una tarea de limpieza
-     */
-    registerCleanup(id, cleanup, intervalMs) {
-        // Limpiar tarea previa si existe
-        this.unregisterCleanup(id);
-        const task = { id, cleanup };
-        if (intervalMs) {
-            task.interval = setInterval(() => {
-                try {
-                    cleanup();
-                }
-                catch (error) {
-                    console.warn(`Cleanup task ${id} failed:`, error);
-                }
-            }, intervalMs);
-        }
-        this.cleanupTasks.set(id, task);
-    }
-    /**
-     * Desregistrar y limpiar tarea
-     */
-    unregisterCleanup(id) {
-        const task = this.cleanupTasks.get(id);
-        if (task) {
-            if (task.interval) {
-                clearInterval(task.interval);
-            }
-            task.cleanup();
-            this.cleanupTasks.delete(id);
-        }
-    }
-    /**
-     * Limpiar cache con límites de tamaño y edad
-     */
-    cleanCache(cache, maxSize = this.maxCacheSize) {
-        const now = Date.now();
-        // Remover entradas expiradas
-        for (const [key, entry] of cache.entries()) {
-            if (entry.expires <= now || now - entry.created > this.maxCacheAge) {
-                cache.delete(key);
-            }
-        }
-        // Si aún excede el tamaño, remover las más antiguas
-        if (cache.size > maxSize) {
-            const entries = Array.from(cache.entries()).sort((a, b) => a[1].created - b[1].created);
-            const toRemove = entries.slice(0, cache.size - maxSize);
-            toRemove.forEach(([key]) => cache.delete(key));
-        }
-    }
-    /**
-     * Monitorear uso de memoria
-     */
-    getMemoryUsage() {
-        return process.memoryUsage();
-    }
-    /**
-     * Forzar garbage collection si está disponible
-     */
-    forceGC() {
-        if (global.gc) {
-            global.gc();
-        }
-    }
-    /**
-     * Cleanup completo al shutdown
-     */
-    shutdown() {
-        console.log("MemoryManager: Iniciando cleanup completo...");
-        for (const [id, task] of this.cleanupTasks.entries()) {
-            try {
-                this.unregisterCleanup(id);
-            }
-            catch (error) {
-                console.warn(`Error cleaning up task ${id}:`, error);
-            }
-        }
-        this.cleanupTasks.clear();
-        this.forceGC();
-    }
-}
-// Cleanup automático en shutdown
-process.on("SIGTERM", () => MemoryManager.getInstance().shutdown());
-process.on("SIGINT", () => MemoryManager.getInstance().shutdown());
-process.on("uncaughtException", () => MemoryManager.getInstance().shutdown());
-exports.default = MemoryManager;
-//# sourceMappingURL=memory-manager.js.map

package/src/utils/naming.d.ts

@@ -1,8 +0,0 @@
-/**
- * @file naming.ts
- * @descripcion Utilidades de conversión de nombres
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-/** Convierte nombre de clase a formato snake_case plural para tablas */
-export declare function toSnakePlural(input: string): string;

package/src/utils/naming.js

@@ -1,18 +0,0 @@
-"use strict";
-/**
- * @file naming.ts
- * @descripcion Utilidades de conversión de nombres
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toSnakePlural = toSnakePlural;
-const pluralize_1 = __importDefault(require("pluralize"));
-/** Convierte nombre de clase a formato snake_case plural para tablas */
-function toSnakePlural(input) {
-    return (0, pluralize_1.default)(input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase());
-}
-//# sourceMappingURL=naming.js.map

package/src/utils/projection.d.ts

@@ -1,12 +0,0 @@
-/**
- * @file projection.ts
- * @description Selective field loading and projection optimization
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-/** Build DynamoDB ProjectionExpression */
-export declare const buildProjection: (attributes?: string[], meta?: any) => string | undefined;
-/** Optimize attributes loading for relations */
-export declare const optimizeRelationAttributes: (include: any, baseAttributes?: string[]) => string[];
-/** Smart attribute selection for common patterns */
-export declare const getSmartAttributes: (Model: any, scenario: "list" | "detail" | "minimal") => string[];

package/src/utils/projection.js

@@ -1,51 +0,0 @@
-"use strict";
-/**
- * @file projection.ts
- * @description Selective field loading and projection optimization
- * @autor Miguel Alejandro
- * @fecha 2025-01-27
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSmartAttributes = exports.optimizeRelationAttributes = exports.buildProjection = void 0;
-const wrapper_1 = require("../core/wrapper");
-/** Build DynamoDB ProjectionExpression */
-const buildProjection = (attributes, meta) => {
-    if (!attributes?.length || !meta)
-        return undefined;
-    // Validate attributes exist in model
-    const validAttributes = attributes.filter((attr) => meta.columns.has(attr) || meta.relations.has(attr));
-    return validAttributes.length ? validAttributes.join(", ") : undefined;
-};
-exports.buildProjection = buildProjection;
-/** Optimize attributes loading for relations */
-const optimizeRelationAttributes = (include, baseAttributes) => {
-    const attributes = new Set(baseAttributes || []);
-    // Add foreign keys needed for relations
-    Object.entries(include || {}).forEach(([relationKey, options]) => {
-        attributes.add(relationKey);
-        // Add foreign key fields
-        if (options?.foreignKey)
-            attributes.add(options.foreignKey);
-        if (options?.localKey)
-            attributes.add(options.localKey);
-    });
-    return Array.from(attributes);
-};
-exports.optimizeRelationAttributes = optimizeRelationAttributes;
-/** Smart attribute selection for common patterns */
-const getSmartAttributes = (Model, scenario) => {
-    const meta = (0, wrapper_1.mustMeta)(Model);
-    const columns = Array.from(meta.columns.keys());
-    switch (scenario) {
-        case "minimal":
-            return columns.filter((col) => meta.columns.get(col)?.primaryKey ||
-                ["id", "name", "title", "email"].includes(col));
-        case "list":
-            return columns.filter((col) => !["description", "content", "body", "metadata"].includes(col));
-        case "detail":
-        default:
-            return columns;
-    }
-};
-exports.getSmartAttributes = getSmartAttributes;
-//# sourceMappingURL=projection.js.map

package/src/utils/security-validator.d.ts

@@ -1,49 +0,0 @@
-/**
- * @file security-validator.ts
- * @description Security validation and NoSQL injection prevention
- * @author Miguel Alejandro
- * @fecha 2025-08-31
- */
-import { QueryOperator } from "../@types/index";
-interface SecurityConfig {
-    maxStringLength: number;
-    maxArrayLength: number;
-    maxNestedDepth: number;
-    allowedOperators: QueryOperator[];
-    blockedPatterns: RegExp[];
-}
-declare class SecurityValidator {
-    private static readonly DEFAULT_CONFIG;
-    private config;
-    constructor(config?: Partial<SecurityConfig>);
-    /**
-     * Validar nombre de atributo/tabla
-     */
-    validateAttributeName(name: string): void;
-    /**
-     * Validar operador de query
-     */
-    validateOperator(operator: string): QueryOperator;
-    /**
-     * Validar valor de campo
-     */
-    validateValue(value: any, depth?: number): any;
-    /**
-     * Validar filtros de query completos
-     */
-    validateQueryFilters(filters: Record<string, any>): Record<string, any>;
-    /**
-     * Sanitizar string para DynamoDB
-     */
-    sanitizeString(input: string): string;
-    /**
-     * Validar tamaño de item para DynamoDB (límite 400KB)
-     */
-    validateItemSize(item: any): void;
-}
-declare class SecurityError extends Error {
-    constructor(message: string);
-}
-declare const securityValidator: SecurityValidator;
-export { SecurityError, SecurityValidator, securityValidator };
-export default securityValidator;

package/src/utils/security-validator.js

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

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