@arcaelas/dynamite 1.0.10 → 1.0.13

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

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

@@ -0,0 +1,108 @@
+"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/{build/src → src}/utils/projection.js

@@ -7,6 +7,7 @@
  */
 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)
@@ -33,11 +34,11 @@ const optimizeRelationAttributes = (include, baseAttributes) => {
 exports.optimizeRelationAttributes = optimizeRelationAttributes;
 /** Smart attribute selection for common patterns */
 const getSmartAttributes = (Model, scenario) => {
-    const meta = Model.getMeta();
+    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)?.isKey ||
+            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));

package/src/utils/relations.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file relations.ts
+ * @descripcion Sistema de relaciones optimizado
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+/** Decorador @hasMany para relaciones 1:N */
+export declare const hasMany: (targetModel: () => any, foreignKey: string, localKey?: string) => (target: any, propertyKey: string) => void;
+/** Decorador @belongsTo para relaciones N:1 */
+export declare const belongsTo: (targetModel: () => any, localKey: string, foreignKey?: string) => (target: any, propertyKey: string) => void;
+/** Procesamiento optimizado de includes con batch loading transparente */
+export declare const processIncludes: (Model: any, items: any[], include: Record<string, any>, depth?: number) => Promise<any[]>;
+/** Separar opciones de query e include */
+export declare const separateQueryOptions: (options: Record<string, any>) => {
+    queryOptions: Record<string, any>;
+    includeOptions: Record<string, any> | undefined;
+};

