knock-mq/dist/queue.d.ts

Production-grade message queue implementation.

import { EventEmitter } from 'events';
export type QueuePriority = 'high' | 'normal' | 'low';
export type QueueStatus = 'queued' | 'processing' | 'delivered' | 'failed' | 'undeliverable' | 'cancelled';
export interface QueueItem<T = unknown> {
    id: string;
    priority: QueuePriority;
    data: T;
    metadata: {
        attempts: number;
        status: QueueStatus;
        queuedAt: Date;
        lastAttemptAt?: Date;
        nextAttemptAt?: Date;
        error?: string;
        expiresAt?: Date;
    };
}
export interface Logger {
    info(message: string, meta?: any): void;
    warn(message: string, meta?: any): void;
    error(message: string, error: Error, meta?: any): void;
}
export interface Monitoring {
    trackError(error: Error, context?: Record<string, any>): void;
}
export interface QueueStorage<T = unknown> {
    enqueue(item: QueueItem<T>): Promise<void>;
    updateStatus(id: string, status: QueueStatus): Promise<void>;
    complete(id: string, success: boolean): Promise<void>;
    moveToDeadLetter(id: string, reason: string): Promise<void>;
    getProcessingCounts(): Promise<Record<QueuePriority, number>>;
    findStuckProcessing(since: Date): Promise<QueueItem<T>[]>;
}
export interface QueueConfig<T> {
    name: string;
    maxRetries: number;
    backoffBaseMs: number;
    maxConcurrent: number;
    priorityConfig?: Record<QueuePriority, number>;
    timeoutMs: number;
    logger: Logger;
    monitoring?: Monitoring;
    storage: QueueStorage<T>;
}
export declare class Queue<T> extends EventEmitter {
    private readonly config;
    private processing;
    private stats;
    private circuitBreaker;
    private paused;
    constructor(config: QueueConfig<T>);
    pause(): void;
    resume(): void;
    enqueue(data: T, opts?: {
        id?: string;
        priority?: QueuePriority;
    }): Promise<string>;
    processNext(_processor: (item: QueueItem<T>) => Promise<{
        success: boolean;
    }>): Promise<void>;
    processItem(item: QueueItem<T>, processor: (item: QueueItem<T>) => Promise<{
        success: boolean;
    }>): Promise<void>;
    private handleFailure;
    private handleError;
    private handleTimeout;
    private clearProcessing;
    private calculateBackoff;
    private hasCapacity;
    private cleanupStuckItems;
    getStats(): {
        totalProcessed: number;
        totalErrors: number;
        averageProcessingTime: number;
        currentlyProcessing: number;
    };
}
//# sourceMappingURL=queue.d.ts.map