@steedos/objectql 3.0.13-beta.3 → 3.0.13-beta.32

package/lib/formula/core.js

@@ -1,244 +1,177 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFormulaFieldQuotingObjectAndFields = exports.updateQuotedByDocsForFormulaType = exports.updateDocsFieldFormulaValue = exports.updateQuotedByObjectFieldFormulaValue = exports.getCurrentObjectFieldFormulasDoc = exports.runQuotedByObjectFieldFormulas = exports.runAmisFormula = exports.isAmisFormula = exports.getAmisGlobalVariables = exports.runFormula = exports.evalFieldFormula = exports.computeFieldFormulaValue = exports.computeFormulaParams = exports.pickFormulaVarFields = exports.pickFieldFormulaVarFields = exports.pickFormulaVars = void 0;
-var tslib_1 = require("tslib");
-var index_1 = require("../index");
-var type_1 = require("./type");
-var field_formula_1 = require("./field_formula");
-var summary_1 = require("../summary");
-var util_1 = require("./util");
-var _ = require("lodash");
-var formula_1 = require("@steedos/formula");
-var params_1 = require("./params");
-var simple_params_1 = require("./simple_params");
-var amis_formula_1 = require("amis-formula");
+const index_1 = require("../index");
+const type_1 = require("./type");
+const field_formula_1 = require("./field_formula");
+const summary_1 = require("../summary");
+const util_1 = require("./util");
+const _ = require("lodash");
+const formula_1 = require("@steedos/formula");
+const params_1 = require("./params");
+const simple_params_1 = require("./simple_params");
+const amis_formula_1 = require("amis-formula");
 function convertToNestedObject(flatObject) {
-    var nestedObject = {};
-    for (var flatKey in flatObject) {
+    const nestedObject = {};
+    for (const flatKey in flatObject) {
         _.set(nestedObject, flatKey, flatObject[flatKey]);
     }
     return nestedObject;
 }
-var pickFormulaVars = function (formula) {
+const pickFormulaVars = (formula) => {
     return (0, formula_1.extract)(formula);
 };
 exports.pickFormulaVars = pickFormulaVars;
-var pickFieldFormulaVarFields = function (fieldFormulaConfigs) {
+const pickFieldFormulaVarFields = (fieldFormulaConfigs) => {
     if (!_.isArray(fieldFormulaConfigs)) {
         fieldFormulaConfigs = [fieldFormulaConfigs];
     }
-    var result = [];
-    fieldFormulaConfigs.forEach(function (fieldFormulaConfig) {
-        var vars = fieldFormulaConfig.vars;
+    let result = [];
+    fieldFormulaConfigs.forEach((fieldFormulaConfig) => {
+        let { vars } = fieldFormulaConfig;
         result = _.union(result, (0, exports.pickFormulaVarFields)(vars));
     });
     return _.uniq(result);
 };
 exports.pickFieldFormulaVarFields = pickFieldFormulaVarFields;
-var pickFormulaVarFields = function (vars) {
-    var result = [];
-    vars.forEach(function (varItem) {
+const pickFormulaVarFields = (vars) => {
+    let result = [];
+    vars.forEach((varItem) => {
         if (varItem.paths.length) {
-            var firstPath = varItem.paths[0];
-            var firstKey = firstPath.field_name;
+            let firstPath = varItem.paths[0];
+            let firstKey = firstPath.field_name;
             result.push(firstKey);
         }
     });
     return _.uniq(result);
 };
 exports.pickFormulaVarFields = pickFormulaVarFields;
-var computeFormulaParams = function (doc, vars, userSession) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var params, spaceId, currentUserId, _loop_1, vars_1, vars_1_1, _a, key, paths, isUserVar, isUserSessionVar, isSimpleVar, e_1_1;
-    var e_1, _b;
-    return tslib_1.__generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                params = [];
-                spaceId = userSession === null || userSession === void 0 ? void 0 : userSession.spaceId;
-                currentUserId = userSession === null || userSession === void 0 ? void 0 : userSession.userId;
-                if (!(vars && vars.length)) return [3, 8];
-                _loop_1 = function (key, paths, isUserVar, isUserSessionVar, isSimpleVar) {
-                    var tempValue;
-                    return tslib_1.__generator(this, function (_d) {
-                        switch (_d.label) {
-                            case 0:
-                                key = key.trim();
-                                tempValue = void 0;
-                                if (isUserVar || isUserSessionVar) {
-                                    if (!userSession) {
-                                        throw new Error("computeFormulaParams:The param 'userSession' is required for the formula var key ".concat(key, " while running"));
-                                    }
-                                }
-                                if (isSimpleVar) {
-                                    tempValue = doc[key];
-                                    params.push({
-                                        key: key,
-                                        value: tempValue,
-                                    });
-                                    return [2, "continue"];
-                                }
-                                if (isUserSessionVar) {
-                                    tempValue = _.reduce(key.split("."), function (reslut, next, index) {
-                                        if (index === 0) {
-                                            return reslut;
-                                        }
-                                        else {
-                                            return reslut[next];
-                                        }
-                                    }, userSession);
-                                    params.push({
-                                        key: key,
-                                        value: tempValue,
-                                    });
-                                    return [2, "continue"];
-                                }
-                                return [4, (function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-                                        var reslut, lastReferenceToField, index, next, sus, found;
-                                        return tslib_1.__generator(this, function (_a) {
-                                            switch (_a.label) {
-                                                case 0:
-                                                    reslut = null;
-                                                    lastReferenceToField = null;
-                                                    index = 0;
-                                                    _a.label = 1;
-                                                case 1:
-                                                    if (!(index < paths.length)) return [3, 11];
-                                                    next = paths[index];
-                                                    if (!(index === 0)) return [3, 5];
-                                                    lastReferenceToField = next.reference_to_field;
-                                                    if (!isUserVar) return [3, 3];
-                                                    return [4, (0, index_1.getSteedosSchema)()
-                                                            .getObject("space_users")
-                                                            .find({
-                                                            filters: [
-                                                                ["user", "=", currentUserId],
-                                                                ["space", "=", spaceId],
-                                                            ],
-                                                            fields: [next.field_name],
-                                                        })];
-                                                case 2:
-                                                    sus = _a.sent();
-                                                    reslut = sus && sus.length && sus[0];
-                                                    if (reslut) {
-                                                        reslut = reslut[next.field_name];
-                                                    }
-                                                    else {
-                                                        reslut = null;
-                                                    }
-                                                    return [3, 4];
-                                                case 3:
-                                                    reslut = doc[next.field_name];
-                                                    _a.label = 4;
-                                                case 4: return [3, 10];
-                                                case 5:
-                                                    if (!reslut) {
-                                                        return [3, 11];
-                                                    }
-                                                    found = void 0;
-                                                    if (!(lastReferenceToField && lastReferenceToField !== "_id")) return [3, 7];
-                                                    return [4, (0, index_1.getSteedosSchema)()
-                                                            .getObject(next.reference_from)
-                                                            .findOne({ filters: [lastReferenceToField, "=", reslut] }, { fields: [next.field_name] })];
-                                                case 6:
-                                                    found = _a.sent();
-                                                    return [3, 9];
-                                                case 7: return [4, (0, index_1.getSteedosSchema)()
-                                                        .getObject(next.reference_from)
-                                                        .findOne(reslut, { fields: [next.field_name] })];
-                                                case 8:
-                                                    found = _a.sent();
-                                                    _a.label = 9;
-                                                case 9:
-                                                    lastReferenceToField = next.reference_to_field;
-                                                    if (found) {
-                                                        reslut = found[next.field_name];
-                                                    }
-                                                    else {
-                                                        reslut = null;
-                                                    }
-                                                    _a.label = 10;
-                                                case 10:
-                                                    index++;
-                                                    return [3, 1];
-                                                case 11: return [2, reslut];
-                                            }
-                                        });
-                                    }); })()];
-                            case 1:
-                                tempValue = _d.sent();
-                                params.push({
-                                    key: key,
-                                    path: _.last(paths),
-                                    value: tempValue,
-                                });
-                                return [2];
+const computeFormulaParams = async (doc, vars, userSession) => {
+    let params = [];
+    const spaceId = userSession?.spaceId;
+    const currentUserId = userSession?.userId;
+    if (vars && vars.length) {
+        for (let { key, paths, is_user_var: isUserVar, is_user_session_var: isUserSessionVar, is_simple_var: isSimpleVar, } of vars) {
+            key = key.trim();
+            let tempValue;
+            if (isUserVar || isUserSessionVar) {
+                if (!userSession) {
+                    throw new Error(`computeFormulaParams:The param 'userSession' is required for the formula var key ${key} while running`);
+                }
+            }
+            if (isSimpleVar) {
+                tempValue = doc[key];
+                params.push({
+                    key: key,
+                    value: tempValue,
+                });
+                continue;
+            }
+            if (isUserSessionVar) {
+                tempValue = _.reduce(key.split("."), function (reslut, next, index) {
+                    if (index === 0) {
+                        return reslut;
+                    }
+                    else {
+                        return reslut[next];
+                    }
+                }, userSession);
+                params.push({
+                    key: key,
+                    value: tempValue,
+                });
+                continue;
+            }
+            tempValue = await (async () => {
+                let reslut = null;
+                let lastReferenceToField = null;
+                for (let index = 0; index < paths.length; index++) {
+                    let next = paths[index];
+                    if (index === 0) {
+                        lastReferenceToField = next.reference_to_field;
+                        if (isUserVar) {
+                            const sus = await (0, index_1.getSteedosSchema)()
+                                .getObject("space_users")
+                                .find({
+                                filters: [
+                                    ["user", "=", currentUserId],
+                                    ["space", "=", spaceId],
+                                ],
+                                fields: [next.field_name],
+                            });
+                            reslut = sus && sus.length && sus[0];
+                            if (reslut) {
+                                reslut = reslut[next.field_name];
+                            }
+                            else {
+                                reslut = null;
+                            }
                         }
-                    });
-                };
-                _c.label = 1;
-            case 1:
-                _c.trys.push([1, 6, 7, 8]);
-                vars_1 = tslib_1.__values(vars), vars_1_1 = vars_1.next();
-                _c.label = 2;
-            case 2:
-                if (!!vars_1_1.done) return [3, 5];
-                _a = vars_1_1.value, key = _a.key, paths = _a.paths, isUserVar = _a.is_user_var, isUserSessionVar = _a.is_user_session_var, isSimpleVar = _a.is_simple_var;
-                return [5, _loop_1(key, paths, isUserVar, isUserSessionVar, isSimpleVar)];
-            case 3:
-                _c.sent();
-                _c.label = 4;
-            case 4:
-                vars_1_1 = vars_1.next();
-                return [3, 2];
-            case 5: return [3, 8];
-            case 6:
-                e_1_1 = _c.sent();
-                e_1 = { error: e_1_1 };
-                return [3, 8];
-            case 7:
-                try {
-                    if (vars_1_1 && !vars_1_1.done && (_b = vars_1.return)) _b.call(vars_1);
+                        else {
+                            reslut = doc[next.field_name];
+                        }
+                    }
+                    else {
+                        if (!reslut) {
+                            break;
+                        }
+                        let found;
+                        if (lastReferenceToField && lastReferenceToField !== "_id") {
+                            found = await (0, index_1.getSteedosSchema)()
+                                .getObject(next.reference_from)
+                                .findOne({ filters: [lastReferenceToField, "=", reslut] }, { fields: [next.field_name] });
+                        }
+                        else {
+                            found = await (0, index_1.getSteedosSchema)()
+                                .getObject(next.reference_from)
+                                .findOne(reslut, { fields: [next.field_name] });
+                        }
+                        lastReferenceToField = next.reference_to_field;
+                        if (found) {
+                            reslut = found[next.field_name];
+                        }
+                        else {
+                            reslut = null;
+                        }
+                    }
                 }
-                finally { if (e_1) throw e_1.error; }
-                return [7];
-            case 8: return [2, params];
+                return reslut;
+            })();
+            params.push({
+                key: key,
+                path: _.last(paths),
+                value: tempValue,
+            });
         }
-    });
-}); };
+    }
+    return params;
+};
 exports.computeFormulaParams = computeFormulaParams;
-var computeFieldFormulaValue = function (doc, fieldFormulaConfig, userSession) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var formula, vars, data_type, formula_blank_value, params;
-    return tslib_1.__generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (!userSession) {
-                    (0, util_1.checkUserSessionNotRequiredForFieldFormulas)(fieldFormulaConfig);
-                }
-                formula = fieldFormulaConfig.formula, vars = fieldFormulaConfig.vars, data_type = fieldFormulaConfig.data_type, formula_blank_value = fieldFormulaConfig.formula_blank_value;
-                return [4, (0, exports.computeFormulaParams)(doc, vars, userSession)];
-            case 1:
-                params = _a.sent();
-                return [2, (0, exports.runFormula)(formula, params, {
-                        returnType: data_type,
-                        blankValue: formula_blank_value,
-                        record: doc,
-                        userSession: userSession,
-                    }, fieldFormulaConfig)];
-        }
-    });
-}); };
+const computeFieldFormulaValue = async (doc, fieldFormulaConfig, userSession) => {
+    if (!userSession) {
+        (0, util_1.checkUserSessionNotRequiredForFieldFormulas)(fieldFormulaConfig);
+    }
+    const { formula, vars, data_type, formula_blank_value } = fieldFormulaConfig;
+    let params = await (0, exports.computeFormulaParams)(doc, vars, userSession);
+    return (0, exports.runFormula)(formula, params, {
+        returnType: data_type,
+        blankValue: formula_blank_value,
+        record: doc,
+        userSession: userSession,
+    }, fieldFormulaConfig);
+};
 exports.computeFieldFormulaValue = computeFieldFormulaValue;
