@steedos/objectql 2.2.55-beta.6 → 2.2.55

package/lib/formula/core.js

@@ -9,27 +9,18 @@ var summary_1 = require("../summary");
 var util_1 = require("./util");
 var util_2 = require("../util");
 var _ = require("lodash");
-// import _eval = require('eval')
 var formula_1 = require("@steedos/formula");
 var params_1 = require("./params");
 var simple_params_1 = require("./simple_params");
-/**
- * 根据公式内容，取出其中{}中的变量
- * @param formula
- */
 var pickFormulaVars = function (formula) {
     return (0, formula_1.extract)(formula);
 };
 exports.pickFormulaVars = pickFormulaVars;
-/**
- * 根据公式内容，取出其中{}中的变量，并进一步取出这些变量中引用了当前对象的哪些字段
- * @param fieldFormulaConfig
- */
 var pickFieldFormulaVarFields = function (fieldFormulaConfigs) {
     if (!_.isArray(fieldFormulaConfigs)) {
         fieldFormulaConfigs = [fieldFormulaConfigs];
     }
-    var result = ["space"]; //space字段作为基础字段不能少
+    var result = ["space"];
     fieldFormulaConfigs.forEach(function (fieldFormulaConfig) {
         var vars = fieldFormulaConfig.vars;
         result = _.union(result, (0, exports.pickFormulaVarFields)(vars));
@@ -37,15 +28,10 @@ var pickFieldFormulaVarFields = function (fieldFormulaConfigs) {
     return _.uniq(result);
 };
 exports.pickFieldFormulaVarFields = pickFieldFormulaVarFields;
-/**
- * 根据公式内容已取出的{}中的变量，进一步取出这些变量中引用了当前对象的哪些字段
- * @param vars
- */
 var pickFormulaVarFields = function (vars) {
-    var result = ["space"]; //space字段作为基础字段不能少
+    var result = ["space"];
     vars.forEach(function (varItem) {
         if (varItem.paths.length) {
-            // 如果是$user变量则paths肯定为空，所以取paths中第一个，第一个一定是当前对象中的字段
             var firstPath = varItem.paths[0];
             var firstKey = firstPath.field_name;
             result.push(firstKey);
@@ -54,12 +40,6 @@ var pickFormulaVarFields = function (vars) {
     return _.uniq(result);
 };
 exports.pickFormulaVarFields = pickFormulaVarFields;
-/**
- * 根据公式中的变量值，计算出跨对象引用的记录对应的字段值，作为公式运算的参数返回
- * @param doc
- * @param vars
- * return Array<SteedosFormulaParamTypeConfig>
- */
 var computeFormulaParams = function (doc, vars, currentUserId) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
     var params, spaceId, _loop_1, lastReferenceToField, vars_1, vars_1_1, _a, key, paths, isUserVar, isSimpleVar;
     var e_1, _b;
@@ -69,7 +49,6 @@ var computeFormulaParams = function (doc, vars, currentUserId) { return tslib_1.
         if (vars && vars.length) {
             _loop_1 = function (key, paths, isUserVar, isSimpleVar) {
                 key = key.trim();
-                // 如果变量key以$user开头,则解析为userSession,此时paths为空
                 var tempValue = void 0;
                 if (isUserVar) {
                     if (!currentUserId) {
@@ -78,18 +57,8 @@ var computeFormulaParams = function (doc, vars, currentUserId) { return tslib_1.
                     if (!spaceId) {
                         throw new Error("computeFormulaParams:The 'space' property is required for the doc of the formula var key ".concat(key, " while running"));
                     }
-                    // if (!currentUserId) {
-                    //     throw new Error(`computeFormulaParams:The param 'currentUserId' is required for the formula var key ${key}`);
-                    // }
-                    // let tempFormulaParams = {};
-                    // let tepmFormula = key.replace(FormulaUserKey, `__params["${FormulaUserKey}"]`);
-                    // tepmFormula = `return ${tepmFormula}`
-                    // tempFormulaParams[FormulaUserKey] = currentUserId;
-                    // tempValue = evalFieldFormula(tepmFormula, tempFormulaParams);
                 }
                 if (isSimpleVar) {
-                    // 普通变量，取参数值时直接取值，而不用走变量上的paths属性。
-                    // 注意未传入objectName时，公式中的user var的isSimpleVar为false，还是走下面的paths取值逻辑。
                     tempValue = doc[key];
                     params.push({
                         key: key,
@@ -102,7 +71,6 @@ var computeFormulaParams = function (doc, vars, currentUserId) { return tslib_1.
                     if (index === 0) {
                         lastReferenceToField = next.reference_to_field;
                         if (isUserVar) {
-                            // $user变量也要按查相关表记录的方式取值，第一个path为根据id取出对应的space_users记录
                             var sus = (0, util_2.wrapAsync)(function () {
                                 return (0, index_1.getSteedosSchema)().getObject("space_users").find({
                                     filters: [["user", "=", currentUserId], ["space", "=", spaceId]],
@@ -123,7 +91,6 @@ var computeFormulaParams = function (doc, vars, currentUserId) { return tslib_1.
                     }
                     else {
                         if (!reslut) {
-                            // 当上一轮返回空值或0时，直接返回
                             return reslut;
                         }
                         reslut = (0, util_2.wrapAsync)(function () {
@@ -163,7 +130,7 @@ var computeFormulaParams = function (doc, vars, currentUserId) { return tslib_1.
                 finally { if (e_1) throw e_1.error; }
             }
         }
-        return [2 /*return*/, params];
+        return [2, params];
     });
 }); };
 exports.computeFormulaParams = computeFormulaParams;
@@ -176,10 +143,10 @@ var computeFieldFormulaValue = function (doc, fieldFormulaConfig, currentUserId)
                     (0, util_1.checkCurrentUserIdNotRequiredForFieldFormulas)(fieldFormulaConfig);
                 }
                 formula = fieldFormulaConfig.formula, vars = fieldFormulaConfig.vars, data_type = fieldFormulaConfig.data_type, formula_blank_value = fieldFormulaConfig.formula_blank_value;
-                return [4 /*yield*/, (0, exports.computeFormulaParams)(doc, vars, currentUserId)];
+                return [4, (0, exports.computeFormulaParams)(doc, vars, currentUserId)];
             case 1:
                 params = _a.sent();
-                return [2 /*return*/, (0, exports.runFormula)(formula, params, {
+                return [2, (0, exports.runFormula)(formula, params, {
                         returnType: data_type,
                         blankValue: formula_blank_value
                     }, fieldFormulaConfig)];
@@ -189,117 +156,82 @@ var computeFieldFormulaValue = function (doc, fieldFormulaConfig, currentUserId)
 exports.computeFieldFormulaValue = computeFieldFormulaValue;
 var evalFieldFormula = function (formula, formulaParams) {
     try {
-        // let formulaFun = `module.exports = function (__params) { ${formula} }`;
-        // console.log("==evalFieldFormula==formulaFun===", formulaFun);
-        // console.log("==evalFieldFormula==formulaParams===", formulaParams);
-        // return _eval(formulaFun)(formulaParams);
         return (0, formula_1.parse)(formula, formulaParams);
     }
     catch (ex) {
-        formulaParams[type_1.FormulaUserKey] = "{...}"; //$user简化，打出的日志看得清楚点
+        formulaParams[type_1.FormulaUserKey] = "{...}";
         throw new Error("evalFieldFormula:Catch an error \"".concat(ex, "\" while eval formula \"").concat(formula, "\" with params \"").concat(JSON.stringify(formulaParams), "\""));
     }
 };
 exports.evalFieldFormula = evalFieldFormula;
-/**
- * 运行公式
- * @param formula 公式脚本内容
- * @param params 参数
- * @param options 公式返回类型，及空值配置
- * @param messageTag 用于显示错误日志的标识信息，可以是一个json对象
- */
 var runFormula = function (formula, params, options, messageTag) {
     if (!options) {
         options = {};
     }
-    // console.log("===runFormula===formula====", formula);
-    // console.log("===runFormula===params====", params);
     var returnType = options.returnType, blankValue = options.blankValue;
     var formulaParams = {};
     params.forEach(function (_a) {
         var key = _a.key, path = _a.path, value = _a.value;
-        // formulaParams[key] = value;
-        // 把{}括起来的变量替换为计算得到的变量值
-        // formula = formula.replace(`{${key}}`, `__params["${key}"]`);
         if (path) {
             formulaParams[key] = (0, params_1.getFieldSubstitution)(path.reference_from, path.field_name, value, blankValue);
         }
         else {
-            // 变量中没有path属性说明是普通变量
             formulaParams[key] = (0, simple_params_1.getSimpleParamSubstitution)(value, blankValue);
         }
     });
-    // console.log("===runFormula===formula====", formula);
-    // console.log("===runFormula===formulaParams====", formulaParams);
     var result = (0, exports.evalFieldFormula)(formula, formulaParams);
-    // console.log("===runFormula===result====", result);
     var formulaValue = result.value;
     var 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), "\""));
-        // if(blankValue === SteedosFormulaBlankValue.blanks && result.errorType === "ArgumentError"){
-        //     // 配置了空参数视为空值时会直接返回空值类型，这里就会报错，直接返回空值，而不是抛错
-        //     // TODO:result.errorType === "ArgumentError"不够细化，下一版本应该视错误情况优化返回空值的条件
-        //     formulaValue = null;
-        // }yar
-        // else{
-        //     throw new Error(result.message);
-        // }
     }
-    if (formulaValueType === "number" /* Number */ && _.isNaN(formulaValue)) {
-        // 数值类型计算结果为NaN时，保存为空值
+    if (formulaValueType === "number" && _.isNaN(formulaValue)) {
         formulaValue = null;
     }
     if (returnType && formulaValueType && formulaValueType != "null") {
         switch (returnType) {
             case "boolean":
-                if (formulaValueType !== "checkbox" /* Checkbox */) {
+                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, "'."));
                 }
                 break;
             case "number":
-                if (formulaValueType !== "number" /* 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, "'."));
                 }
                 break;
             case "currency":
-                if (formulaValueType !== "number" /* 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, "'."));
                 }
                 break;
             case "percent":
-                if (formulaValueType !== "number" /* 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, "'."));
                 }
                 break;
             case "text":
-                if (formulaValueType !== "text" /* 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, "'."));
                 }
                 break;
             case "date":
-                if (formulaValueType !== "date" /* Date */) {
-                    // 这里不可以直接用result.constructor == Date或result instanceof Date，因为eval后的同一个基础类型的构造函数指向的不是同一个
+                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, "'."));
                 }
                 break;
             case "datetime":
-                if (formulaValueType !== "datetime" /* Datetime */) {
-                    // 这里不可以直接用result.constructor == Date或result instanceof Date，因为eval后的同一个基础类型的构造函数指向的不是同一个
+                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, "'."));
                 }
                 break;
         }
     }
-    // console.log("===runFormula===formulaValue====", formulaValue);
     return formulaValue;
 };
 exports.runFormula = runFormula;
 var addToAggregatePaths = function (varItemToAggregatePaths, toAggregatePaths) {
-    // 当引用了同一个对象的不同属性时，只需要记录其中一个，因为一个公式里面引用的字段变更后，只需要重算一次，比如以下两个都将只有第一条会加入到toAggregatePaths中
-    // [{"key":"account.website","paths":[{"field_name":"account","reference_from":"contacts"},{"field_name":"website","reference_from":"accounts"}]}]
-    // [{"key":"account.name","paths":[{"field_name":"account","reference_from":"contacts"},{"field_name":"name","reference_from":"accounts"}]}]
     var pathLength = varItemToAggregatePaths.length;
     var existPath = toAggregatePaths.find(function (item) {
         return JSON.stringify(item.slice(0, pathLength)) === JSON.stringify(varItemToAggregatePaths.slice(0, pathLength));
@@ -308,16 +240,6 @@ var addToAggregatePaths = function (varItemToAggregatePaths, toAggregatePaths) {
         toAggregatePaths.push(varItemToAggregatePaths);
     }
 };
-/**
- * 在所有字段引用关系（包括跨对象的字段引用关系）中找到引用了当前正在update的对象字段的公式字段并更新其字段值
- * 如果当前不是update而是insert则不需要调用该函数，因为这时这条记录不可能存在引用关系
- * @param objectName
- * @param recordId
- * @param currentUserId
- * @param options.fieldNames 传入该参数时，只查找和处理引用了该对象中这些指定字段的公式字段
- * @param options.escapeConfigs 传入该参数时，将额外跳过这些公式字段配置的运算，提高性能
- * @param options.quotedByConfigs 如果已经根据objectName和fieldNames查过相关配置了，请直接传入，可以避免重复查找，提高性能
- */
 var runQuotedByObjectFieldFormulas = function (objectName, recordId, userSession, options) {
     if (options === void 0) { options = {}; }
     return tslib_1.__awaiter(this, void 0, void 0, function () {
@@ -328,14 +250,14 @@ var runQuotedByObjectFieldFormulas = function (objectName, recordId, userSession
                 case 0:
                     currentUserId = userSession ? userSession.userId : undefined;
                     fieldNames = options.fieldNames, escapeConfigs = options.escapeConfigs, quotedByConfigs = options.quotedByConfigs, onlyForOwn = options.onlyForOwn, withoutCurrent = options.withoutCurrent;
-                    if (!!quotedByConfigs) return [3 /*break*/, 2];
-                    return [4 /*yield*/, (0, field_formula_1.getObjectQuotedByFieldFormulaConfigs)(objectName, fieldNames, escapeConfigs, { onlyForOwn: onlyForOwn, withoutCurrent: 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 /*return*/];
+                        return [2];
                     }
                     if (!currentUserId) {
                         (0, util_1.checkCurrentUserIdNotRequiredForFieldFormulas)(quotedByConfigs.allConfigs);
@@ -346,41 +268,32 @@ var runQuotedByObjectFieldFormulas = function (objectName, recordId, userSession
                     _a = tslib_1.__values(quotedByConfigs.allConfigs), _b = _a.next();
                     _d.label = 4;
                 case 4:
-                    if (!!_b.done) return [3 /*break*/, 7];
+                    if (!!_b.done) return [3, 7];
                     config = _b.value;
-                    return [4 /*yield*/, (0, exports.updateQuotedByObjectFieldFormulaValue)(objectName, recordId, config, userSession, quotedByConfigs.ownConfigs)];
+                    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 /*break*/, 4];
-                case 7: return [3 /*break*/, 10];
+                    return [3, 4];
+                case 7: return [3, 10];
                 case 8:
                     e_2_1 = _d.sent();
                     e_2 = { error: e_2_1 };
-                    return [3 /*break*/, 10];
+                    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 /*endfinally*/];
-                case 10: return [2 /*return*/];
+                    return [7];
+                case 10: return [2];
             }
         });
     });
 };
 exports.runQuotedByObjectFieldFormulas = runQuotedByObjectFieldFormulas;
-/**
- * 找到当前正在insert/update的对象中的公式字段并更新其字段值
- * @param objectName
- * @param recordId
- * @param doc
- * @param currentUserId
- * @param needRefetchDoc 当doc不可信赖时，需要从数据库中重新抓取doc，请传入true值
- * @param configs 如果已经根据objectName查过相关配置了，请直接传入，可以避免重复查找，提高性能
- */
 var runCurrentObjectFieldFormulas = function (objectName, recordId, doc, currentUserId, needRefetchDoc, configs) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
         var formulaVarFields, setDoc, configs_1, configs_1_1, config, _a, _b, e_3_1;
@@ -388,21 +301,21 @@ var runCurrentObjectFieldFormulas = function (objectName, recordId, doc, current
         return tslib_1.__generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
-                    if (!!configs) return [3 /*break*/, 2];
-                    return [4 /*yield*/, (0, field_formula_1.getObjectFieldFormulaConfigs)(objectName)];
+                    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 /*return*/];
+                        return [2];
                     }
                     if (!currentUserId) {
                         (0, util_1.checkCurrentUserIdNotRequiredForFieldFormulas)(configs);
                     }
-                    if (!(needRefetchDoc !== false)) return [3 /*break*/, 4];
+                    if (!(needRefetchDoc !== false)) return [3, 4];
                     formulaVarFields = (0, exports.pickFieldFormulaVarFields)(configs);
-                    return [4 /*yield*/, (0, index_1.getSteedosSchema)().getObject(objectName).findOne(recordId, { fields: formulaVarFields })];
+                    return [4, (0, index_1.getSteedosSchema)().getObject(objectName).findOne(recordId, { fields: formulaVarFields })];
                 case 3:
                     doc = _d.sent();
                     _d.label = 4;
@@ -414,61 +327,55 @@ var runCurrentObjectFieldFormulas = function (objectName, recordId, doc, current
                     configs_1 = tslib_1.__values(configs), configs_1_1 = configs_1.next();
                     _d.label = 6;
                 case 6:
-                    if (!!configs_1_1.done) return [3 /*break*/, 9];
+                    if (!!configs_1_1.done) return [3, 9];
                     config = configs_1_1.value;
-                    doc = Object.assign({}, doc, setDoc); //setDoc中计算得到的结果应该重新并到doc中支持计算
+                    doc = Object.assign({}, doc, setDoc);
                     _a = setDoc;
                     _b = config.field_name;
-                    return [4 /*yield*/, (0, exports.computeFieldFormulaValue)(doc, config, currentUserId)];
+                    return [4, (0, exports.computeFieldFormulaValue)(doc, config, currentUserId)];
                 case 7:
                     _a[_b] = _d.sent();
                     _d.label = 8;
                 case 8:
                     configs_1_1 = configs_1.next();
-                    return [3 /*break*/, 6];
-                case 9: return [3 /*break*/, 12];
+                    return [3, 6];
+                case 9: return [3, 12];
                 case 10:
                     e_3_1 = _d.sent();
                     e_3 = { error: e_3_1 };
-                    return [3 /*break*/, 12];
+                    return [3, 12];
                 case 11:
                     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 /*endfinally*/];
-                case 12: return [4 /*yield*/, (0, index_1.getSteedosSchema)().getObject(objectName).directUpdate(recordId, setDoc)];
+                    return [7];
+                case 12: return [4, (0, index_1.getSteedosSchema)().getObject(objectName).directUpdate(recordId, setDoc)];
                 case 13:
                     _d.sent();
-                    return [2 /*return*/];
+                    return [2];
             }
         });
     });
 };
 exports.runCurrentObjectFieldFormulas = runCurrentObjectFieldFormulas;
-/**
- * 找到当前正在update的对象多条记录的公式字段并更新其字段值
- * @param objectName
- * @param filters
- * @param currentUserId
- */
 var runManyCurrentObjectFieldFormulas = function (objectName, filters, currentUserId) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
         var configs, formulaVarFields, docs, docs_1, docs_1_1, doc, e_4_1;
         var e_4, _a;
         return tslib_1.__generator(this, function (_b) {
             switch (_b.label) {
-                case 0: return [4 /*yield*/, (0, field_formula_1.getObjectFieldFormulaConfigs)(objectName)];
+                case 0: return [4, (0, field_formula_1.getObjectFieldFormulaConfigs)(objectName)];
                 case 1:
                     configs = _b.sent();
                     if (!configs.length) {
-                        return [2 /*return*/];
+                        return [2];
                     }
                     if (!currentUserId) {
                         (0, util_1.checkCurrentUserIdNotRequiredForFieldFormulas)(configs);
                     }
                     formulaVarFields = (0, exports.pickFieldFormulaVarFields)(configs);
-                    return [4 /*yield*/, (0, index_1.getSteedosSchema)().getObject(objectName).find({ filters: filters, fields: formulaVarFields })];
+                    return [4, (0, index_1.getSteedosSchema)().getObject(objectName).find({ filters: filters, fields: formulaVarFields })];
                 case 2:
                     docs = _b.sent();
                     _b.label = 3;
@@ -477,38 +384,32 @@ var runManyCurrentObjectFieldFormulas = function (objectName, filters, currentUs
                     docs_1 = tslib_1.__values(docs), docs_1_1 = docs_1.next();
                     _b.label = 4;
                 case 4:
-                    if (!!docs_1_1.done) return [3 /*break*/, 7];
+                    if (!!docs_1_1.done) return [3, 7];
                     doc = docs_1_1.value;
-                    return [4 /*yield*/, (0, exports.runCurrentObjectFieldFormulas)(objectName, doc._id, doc, currentUserId, false, configs)];
+                    return [4, (0, exports.runCurrentObjectFieldFormulas)(objectName, doc._id, doc, currentUserId, false, configs)];
                 case 5:
                     _b.sent();
                     _b.label = 6;
                 case 6:
                     docs_1_1 = docs_1.next();
-                    return [3 /*break*/, 4];
-                case 7: return [3 /*break*/, 10];
+                    return [3, 4];
+                case 7: return [3, 10];
                 case 8:
                     e_4_1 = _b.sent();
                     e_4 = { error: e_4_1 };
-                    return [3 /*break*/, 10];
+                    return [3, 10];
                 case 9:
                     try {
                         if (docs_1_1 && !docs_1_1.done && (_a = docs_1.return)) _a.call(docs_1);
                     }
                     finally { if (e_4) throw e_4.error; }
-                    return [7 /*endfinally*/];
-                case 10: return [2 /*return*/];
+                    return [7];
+                case 10: return [2];
             }
         });
     });
 };
 exports.runManyCurrentObjectFieldFormulas = runManyCurrentObjectFieldFormulas;
-/**
- * 修改记录时，根据查到的引用了该记录相关字段公式配置，重新计算字段公式，并把计算结果更新到数据库相关记录中
- * @param objectName 当前修改的记录所属对象名称
- * @param recordId 当前修改的记录ID
- * @param fieldFormulaConfig 查到的引用了该记录所属对象的相关字段公式配置之一
- */
 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_5_1;
     var e_6, _a, e_7, _b, e_5, _c;
@@ -543,7 +444,6 @@ var updateQuotedByObjectFieldFormulaValue = function (objectName, recordId, fiel
                             finally { if (e_7) throw e_7.error; }
                         }
                         if (isInPaths) {
-                            // 添加时去除重复项
                             addToAggregatePaths(varItemToAggregatePaths, toAggregatePaths);
                         }
                     }
@@ -562,71 +462,71 @@ var updateQuotedByObjectFieldFormulaValue = function (objectName, recordId, fiel
                 toAggregatePaths_1 = tslib_1.__values(toAggregatePaths), toAggregatePaths_1_1 = toAggregatePaths_1.next();
                 _d.label = 2;
             case 2:
-                if (!!toAggregatePaths_1_1.done) return [3 /*break*/, 17];
+                if (!!toAggregatePaths_1_1.done) return [3, 17];
                 toAggregatePathsItem = toAggregatePaths_1_1.value;
-                if (!(toAggregatePathsItem.length < 3)) return [3 /*break*/, 11];
+                if (!(toAggregatePathsItem.length < 3)) return [3, 11];
                 tempPath = toAggregatePathsItem[0];
-                if (!(fieldFormulaObjectName === objectName && tempPath.reference_from === objectName)) return [3 /*break*/, 5];
-                return [4 /*yield*/, fieldFormulaObject.findOne(recordId, { fields: formulaVarFields })];
+                if (!(fieldFormulaObjectName === objectName && tempPath.reference_from === objectName)) return [3, 5];
+                return [4, fieldFormulaObject.findOne(recordId, { fields: formulaVarFields })];
             case 3:
                 doc = _d.sent();
-                return [4 /*yield*/, (0, exports.updateDocsFieldFormulaValue)(doc, fieldFormulaConfig, userSession, escapeConfigs)];
+                return [4, (0, exports.updateDocsFieldFormulaValue)(doc, fieldFormulaConfig, userSession, escapeConfigs)];
             case 4:
                 _d.sent();
-                return [3 /*break*/, 10];
+                return [3, 10];
             case 5:
                 referenceToValue = recordId;
-                if (!(tempPath.reference_to_field && tempPath.reference_to_field !== "_id")) return [3 /*break*/, 7];
-                return [4 /*yield*/, currentObject.findOne(recordId, { fields: [tempPath.reference_to_field] })];
+                if (!(tempPath.reference_to_field && tempPath.reference_to_field !== "_id")) return [3, 7];
+                return [4, 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 /*yield*/, fieldFormulaObject.find({ filters: [[tempPath.field_name, "=", referenceToValue]], fields: formulaVarFields })];
+            case 7: return [4, fieldFormulaObject.find({ filters: [[tempPath.field_name, "=", referenceToValue]], fields: formulaVarFields })];
             case 8:
                 docs = _d.sent();
-                return [4 /*yield*/, (0, exports.updateDocsFieldFormulaValue)(docs, fieldFormulaConfig, userSession, escapeConfigs)];
+                return [4, (0, exports.updateDocsFieldFormulaValue)(docs, fieldFormulaConfig, userSession, escapeConfigs)];
             case 9:
                 _d.sent();
                 _d.label = 10;
-            case 10: return [3 /*break*/, 16];
+            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 /*break*/, 13];
-                return [4 /*yield*/, currentObject.findOne(recordId, { fields: [lastLookup.foreignField] })];
+                if (!(lastLookup.foreignField && lastLookup.foreignField !== "_id")) return [3, 13];
+                return [4, currentObject.findOne(recordId, { fields: [lastLookup.foreignField] })];
             case 12:
                 record = _d.sent();
                 referenceToValue = record && record[lastLookup.foreignField];
                 _d.label = 13;
             case 13:
                 aggregateFilters = [["".concat(lastLookup.as, ".").concat(lastLookup.foreignField), "=", referenceToValue]];
-                return [4 /*yield*/, fieldFormulaObject.directAggregatePrefixalPipeline({
+                return [4, fieldFormulaObject.directAggregatePrefixalPipeline({
                         filters: aggregateFilters,
                         fields: formulaVarFields
                     }, aggregateLookups)];
             case 14:
                 docs = _d.sent();
-                return [4 /*yield*/, (0, exports.updateDocsFieldFormulaValue)(docs, fieldFormulaConfig, userSession, escapeConfigs)];
+                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 /*break*/, 2];
-            case 17: return [3 /*break*/, 20];
+                return [3, 2];
+            case 17: return [3, 20];
             case 18:
                 e_5_1 = _d.sent();
                 e_5 = { error: e_5_1 };
-                return [3 /*break*/, 20];
+                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_5) throw e_5.error; }
-                return [7 /*endfinally*/];
-            case 20: return [2 /*return*/];
+                return [7];
+            case 20: return [2];
         }
     });
 }); };
