@cleotasks/core/dist/groups/taskGroup.d.ts

A distributed task queue system for Node.js, inspired by Celery and BullMQ

import { Redis } from "ioredis";
import { TaskStatus, GroupProcessingStrategy } from "../types/enums";
import type { Task, TaskOptions } from "../types/interfaces";
import type { Worker } from "../workers";
import { QueueManager } from "../queue/queueManager";
export interface GroupStats {
    total: number;
    active: number;
    completed: number;
    failed: number;
    paused: number;
}
export interface GroupConfig {
    name: string;
    concurrency?: number;
    maxConcurrency?: number;
    rateLimit?: {
        max: number;
        duration: number;
    };
    priority?: number;
    strategy?: GroupProcessingStrategy;
    retryDelay?: number;
    retryLimit?: number;
    timeout?: number;
}
export declare class TaskGroup {
    private redis;
    private groupKey;
    private stateKey;
    private processingKey;
    private processingOrderKey;
    private queueManager;
    private worker;
    private config;
    private rateLimitKey;
    private lockKey;
    private groupLock;
    private lockHolder;
    private isProcessing;
    private processingInterval;
    constructor(redis: Redis, config: GroupConfig);
    /**
     * Connect this group to a QueueManager and Worker
     */
    connect(queueManager: QueueManager, worker: Worker): void;
    private acquireLock;
    private releaseLock;
    private checkRateLimit;
    private trackRateLimit;
    addTask(methodName: string, taskOptions: TaskOptions, taskData: any): Promise<void>;
    getAllTasks(): Promise<[
        taskId: string,
        queue: string,
        taskData: any,
        taskMethod: string
    ][]>;
    private updateStats;
    removeTask(taskId: string): Promise<void>;
    getTasks(): Promise<string[]>;
    getTaskOptionsAndData(taskId: string): Promise<{
        options: TaskOptions;
        data: any;
        method: string | null;
    } | null>;
    getTasksWithDetails(): Promise<Task[]>;
    getTaskStatus(taskId: string): Promise<TaskStatus | null>;
    updateTaskStatus(taskId: string, status: TaskStatus): Promise<void>;
    private mapTaskStatusToState;
    getStats(): Promise<GroupStats>;
    getNextTask(): Promise<[
        string,
        string,
        any,
        string,
        TaskOptions
    ] | null>;
    processNextTask(): Promise<void>;
    startProcessing(): Promise<void>;
    stopProcessing(): Promise<void>;
    private processNextBatch;
    pauseAll(): Promise<void>;
    resumeAll(): Promise<void>;
    completeTask(taskId: string): Promise<void>;
    failTask(taskId: string, error: Error): Promise<void>;
    recoverStuckTasks(maxProcessingTime?: number): Promise<void>;
    cleanup(): Promise<void>;
    hasAvailableTasks(): Promise<boolean>;
    updateConfig(updates: Partial<GroupConfig>): Promise<void>;
}