wakaq/dist/wakaq.d.ts

Background task queue for Node backed by Redis, a super minimal Celery

/// <reference types="node" />
import { Callback, Redis, Result } from 'ioredis';
import { type ConnectionOptions } from 'tls';
import { Duration } from 'ts-duration';
import { type Logger } from 'winston';
import { CronTask } from './cronTask.js';
import { Level } from './logger.js';
import { WakaQueue } from './queue.js';
import { Task } from './task.js';
declare module 'ioredis' {
    interface RedisCommander<Context> {
        getetatasks(key: string, argv: string, callback?: Callback<string[]>): Result<string[], Context>;
    }
}
export interface RegisterTaskParams {
    name?: string;
    queue?: WakaQueue | string;
    maxRetries?: number;
    softTimeout?: Duration;
    hardTimeout?: Duration;
}
export interface WakaQParams {
    queues?: WakaQueue[];
    schedules?: CronTask[];
    host?: string;
    port?: number;
    db?: number;
    tls?: ConnectionOptions;
    concurrency?: string | number;
    excludeQueues?: string[];
    maxRetries?: number;
    softTimeout?: Duration | number;
    hardTimeout?: Duration | number;
    maxMemPercent?: number;
    maxTasksPerWorker?: number;
    connectTimeout?: number;
    commandTimeout?: number;
    keepAlive?: number;
    noDelay?: boolean;
    waitTimeout?: Duration | number;
    username?: string;
    password?: string;
    workerLogFile?: string;
    schedulerLogFile?: string;
    singleProcess?: boolean;
    workerLogLevel?: Level;
    schedulerLogLevel?: Level;
    afterWorkerStartedCallback?: () => Promise<void>;
    beforeTaskStartedCallback?: (task: Task) => Promise<void>;
    afterTaskFinishedCallback?: (task: Task) => Promise<void>;
}
export declare class WakaQ {
    tasks: Map<string, Task>;
    broker: Redis;
    queues: WakaQueue[];
    queuesByName: Map<string, WakaQueue>;
    queuesByKey: Map<string, WakaQueue>;
    softTimeout: Duration;
    hardTimeout: Duration;
    concurrency: number;
    schedules: CronTask[];
    excludeQueues: string[];
    maxRetries: number;
    connectTimeout: number;
    commandTimeout: number;
    keepAlive: number;
    noDelay: boolean;
    waitTimeout: Duration;
    maxMemPercent: number;
    maxTasksPerWorker: number;
    workerLogFile?: string;
    schedulerLogFile?: string;
    singleProcess: boolean;
    workerLogLevel: Level;
    schedulerLogLevel: Level;
    logger?: Logger;
    private _pubsub?;
    currentTask?: any;
    brokerKeys: string[];
    afterWorkerStartedCallback?: () => Promise<void>;
    beforeTaskStartedCallback?: (task: Task) => Promise<void>;
    afterTaskFinishedCallback?: (task: Task) => Promise<void>;
    broadcastKey: string;
    constructor(params?: WakaQParams);
    connect(): Promise<this>;
    disconnect(): void;
    task<TData = unknown>(fn: ((variables: TData) => Promise<void>) | ((variables?: TData) => Promise<void>), params?: RegisterTaskParams): Task<TData>;
    afterWorkerStarted(callback: () => Promise<void>): () => Promise<void>;
    beforeTaskStarted(callback: (task: Task) => Promise<void>): (task: Task) => Promise<void>;
    afterTaskFinished(callback: (task: Task) => Promise<void>): (task: Task) => Promise<void>;
    private _validateQueueNames;
    private _asDuration;
    enqueueAtFront(taskName: string, args: unknown, queue?: WakaQueue | string): Promise<void>;
    enqueueWithEta(taskName: string, args: unknown, eta: Date | Duration, queue?: WakaQueue | string): Promise<void>;
    enqueueAtEnd(taskName: string, args: unknown, queue?: WakaQueue | string, retry?: number): Promise<void>;
    broadcast(taskName: string, args: unknown): Promise<number>;
    sleep(duration: Duration): Promise<unknown>;
    pubsub(): Promise<Redis>;
    get defaultQueue(): WakaQueue;
    blockingDequeue(): Promise<{
        queueBrokerKey?: string;
        payload?: {
            name: string;
            args: any[];
            retry?: number;
        };
    }>;
    private _queueOrDefault;
    private _formatConcurrency;
    private _parseConcurrency;
}