@@ -642,7 +542,7 @@ var updateDocsFieldFormulaValue = function (docs, fieldFormulaConfig, userSessio
                     docs = [docs];
                 }
                 if (!docs.length) {
-                    return [2 /*return*/];
+                    return [2];
                 }
                 fieldFormulaObject = (0, index_1.getSteedosSchema)().getObject(fieldFormulaObjectName);
                 currentUserId = userSession ? userSession.userId : undefined;
@@ -652,38 +552,35 @@ var updateDocsFieldFormulaValue = function (docs, fieldFormulaConfig, userSessio
                 docs_2 = tslib_1.__values(docs), docs_2_1 = docs_2.next();
                 _b.label = 2;
             case 2:
-                if (!!docs_2_1.done) return [3 /*break*/, 6];
+                if (!!docs_2_1.done) return [3, 6];
                 doc = docs_2_1.value;
-                return [4 /*yield*/, (0, exports.computeFieldFormulaValue)(doc, fieldFormulaConfig, currentUserId)];
+                return [4, (0, exports.computeFieldFormulaValue)(doc, fieldFormulaConfig, currentUserId)];
             case 3:
                 value = _b.sent();
                 setDoc = {};
                 setDoc[fieldFormulaConfig.field_name] = value;
-                return [4 /*yield*/, fieldFormulaObject.directUpdate(doc._id, setDoc)];
+                return [4, fieldFormulaObject.directUpdate(doc._id, setDoc)];
             case 4:
                 _b.sent();
                 _b.label = 5;
             case 5:
                 docs_2_1 = docs_2.next();
-                return [3 /*break*/, 2];
-            case 6: return [3 /*break*/, 9];
+                return [3, 2];
+            case 6: return [3, 9];
             case 7:
                 e_8_1 = _b.sent();
                 e_8 = { error: e_8_1 };
-                return [3 /*break*/, 9];
+                return [3, 9];
             case 8:
                 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 /*endfinally*/];
