@fluyappgocore/commons-backend 1.0.202

package/build/classes/BacklogMonitor.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BacklogMonitor = void 0;
+var BacklogMonitor = /** @class */ (function () {
+    function BacklogMonitor() {
+        this.listeners = new Map();
+    }
+    BacklogMonitor.getInstance = function () {
+        if (!BacklogMonitor.instance) {
+            BacklogMonitor.instance = new BacklogMonitor();
+        }
+        return BacklogMonitor.instance;
+    };
+    /**
+     * Registra un listener para monitoreo (EnhancedListener o BatchEnhancedListener)
+     */
+    BacklogMonitor.prototype.registerListener = function (listener) {
+        var key = listener.groupName + ":" + listener.topic;
+        this.listeners.set(key, listener);
+        console.log("\uD83D\uDCCB Registered listener for monitoring: " + key);
+    };
+    /**
+     * Desregistra un listener
+     */
+    BacklogMonitor.prototype.unregisterListener = function (groupName, topic) {
+        var key = groupName + ":" + topic;
+        this.listeners.delete(key);
+        console.log("\uD83D\uDCCB Unregistered listener: " + key);
+    };
+    /**
+     * Obtiene estadísticas de un listener específico
+     */
+    BacklogMonitor.prototype.getListenerStats = function (groupName, topic) {
+        var key = groupName + ":" + topic;
+        var listener = this.listeners.get(key);
+        if (!listener) {
+            return null;
+        }
+        var stats = listener.getStats();
+        var successRate = stats.processed + stats.failed > 0
+            ? (stats.processed / (stats.processed + stats.failed)) * 100
+            : 100;
+        return {
+            listenerName: stats.listenerName,
+            topic: stats.topic,
+            groupName: stats.groupName,
+            processed: stats.processed,
+            failed: stats.failed,
+            retries: stats.retries,
+            queueSize: stats.queueSize,
+            activeProcessing: stats.activeProcessing,
+            circuitBreakerOpen: stats.circuitBreakerOpen,
+            averageProcessingTime: stats.averageProcessingTime,
+            successRate: parseFloat(successRate.toFixed(2)),
+            lastProcessedAt: stats.lastProcessedAt,
+            config: stats.config
+        };
+    };
+    /**
+     * Obtiene estadísticas de todos los listeners
+     */
+    BacklogMonitor.prototype.getAllListenersStats = function () {
+        var allStats = [];
+        Array.from(this.listeners.entries()).forEach(function (_a) {
+            var key = _a[0], listener = _a[1];
+            var stats = listener.getStats();
+            var successRate = stats.processed + stats.failed > 0
+                ? (stats.processed / (stats.processed + stats.failed)) * 100
+                : 100;
+            allStats.push({
+                listenerName: stats.listenerName,
+                topic: stats.topic,
+                groupName: stats.groupName,
+                processed: stats.processed,
+                failed: stats.failed,
+                retries: stats.retries,
+                queueSize: stats.queueSize,
+                activeProcessing: stats.activeProcessing,
+                circuitBreakerOpen: stats.circuitBreakerOpen,
+                averageProcessingTime: stats.averageProcessingTime,
+                successRate: parseFloat(successRate.toFixed(2)),
+                lastProcessedAt: stats.lastProcessedAt,
+                config: stats.config
+            });
+        });
+        return allStats;
+    };
+    /**
+     * Obtiene estadísticas del sistema completo
+     */
+    BacklogMonitor.prototype.getSystemStats = function () {
+        var allStats = this.getAllListenersStats();
+        var totalProcessed = allStats.reduce(function (sum, stats) { return sum + stats.processed; }, 0);
+        var totalFailed = allStats.reduce(function (sum, stats) { return sum + stats.failed; }, 0);
+        var totalRetries = allStats.reduce(function (sum, stats) { return sum + stats.retries; }, 0);
+        var totalQueueSize = allStats.reduce(function (sum, stats) { return sum + stats.queueSize; }, 0);
+        var totalActiveProcessing = allStats.reduce(function (sum, stats) { return sum + stats.activeProcessing; }, 0);
+        var circuitBreakersOpen = allStats.filter(function (stats) { return stats.circuitBreakerOpen; }).length;
+        var overallSuccessRate = totalProcessed + totalFailed > 0
+            ? (totalProcessed / (totalProcessed + totalFailed)) * 100
+            : 100;
+        // Determinar salud del sistema
+        var systemHealth = 'healthy';
+        if (circuitBreakersOpen > 0 || overallSuccessRate < 90) {
+            systemHealth = 'degraded';
+        }
+        if (circuitBreakersOpen > allStats.length * 0.5 || overallSuccessRate < 70) {
+            systemHealth = 'critical';
+        }
+        return {
+            totalListeners: allStats.length,
+            activeListeners: allStats.filter(function (stats) { return stats.activeProcessing > 0 || stats.queueSize > 0; }).length,
+            totalProcessed: totalProcessed,
+            totalFailed: totalFailed,
+            totalRetries: totalRetries,
+            totalQueueSize: totalQueueSize,
+            totalActiveProcessing: totalActiveProcessing,
+            circuitBreakersOpen: circuitBreakersOpen,
+            overallSuccessRate: parseFloat(overallSuccessRate.toFixed(2)),
+            systemHealth: systemHealth
+        };
+    };
+    /**
+     * Actualiza configuración de un listener específico
+     */
+    BacklogMonitor.prototype.updateListenerConfig = function (groupName, topic, newConfig) {
+        var key = groupName + ":" + topic;
+        var listener = this.listeners.get(key);
+        if (!listener) {
+            return false;
+        }
+        listener.updateBacklogConfig(newConfig);
+        return true;
+    };
+    /**
+     * Actualiza configuración de todos los listeners
+     */
+    BacklogMonitor.prototype.updateAllListenersConfig = function (newConfig) {
+        var updated = 0;
+        Array.from(this.listeners.entries()).forEach(function (_a) {
+            var key = _a[0], listener = _a[1];
+            listener.updateBacklogConfig(newConfig);
+            updated++;
+        });
+        console.log("\uD83D\uDD27 Updated config for " + updated + " listeners");
+        return updated;
+    };
+    /**
+     * Resetea estadísticas de un listener específico
+     */
+    BacklogMonitor.prototype.resetListenerStats = function (groupName, topic) {
+        var key = groupName + ":" + topic;
+        var listener = this.listeners.get(key);
+        if (!listener) {
+            return false;
+        }
+        listener.resetStats();
+        return true;
+    };
+    /**
+     * Resetea estadísticas de todos los listeners
+     */
+    BacklogMonitor.prototype.resetAllStats = function () {
+        var reset = 0;
+        Array.from(this.listeners.entries()).forEach(function (_a) {
+            var key = _a[0], listener = _a[1];
+            listener.resetStats();
+            reset++;
+        });
+        console.log("\uD83D\uDD04 Reset stats for " + reset + " listeners");
+        return reset;
+    };
+    /**
+     * Fuerza circuit breaker para un listener específico
+     */
+    BacklogMonitor.prototype.forceCircuitBreaker = function (groupName, topic, open) {
+        var key = groupName + ":" + topic;
+        var listener = this.listeners.get(key);
+        if (!listener) {
+            return false;
+        }
+        listener.forceCircuitBreaker(open);
+        return true;
+    };
+    /**
+     * Obtiene resumen de salud del sistema
+     */
+    BacklogMonitor.prototype.getHealthSummary = function () {
+        var systemStats = this.getSystemStats();
+        var problematicListeners = this.getAllListenersStats()
+            .filter(function (stats) { return stats.circuitBreakerOpen || stats.successRate < 90; });
+        var message = '';
+        var status = systemStats.systemHealth;
+        switch (systemStats.systemHealth) {
+            case 'healthy':
+                message = 'All listeners operating normally';
+                break;
+            case 'degraded':
+                message = problematicListeners.length + " listener(s) experiencing issues";
+                break;
+            case 'critical':
+                message = "System critical: " + systemStats.circuitBreakersOpen + " circuit breakers open";
+                break;
+        }
+        return {
+            status: status,
+            message: message,
+            details: {
+                systemStats: systemStats,
+                problematicListeners: problematicListeners.map(function (l) { return ({
+                    name: l.listenerName,
+                    topic: l.topic,
+                    successRate: l.successRate,
+                    circuitBreakerOpen: l.circuitBreakerOpen,
+                    queueSize: l.queueSize
+                }); })
+            }
+        };
+    };
+    return BacklogMonitor;
+}());
+exports.BacklogMonitor = BacklogMonitor;

