@node-elion/utils/dist/types/actions/chainActions.d.ts

Super scalable enterprise Node.js server library

import { Logger } from "../logger";
export type ExecutorFunction = (...previousFunctionResults: any[]) => Promise<any>;
export type RollbackFunction = (options: {
    previousFunctionResults: any[];
    currentFunctionResult: any[];
}) => Promise<any>;
export type StoredActionStep = {
    executor: {
        call: ExecutorFunction;
    };
    rollback: {
        call: RollbackFunction;
    } | null;
    options: Required<StepOptions>;
};
export type StepOptions = {
    abortOnFail?: boolean;
    name?: string;
};
export type ChainActionParams = {
    logger?: Logger | false;
    chainName?: string;
    ableRollback?: boolean;
    optimizeSubChainActions?: boolean;
    usePreBind?: boolean;
};
export declare class BindFactory {
    additionalContext: any;
    executor: ExecutorFunction;
    constructor(executor: ExecutorFunction, additionalContext?: any);
    emulateFunction(): BindFactory;
    bind(context: any): BindFactory;
}
export type ExecutorBindFunction = (executor: ExecutorFunction, additionalContext?: any) => BindFactory;
export type RollbackBindFunction = (rollback: RollbackFunction, additionalContext?: any) => BindFactory;
export type StepFactoryFunction = (options: {
    executorBind: ExecutorBindFunction;
    rollbackBind: RollbackBindFunction;
}) => {
    executor: ExecutorFunction;
    rollback?: RollbackFunction;
    options?: StepOptions;
};
export default class ChainAction {
    private actions;
    __chainActions: boolean;
    private options;
    private logger;
    constructor(options?: ChainActionParams);
    private setExecutorContext;
    private setRollbackContext;
    step(executor: ExecutorFunction, rollback?: RollbackFunction, options?: StepOptions): ChainAction;
    stepFactory(factory: StepFactoryFunction): ChainAction;
    upgradeLogger(logger: Logger): ChainAction;
    execute(...params: any[]): void;
    private abort;
}