flowie/dist/flowie3.js

Library for creating, and working with flows

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const immutable_1 = require("immutable");
const gensequence_1 = require("gensequence");
const _get = require("lodash.get");
const flowieResult3_1 = require("./flowieResult3");
function flowie(...flowFunctionsList) {
    const isSplit = flowFunctionsList.length > 1;
    if (!isSplit)
        return createFlowie([], flowFunctionsList[0]);
    const flowieFromFunctionList = flowFunctionsList.map(convertFlowFunctionToFlowie);
    const splittedFlowFunction = createSplittedFlowFunction(flowieFromFunctionList);
    const flowieForSplitFlow = flowie(splittedFlowFunction);
    return flowieForSplitFlow;
}
exports.flowie = flowie;
function createFlowie(previousFunctionsList, newFlowFunction) {
    const flowFunctionList = previousFunctionsList.concat(newFlowFunction);
    async function executeFlow(parameter) {
        return parameter;
    }
    // eslint-disable-next-line functional/immutable-data
    return Object.assign(executeFlow, {
        split(...flowieList) {
            const splittedFlowFunction = createSplittedFlowFunction(flowieList);
            const splittedFlowie = createFlowie(flowFunctionList, splittedFlowFunction);
            return splittedFlowie;
        },
        pipe(flowFunction) {
            return createFlowie(flowFunctionList, flowFunction);
        },
        async executeFlow(parameter) {
            const startTime = Date.now();
            const initialFunctionReport = {
                result: parameter,
                functionsReport: immutable_1.Map()
            };
            const { result, functionsReport } = await flowFunctionList.reduce(executeFlowStep, Promise.resolve(initialFunctionReport));
            return flowieResult3_1.default.success(result, startTime, functionsReport.toJS());
        }
    });
}
function createSplittedFlowFunction(flowieList) {
    return function executeSplittedFlow(argument) {
        const results = flowieList.map(getFlowFunctionResult, { argument });
        return Promise.all(results);
    };
}
async function getFlowFunctionResult(flowieItem) {
    const flowieResult = await flowieItem.executeFlow(this.argument);
    return flowieResult.result;
}
function convertFlowFunctionToFlowie(flowFunction) {
    return flowie(flowFunction);
}
async function executeFlowStep(previousValue, flowFunction) {
    // console.log('flowFunction.name', flowFunction.name)
    const previousFunctionReport = await previousValue;
    const startTime = Date.now();
    const nextFunction = _get(previousFunctionReport.result, 'next');
    if (typeof nextFunction === 'function') {
        const { result } = await gensequence_1.genSequence(previousFunctionReport.result)
            .reduceAsync(executeFlowFunctionForResultFromIterator, { flowFunction, result: null });
        const report = {
            executionTime: Date.now() - startTime
        };
        return {
            result,
            functionsReport: previousFunctionReport.functionsReport.set(flowFunction.name, report)
        };
    }
    const result = await flowFunction(previousFunctionReport.result);
    const report = {
        executionTime: Date.now() - startTime
    };
    return {
        result,
        functionsReport: previousFunctionReport.functionsReport.set(flowFunction.name, report)
    };
}
async function executeFlowFunctionForResultFromIterator({ flowFunction }, item) {
    const result = await flowFunction(item);
    return { result, flowFunction };
}
//# sourceMappingURL=flowie3.js.map