package/build/classes/HttpResponse.d.ts

@@ -0,0 +1,7 @@
+export declare class HttpResponse {
+    code: String;
+    data: any;
+    metadata?: any;
+    message?: any;
+    constructor(code: String, data: any, metadata?: any, message?: any);
+}

package/build/classes/HttpResponse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpResponse = void 0;
+var HttpResponse = /** @class */ (function () {
+    function HttpResponse(code, data, metadata, message) {
+        this.code = code;
+        this.data = data;
+        this.metadata = metadata;
+        this.message = message;
+    }
+    return HttpResponse;
+}());
+exports.HttpResponse = HttpResponse;

package/build/classes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './HttpResponse';
+export * from './BacklogManager';
+export * from './BacklogMonitor';

package/build/classes/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./HttpResponse"), exports);
+__exportStar(require("./BacklogManager"), exports);
+__exportStar(require("./BacklogMonitor"), exports);

package/build/dtos/file.dto.d.ts

@@ -0,0 +1,5 @@
+export declare class FileDTO {
+    Key: string;
+    ContentType: string;
+    folder: string;
+}

package/build/dtos/file.dto.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileDTO = void 0;
+var class_validator_1 = require("class-validator");
+var FileDTO = /** @class */ (function () {
+    function FileDTO() {
+    }
+    __decorate([
+        class_validator_1.IsString()
+    ], FileDTO.prototype, "Key", void 0);
+    __decorate([
+        class_validator_1.IsString()
+    ], FileDTO.prototype, "ContentType", void 0);
+    __decorate([
+        class_validator_1.IsString()
+    ], FileDTO.prototype, "folder", void 0);
+    return FileDTO;
+}());
+exports.FileDTO = FileDTO;