-var evalFieldFormula = function (formula, formulaParams) {
+const evalFieldFormula = function (formula, formulaParams) {
     try {
         return (0, formula_1.parse)(formula, formulaParams);
     }
     catch (ex) {
         formulaParams[type_1.FormulaUserKey] = "{...}";
-        throw new Error("evalFieldFormula:Catch an error \"".concat(ex, "\" while eval formula \"").concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\""));
+        throw new Error(`evalFieldFormula:Catch an error "${ex}" while eval formula "${formula}" with params "${JSON.stringify(formulaParams)}"`);
     }
 };
 exports.evalFieldFormula = evalFieldFormula;
-var runFormula = function (formula, params, options, messageTag) {
+const runFormula = function (formula, params, options, messageTag) {
     if ((0, exports.isAmisFormula)(formula)) {
         return (0, exports.runAmisFormula)(formula, params, options, messageTag);
     }
@@ -247,7 +180,7 @@ var runFormula = function (formula, params, options, messageTag) {
     }
 };
 exports.runFormula = runFormula;
-var getAmisGlobalVariables = function (userSession) {
+const getAmisGlobalVariables = (userSession) => {
     if (!userSession) {
         return {};
     }
@@ -260,40 +193,39 @@ var getAmisGlobalVariables = function (userSession) {
     };
 };
 exports.getAmisGlobalVariables = getAmisGlobalVariables;
-var isAmisFormula = function (formula) {
+const isAmisFormula = (formula) => {
     return /\$\{.+\}/.test(formula);
 };
 exports.isAmisFormula = isAmisFormula;
-var runAmisFormula = function (formula, params, options, messageTag) {
-    var record = options.record, userSession = options.userSession;
+const runAmisFormula = function (formula, params, options, messageTag) {
+    const { record, userSession } = options;
     try {
-        var globalVariables = (0, exports.getAmisGlobalVariables)(userSession);
-        var data_1 = {};
-        _.each(params, function (item) {
-            data_1[item.key] = item.value;
+        const globalVariables = (0, exports.getAmisGlobalVariables)(userSession);
+        let data = {};
+        _.each(params, (item) => {
+            data[item.key] = item.value;
         });
-        data_1 = convertToNestedObject(data_1);
-        var amisFormulaValue = (0, amis_formula_1.evaluate)(formula, Object.assign({}, globalVariables, record, data_1), {});
+        data = convertToNestedObject(data);
+        const amisFormulaValue = (0, amis_formula_1.evaluate)(formula, Object.assign({}, globalVariables, record, data), {});
         if (formula === amisFormulaValue) {
-            throw new Error("Amis formula \"".concat(formula, "\" evaluate failed \"Function is not defined\"."));
+            throw new Error(`Amis formula "${formula}" evaluate failed "Function is not defined".`);
         }
         else {
             return amisFormulaValue;
         }
     }
     catch (e) {
-        throw new Error("Catch an error \"".concat(e.message, "\" while evaluate amis formula \"").concat(formula, "\"."));
+        throw new Error(`Catch an error "${e.message}" while evaluate amis formula "${formula}".`);
     }
 };
 exports.runAmisFormula = runAmisFormula;
-var runSFFormula = function (formula, params, options, messageTag) {
+const runSFFormula = function (formula, params, options, messageTag) {
     if (!options) {
         options = {};
     }
-    var returnType = options.returnType, blankValue = options.blankValue;
-    var formulaParams = {};
-    params.forEach(function (_a) {
-        var key = _a.key, path = _a.path, value = _a.value;
+    let { returnType, blankValue } = options;
+    let formulaParams = {};
+    params.forEach(({ key, path, value }) => {
         if (path) {
             formulaParams[key] = (0, params_1.getFieldSubstitution)(path.reference_from, path.field_name, value, blankValue);
         }
@@ -301,12 +233,12 @@ var runSFFormula = function (formula, params, options, messageTag) {
             formulaParams[key] = (0, simple_params_1.getSimpleParamSubstitution)(value, blankValue);
         }
     });
-    var result = (0, exports.evalFieldFormula)(formula, formulaParams);
-    var formulaValue = result.value;
-    var formulaValueType = result.dataType;
+    let result = (0, exports.evalFieldFormula)(formula, formulaParams);
+    let formulaValue = result.value;
+    let formulaValueType = result.dataType;
     if (result.type === "error") {
         console.error(formula, formulaParams);
-        throw new Error("runFormula:Catch an error \"".concat(result.message, "\" while eval formula \"").concat(formula, "\" with params: \"").concat(JSON.stringify(formulaParams), "\" for \"").concat(JSON.stringify(messageTag), "\""));
+        throw new Error(`runFormula:Catch an error "${result.message}" while eval formula "${formula}" with params: "${JSON.stringify(formulaParams)}" for "${JSON.stringify(messageTag)}"`);
     }
     if (formulaValueType === "number" && _.isNaN(formulaValue)) {
         formulaValue = null;
@@ -315,46 +247,46 @@ var runSFFormula = function (formula, params, options, messageTag) {
         switch (returnType) {
             case "boolean":
                 if (formulaValueType !== "checkbox") {
-                    throw new Error("runFormula:The field formula \"".concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\" should return a boolean type result but got a ").concat(formulaValueType, " type value '").concat(formulaValue, "'."));
+                    throw new Error(`runFormula:The field formula "${formula}" with params "${JSON.stringify(formulaParams)}" should return a boolean type result but got a ${formulaValueType} type value '${formulaValue}'.`);
                 }
                 break;
             case "number":
                 if (formulaValueType !== "number") {
-                    throw new Error("runFormula:The field formula \"".concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\" should return a number type result but got a ").concat(formulaValueType, " type value '").concat(formulaValue, "'."));
+                    throw new Error(`runFormula:The field formula "${formula}" with params "${JSON.stringify(formulaParams)}" should return a number type result but got a ${formulaValueType} type value '${formulaValue}'.`);
                 }
                 break;
             case "currency":
                 if (formulaValueType !== "number") {
-                    throw new Error("runFormula:The field formula \"".concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\" should return a number type result but got a ").concat(formulaValueType, " type value '").concat(formulaValue, "'."));
+                    throw new Error(`runFormula:The field formula "${formula}" with params "${JSON.stringify(formulaParams)}" should return a number type result but got a ${formulaValueType} type value '${formulaValue}'.`);
                 }
                 break;
             case "percent":
                 if (formulaValueType !== "number") {
-                    throw new Error("runFormula:The field formula \"".concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\" should return a number type result but got a ").concat(formulaValueType, " type value '").concat(formulaValue, "'."));
+                    throw new Error(`runFormula:The field formula "${formula}" with params "${JSON.stringify(formulaParams)}" should return a number type result but got a ${formulaValueType} type value '${formulaValue}'.`);
                 }
                 break;
             case "text":
                 if (formulaValueType !== "text") {
-                    throw new Error("runFormula:The field formula \"".concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\" should return a string type result but got a ").concat(formulaValueType, " type value '").concat(formulaValue, "'."));
+                    throw new Error(`runFormula:The field formula "${formula}" with params "${JSON.stringify(formulaParams)}" should return a string type result but got a ${formulaValueType} type value '${formulaValue}'.`);
                 }
                 break;
             case "date":
                 if (formulaValueType !== "date") {
-                    throw new Error("runFormula:The field formula \"".concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\" should return a date type result but got a ").concat(formulaValueType, " type value '").concat(formulaValue, "'."));
+                    throw new Error(`runFormula:The field formula "${formula}" with params "${JSON.stringify(formulaParams)}" should return a date type result but got a ${formulaValueType} type value '${formulaValue}'.`);
                 }
                 break;
             case "datetime":
                 if (formulaValueType !== "datetime") {
-                    throw new Error("runFormula:The field formula \"".concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\" should return a date type result but got a ").concat(formulaValueType, " type value '").concat(formulaValue, "'."));
+                    throw new Error(`runFormula:The field formula "${formula}" with params "${JSON.stringify(formulaParams)}" should return a date type result but got a ${formulaValueType} type value '${formulaValue}'.`);
                 }
                 break;
         }
     }
     return formulaValue;
 };
-var addToAggregatePaths = function (varItemToAggregatePaths, toAggregatePaths) {
-    var pathLength = varItemToAggregatePaths.length;
-    var existPath = toAggregatePaths.find(function (item) {
+const addToAggregatePaths = (varItemToAggregatePaths, toAggregatePaths) => {
+    const pathLength = varItemToAggregatePaths.length;
+    let existPath = toAggregatePaths.find((item) => {
         return (JSON.stringify(item.slice(0, pathLength)) ===
             JSON.stringify(varItemToAggregatePaths.slice(0, pathLength)));
     });
@@ -362,378 +294,159 @@ var addToAggregatePaths = function (varItemToAggregatePaths, toAggregatePaths) {
         toAggregatePaths.push(varItemToAggregatePaths);
     }
 };
-var runQuotedByObjectFieldFormulas = function (objectName_1, recordId_1, userSession_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function (objectName, recordId, userSession, options) {
-        var fieldNames, escapeConfigs, quotedByConfigs, onlyForOwn, withoutCurrent, _a, _b, config, e_2_1;
-        var e_2, _c;
-        if (options === void 0) { options = {}; }
-        return tslib_1.__generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    fieldNames = options.fieldNames, escapeConfigs = options.escapeConfigs, quotedByConfigs = options.quotedByConfigs, onlyForOwn = options.onlyForOwn, withoutCurrent = options.withoutCurrent;
-                    if (!!quotedByConfigs) return [3, 2];
-                    return [4, (0, field_formula_1.getObjectQuotedByFieldFormulaConfigs)(objectName, fieldNames, escapeConfigs, { onlyForOwn: onlyForOwn, withoutCurrent: withoutCurrent })];
-                case 1:
-                    quotedByConfigs = _d.sent();
-                    _d.label = 2;
-                case 2:
-                    if (!quotedByConfigs.allConfigs.length) {
-                        return [2];
-                    }
-                    if (!userSession) {
-                        (0, util_1.checkUserSessionNotRequiredForFieldFormulas)(quotedByConfigs.allConfigs);
-                    }
-                    _d.label = 3;
-                case 3:
-                    _d.trys.push([3, 8, 9, 10]);
-                    _a = tslib_1.__values(quotedByConfigs.allConfigs), _b = _a.next();
-                    _d.label = 4;
-                case 4:
-                    if (!!_b.done) return [3, 7];
-                    config = _b.value;
-                    return [4, (0, exports.updateQuotedByObjectFieldFormulaValue)(objectName, recordId, config, userSession, quotedByConfigs.ownConfigs)];
-                case 5:
-                    _d.sent();
-                    _d.label = 6;
-                case 6:
-                    _b = _a.next();
-                    return [3, 4];
-                case 7: return [3, 10];
-                case 8:
-                    e_2_1 = _d.sent();
-                    e_2 = { error: e_2_1 };
-                    return [3, 10];
-                case 9:
-                    try {
-                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                    return [7];
-                case 10: return [2];
-            }
-        });
-    });
+const runQuotedByObjectFieldFormulas = async function (objectName, recordId, userSession, options = {}) {
+    let { fieldNames, escapeConfigs, quotedByConfigs, onlyForOwn, withoutCurrent, } = options;
+    if (!quotedByConfigs) {
+        quotedByConfigs = await (0, field_formula_1.getObjectQuotedByFieldFormulaConfigs)(objectName, fieldNames, escapeConfigs, { onlyForOwn, withoutCurrent });
+    }
+    if (!quotedByConfigs.allConfigs.length) {
+        return;
+    }
+    if (!userSession) {
+        (0, util_1.checkUserSessionNotRequiredForFieldFormulas)(quotedByConfigs.allConfigs);
+    }
+    for (const config of quotedByConfigs.allConfigs) {
+        await (0, exports.updateQuotedByObjectFieldFormulaValue)(objectName, recordId, config, userSession, quotedByConfigs.ownConfigs);
+    }
 };
 exports.runQuotedByObjectFieldFormulas = runQuotedByObjectFieldFormulas;
-var getCurrentObjectFieldFormulasDoc = function (objectName, doc, userSession, configs) {
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var setDoc, configs_1, configs_1_1, config, _a, _b, e_3_1;
-        var e_3, _c;
-        return tslib_1.__generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    if (!!configs) return [3, 2];
-                    return [4, (0, field_formula_1.getObjectFieldFormulaConfigs)(objectName)];
-                case 1:
-                    configs = _d.sent();
-                    _d.label = 2;
-                case 2:
-                    if (!configs.length) {
-                        return [2];
-                    }
-                    if (!userSession) {
-                        (0, util_1.checkUserSessionNotRequiredForFieldFormulas)(configs);
-                    }
-                    setDoc = {};
-                    _d.label = 3;
-                case 3:
-                    _d.trys.push([3, 8, 9, 10]);
-                    configs_1 = tslib_1.__values(configs), configs_1_1 = configs_1.next();
-                    _d.label = 4;
-                case 4:
-                    if (!!configs_1_1.done) return [3, 7];
-                    config = configs_1_1.value;
-                    doc = Object.assign({}, doc, setDoc);
-                    _a = setDoc;
-                    _b = config.field_name;
-                    return [4, (0, exports.computeFieldFormulaValue)(doc, config, userSession)];
-                case 5:
-                    _a[_b] = _d.sent();
-                    _d.label = 6;
-                case 6:
-                    configs_1_1 = configs_1.next();
-                    return [3, 4];
-                case 7: return [3, 10];
-                case 8:
-                    e_3_1 = _d.sent();
-                    e_3 = { error: e_3_1 };
-                    return [3, 10];
-                case 9:
-                    try {
-                        if (configs_1_1 && !configs_1_1.done && (_c = configs_1.return)) _c.call(configs_1);
-                    }
-                    finally { if (e_3) throw e_3.error; }
-                    return [7];
-                case 10: return [2, setDoc];
-            }
-        });
-    });
+const getCurrentObjectFieldFormulasDoc = async function (objectName, doc, userSession, configs) {
+    if (!configs) {
+        configs = await (0, field_formula_1.getObjectFieldFormulaConfigs)(objectName);
+    }
+    if (!configs.length) {
+        return;
+    }
+    if (!userSession) {
+        (0, util_1.checkUserSessionNotRequiredForFieldFormulas)(configs);
+    }
+    let setDoc = {};
+    for (const config of configs) {
+        doc = Object.assign({}, doc, setDoc);
+        setDoc[config.field_name] = await (0, exports.computeFieldFormulaValue)(doc, config, userSession);
+    }
+    return setDoc;
 };
 exports.getCurrentObjectFieldFormulasDoc = getCurrentObjectFieldFormulasDoc;
