mollitia/dist/module/bulkhead.d.ts

JavaScript Resilience Library

import { Module, ModuleOptions } from './index.js';
import { Circuit, CircuitFunction } from '../circuit.js';
import { EventEmitter } from '../helpers/event.js';

/**
 * Properties that customizes the bulkhead behavior.
 */
export declare abstract class BulkheadOptions extends ModuleOptions {
    /**
     * The number of concurrent requests that can be running in parallel.
     */
    concurrentSize?: number;
    /**
     * The number of requests that can be queued.
     */
    queueSize?: number;
    /**
     * The amount of time before a queued request is rejected.
     */
    maxQueueWait?: number;
}
/**
 * Returned when a bulkhead module concurrent buffer and queue are overloaded.
 * @param message Circuit is overloaded
 */
export declare class BulkheadOverloadError extends Error {
    constructor();
}
/**
 * Returned when a bulkhead module request has been waiting for too long in queue.
 * @param message Waiting for too long in queue
 */
export declare class BulkheadQueueWaitError extends Error {
    constructor();
}
declare class BufferedPromise extends EventEmitter {
    private promise;
    private params;
    constructor(promise: CircuitFunction, ...params: any[]);
    execute<T>(): Promise<T>;
}
/**
 * The Bulkhead Module, that allows to limit concurrent executions.
 */
export declare class Bulkhead extends Module {
    /**
     * The number of concurrent requests that can be running in parallel.
     */
    concurrentSize: number;
    /**
     * The number of requests that can be queued.
     */
    queueSize: number;
    /**
     * The amount of time before a queued request is rejected.
     */
    maxQueueWait: number;
    concurrentBuffer: BufferedPromise[];
    queueBuffer: BufferedPromise[];
    constructor(options?: BulkheadOptions);
    execute<T>(circuit: Circuit, promise: CircuitFunction, ...params: any[]): Promise<T>;
    private _promiseBulkhead;
    private _addBufferedPromise;
}
export {};