package/build/dtos/index.d.ts

@@ -0,0 +1 @@
+export * from './file.dto';

package/build/dtos/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./file.dto"), exports);

package/build/events/BatchEnhancedListener.d.ts

@@ -0,0 +1,106 @@
+import { KafkaMessage } from "kafkajs";
+import { TicketTopics, AgentTopics, EntityTreeTopics, AgentCrudTopics, MatchTopics, TicketTrackingTopics, AgentTrackingTopics, ManualMatchTopics, MonitorTopics, UserTopics, DeleteTrackingTopics, AuditTopics, NotificationTopics, TicketNoteTopics, TopicsTopics, TicketxTopicsTopics, DeviceTopics, PlanningTopics, WaitingTopics, PaymentsTopics, SubscriptionTopics } from "@fluyappgo/commons";
+import { BacklogManager, CircuitBreakerCallback } from "../classes/BacklogManager";
+import { MonitorableListener } from "../classes/BacklogMonitor";
+interface Event {
+    topic: TicketTopics | AgentTopics | EntityTreeTopics | AgentCrudTopics | MatchTopics | TicketTrackingTopics | AgentTrackingTopics | ManualMatchTopics | MonitorTopics | UserTopics | DeleteTrackingTopics | AuditTopics | NotificationTopics | TicketNoteTopics | TopicsTopics | TicketxTopicsTopics | DeviceTopics | PlanningTopics | WaitingTopics | PaymentsTopics | SubscriptionTopics;
+    data: any;
+    keyKafka: number;
+    groupName: string;
+}
+/**
+ * 🔥 BULLETPROOF: BatchEnhancedListener con control de flujo real en la entrada
+ *
+ * DIFERENCIAS CLAVE vs EnhancedListener:
+ * ✅ Control de flujo en la ENTRADA del consumer (eachBatch)
+ * ✅ NUNCA más mensajes en memoria de los que puede procesar
+ * ✅ Pausa automática cuando BacklogManager está saturado
+ * ✅ Resolución manual de offsets para mejor control de errores
+ * ✅ Heartbeat automático para mantener conexión viva
+ */
+export declare abstract class BatchEnhancedListener<T extends Event> implements MonitorableListener {
+    abstract topic: T["topic"];
+    abstract groupName: string;
+    protected client: any;
+    protected backlogManager: BacklogManager;
+    protected listenerName: string;
+    protected batchConfig: {
+        maxBytesPerPartition: number;
+        maxBytes: number;
+    };
+    abstract processMessage(data: T["data"], msg: KafkaMessage): Promise<void>;
+    constructor(client: any, listenerName: string, backlogConfig?: any, batchConfig?: {
+        maxBytesPerPartition?: number;
+        maxBytes?: number;
+    });
+    /**
+     * Configuración por defecto que puede ser sobrescrita por cada listener
+     */
+    protected getDefaultBacklogConfig(): {
+        maxConcurrent: number;
+        rateLimitMs: number;
+        circuitBreakerThreshold: number;
+        circuitBreakerResetTime: number;
+        maxRetries: number;
+        backlogRecoveryBatchSize: number;
+        enableBacklogRecovery: boolean;
+    };
+    /**
+     * 🔥 BULLETPROOF: Listen usando eachBatch con control de flujo real
+     */
+    listen(fromBeginning: boolean): void;
+    /**
+     * 🔥 BULLETPROOF: Procesa batch con control de flujo real
+     */
+    private processBatch;
+    /**
+     * Parse message helper
+     */
+    private parseMessage;
+    /**
+     * Log de estadísticas del BacklogManager
+     */
+    private logStats;
+    /**
+     * Obtener estadísticas del listener
+     */
+    getStats(): {
+        availableCapacity: number;
+        isAtMaxCapacity: boolean;
+        processed: number;
+        failed: number;
+        retries: number;
+        circuitBreakerTrips: number;
+        lastProcessedAt: Date;
+        averageProcessingTime: number;
+        queueSize: number;
+        activeProcessing: number;
+        circuitBreakerOpen: boolean;
+        config: import("../classes/BacklogManager").BacklogConfig;
+        listenerName: string;
+        topic: T["topic"];
+        groupName: string;
+    };
+    /**
+     * Actualizar configuración del BacklogManager en tiempo real
+     */
+    updateBacklogConfig(newConfig: any): void;
+    /**
+     * Resetear estadísticas
+     */
+    resetStats(): void;
+    /**
+     * Forzar circuit breaker (para debugging)
+     */
+    forceCircuitBreaker(open: boolean): void;
+    /**
+     * Registra un callback para cambios de estado del circuit breaker
+     * @param callback Función que se ejecuta cuando cambia el estado del circuit breaker
+     */
+    onCircuitBreakerStateChange(callback: CircuitBreakerCallback): void;
+    /**
+     * Obtiene el nombre del listener
+     */
+    getListenerName(): string;
+}
+export {};