@arcaelas/dynamite 1.0.13 → 1.0.14

package/src/utils/relations.js

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

@@ -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 { SecurityValidator, SecurityError, securityValidator };
-export default securityValidator;

package/src/utils/security-validator.js

@@ -1,152 +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.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

@@ -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 { ThrottleManager, RetryConfig, ThrottleStats, throttleManager };
-export default throttleManager;

package/src/utils/throttle-manager.js

@@ -1,196 +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