typepool/dist/ObjectPool.d.ts

Object pooling inspired by generic-pool - with Typing

import Deferred from "./Deferred";
export interface IPoolOptions {
    min?: number;
    max?: number;
    limit?: number;
}
export declare enum PoolResourceStatus {
    Created = 0,
    Ready = 1,
    Destroyed = 2
}
export interface IPoolResource<T> {
    resource: T;
    reserved: boolean;
    status: PoolResourceStatus;
}
export interface IPoolResourceInternal<T> extends IPoolResource<T> {
    createDeferred: Deferred<T>;
    destroyDeferred?: Deferred<T>;
}
export interface IPoolResourceFactory<T> {
    create(): Promise<T>;
    destroy(resource: T): Promise<void>;
    validate(resource: T): Promise<boolean>;
}
export declare class Pool<T> {
    private factory;
    private resources;
    private killed;
    private running;
    private readonly opts;
    constructor(factory: IPoolResourceFactory<T>, opts?: IPoolOptions);
    /**
     * Start the pool
     */
    private checkInventory;
    /**
     * Create a resource
     *
     * @returns {Promise<IPoolResource>}
     */
    private createResource;
    /**
     * is running
     *
     * @returns {boolean}
     */
    readonly isRunning: boolean;
    /**
     * is shutting down
     *
     * @returns {boolean}
     */
    readonly isShuttingDown: boolean;
    /**
     * is completely shutdown
     *
     * @returns {boolean}
     */
    readonly isShutdown: boolean;
    /**
     * Find a pooled resource record
     *
     * @param resource
     * @returns {IPoolResource}
     */
    private getPoolResource;
    /**
     * Get all resources
     *
     * @returns {List<IPoolResource>}
     */
    getResources(): Array<IPoolResource<T>>;
    /**
     * Get active not destroyed resources
     *
     * @returns {List<IPoolResource>}
     */
    getActiveResources(): Array<IPoolResource<T>>;
    /**
     * Get available - active + not reserved instances
     *
     * @returns {any}
     */
    getAvailableResources(): Array<IPoolResource<T>>;
    canCreateResource(): boolean;
    /**
     * Acquire a resource
     *
     * @returns {Promise<any>}
     */
    acquire(): Promise<T>;
    /**
     * Validate a resource is still valid
     *
     * @param resource
     * @returns {boolean|Promise<boolean>}
     */
    validate(resource: T): Promise<boolean>;
    /**
     * Release a resource
     *
     * @param resource
     * @returns {Promise<void>}
     */
    release(resource: T): Promise<void>;
    /**
     * Destroy a resource
     *
     * @param resource
     * @returns {Promise<void>}
     */
    destroy(resource: T): Promise<void>;
    /**
     * Drain the pool
     */
    drain(): Promise<void>;
}