@zintrust/core 0.1.48 → 0.1.50

package/packages/workers/src/HealthMonitor.js

@@ -1,312 +0,0 @@
-import { ErrorFactory, Logger } from '../../../src/index.js';
-import { WorkerCreationStatus, WorkerFactory } from './WorkerFactory.js';
-const DEFAULT_CONFIG = {
-    enabled: true,
-    tickIntervalMs: 1000,
-    concurrencyLimit: 50,
-    checkTimeoutMs: 5000,
-    intervalHealthyMs: 30000,
-    intervalSuspectMs: 5000,
-    failureThreshold: 2,
-    historyLimit: 50,
-};
-// Module-level state (Singleton by nature of ESM)
-const registry = new Map();
-let config = { ...DEFAULT_CONFIG };
-let timer = null;
-let runningChecks = 0;
-// Internal Helpers
-const persistStatusChange = async (name, status, lastError) => {
-    try {
-        await WorkerFactory.updateStatus(name, status, lastError);
-    }
-    catch (err) {
-        Logger.error(`Failed to persist status change for ${name}`, err);
-    }
-};
-const verifyWorkerHealth = async (worker) => {
-    // Check if isClosing exists (isClosing check safe for mocks)
-    const workerAny = worker;
-    const isClosingFn = workerAny['isClosing'];
-    if (worker.isPaused() ||
-        (typeof isClosingFn === 'function' && isClosingFn())) {
-        return false;
-    }
-    const isRunning = await worker.isRunning();
-    if (!isRunning)
-        return false;
-    const client = await worker.client;
-    const pingResult = await client.ping();
-    if (pingResult !== 'PONG') {
-        throw ErrorFactory.createWorkerError(`Redis ping failed: ${pingResult}`);
-    }
-    return true;
-};
-const withTimeout = async (promise, timeoutMs, onTimeout) => {
-    let timeoutId = null;
-    return await new Promise((resolve, reject) => {
-        timeoutId = globalThis.setTimeout(() => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-                timeoutId = null;
-            }
-            reject(onTimeout());
-        }, timeoutMs);
-        timeoutId.unref();
-        promise
-            .then(resolve)
-            .catch(reject)
-            .finally(() => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-                timeoutId = null;
-            }
-        });
-    });
-};
-const updateState = (state, isHealthy, errorMsg, latency) => {
-    const now = new Date();
-    state.lastCheck = now;
-    // Determine status (healthy > degraded > critical)
-    let status;
-    if (isHealthy) {
-        status = 'healthy';
-    }
-    else if (state.consecutiveFailures < config.failureThreshold) {
-        status = 'degraded';
-    }
-    else {
-        status = 'critical';
-    }
-    // Create Check Result
-    const result = {
-        timestamp: now,
-        status,
-        latency,
-        message: errorMsg,
-    };
-    // Add to history
-    state.history.push(result);
-    if (state.history.length > config.historyLimit) {
-        state.history.shift();
-    }
-    // Callbacks
-    if (!isHealthy && state.config?.degradedCallback) {
-        state.config.degradedCallback(state.name, result);
-    }
-    if (result.status === 'critical' && state.config?.criticalCallback) {
-        state.config.criticalCallback(state.name, result);
-    }
-    if (isHealthy) {
-        state.consecutiveFailures = 0;
-        if (state.status !== WorkerCreationStatus.RUNNING) {
-            persistStatusChange(state.name, WorkerCreationStatus.RUNNING);
-            state.status = WorkerCreationStatus.RUNNING;
-            Logger.info(`Worker ${state.name} recovered to RUNNING`);
-        }
-        const jitter = Math.floor(Math.random() * 500); //NOSONAR
-        state.nextCheck = new Date(now.getTime() + config.intervalHealthyMs + jitter);
-    }
-    else {
-        state.consecutiveFailures++;
-        if (state.consecutiveFailures >= config.failureThreshold &&
-            state.status !== WorkerCreationStatus.FAILED) {
-            persistStatusChange(state.name, WorkerCreationStatus.FAILED, errorMsg);
-            state.status = WorkerCreationStatus.FAILED;
-            Logger.warn(`Worker ${state.name} marked FAILED after ${state.consecutiveFailures} checks`, {
-                error: errorMsg,
-            });
-        }
-        const jitter = Math.floor(Math.random() * 500); //NOSONAR
-        state.nextCheck = new Date(now.getTime() + config.intervalSuspectMs + jitter);
-    }
-};
-const performCheck = async (state) => {
-    const startTime = Date.now();
-    let isHealthy = false;
-    let errorMsg;
-    try {
-        if (!state.worker) {
-            throw ErrorFactory.createWorkerError('Worker instance not available');
-        }
-        isHealthy = await withTimeout(verifyWorkerHealth(state.worker), config.checkTimeoutMs, () => ErrorFactory.createWorkerError('Health check timeout'));
-    }
-    catch (err) {
-        isHealthy = false;
-        errorMsg = err.message;
-    }
-    const duration = Date.now() - startTime;
-    updateState(state, isHealthy, errorMsg, duration);
-};
-const scheduleCheck = async (state) => {
-    state.inProgress = true;
-    runningChecks++;
-    performCheck(state).finally(() => {
-        state.inProgress = false;
-        runningChecks--;
-    });
-};
-const tick = async () => {
-    const now = new Date();
-    const candidates = [];
-    for (const state of registry.values()) {
-        if (runningChecks >= config.concurrencyLimit)
-            break;
-        // Skip if checks are paused or if worker instance is missing (wait for register)
-        if (!state.worker && !state.queueName)
-            continue;
-        if (!state.inProgress && state.nextCheck <= now) {
-            candidates.push(state);
-        }
-    }
-    for (const candidate of candidates) {
-        if (runningChecks >= config.concurrencyLimit)
-            break;
-        scheduleCheck(candidate);
-    }
-};
-const start = () => {
-    if (timer)
-        return;
-    timer = setInterval(() => tick(), config.tickIntervalMs);
-    Logger.debug('HealthMonitor started');
-};
-const stop = () => {
-    if (timer) {
-        clearInterval(timer);
-        timer = null;
-    }
-    Logger.debug('HealthMonitor stopped');
-};
-// Exported Public Methods
-const configure = (newConfig) => {
-    config = { ...config, ...newConfig };
-    if (timer) {
-        stop();
-        start();
-    }
-};
-const register = (name, worker, queueName) => {
-    let state = registry.get(name);
-    if (state) {
-        // update existing entry (maybe created by startMonitoring)
-        state.worker = worker;
-        state.queueName = queueName;
-    }
-    else {
-        // Add jitter
-        const initialDelay = Math.floor(Math.random() * 5000); //NOSONAR
-        state = {
-            name,
-            worker,
-            queueName,
-            status: WorkerCreationStatus.STARTING,
-            lastCheck: new Date(),
-            nextCheck: new Date(Date.now() + initialDelay),
-            consecutiveFailures: 0,
-            inProgress: false,
-            history: [],
-        };
-        registry.set(name, state);
-    }
-    if (!timer) {
-        start();
-    }
-};
-const startMonitoring = (name, monitorConfig) => {
-    const state = registry.get(name);
-    if (state) {
-        if (monitorConfig)
-            state.config = { ...state.config, ...monitorConfig };
-    }
-    else {
-        // Worker instance not yet registered, create placeholder
-        const initialDelay = Math.floor(Math.random() * 5000); //NOSONAR
-        registry.set(name, {
-            name,
-            status: WorkerCreationStatus.STARTING,
-            lastCheck: new Date(),
-            nextCheck: new Date(Date.now() + initialDelay),
-            consecutiveFailures: 0,
-            inProgress: false,
-            history: [],
-            config: monitorConfig,
-        });
-    }
-    if (!timer)
-        start();
-};
-const unregister = (name) => {
-    registry.delete(name);
-    if (registry.size === 0) {
-        stop();
-    }
-};
-const stopMonitoring = (name) => {
-    unregister(name);
-};
-const updateConfig = (name, monitorConfig) => {
-    startMonitoring(name, monitorConfig);
-};
-const getCurrentHealth = (name) => {
-    const state = registry.get(name);
-    if (!state || state.history.length === 0)
-        return null;
-    return state.history[state.history.length - 1];
-};
-const getHealthHistory = (name, limit) => {
-    const state = registry.get(name);
-    if (!state)
-        return [];
-    const history = state.history;
-    return limit ? history.slice(-limit) : history;
-};
-const getHealthTrend = (name) => {
-    const history = getHealthHistory(name, 10);
-    const uptime = history.filter((h) => h.status === 'healthy').length / (history.length || 1);
-    return { uptime, samples: history.length };
-};
-const getSummary = async () => {
-    const summary = {
-        total: registry.size,
-        healthy: 0,
-        degraded: 0,
-        critical: 0,
-        details: [],
-    };
-    for (const [name, state] of registry) {
-        const lastResult = state.history[state.history.length - 1];
-        const status = lastResult?.status || 'unknown';
-        if (status === 'healthy')
-            summary.healthy++;
-        else if (status === 'degraded')
-            summary.degraded++;
-        else if (status === 'critical')
-            summary.critical++;
-        summary.details.push({
-            name,
-            status,
-            lastCheck: state.lastCheck,
-        });
-    }
-    return summary;
-};
-const shutdown = () => {
-    stop();
-    registry.clear();
-};
-export const HealthMonitor = Object.freeze({
-    configure,
-    register,
-    unregister,
-    start,
-    stop,
-    startMonitoring,
-    stopMonitoring,
-    updateConfig,
-    getCurrentHealth,
-    getHealthHistory,
-    getHealthTrend,
-    getSummary,
-    shutdown,
-});

