@backgroundjs/core/dist/bun/queue/job-queue.d.ts

An extendible background job queue for js/ts applications

import { Job } from "../types.js";
import { JobStorage } from "../storage/base-storage.js";
import { JobHandler } from "../types.js";
export declare class JobQueue extends EventTarget {
    /**
     * Job handlers registered with this queue
     */
    protected handlers: Map<string, JobHandler>;
    protected storage: JobStorage;
    /**
     * Set of job IDs that are currently being processed
     */
    protected activeJobs: Set<string>;
    /**
     * Buffer that is filled based on prefetchBatchSize
     */
    protected readonly jobBuffer: Job[];
    protected preFetchBatchSize: number | undefined;
    /**
     * Number of jobs that can be processed concurrently
     */
    protected concurrency: number;
    /**
     * Interval in milliseconds at which to check for new jobs
     */
    private processing;
    private processingInterval;
    private intervalId?;
    protected name: string;
    protected maxRetries: number;
    protected logging: boolean;
    private lastPollingInterval;
    private pollingErrorCount;
    private intelligentPolling;
    private minInterval;
    private maxInterval;
    private emptyPollsCount;
    private maxEmptyPolls;
    private loadFactor;
    private maxConcurrency;
    protected isStopping: boolean;
    private isUpdatingInterval;
    private isStopped;
    constructor(storage: JobStorage, options?: {
        concurrency?: number;
        name?: string;
        processingInterval?: number;
        maxRetries?: number;
        logging?: boolean;
        intelligentPolling?: boolean;
        minInterval?: number;
        maxInterval?: number;
        maxEmptyPolls?: number;
        loadFactor?: number;
        maxConcurrency?: number;
        preFetchBatchSize?: number;
    });
    register<T, R>(name: string, handler: JobHandler<T, R>): void;
    add<T>(name: string, data: T, options?: {
        priority?: number;
        timeout?: number;
    }): Promise<Job<T>>;
    schedule<T>(name: string, data: T, scheduledAt: Date, options?: {
        timeout?: number;
    }): Promise<Job<T>>;
    scheduleIn<T>(name: string, data: T, delayMs: number): Promise<Job<T>>;
    getJob<T>(id: string): Promise<Job<T> | null>;
    getName(): string;
    start(): void;
    rollbackActiveJobs(): Promise<void>;
    stop(): Promise<void>;
    setProcessingInterval(ms: number): void;
    setConcurrency(level: number): void;
    /**
     * Process jobs with prefetching
     * Override the parent's protected method
     */
    protected processNextBatch(): Promise<void>;
    /**
     * Refill the job buffer when it's running low
     */
    protected refillJobBuffer(): Promise<void>;
    protected updatePollingInterval(hadJobs: boolean): void;
    protected processJob(job: Job): Promise<void>;
    protected scheduleNextRepeat(job: Job): Promise<void>;
    protected calculateNextExecutionTime(job: Job): Date | undefined;
    addRepeatable<T>(name: string, data: T, options: {
        every: number;
        unit: "seconds" | "minutes" | "hours" | "days" | "weeks" | "months";
        startDate?: Date;
        endDate?: Date;
        limit?: number;
        priority?: number;
        timeout?: number;
    }): Promise<Job<T>>;
}
//# sourceMappingURL=job-queue.d.ts.map