peanar/dist/app.d.ts

A job queue for Node.js based on RabbitMQ

import Broker from './amqplib_compat/broker';
import Worker, { IWorkerResult } from './worker';
import PeanarJob from './job';
import { IConnectionParams } from 'ts-amqp/dist/interfaces/Connection';
import { Writable } from 'stream';
import Registry from './registry';
import PeanarTransactor from './transact';
import Consumer from './amqplib_compat/consumer';
import { Channel } from 'amqplib';
export interface IPeanarJobDefinitionInput {
    queue: string;
    name?: string;
    routingKey?: string;
    exchange?: string;
    replyTo?: string;
    handler: (...args: any[]) => Promise<any>;
    jobClass?: typeof PeanarJob;
    expires?: number;
    retry_exchange?: string;
    error_exchange?: string;
    max_retries?: number;
    retry_delay?: number;
    delayed_run_wait?: number;
    max_priority?: number;
    default_priority?: number;
}
export interface IPeanarJobDefinition {
    name: string;
    queue: string;
    handler: (...args: any[]) => Promise<any>;
    routingKey: string;
    exchange?: string;
    replyTo?: string;
    jobClass?: typeof PeanarJob;
    expires?: number;
    retry_exchange?: string;
    error_exchange?: string;
    max_retries?: number;
    retry_delay?: number;
    delayed_run_wait?: number;
    max_priority?: number;
    default_priority?: number;
}
export interface IPeanarRequest {
    id: string;
    name: string;
    args: any[];
    attempt: number;
    correlationId?: string;
    deliveryTag?: bigint;
    priority?: number;
}
export interface IPeanarJob extends IPeanarJobDefinition, IPeanarRequest {
    deliveryTag: bigint;
}
export interface IPeanarResponse {
    id: string;
    name: string;
    status: 'SUCCESS' | 'FAILURE';
    error?: unknown;
    result?: unknown;
}
export interface IPeanarOptions {
    connection?: IConnectionParams;
    poolSize?: number;
    prefetch?: number;
    jobClass?: typeof PeanarJob;
    logger?(...args: any[]): any;
}
interface IWorkerOptions {
    queues?: string[];
    concurrency?: number;
    prefetch?: number;
    outputWritable?: Writable;
    logger?: (msg: string) => void;
}
export declare enum EAppState {
    RUNNING = "RUNNING",
    CLOSING = "CLOSING",
    CLOSED = "CLOSED"
}
export default class PeanarApp {
    registry: Registry;
    log: (...args: any[]) => any;
    broker: Broker;
    jobClass: typeof PeanarJob;
    protected consumers: Map<string, Consumer[]>;
    protected workers: Map<string, Worker[]>;
    protected jobs: Map<string, (...args: unknown[]) => Promise<unknown>>;
    protected transactions: Set<PeanarTransactor>;
    state: EAppState;
    constructor(options?: IPeanarOptions);
    protected _shutdown(timeout?: number): Promise<void>;
    shutdown(timeout?: number): Promise<void>;
    protected _registerWorker(queue: string, worker: Worker): void;
    protected _registerConsumer(queue: string, consumer: Consumer): void;
    call(name: string, args: unknown[]): Promise<unknown>;
    protected _publish(routing_key: string, exchange: string | undefined, def: IPeanarJobDefinition, req: IPeanarRequest): Promise<string>;
    enqueueJobRequest(def: IPeanarJobDefinition, req: IPeanarRequest): Promise<string>;
    protected _enqueueJobResponse(job: PeanarJob, result: IWorkerResult): Promise<void>;
    protected _prepareJobRequest(name: string, args: any[]): IPeanarRequest;
    protected _prepareJobResponse(job: PeanarJob, result: IWorkerResult): IPeanarResponse;
    protected _createTransactor(def: IPeanarJobDefinition): () => PeanarTransactor;
    protected _createDelayedEnqueuer(def: IPeanarJobDefinition): (...args: unknown[]) => Promise<string>;
    protected _createEnqueuerWithPriority(def: IPeanarJobDefinition): (priority: number, ...args: unknown[]) => Promise<string>;
    protected _createEnqueuer(def: IPeanarJobDefinition): {
        (...args: unknown[]): Promise<string>;
        rpc(...args: unknown[]): Promise<void>;
        delayed: (...args: unknown[]) => Promise<string>;
        transaction: () => PeanarTransactor;
        withPriority: (priority: number, ...args: unknown[]) => Promise<string>;
    };
    job(def: IPeanarJobDefinitionInput): {
        (...args: unknown[]): Promise<string>;
        rpc(...args: unknown[]): Promise<void>;
        delayed: (...args: unknown[]) => Promise<string>;
        transaction: () => PeanarTransactor;
        withPriority: (priority: number, ...args: unknown[]) => Promise<string>;
    };
    declareAmqResources(): Promise<void>;
    pauseQueue(queue: string): void;
    resumeQueue(queue: string): void;
    protected _startWorker(queue: string, channel: Channel, consumer: Consumer, options?: Omit<IWorkerOptions, 'queues' | 'concurrency'>): Promise<Writable>;
    worker(options: IWorkerOptions): Promise<Writable[]>;
}
export {};