package/packages/workers/src/MultiQueueWorker.d.ts

@@ -1,90 +0,0 @@
-/**
- * Multi-Queue Worker Support
- * Enable workers to process multiple queues with different priorities
- * Sealed namespace for immutability
- */
-import { type Job } from 'bullmq';
-export type QueueConfig = {
-    name: string;
-    concurrency: number;
-    priority: number;
-    enabled: boolean;
-    rateLimit?: {
-        max: number;
-        duration: number;
-    };
-};
-export type MultiQueueWorkerConfig = {
-    workerName: string;
-    queues: QueueConfig[];
-    processor: (job: Job) => Promise<unknown>;
-    sharedConcurrency?: number;
-    defaultConcurrency?: number;
-};
-export type QueueStats = {
-    queueName: string;
-    processed: number;
-    failed: number;
-    active: number;
-    waiting: number;
-    enabled: boolean;
-    lastProcessedAt?: Date;
-};
-/**
- * Multi-Queue Worker Manager - Sealed namespace
- */
-export declare const MultiQueueWorker: Readonly<{
-    /**
-     * Create multi-queue worker
-     */
-    create(config: MultiQueueWorkerConfig): Promise<void>;
-    /**
-     * Start processing for a specific queue
-     */
-    startQueue(workerName: string, queueName: string): Promise<void>;
-    /**
-     * Stop processing for a specific queue
-     */
-    stopQueue(workerName: string, queueName: string): Promise<void>;
-    /**
-     * Start all queues
-     */
-    startAll(workerName: string): Promise<void>;
-    /**
-     * Stop all queues
-     */
-    stopAll(workerName: string): Promise<void>;
-    /**
-     * Update queue priority
-     */
-    updateQueuePriority(workerName: string, queueName: string, priority: number): void;
-    /**
-     * Update queue concurrency
-     */
-    updateQueueConcurrency(workerName: string, queueName: string, concurrency: number): Promise<void>;
-    /**
-     * Get stats for a queue
-     */
-    getQueueStats(workerName: string, queueName: string): Promise<QueueStats>;
-    /**
-     * Get stats for all queues
-     */
-    getAllStats(workerName: string): Promise<ReadonlyArray<QueueStats>>;
-    /**
-     * Get configuration
-     */
-    getConfig(workerName: string): MultiQueueWorkerConfig | null;
-    /**
-     * List all multi-queue workers
-     */
-    list(): string[];
-    /**
-     * Remove multi-queue worker
-     */
-    remove(workerName: string): Promise<void>;
-    /**
-     * Shutdown all multi-queue workers
-     */
-    shutdown(): Promise<void>;
-}>;
-//# sourceMappingURL=MultiQueueWorker.d.ts.map