-            case 9: 
-            // 这里特意重新遍历一次docs而不是直接在当前函数中每次更新一条记录后立即处理被引用字段的级联变更，见：公式或汇总触发级联重算时，数据类型变更可能会造成无法重算 #965
-            return [4 /*yield*/, (0, exports.updateQuotedByDocsForFormulaType)(docs, fieldFormulaConfig, userSession, escapeConfigs)];
+                return [7];
+            case 9: return [4, (0, exports.updateQuotedByDocsForFormulaType)(docs, fieldFormulaConfig, userSession, escapeConfigs)];
             case 10:
-                // 这里特意重新遍历一次docs而不是直接在当前函数中每次更新一条记录后立即处理被引用字段的级联变更，见：公式或汇总触发级联重算时，数据类型变更可能会造成无法重算 #965
                 _b.sent();
-                return [2 /*return*/];
+                return [2];
         }
     });
 }); };
@@ -699,13 +596,13 @@ var updateQuotedByDocsForFormulaType = function (docs, fieldFormulaConfig, userS
                     docs = [docs];
                 }
                 if (!docs.length) {
-                    return [2 /*return*/];
+                    return [2];
                 }
                 fieldNames = [fieldFormulaConfig.field_name];
-                return [4 /*yield*/, (0, field_formula_1.getObjectQuotedByFieldFormulaConfigs)(fieldFormulaObjectName, fieldNames, escapeConfigs)];
+                return [4, (0, field_formula_1.getObjectQuotedByFieldFormulaConfigs)(fieldFormulaObjectName, fieldNames, escapeConfigs)];
             case 1:
                 formulaQuotedByConfigs = _b.sent();
