flowed/dist/resolver-library.js

A fast and reliable flow engine for orchestration and more uses in *Node.js*, *Deno* and the browser

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PauseResolver = exports.StopResolver = exports.LoopResolver = exports.ArrayMapResolver = exports.RepeaterResolver = exports.SubFlowResolver = exports.WaitResolver = exports.ConditionalResolver = exports.ThrowErrorResolver = exports.EchoResolver = exports.NoopResolver = void 0;
const engine_1 = require("./engine");
const task_process_1 = require("./engine/task-process");
class NoopResolver {
    exec() {
        return {};
    }
}
exports.NoopResolver = NoopResolver;
class EchoResolver {
    exec(params) {
        return { out: params.in };
    }
}
exports.EchoResolver = EchoResolver;
class ThrowErrorResolver {
    exec(params) {
        throw new Error(typeof params.message !== 'undefined' ? params.message : 'ThrowErrorResolver resolver has thrown an error');
    }
}
exports.ThrowErrorResolver = ThrowErrorResolver;
class ConditionalResolver {
    exec(params) {
        return params.condition ? { onTrue: params.trueResult } : { onFalse: params.falseResult };
    }
}
exports.ConditionalResolver = ConditionalResolver;
class WaitResolver {
    exec(params) {
        return new Promise(resolve => {
            setTimeout(() => {
                resolve({ result: params.result });
            }, params.ms);
        });
    }
}
exports.WaitResolver = WaitResolver;
class SubFlowResolver {
    async exec(params, context) {
        let flowResolvers = params.flowResolvers;
        if (typeof flowResolvers === 'undefined') {
            flowResolvers = context.$flowed.getResolvers();
        }
        let flowResult = await engine_1.FlowManager.run(params.flowSpec, params.flowParams, params.flowExpectedResults, flowResolvers, context, context.$flowed.flow.runStatus.runOptions);
        if (typeof params.uniqueResult === 'string') {
            flowResult = flowResult[params.uniqueResult];
        }
        return { flowResult };
    }
}
exports.SubFlowResolver = SubFlowResolver;
class RepeaterResolver {
    async exec(params, context, task, debug, log) {
        const resolver = context.$flowed.getResolverByName(params.resolver);
        if (resolver === null) {
            throw new Error(`Task resolver '${params.resolver}' for inner flowed::Repeater task has no definition.`);
        }
        const innerTask = new engine_1.Task('task-repeat-model', params.taskSpec);
        const resultPromises = [];
        let results = [];
        for (let i = 0; i < params.count; i++) {
            innerTask.resetRunStatus();
            innerTask.supplyReqs(params.taskParams);
            const process = new task_process_1.TaskProcess(context.$flowed.processManager, 0, innerTask, resolver, context, !!params.resolverAutomapParams, !!params.resolverAutomapResults, params.flowId, debug, log);
            const result = process.run();
            if (params.parallel) {
                resultPromises.push(result);
            }
            else {
                results.push(await result);
            }
        }
        if (params.parallel) {
            results = await Promise.all(resultPromises);
        }
        return { results };
    }
}
exports.RepeaterResolver = RepeaterResolver;
class ArrayMapResolver {
    async exec(params, context, task, debug, log) {
        const resolver = context.$flowed.getResolverByName(params.resolver);
        if (resolver === null) {
            throw new Error(`Task resolver '${params.resolver}' for inner flowed::ArrayMap task has no definition.`);
        }
        const innerTask = new engine_1.Task('task-loop-model', params.spec);
        const resultPromises = [];
        let results = [];
        for (const taskParams of params.params) {
            innerTask.resetRunStatus();
            innerTask.supplyReqs(taskParams);
            const process = new task_process_1.TaskProcess(context.$flowed.processManager, 0, innerTask, resolver, context, !!params.automapParams, !!params.automapResults, params.flowId, debug, log);
            const result = process.run();
            if (params.parallel) {
                resultPromises.push(result);
            }
            else {
                results.push(await result);
            }
        }
        if (params.parallel) {
            results = await Promise.all(resultPromises);
        }
        return { results };
    }
}
exports.ArrayMapResolver = ArrayMapResolver;
class LoopResolver {
    async exec(params, context, task, debug, log) {
        const resolverName = params.subtask.resolver.name;
        const resolver = context.$flowed.getResolverByName(resolverName);
        if (resolver === null) {
            throw new Error(`Task resolver '${resolverName}' for inner flowed::Loop task has no definition.`);
        }
        const innerTask = new engine_1.Task('task-loop-model', params.subtask);
        const resultPromises = [];
        let outCollection = [];
        for (const item of params.inCollection) {
            const taskParams = { [params.inItemName]: item };
            innerTask.resetRunStatus();
            innerTask.supplyReqs(taskParams);
            const process = new task_process_1.TaskProcess(context.$flowed.processManager, 0, innerTask, resolver, context, !!params.automapParams, !!params.automapResults, params.flowId, debug, log);
            const itemResultPromise = process.run();
            if (params.parallel) {
                resultPromises.push(itemResultPromise);
            }
            else {
                const itemResult = await itemResultPromise;
                outCollection.push(itemResult[params.outItemName]);
            }
        }
        if (params.parallel) {
            const outCollectionResults = await Promise.all(resultPromises);
            outCollection = outCollectionResults.map(itemResult => itemResult[params.outItemName]);
        }
        return { outCollection };
    }
}
exports.LoopResolver = LoopResolver;
class StopResolver {
    exec(params, context) {
        return { promise: context.$flowed.flow.stop() };
    }
}
exports.StopResolver = StopResolver;
class PauseResolver {
    exec(params, context) {
        return { promise: context.$flowed.flow.pause() };
    }
}
exports.PauseResolver = PauseResolver;
//# sourceMappingURL=resolver-library.js.map