package/packages/workers/src/MultiQueueWorker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MultiQueueWorker.d.ts","sourceRoot":"","sources":["../../../../packages/workers/src/MultiQueueWorker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAU,KAAK,GAAG,EAAsB,MAAM,QAAQ,CAAC;AAG9D,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE;QACV,GAAG,EAAE,MAAM,CAAC;QACZ,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,IAAI,CAAC;CACxB,CAAC;AAgGF;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;mBACkB,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAuC3D;;OAEG;2BAC0B,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBtE;;OAEG;0BACyB,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBrE;;OAEG;yBACwB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBjD;;OAEG;wBACuB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBhD;;OAEG;oCAC6B,MAAM,aAAa,MAAM,YAAY,MAAM,GAAG,IAAI;IAoBlF;;OAEG;uCAEW,MAAM,aACP,MAAM,eACJ,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC;IAkChB;;OAEG;8BAC6B,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAwB/E;;OAEG;4BAC2B,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IAgBzE;;OAEG;0BACmB,MAAM,GAAG,sBAAsB,GAAG,IAAI;IAK5D;;OAEG;YACK,MAAM,EAAE;IAIhB;;OAEG;uBACsB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB/C;;OAEG;gBACe,OAAO,CAAC,IAAI,CAAC;EAc/B,CAAC"}