-var updateQuotedByObjectFieldFormulaValue = function (objectName, recordId, fieldFormulaConfig, userSession, escapeConfigs) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var vars, fieldFormulaObjectName, currentObject, fieldFormulaObject, toAggregatePaths, vars_2, vars_2_1, varItem, paths, isInPaths, varItemToAggregatePaths, paths_1, paths_1_1, pathItem, formulaVarFields, toAggregatePaths_1, toAggregatePaths_1_1, toAggregatePathsItem, tempPath, doc, referenceToValue, record, docs, aggregateLookups, lastLookup, referenceToValue, record, aggregateFilters, docs, e_4_1;
-    var e_5, _a, e_6, _b, e_4, _c;
-    return tslib_1.__generator(this, function (_d) {
-        switch (_d.label) {
-            case 0:
-                vars = fieldFormulaConfig.vars, fieldFormulaObjectName = fieldFormulaConfig.object_name;
-                currentObject = (0, index_1.getSteedosSchema)().getObject(objectName);
-                fieldFormulaObject = (0, index_1.getSteedosSchema)().getObject(fieldFormulaObjectName);
-                toAggregatePaths = [];
-                try {
-                    for (vars_2 = tslib_1.__values(vars), vars_2_1 = vars_2.next(); !vars_2_1.done; vars_2_1 = vars_2.next()) {
-                        varItem = vars_2_1.value;
-                        paths = varItem.paths;
-                        isInPaths = false;
-                        varItemToAggregatePaths = [];
-                        try {
-                            for (paths_1 = (e_6 = void 0, tslib_1.__values(paths)), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
-                                pathItem = paths_1_1.value;
-                                varItemToAggregatePaths.push(pathItem);
-                                if (pathItem.reference_from === objectName) {
-                                    isInPaths = true;
-                                    break;
-                                }
-                            }
-                        }
-                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                        finally {
-                            try {
-                                if (paths_1_1 && !paths_1_1.done && (_b = paths_1.return)) _b.call(paths_1);
-                            }
-                            finally { if (e_6) throw e_6.error; }
-                        }
-                        if (isInPaths) {
-                            addToAggregatePaths(varItemToAggregatePaths, toAggregatePaths);
-                        }
-                    }
-                }
-                catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                finally {
-                    try {
-                        if (vars_2_1 && !vars_2_1.done && (_a = vars_2.return)) _a.call(vars_2);
-                    }
-                    finally { if (e_5) throw e_5.error; }
-                }
-                formulaVarFields = (0, exports.pickFieldFormulaVarFields)(fieldFormulaConfig);
-                _d.label = 1;
-            case 1:
-                _d.trys.push([1, 18, 19, 20]);
-                toAggregatePaths_1 = tslib_1.__values(toAggregatePaths), toAggregatePaths_1_1 = toAggregatePaths_1.next();
-                _d.label = 2;
-            case 2:
-                if (!!toAggregatePaths_1_1.done) return [3, 17];
-                toAggregatePathsItem = toAggregatePaths_1_1.value;
-                if (!(toAggregatePathsItem.length < 3)) return [3, 11];
-                tempPath = toAggregatePathsItem[0];
-                if (!(fieldFormulaObjectName === objectName &&
-                    tempPath.reference_from === objectName)) return [3, 5];
-                return [4, fieldFormulaObject.findOne(recordId, {
-                        fields: formulaVarFields,
-                    })];
-            case 3:
-                doc = _d.sent();
-                return [4, (0, exports.updateDocsFieldFormulaValue)(doc, fieldFormulaConfig, userSession, escapeConfigs)];
-            case 4:
-                _d.sent();
-                return [3, 10];
-            case 5:
-                referenceToValue = recordId;
-                if (!(tempPath.reference_to_field &&
-                    tempPath.reference_to_field !== "_id")) return [3, 7];
-                return [4, currentObject.findOne(recordId, {
+const updateQuotedByObjectFieldFormulaValue = async (objectName, recordId, fieldFormulaConfig, userSession, escapeConfigs) => {
+    const { vars, object_name: fieldFormulaObjectName } = fieldFormulaConfig;
+    const currentObject = (0, index_1.getSteedosSchema)().getObject(objectName);
+    const fieldFormulaObject = (0, index_1.getSteedosSchema)().getObject(fieldFormulaObjectName);
+    let toAggregatePaths = [];
+    for (let varItem of vars) {
+        const { paths } = varItem;
+        let isInPaths = false;
+        let varItemToAggregatePaths = [];
+        for (let pathItem of paths) {
+            varItemToAggregatePaths.push(pathItem);
+            if (pathItem.reference_from === objectName) {
+                isInPaths = true;
+                break;
+            }
+        }
+        if (isInPaths) {
+            addToAggregatePaths(varItemToAggregatePaths, toAggregatePaths);
+        }
+    }
+    const formulaVarFields = (0, exports.pickFieldFormulaVarFields)(fieldFormulaConfig);
+    for (let toAggregatePathsItem of toAggregatePaths) {
+        if (toAggregatePathsItem.length < 3) {
+            let tempPath = toAggregatePathsItem[0];
+            if (fieldFormulaObjectName === objectName &&
+                tempPath.reference_from === objectName) {
+                let doc = await fieldFormulaObject.findOne(recordId, {
+                    fields: formulaVarFields,
+                });
+                await (0, exports.updateDocsFieldFormulaValue)(doc, fieldFormulaConfig, userSession, escapeConfigs);
+            }
+            else {
+                let referenceToValue = recordId;
+                if (tempPath.reference_to_field &&
+                    tempPath.reference_to_field !== "_id") {
+                    let record = await currentObject.findOne(recordId, {
                         fields: [tempPath.reference_to_field],
-                    })];
-            case 6:
-                record = _d.sent();
-                referenceToValue = record && record[tempPath.reference_to_field];
-                _d.label = 7;
-            case 7: return [4, fieldFormulaObject.find({
+                    });
+                    referenceToValue = record && record[tempPath.reference_to_field];
+                }
+                let docs = await fieldFormulaObject.find({
                     filters: [[tempPath.field_name, "=", referenceToValue]],
                     fields: formulaVarFields,
-                })];
-            case 8:
-                docs = _d.sent();
-                return [4, (0, exports.updateDocsFieldFormulaValue)(docs, fieldFormulaConfig, userSession, escapeConfigs)];
-            case 9:
-                _d.sent();
-                _d.label = 10;
-            case 10: return [3, 16];
-            case 11:
-                aggregateLookups = (0, util_1.getFormulaVarPathsAggregateLookups)(toAggregatePathsItem);
-                lastLookup = aggregateLookups[aggregateLookups.length - 1]["$lookup"];
-                referenceToValue = recordId;
-                if (!(lastLookup.foreignField && lastLookup.foreignField !== "_id")) return [3, 13];
-                return [4, currentObject.findOne(recordId, {
-                        fields: [lastLookup.foreignField],
-                    })];
-            case 12:
-                record = _d.sent();
+                });
+                await (0, exports.updateDocsFieldFormulaValue)(docs, fieldFormulaConfig, userSession, escapeConfigs);
+            }
+        }
+        else {
+            let aggregateLookups = (0, util_1.getFormulaVarPathsAggregateLookups)(toAggregatePathsItem);
+            let lastLookup = aggregateLookups[aggregateLookups.length - 1]["$lookup"];
+            let referenceToValue = recordId;
+            if (lastLookup.foreignField && lastLookup.foreignField !== "_id") {
+                let record = await currentObject.findOne(recordId, {
+                    fields: [lastLookup.foreignField],
+                });
                 referenceToValue = record && record[lastLookup.foreignField];
-                _d.label = 13;
-            case 13:
-                aggregateFilters = [
-                    ["".concat(lastLookup.as, ".").concat(lastLookup.foreignField), "=", referenceToValue],
-                ];
-                return [4, fieldFormulaObject.directAggregatePrefixalPipeline({
-                        filters: aggregateFilters,
-                        fields: formulaVarFields,
-                    }, aggregateLookups)];
-            case 14:
-                docs = _d.sent();
-                return [4, (0, exports.updateDocsFieldFormulaValue)(docs, fieldFormulaConfig, userSession, escapeConfigs)];
-            case 15:
-                _d.sent();
-                _d.label = 16;
-            case 16:
-                toAggregatePaths_1_1 = toAggregatePaths_1.next();
-                return [3, 2];
-            case 17: return [3, 20];
-            case 18:
-                e_4_1 = _d.sent();
-                e_4 = { error: e_4_1 };
-                return [3, 20];
-            case 19:
-                try {
-                    if (toAggregatePaths_1_1 && !toAggregatePaths_1_1.done && (_c = toAggregatePaths_1.return)) _c.call(toAggregatePaths_1);
-                }
-                finally { if (e_4) throw e_4.error; }
-                return [7];
-            case 20: return [2];
+            }
+            let aggregateFilters = [
+                [`${lastLookup.as}.${lastLookup.foreignField}`, "=", referenceToValue],
+            ];
+            const docs = await fieldFormulaObject.directAggregatePrefixalPipeline({
+                filters: aggregateFilters,
+                fields: formulaVarFields,
+            }, aggregateLookups);
+            await (0, exports.updateDocsFieldFormulaValue)(docs, fieldFormulaConfig, userSession, escapeConfigs);
         }
-    });
-}); };
+    }
+};
 exports.updateQuotedByObjectFieldFormulaValue = updateQuotedByObjectFieldFormulaValue;