-                return [4 /*yield*/, (0, summary_1.getObjectQuotedByFieldSummaryConfigs)(fieldFormulaObjectName, fieldNames)];
+                return [4, (0, summary_1.getObjectQuotedByFieldSummaryConfigs)(fieldFormulaObjectName, fieldNames)];
             case 2:
                 summaryQuotedByConfigs = _b.sent();
                 _b.label = 3;
@@ -714,69 +611,55 @@ var updateQuotedByDocsForFormulaType = function (docs, fieldFormulaConfig, userS
                 docs_3 = tslib_1.__values(docs), docs_3_1 = docs_3.next();
                 _b.label = 4;
             case 4:
-                if (!!docs_3_1.done) return [3 /*break*/, 8];
+                if (!!docs_3_1.done) return [3, 8];
                 doc = docs_3_1.value;
-                // 公式字段修改后，需要找到引用了该公式字段的其他公式字段并更新其值
-                return [4 /*yield*/, (0, exports.runQuotedByObjectFieldFormulas)(fieldFormulaObjectName, doc._id, userSession, {
+                return [4, (0, exports.runQuotedByObjectFieldFormulas)(fieldFormulaObjectName, doc._id, userSession, {
                         fieldNames: fieldNames,
                         quotedByConfigs: formulaQuotedByConfigs,
                         escapeConfigs: escapeConfigs
-                    })
-                    // 公式字段修改后，需要找到引用了该公式字段的其他汇总字段并更新其值
-                ];
+                    })];
             case 5:
-                // 公式字段修改后，需要找到引用了该公式字段的其他公式字段并更新其值
                 _b.sent();
-                // 公式字段修改后，需要找到引用了该公式字段的其他汇总字段并更新其值
-                return [4 /*yield*/, (0, summary_1.runQuotedByObjectFieldSummaries)(fieldFormulaObjectName, doc._id, null, userSession, {
+                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_3_1 = docs_3.next();
-                return [3 /*break*/, 4];
-            case 8: return [3 /*break*/, 11];
+                return [3, 4];
+            case 8: return [3, 11];
             case 9:
                 e_9_1 = _b.sent();
                 e_9 = { error: e_9_1 };
-                return [3 /*break*/, 11];
+                return [3, 11];
             case 10:
                 try {
                     if (docs_3_1 && !docs_3_1.done && (_a = docs_3.return)) _a.call(docs_3);
                 }
                 finally { if (e_9) throw e_9.error; }
-                return [7 /*endfinally*/];
-            case 11: return [2 /*return*/];
+                return [7];
+            case 11: return [2];
         }
     });
 }); };
 exports.updateQuotedByDocsForFormulaType = updateQuotedByDocsForFormulaType;
-/**
- * 某个对象上的公式字段是否引用了某个对象和字段
- * @param formulaObjectName 公式字段在所在对象名称
- * @param formulaFieldName 公式字段名称
- * @param object_name 是否引用了该对象
- * @param field_name 是否引用了该字段
- */
 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 /*yield*/, (0, field_formula_1.getObjectFieldFormulaConfigs)(formulaObjectName, formulaFieldName)];
+            case 0: return [4, (0, field_formula_1.getObjectFieldFormulaConfigs)(formulaObjectName, formulaFieldName)];
             case 1:
                 configs = _a.sent();
                 if (configs && configs.length) {
-                    return [2 /*return*/, (0, util_1.isFieldFormulaConfigQuotingObjectAndFields)(configs[0], objectName, fieldNames)];
+                    return [2, (0, util_1.isFieldFormulaConfigQuotingObjectAndFields)(configs[0], objectName, fieldNames)];
                 }
                 else {
-                    // 没找到公式字段配置说明传入的参数不是公式字段
-                    return [2 /*return*/, false];
+                    return [2, false];
                 }
-                return [2 /*return*/];
+                return [2];
         }
     });
 }); };