package/packages/workers/src/MultiQueueWorker.js

@@ -1,282 +0,0 @@
-/**
- * Multi-Queue Worker Support
- * Enable workers to process multiple queues with different priorities
- * Sealed namespace for immutability
- */
-import { ErrorFactory, Logger } from '../../../src/index.js';
-import { Worker } from 'bullmq';
-import { PriorityQueue } from './PriorityQueue.js';
-// Internal state
-const multiQueueWorkers = new Map();
-/**
- * Helper: Create worker for a queue
- */
-const createQueueWorker = async (workerName, queueConfig, processor) => {
-    const queue = await PriorityQueue.getQueueInstance(queueConfig.name);
-    const connection = queue.opts.connection;
-    const workerOptions = {
-        connection,
-        concurrency: queueConfig.concurrency,
-        limiter: queueConfig.rateLimit,
-        autorun: queueConfig.enabled,
-        prefix: queue.opts.prefix,
-    };
-    const worker = new Worker(queueConfig.name, async (job) => {
-        Logger.debug(`Processing job from queue: ${queueConfig.name}`, {
-            jobId: job.id,
-            workerName,
-        });
-        return processor(job);
-    }, workerOptions);
-    // Set up event listeners
-    worker.on('completed', (job) => {
-        const stats = multiQueueWorkers.get(workerName)?.stats.get(queueConfig.name);
-        if (stats) {
-            stats.processed++;
-            stats.lastProcessedAt = new Date();
-        }
-        Logger.debug(`Job completed from queue: ${queueConfig.name}`, {
-            jobId: job.id,
-            workerName,
-        });
-    });
-    worker.on('failed', (job, error) => {
-        const stats = multiQueueWorkers.get(workerName)?.stats.get(queueConfig.name);
-        if (stats) {
-            stats.failed++;
-        }
-        Logger.error(`Job failed from queue: ${queueConfig.name}`, error, 'workers');
-        Logger.debug('Queue job failure details', {
-            jobId: job?.id,
-            workerName,
-            queueName: queueConfig.name,
-        });
-    });
-    worker.on('active', (_job) => {
-        const stats = multiQueueWorkers.get(workerName)?.stats.get(queueConfig.name);
-        if (stats) {
-            stats.active++;
-        }
-    });
-    return worker;
-};
-/**
- * Helper: Initialize stats for queue
- */
-const initializeQueueStats = (queueName, enabled) => {
-    return {
-        queueName,
-        processed: 0,
-        failed: 0,
-        active: 0,
-        waiting: 0,
-        enabled,
-    };
-};
-/**
- * Multi-Queue Worker Manager - Sealed namespace
- */
-export const MultiQueueWorker = Object.freeze({
-    /**
-     * Create multi-queue worker
-     */
-    async create(config) {
-        if (multiQueueWorkers.has(config.workerName)) {
-            throw ErrorFactory.createWorkerError(`Multi-queue worker "${config.workerName}" already exists`);
-        }
-        const workers = new Map();
-        const stats = new Map();
-        // Sort queues by priority (higher first)
-        const sortedQueues = [...config.queues].sort((a, b) => b.priority - a.priority);
-        // Create workers for each queue in parallel
-        const workerPromises = sortedQueues.map(async (queueConfig) => {
-            const worker = await createQueueWorker(config.workerName, queueConfig, config.processor);
-            return { queueConfig, worker };
-        });
-        const workerResults = await Promise.all(workerPromises);
-        // Store workers and stats
-        for (const { queueConfig, worker } of workerResults) {
-            workers.set(queueConfig.name, worker);
-            stats.set(queueConfig.name, initializeQueueStats(queueConfig.name, queueConfig.enabled));
-        }
-        multiQueueWorkers.set(config.workerName, {
-            config,
-            workers,
-            stats,
-        });
-        Logger.info(`Multi-queue worker created: ${config.workerName}`, {
-            queues: sortedQueues.map((q) => q.name),
-            totalConcurrency: sortedQueues.reduce((sum, q) => sum + q.concurrency, 0),
-        });
-    },
-    /**
-     * Start processing for a specific queue
-     */
-    async startQueue(workerName, queueName) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        const worker = mqw.workers.get(queueName);
-        if (!worker) {
-            throw ErrorFactory.createNotFoundError(`Queue "${queueName}" not found in worker "${workerName}"`);
-        }
-        await worker.run();
-        const stats = mqw.stats.get(queueName);
-        if (stats) {
-            stats.enabled = true;
-        }
-        Logger.info(`Queue started: ${queueName}`, { workerName });
-    },
-    /**
-     * Stop processing for a specific queue
-     */
-    async stopQueue(workerName, queueName) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        const worker = mqw.workers.get(queueName);
-        if (!worker) {
-            throw ErrorFactory.createNotFoundError(`Queue "${queueName}" not found in worker "${workerName}"`);
-        }
-        await worker.pause();
-        const stats = mqw.stats.get(queueName);
-        if (stats) {
-            stats.enabled = false;
-        }
-        Logger.info(`Queue stopped: ${queueName}`, { workerName });
-    },
-    /**
-     * Start all queues
-     */
-    async startAll(workerName) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        const promises = Array.from(mqw.workers.keys()).map(async (queueName) => MultiQueueWorker.startQueue(workerName, queueName));
-        await Promise.all(promises);
-        Logger.info(`All queues started for worker: ${workerName}`);
-    },
-    /**
-     * Stop all queues
-     */
-    async stopAll(workerName) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        const promises = Array.from(mqw.workers.keys()).map(async (queueName) => MultiQueueWorker.stopQueue(workerName, queueName));
-        await Promise.all(promises);
-        Logger.info(`All queues stopped for worker: ${workerName}`);
-    },
-    /**
-     * Update queue priority
-     */
-    updateQueuePriority(workerName, queueName, priority) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        const queueConfig = mqw.config.queues.find((q) => q.name === queueName);
-        if (!queueConfig) {
-            throw ErrorFactory.createNotFoundError(`Queue "${queueName}" not found in worker "${workerName}"`);
-        }
-        queueConfig.priority = priority;
-        Logger.info(`Queue priority updated: ${queueName}`, { workerName, priority });
-    },
-    /**
-     * Update queue concurrency
-     */
-    async updateQueueConcurrency(workerName, queueName, concurrency) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        const worker = mqw.workers.get(queueName);
-        if (!worker) {
-            throw ErrorFactory.createNotFoundError(`Queue "${queueName}" not found in worker "${workerName}"`);
-        }
-        const queueConfig = mqw.config.queues.find((q) => q.name === queueName);
-        if (!queueConfig) {
-            throw ErrorFactory.createNotFoundError(`Queue "${queueName}" not found in worker "${workerName}"`);
-        }
-        queueConfig.concurrency = concurrency;
-        // Update worker concurrency (requires restart in BullMQ)
-        await worker.close();
-        const newWorker = await createQueueWorker(workerName, queueConfig, mqw.config.processor);
-        mqw.workers.set(queueName, newWorker);
-        Logger.info(`Queue concurrency updated: ${queueName}`, { workerName, concurrency });
-    },
-    /**
-     * Get stats for a queue
-     */
-    async getQueueStats(workerName, queueName) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        const stats = mqw.stats.get(queueName);
-        if (!stats) {
-            throw ErrorFactory.createNotFoundError(`Stats for queue "${queueName}" not found in worker "${workerName}"`);
-        }
-        // Update waiting count from queue
-        PriorityQueue.getQueueInstance(queueName);
-        const queueInfo = await PriorityQueue.getQueueInfo(queueName);
-        stats.waiting = queueInfo.jobCounts.waiting;
-        return { ...stats };
-    },
-    /**
-     * Get stats for all queues
-     */
-    async getAllStats(workerName) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        const allStats = await Promise.all(Array.from(mqw.workers.keys()).map(async (queueName) => MultiQueueWorker.getQueueStats(workerName, queueName)));
-        return allStats;
-    },
-    /**
-     * Get configuration
-     */
-    getConfig(workerName) {
-        const mqw = multiQueueWorkers.get(workerName);
-        return mqw ? { ...mqw.config } : null;
-    },
-    /**
-     * List all multi-queue workers
-     */
-    list() {
-        return Array.from(multiQueueWorkers.keys());
-    },
-    /**
-     * Remove multi-queue worker
-     */
-    async remove(workerName) {
-        const mqw = multiQueueWorkers.get(workerName);
-        if (!mqw) {
-            throw ErrorFactory.createNotFoundError(`Multi-queue worker "${workerName}" not found`);
-        }
-        // Close all workers
-        const closePromises = Array.from(mqw.workers.values()).map(async (worker) => worker.close());
-        await Promise.all(closePromises);
-        multiQueueWorkers.delete(workerName);
-        Logger.info(`Multi-queue worker removed: ${workerName}`);
-    },
-    /**
-     * Shutdown all multi-queue workers
-     */
-    async shutdown() {
-        Logger.info('MultiQueueWorker shutting down...');
-        const shutdownPromises = Array.from(multiQueueWorkers.values()).map(async (mqw) => {
-            const closePromises = Array.from(mqw.workers.values()).map(async (worker) => worker.close());
-            await Promise.all(closePromises);
-        });
-        await Promise.all(shutdownPromises);
-        multiQueueWorkers.clear();
-        Logger.info('MultiQueueWorker shutdown complete');
-    },
-});
-// Graceful shutdown handled by WorkerShutdown