-var updateDocsFieldFormulaValue = function (docs, fieldFormulaConfig, userSession, escapeConfigs) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var fieldFormulaObjectName, fieldFormulaObject, docs_1, docs_1_1, doc, value, setDoc, e_7_1;
-    var e_7, _a;
-    return tslib_1.__generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                fieldFormulaObjectName = fieldFormulaConfig.object_name;
-                if (!_.isArray(docs)) {
-                    docs = [docs];
-                }
-                if (!docs.length) {
-                    return [2];
-                }
-                fieldFormulaObject = (0, index_1.getSteedosSchema)().getObject(fieldFormulaObjectName);
-                _b.label = 1;
-            case 1:
-                _b.trys.push([1, 7, 8, 9]);
-                docs_1 = tslib_1.__values(docs), docs_1_1 = docs_1.next();
-                _b.label = 2;
-            case 2:
-                if (!!docs_1_1.done) return [3, 6];
-                doc = docs_1_1.value;
-                return [4, (0, exports.computeFieldFormulaValue)(doc, fieldFormulaConfig, userSession)];
-            case 3:
-                value = _b.sent();
-                setDoc = {};
-                setDoc[fieldFormulaConfig.field_name] = value;
-                return [4, fieldFormulaObject.directUpdate(doc._id, setDoc)];
-            case 4:
-                _b.sent();
-                _b.label = 5;
-            case 5:
-                docs_1_1 = docs_1.next();
-                return [3, 2];
-            case 6: return [3, 9];
-            case 7:
-                e_7_1 = _b.sent();
-                e_7 = { error: e_7_1 };
-                return [3, 9];
-            case 8:
-                try {
-                    if (docs_1_1 && !docs_1_1.done && (_a = docs_1.return)) _a.call(docs_1);
-                }
-                finally { if (e_7) throw e_7.error; }
-                return [7];
-            case 9: return [4, (0, exports.updateQuotedByDocsForFormulaType)(docs, fieldFormulaConfig, userSession, escapeConfigs)];
-            case 10:
-                _b.sent();
-                return [2];
-        }
-    });
-}); };
+const updateDocsFieldFormulaValue = async (docs, fieldFormulaConfig, userSession, escapeConfigs) => {
+    const { object_name: fieldFormulaObjectName } = fieldFormulaConfig;
+    if (!_.isArray(docs)) {
+        docs = [docs];
+    }
+    if (!docs.length) {
+        return;
+    }
+    const fieldFormulaObject = (0, index_1.getSteedosSchema)().getObject(fieldFormulaObjectName);
+    for (let doc of docs) {
+        let value = await (0, exports.computeFieldFormulaValue)(doc, fieldFormulaConfig, userSession);
+        let setDoc = {};
+        setDoc[fieldFormulaConfig.field_name] = value;
+        await fieldFormulaObject.directUpdate(doc._id, setDoc);
+    }
+    await (0, exports.updateQuotedByDocsForFormulaType)(docs, fieldFormulaConfig, userSession, escapeConfigs);
+};
 exports.updateDocsFieldFormulaValue = updateDocsFieldFormulaValue;