package/src/utils/relations.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * @file relations.ts
+ * @descripcion Sistema de relaciones optimizado
+ * @autor Miguel Alejandro
+ * @fecha 2025-01-28
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.separateQueryOptions = exports.processIncludes = exports.belongsTo = exports.hasMany = void 0;
+// =============================================================================
+// IMPORTS
+// =============================================================================
+const wrapper_1 = require("../core/wrapper");
+const naming_1 = require("./naming");
+// =============================================================================
+// DECORATORS
+// =============================================================================
+/** Decorador @hasMany para relaciones 1:N */
+const hasMany = (targetModel, foreignKey, localKey = "id") => (target, propertyKey) => {
+    (0, wrapper_1.ensureConfig)(target.constructor, (0, naming_1.toSnakePlural)(target.constructor.name)).relations.set(propertyKey, {
+        type: "hasMany",
+        targetModel,
+        foreignKey,
+        localKey,
+    });
+    Object.defineProperty(target, propertyKey, {
+        get() {
+            const cached = this[`_${propertyKey}`];
+            return cached !== undefined
+                ? cached
+                : (console.warn(`Relación ${propertyKey} no cargada. Use includes en la consulta.`),
+                    []);
+        },
+        configurable: true,
+        enumerable: false,
+    });
+};
+exports.hasMany = hasMany;
+/** Decorador @belongsTo para relaciones N:1 */
+const belongsTo = (targetModel, localKey, foreignKey = "id") => (target, propertyKey) => {
+    (0, wrapper_1.ensureConfig)(target.constructor, (0, naming_1.toSnakePlural)(target.constructor.name)).relations.set(propertyKey, {
+        type: "belongsTo",
+        targetModel,
+        localKey,
+        foreignKey,
+    });
+    Object.defineProperty(target, propertyKey, {
+        get() {
+            const cached = this[`_${propertyKey}`];
+            return cached !== undefined
+                ? cached
+                : (console.warn(`Relación ${propertyKey} no cargada. Use includes en la consulta.`),
+                    null);
+        },
+        configurable: true,
+        enumerable: false,
+    });
+};
+exports.belongsTo = belongsTo;
+// =============================================================================
+// FUNCTIONS
+// =============================================================================
+/** Batch loading para relaciones hasMany */
+const batchLoadHasMany = async (Model, items, relation, options = {}) => {
+    const { targetModel, foreignKey, localKey = "id" } = relation;
+    const parent_keys = items.map((item) => item[localKey]).filter(Boolean);
+    if (!parent_keys.length)
+        return new Map();
+    // Build query with relation options
+    let query = targetModel().where(foreignKey, "in", parent_keys);
+    // Apply additional filters if specified
+    if (options.where) {
+        const additionalFilters = Object.entries(options.where);
+        for (const [key, value] of additionalFilters) {
+            const currentResults = await query;
+            query = Promise.resolve(currentResults.filter((item) => item[key] === value));
+        }
+    }
+    const related_items = await query;
+    // TODO: Apply attributes selection 
+    // For now, skip attributes filtering to ensure basic relations work
+    let processedItems = related_items;
+    // Apply other options like limit, order
+    let filteredItems = processedItems;
+    if (options.order === "DESC") {
+        filteredItems.sort((a, b) => b.id.localeCompare(a.id));
+    }
+    else if (options.order === "ASC") {
+        filteredItems.sort((a, b) => a.id.localeCompare(b.id));
+    }
+    if (options.limit) {
+        filteredItems = filteredItems.slice(0, options.limit);
+    }
+    const grouped = new Map();
+    filteredItems.forEach((item) => {
+        const key = item[foreignKey];
+        grouped.has(key) ? grouped.get(key).push(item) : grouped.set(key, [item]);
+    });
+    return grouped;
+};
+/** Batch loading para relaciones belongsTo */
+const batchLoadBelongsTo = async (Model, items, relation, options = {}) => {
+    const { targetModel, localKey, foreignKey = "id" } = relation;
+    // Para BelongsTo: obtener valores de localKey (ej: category_id) de los items
+    const keys = items.map((item) => localKey ? item[localKey] : null).filter(Boolean);
+    if (!keys.length)
+        return new Map();
+    // Buscar en targetModel donde foreignKey (ej: id) esté en los keys
+    const fetched_items = await targetModel().where(foreignKey, "in", keys);
+    // TODO: Apply attributes selection
+    // For now, skip attributes filtering to ensure basic relations work  
+    let processedItems = fetched_items;
+    const results = new Map();
+    // Mapear por foreignKey para que coincida con localKey de los items
+    processedItems.forEach((item) => results.set(item[foreignKey], item));
+    return results;
+};
+/** Procesamiento optimizado de includes con batch loading transparente */
+const processIncludes = async (Model, items, include, depth = 0) => {
+    if (!include || depth > 10 || !items.length)
+        return items;
+    const meta = (0, wrapper_1.mustMeta)(Model);
+    const relation_promises = Object.entries(include).map(async ([relation_key, relation_options]) => {
+        const relation = meta.relations.get(relation_key);
+        if (!relation)
+            return;
+        const related_data = relation.type === "hasMany"
+            ? await batchLoadHasMany(Model, items, relation, relation_options)
+            : await batchLoadBelongsTo(Model, items, relation, relation_options);
+        items.forEach((item) => {
+            let key;
+            if (relation.type === "hasMany") {
+                // Para HasMany: usar localKey (ej: "id") del item actual
+                key = item[relation.localKey || "id"];
+            }
+            else {
+                // Para BelongsTo: usar localKey (ej: "category_id") del item actual
+                key = relation.localKey ? item[relation.localKey] : null;
+            }
+            const related = related_data.get(key);
+            // Usar una propiedad temporal para evitar conflictos con getters
+            Object.defineProperty(item, relation_key, {
+                value: relation.type === "hasMany" ? related || [] : related || null,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        });
+        if (relation_options?.include && related_data.size) {
+            const all_related = Array.from(related_data.values())
+                .flat()
+                .filter(Boolean);
+            await (0, exports.processIncludes)(relation.targetModel(), all_related, relation_options.include, depth + 1);
+        }
+    });
+    await Promise.all(relation_promises);
+    return items;
+};
+exports.processIncludes = processIncludes;
+/** Separar opciones de query e include */
+const separateQueryOptions = (options) => {
+    const { include, ...queryOptions } = options;
+    return { queryOptions, includeOptions: include };
+};
+exports.separateQueryOptions = separateQueryOptions;
+//# sourceMappingURL=relations.js.map

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

@@ -0,0 +1,49 @@
+/**
+ * @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 { SecurityValidator, SecurityError, securityValidator };
+export default securityValidator;

package/src/utils/security-validator.js

@@ -0,0 +1,152 @@
+"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.SecurityError = exports.SecurityValidator = 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 { ThrottleManager, RetryConfig, ThrottleStats, throttleManager };
+export default throttleManager;