-var updateQuotedByDocsForFormulaType = function (docs, fieldFormulaConfig, userSession, escapeConfigs) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var fieldFormulaObjectName, fieldNames, formulaQuotedByConfigs, summaryQuotedByConfigs, docs_2, docs_2_1, doc, e_8_1;
-    var e_8, _a;
-    return tslib_1.__generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                fieldFormulaObjectName = fieldFormulaConfig.object_name;
-                if (!_.isArray(docs)) {
-                    docs = [docs];
-                }
-                if (!docs.length) {
-                    return [2];
-                }
-                fieldNames = [fieldFormulaConfig.field_name];
-                return [4, (0, field_formula_1.getObjectQuotedByFieldFormulaConfigs)(fieldFormulaObjectName, fieldNames, escapeConfigs)];
-            case 1:
-                formulaQuotedByConfigs = _b.sent();
-                return [4, (0, summary_1.getObjectQuotedByFieldSummaryConfigs)(fieldFormulaObjectName, fieldNames)];
-            case 2:
-                summaryQuotedByConfigs = _b.sent();
-                _b.label = 3;
-            case 3:
-                _b.trys.push([3, 9, 10, 11]);
-                docs_2 = tslib_1.__values(docs), docs_2_1 = docs_2.next();
-                _b.label = 4;
-            case 4:
-                if (!!docs_2_1.done) return [3, 8];
-                doc = docs_2_1.value;
-                return [4, (0, exports.runQuotedByObjectFieldFormulas)(fieldFormulaObjectName, doc._id, userSession, {
-                        fieldNames: fieldNames,
-                        quotedByConfigs: formulaQuotedByConfigs,
-                        escapeConfigs: escapeConfigs,
-                    })];
-            case 5:
-                _b.sent();
-                return [4, (0, summary_1.runQuotedByObjectFieldSummaries)(fieldFormulaObjectName, doc._id, null, userSession, {
-                        fieldNames: fieldNames,
-                        quotedByConfigs: summaryQuotedByConfigs,
-                    })];
-            case 6:
-                _b.sent();
-                _b.label = 7;
-            case 7:
-                docs_2_1 = docs_2.next();
-                return [3, 4];
-            case 8: return [3, 11];
-            case 9:
-                e_8_1 = _b.sent();
-                e_8 = { error: e_8_1 };
-                return [3, 11];
-            case 10:
-                try {
-                    if (docs_2_1 && !docs_2_1.done && (_a = docs_2.return)) _a.call(docs_2);
-                }
-                finally { if (e_8) throw e_8.error; }
-                return [7];
-            case 11: return [2];
-        }
-    });
-}); };
+const updateQuotedByDocsForFormulaType = async (docs, fieldFormulaConfig, userSession, escapeConfigs) => {
+    const { object_name: fieldFormulaObjectName } = fieldFormulaConfig;
+    if (!_.isArray(docs)) {
+        docs = [docs];
+    }
+    if (!docs.length) {
+        return;
+    }
+    const fieldNames = [fieldFormulaConfig.field_name];
+    const formulaQuotedByConfigs = await (0, field_formula_1.getObjectQuotedByFieldFormulaConfigs)(fieldFormulaObjectName, fieldNames, escapeConfigs);
+    const summaryQuotedByConfigs = await (0, summary_1.getObjectQuotedByFieldSummaryConfigs)(fieldFormulaObjectName, fieldNames);
+    for (let doc of docs) {
+        await (0, exports.runQuotedByObjectFieldFormulas)(fieldFormulaObjectName, doc._id, userSession, {
+            fieldNames,
+            quotedByConfigs: formulaQuotedByConfigs,
+            escapeConfigs,
+        });
+        await (0, summary_1.runQuotedByObjectFieldSummaries)(fieldFormulaObjectName, doc._id, null, userSession, {
+            fieldNames,
+            quotedByConfigs: summaryQuotedByConfigs,
+        });
+    }
+};
 exports.updateQuotedByDocsForFormulaType = updateQuotedByDocsForFormulaType;
-var isFormulaFieldQuotingObjectAndFields = function (formulaObjectName, formulaFieldName, objectName, fieldNames) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
-    var configs;
-    return tslib_1.__generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4, (0, field_formula_1.getObjectFieldFormulaConfigs)(formulaObjectName, formulaFieldName)];
-            case 1:
-                configs = _a.sent();
-                if (configs && configs.length) {
-                    return [2, (0, util_1.isFieldFormulaConfigQuotingObjectAndFields)(configs[0], objectName, fieldNames)];
-                }
-                else {
-                    return [2, false];
-                }
-                return [2];
-        }
-    });
-}); };
+const isFormulaFieldQuotingObjectAndFields = async (formulaObjectName, formulaFieldName, objectName, fieldNames) => {
+    const configs = await (0, field_formula_1.getObjectFieldFormulaConfigs)(formulaObjectName, formulaFieldName);
+    if (configs && configs.length) {
+        return (0, util_1.isFieldFormulaConfigQuotingObjectAndFields)(configs[0], objectName, fieldNames);
+    }
+    else {
+        return false;
+    }
+};
 exports.isFormulaFieldQuotingObjectAndFields = isFormulaFieldQuotingObjectAndFields;
 //# sourceMappingURL=core.js.map