@steedos/service-metadata-objects 3.0.13-beta.9 → 3.0.14-beta.1

package/lib/formula/formulaActionHandler.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormulaActionHandler = void 0;
-const tslib_1 = require("tslib");
 const type_1 = require("./type");
 const core_1 = require("./core");
 const metadata_registrar_1 = require("@steedos/metadata-registrar");
@@ -15,32 +14,28 @@ function getDynamicCalcMapCacherKey(objectApiName, mainObjectApiName) {
     return `$dynamic_calc_map.${objectApiName}.${mainObjectApiName}`;
 }
 class FormulaActionHandler {
+    broker = null;
     constructor(broker) {
-        this.broker = null;
         this.broker = broker;
     }
-    deleteAll(objectConfig) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!objectConfig) {
-                    return;
-                }
-                yield metadata_registrar_1.Register.fuzzyDelete(this.broker, `${this.cacherKey(objectConfig.name)}.*`);
-                return true;
-            }
-            catch (error) {
-                this.broker.logger.error(error);
+    async deleteAll(objectConfig) {
+        try {
+            if (!objectConfig) {
+                return;
             }
-            return false;
-        });
+            await metadata_registrar_1.Register.fuzzyDelete(this.broker, `${this.cacherKey(objectConfig.name)}.*`);
+            return true;
+        }
+        catch (error) {
+            this.broker.logger.error(error);
+        }
+        return false;
     }
-    getObjectConfig(objectApiName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const data = yield this.broker.call("objects.get", {
-                objectApiName: objectApiName,
-            });
-            return data ? data.metadata : null;
+    async getObjectConfig(objectApiName) {
+        const data = await this.broker.call("objects.get", {
+            objectApiName: objectApiName,
         });
+        return data ? data.metadata : null;
     }
     addFieldFormulaQuotesConfig(quote, quotes) {
         if (quote.field_name === "_id") {
@@ -54,220 +49,173 @@ class FormulaActionHandler {
             quotes.push(quote);
         }
     }
-    computeFormulaVarAndQuotes(formulaVar, objectConfig, quotes, vars) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            let isSimpleVar = objectConfig === null;
-            let isAmisGlobalVar = /^global\./.test(formulaVar);
-            if (isAmisGlobalVar) {
-                return;
+    async computeFormulaVarAndQuotes(formulaVar, objectConfig, quotes, vars) {
+        let isSimpleVar = objectConfig === null;
+        let isAmisGlobalVar = /^global\./.test(formulaVar);
+        if (isAmisGlobalVar) {
+            return;
+        }
+        let isUserVar = new RegExp(`^${type_1.FormulaUserKey.replace("$", "\\$")}\\b`).test(formulaVar);
+        let isUserSessionVar = new RegExp(`^${type_1.FormulaUserSessionKey.replace("$", "\\$")}\\b`).test(formulaVar);
+        let varItems = formulaVar.split(".");
+        let paths = [];
+        let formulaVarItem = {
+            key: formulaVar,
+            paths: paths,
+        };
+        if (isUserVar || isUserSessionVar) {
+            isSimpleVar = false;
+            objectConfig = "space_users";
+        }
+        if (isSimpleVar) {
+            formulaVarItem.is_simple_var = true;
+            vars.push(formulaVarItem);
+            return;
+        }
+        if (isUserSessionVar) {
+            formulaVarItem.is_user_session_var = true;
+            vars.push(formulaVarItem);
+            return;
+        }
+        if (isUserVar) {
+            formulaVarItem.is_user_var = true;
+        }
+        else {
+            if (formulaVar.startsWith("$")) {
+                throw new Error(`computeFormulaVarAndQuotes:The formula var '${formulaVar}' is starts with '$' but not a user session var that starts with $user.`);
             }
-            let isUserVar = new RegExp(`^${type_1.FormulaUserKey.replace("$", "\\$")}\\b`).test(formulaVar);
-            let isUserSessionVar = new RegExp(`^${type_1.FormulaUserSessionKey.replace("$", "\\$")}\\b`).test(formulaVar);
-            let varItems = formulaVar.split(".");
-            let paths = [];
-            let formulaVarItem = {
-                key: formulaVar,
-                paths: paths,
-            };
-            if (isUserVar || isUserSessionVar) {
-                isSimpleVar = false;
-                objectConfig = "space_users";
+            if (!objectConfig) {
+                throw new Error(`computeFormulaVarAndQuotes:The 'objectConfig' is required for the formula var '${formulaVar}'`);
             }
-            if (isSimpleVar) {
-                formulaVarItem.is_simple_var = true;
-                vars.push(formulaVarItem);
-                return;
+        }
+        let tempObjectConfig = objectConfig;
+        let i = -1;
+        for await (let varItem of varItems) {
+            i++;
+            let tempFieldConfig;
+            const isUserKey = varItem === type_1.FormulaUserKey;
+            if (varItem === "_id") {
+                tempFieldConfig = {
+                    name: varItem,
+                    type: "text",
+                };
+            }
+            else if (isUserKey) {
+                tempFieldConfig = {
+                    name: varItem,
+                    type: "lookup",
+                    reference_to: "space_users",
+                };
             }
-            if (isUserSessionVar) {
-                formulaVarItem.is_user_session_var = true;
-                vars.push(formulaVarItem);
-                return;
+            else {
+                tempFieldConfig = tempObjectConfig.fields[varItem];
             }
-            if (isUserVar) {
-                formulaVarItem.is_user_var = true;
+            if (!tempFieldConfig) {
+                return;
             }
-            else {
-                if (formulaVar.startsWith("$")) {
-                    throw new Error(`computeFormulaVarAndQuotes:The formula var '${formulaVar}' is starts with '$' but not a user session var that starts with $user.`);
+            let isFormulaType = tempFieldConfig.type === "formula";
+            if (!isUserKey) {
+                let tempFieldFormulaVarPath = {
+                    field_name: varItem,
+                    reference_from: tempObjectConfig.name,
+                };
+                if (isFormulaType) {
+                    tempFieldFormulaVarPath.is_formula = true;
                 }
-                if (!objectConfig) {
-                    throw new Error(`computeFormulaVarAndQuotes:The 'objectConfig' is required for the formula var '${formulaVar}'`);
+                paths.push(tempFieldFormulaVarPath);
+            }
+            if (!isUserVar) {
+                let tempFieldFormulaQuote = {
+                    object_name: tempObjectConfig.name,
+                    field_name: tempFieldConfig.name,
+                };
+                if (i === 0 && i === varItems.length - 1) {
+                    tempFieldFormulaQuote.is_own = true;
                 }
-            }
-            let tempObjectConfig = objectConfig;
-            let i = -1;
-            try {
-                for (var _d = true, varItems_1 = tslib_1.__asyncValues(varItems), varItems_1_1; varItems_1_1 = yield varItems_1.next(), _a = varItems_1_1.done, !_a; _d = true) {
-                    _c = varItems_1_1.value;
-                    _d = false;
-                    let varItem = _c;
-                    i++;
-                    let tempFieldConfig;
-                    const isUserKey = varItem === type_1.FormulaUserKey;
-                    if (varItem === "_id") {
-                        tempFieldConfig = {
-                            name: varItem,
-                            type: "text",
-                        };
-                    }
-                    else if (isUserKey) {
-                        tempFieldConfig = {
-                            name: varItem,
-                            type: "lookup",
-                            reference_to: "space_users",
-                        };
-                    }
-                    else {
-                        tempFieldConfig = tempObjectConfig.fields[varItem];
-                    }
-                    if (!tempFieldConfig) {
-                        return;
-                    }
-                    let isFormulaType = tempFieldConfig.type === "formula";
-                    if (!isUserKey) {
-                        let tempFieldFormulaVarPath = {
-                            field_name: varItem,
-                            reference_from: tempObjectConfig.name,
-                        };
-                        if (isFormulaType) {
-                            tempFieldFormulaVarPath.is_formula = true;
-                        }
-                        paths.push(tempFieldFormulaVarPath);
-                    }
-                    if (!isUserVar) {
-                        let tempFieldFormulaQuote = {
-                            object_name: tempObjectConfig.name,
-                            field_name: tempFieldConfig.name,
-                        };
-                        if (i === 0 && i === varItems.length - 1) {
-                            tempFieldFormulaQuote.is_own = true;
-                        }
-                        if (isFormulaType) {
-                            tempFieldFormulaQuote.is_formula = true;
-                        }
-                        this.addFieldFormulaQuotesConfig(tempFieldFormulaQuote, quotes);
-                    }
-                    if (tempFieldConfig.type === "lookup" ||
-                        tempFieldConfig.type === "master_detail") {
-                        if (tempFieldConfig.reference_to_field && paths.length) {
-                            paths[paths.length - 1].reference_to_field =
-                                tempFieldConfig.reference_to_field;
-                        }
-                    }
-                    else {
-                        if (i < varItems.length - 1) {
-                            formulaVarItem.key = formulaVarItem.key.replace(new RegExp(`((.+)?${varItem})..+`), "$1");
-                        }
-                        break;
-                    }
-                    if (typeof tempFieldConfig.reference_to !== "string") {
-                        throw new Error(`Field ${tempFieldConfig.name} in formula ${formulaVar} does not define the "Reference Object" property or its "Reference Object" property is a function.`);
-                    }
-                    tempObjectConfig = yield this.getObjectConfig(tempFieldConfig.reference_to);
-                    if (!tempObjectConfig) {
-                        if (isCodeObject(tempFieldConfig.reference_to)) {
-                            throw new Error(`computeFormulaVarAndQuotes:Can't find the object reference_to '${tempFieldConfig.reference_to}' by the field '${tempFieldConfig.name}' for the formula var '${formulaVar}'`);
-                        }
-                        else {
-                            yield metadata_registrar_1.Register.add(this.broker, {
-                                key: this.cacherKey(getDynamicCalcMapCacherKey(tempFieldConfig.reference_to, objectConfig.name)),
-                                data: { objectApiName: objectConfig.name },
-                            }, {});
-                            return;
-                        }
-                    }
+                if (isFormulaType) {
+                    tempFieldFormulaQuote.is_formula = true;
                 }
+                this.addFieldFormulaQuotesConfig(tempFieldFormulaQuote, quotes);
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = varItems_1.return)) yield _b.call(varItems_1);
+            if (tempFieldConfig.type === "lookup" ||
+                tempFieldConfig.type === "master_detail") {
+                if (tempFieldConfig.reference_to_field && paths.length) {
+                    paths[paths.length - 1].reference_to_field =
+                        tempFieldConfig.reference_to_field;
                 }
-                finally { if (e_1) throw e_1.error; }
             }
-            vars.push(formulaVarItem);
-        });
-    }
-    computeFormulaVarsAndQuotes(formula, objectConfig) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, e_2, _b, _c;
-            let quotes = [];
-            let vars = [];
-            let formulaVars = [];
-            try {
-                formulaVars = (0, core_1.pickFormulaVars)(formula);
+            else {
+                if (i < varItems.length - 1) {
+                    formulaVarItem.key = formulaVarItem.key.replace(new RegExp(`((.+)?${varItem})..+`), "$1");
+                }
+                break;
             }
-            catch (ex) {
-                throw new Error(`pickFormulaVars:Catch an error "${ex}" while pick vars from the formula "${formula}" for "${JSON.stringify(objectConfig)}"`);
+            if (typeof tempFieldConfig.reference_to !== "string") {
+                throw new Error(`Field ${tempFieldConfig.name} in formula ${formulaVar} does not define the "Reference Object" property or its "Reference Object" property is a function.`);
             }
-            try {
-                for (var _d = true, formulaVars_1 = tslib_1.__asyncValues(formulaVars), formulaVars_1_1; formulaVars_1_1 = yield formulaVars_1.next(), _a = formulaVars_1_1.done, !_a; _d = true) {
-                    _c = formulaVars_1_1.value;
-                    _d = false;
-                    const formulaVar = _c;
-                    yield this.computeFormulaVarAndQuotes(formulaVar, objectConfig, quotes, vars);
+            tempObjectConfig = await this.getObjectConfig(tempFieldConfig.reference_to);
+            if (!tempObjectConfig) {
+                if (isCodeObject(tempFieldConfig.reference_to)) {
+                    throw new Error(`computeFormulaVarAndQuotes:Can't find the object reference_to '${tempFieldConfig.reference_to}' by the field '${tempFieldConfig.name}' for the formula var '${formulaVar}'`);
                 }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = formulaVars_1.return)) yield _b.call(formulaVars_1);
+                else {
+                    await metadata_registrar_1.Register.add(this.broker, {
+                        key: this.cacherKey(getDynamicCalcMapCacherKey(tempFieldConfig.reference_to, objectConfig.name)),
+                        data: { objectApiName: objectConfig.name },
+                    }, {});
+                    return;
                 }
-                finally { if (e_2) throw e_2.error; }
             }
-            return { quotes, vars };
-        });
+        }
+        vars.push(formulaVarItem);
+    }
+    async computeFormulaVarsAndQuotes(formula, objectConfig) {
+        let quotes = [];
+        let vars = [];
+        let formulaVars = [];
+        try {
+            formulaVars = (0, core_1.pickFormulaVars)(formula);
+        }
+        catch (ex) {
+            throw new Error(`pickFormulaVars:Catch an error "${ex}" while pick vars from the formula "${formula}" for "${JSON.stringify(objectConfig)}"`);
+        }
+        for await (const formulaVar of formulaVars) {
+            await this.computeFormulaVarAndQuotes(formulaVar, objectConfig, quotes, vars);
+        }
+        return { quotes, vars };
     }
     cacherKey(APIName) {
         return `$steedos.#formula.${APIName}`;
     }
-    getObjectFieldFormulaConfig(fieldConfig, objectConfig) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const formula = fieldConfig.formula;
-            let result = yield this.computeFormulaVarsAndQuotes(formula, objectConfig);
-            let formulaConfig = {
-                _id: `${objectConfig.name}.${fieldConfig.name}`,
-                object_name: objectConfig.name,
-                field_name: fieldConfig.name,
-                formula: formula,
-                data_type: fieldConfig.data_type,
-                formula_blank_value: (fieldConfig.formula_blank_value),
-                quotes: result.quotes,
-                vars: result.vars,
-            };
-            return formulaConfig;
-        });
+    async getObjectFieldFormulaConfig(fieldConfig, objectConfig) {
+        const formula = fieldConfig.formula;
+        let result = await this.computeFormulaVarsAndQuotes(formula, objectConfig);
+        let formulaConfig = {
+            _id: `${objectConfig.name}.${fieldConfig.name}`,
+            object_name: objectConfig.name,
+            field_name: fieldConfig.name,
+            formula: formula,
+            data_type: fieldConfig.data_type,
+            formula_blank_value: (fieldConfig.formula_blank_value),
+            quotes: result.quotes,
+            vars: result.vars,
+        };
+        return formulaConfig;
     }
-    getObjectFieldsFormulaConfig(config, datasource) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, e_3, _b, _c;
-            const objectFieldsFormulaConfig = [];
-            try {
-                for (var _d = true, _e = tslib_1.__asyncValues(_.values(config.fields)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const field = _c;
-                    if (field.type === "formula") {
-                        try {
-                            const fieldFormulaConfig = yield this.getObjectFieldFormulaConfig(clone(field), config);
-                            objectFieldsFormulaConfig.push(fieldFormulaConfig);
-                        }
-                        catch (error) {
-                            console.error(error);
-                        }
-                    }
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
+    async getObjectFieldsFormulaConfig(config, datasource) {
+        const objectFieldsFormulaConfig = [];
+        for await (const field of _.values(config.fields)) {
+            if (field.type === "formula") {
                 try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    const fieldFormulaConfig = await this.getObjectFieldFormulaConfig(clone(field), config);
+                    objectFieldsFormulaConfig.push(fieldFormulaConfig);
+                }
+                catch (error) {
+                    console.error(error);
                 }
-                finally { if (e_3) throw e_3.error; }
             }
-            return objectFieldsFormulaConfig;
-        });
+        }
+        return objectFieldsFormulaConfig;
     }
     checkRefMapData(maps, data) {
         let refs = [];
@@ -286,212 +234,127 @@ class FormulaActionHandler {
             throw new Error(`Infinite Loop: ${JSON.stringify(data)}`);
         }
     }
-    getFormulaReferenceMaps(broker) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, e_4, _b, _c;
-            const maps = [];
-            let records = (yield metadata_registrar_1.Register.filter(this.broker, this.cacherKey(`${refMapName}.*`))) ||
-                {};
-            try {
-                for (var _d = true, records_1 = tslib_1.__asyncValues(records), records_1_1; records_1_1 = yield records_1.next(), _a = records_1_1.done, !_a; _d = true) {
-                    _c = records_1_1.value;
-                    _d = false;
-                    const item = _c;
-                    const metadata = item === null || item === void 0 ? void 0 : item.metadata;
-                    if (metadata) {
-                        maps.push(item);
-                    }
-                }
-            }
-            catch (e_4_1) { e_4 = { error: e_4_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = records_1.return)) yield _b.call(records_1);
-                }
-                finally { if (e_4) throw e_4.error; }
-            }
-            return { metadata: maps };
-        });
-    }
-    addFormulaReferenceMaps(broker, key, value) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let { metadata } = (yield this.getFormulaReferenceMaps(broker)) || [];
-            let maps = [];
+    async getFormulaReferenceMaps(broker) {
+        const maps = [];
+        let records = (await metadata_registrar_1.Register.filter(this.broker, this.cacherKey(`${refMapName}.*`))) ||
+            {};
+        for await (const item of records) {
+            const metadata = item?.metadata;
             if (metadata) {
-                maps = metadata;
+                maps.push(item);
             }
-            let data = {
-                key: key,
-                value: value,
-            };
-            this.checkRefMapData(maps, data);
-            yield metadata_registrar_1.Register.add(this.broker, { key: this.cacherKey(`${refMapName}.${key}.${value}`), data: data }, {});
-        });
+        }
+        return { metadata: maps };
     }
-    addFormulaMetadata(config, datasource) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, e_5, _b, _c, _d, e_6, _e, _f;
-            const objectFieldsFormulaConfig = yield this.getObjectFieldsFormulaConfig(config, datasource);
-            const objectFormulas = yield this.filter({
-                params: { objectApiName: config.name },
-            });
-            const formulaFieldsName = _.map(objectFormulas, "field_name");
-            const objectFields = _.map(config.fields, "name");
-            const diff = _.difference(formulaFieldsName, objectFields);
-            try {
-                for (var _g = true, objectFieldsFormulaConfig_1 = tslib_1.__asyncValues(objectFieldsFormulaConfig), objectFieldsFormulaConfig_1_1; objectFieldsFormulaConfig_1_1 = yield objectFieldsFormulaConfig_1.next(), _a = objectFieldsFormulaConfig_1_1.done, !_a; _g = true) {
-                    _c = objectFieldsFormulaConfig_1_1.value;
-                    _g = false;
-                    const fieldFormula = _c;
-                    try {
-                        for (var _h = true, _j = (e_6 = void 0, tslib_1.__asyncValues(fieldFormula.quotes)), _k; _k = yield _j.next(), _d = _k.done, !_d; _h = true) {
-                            _f = _k.value;
-                            _h = false;
-                            const quote = _f;
-                            yield this.addFormulaReferenceMaps(this.broker, `${fieldFormula._id}`, `${quote.object_name}.${quote.field_name}`);
-                        }
-                    }
-                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                    finally {
-                        try {
-                            if (!_h && !_d && (_e = _j.return)) yield _e.call(_j);
-                        }
-                        finally { if (e_6) throw e_6.error; }
-                    }
-                    yield metadata_registrar_1.Register.add(this.broker, { key: this.cacherKey(fieldFormula._id), data: fieldFormula }, {});
-                }
-            }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (!_g && !_a && (_b = objectFieldsFormulaConfig_1.return)) yield _b.call(objectFieldsFormulaConfig_1);
-                }
-                finally { if (e_5) throw e_5.error; }
-            }
-            for (const deletedFieldName of diff) {
-                if (deletedFieldName) {
-                    yield metadata_registrar_1.Register.delete(this.broker, this.cacherKey(`${config.name}.${deletedFieldName}`));
-                }
-            }
-            return true;
-        });
+    async addFormulaReferenceMaps(broker, key, value) {
+        let { metadata } = (await this.getFormulaReferenceMaps(broker)) || [];
+        let maps = [];
+        if (metadata) {
+            maps = metadata;
+        }
+        let data = {
+            key: key,
+            value: value,
+        };
+        this.checkRefMapData(maps, data);
+        await metadata_registrar_1.Register.add(this.broker, { key: this.cacherKey(`${refMapName}.${key}.${value}`), data: data }, {});
     }
-    getObjectDynamicCalcFormulaMap(objectApiName) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return yield metadata_registrar_1.Register.filter(this.broker, this.cacherKey(getDynamicCalcMapCacherKey(objectApiName, "*")));
+    async addFormulaMetadata(config, datasource) {
+        const objectFieldsFormulaConfig = await this.getObjectFieldsFormulaConfig(config, datasource);
+        const objectFormulas = await this.filter({
+            params: { objectApiName: config.name },
         });
-    }
-    recalcObjectsFormulaMap(objectConfig) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, e_7, _b, _c;
-            var _d;
-            const recalcObjects = {};
-            const dynamicCalcFormulaMap = yield this.getObjectDynamicCalcFormulaMap(objectConfig.name);
-            try {
-                for (var _e = true, dynamicCalcFormulaMap_1 = tslib_1.__asyncValues(dynamicCalcFormulaMap), dynamicCalcFormulaMap_1_1; dynamicCalcFormulaMap_1_1 = yield dynamicCalcFormulaMap_1.next(), _a = dynamicCalcFormulaMap_1_1.done, !_a; _e = true) {
-                    _c = dynamicCalcFormulaMap_1_1.value;
-                    _e = false;
-                    const item = _c;
-                    const recalcObjectApiName = (_d = item === null || item === void 0 ? void 0 : item.metadata) === null || _d === void 0 ? void 0 : _d.objectApiName;
-                    if (recalcObjectApiName) {
-                        const recalcObjectConfig = yield this.getObjectConfig(recalcObjectApiName);
-                        if (recalcObjectConfig) {
-                            recalcObjects[recalcObjectApiName] = recalcObjectConfig;
-                        }
-                    }
-                }
+        const formulaFieldsName = _.map(objectFormulas, "field_name");
+        const objectFields = _.map(config.fields, "name");
+        const diff = _.difference(formulaFieldsName, objectFields);
+        for await (const fieldFormula of objectFieldsFormulaConfig) {
+            for await (const quote of fieldFormula.quotes) {
+                await this.addFormulaReferenceMaps(this.broker, `${fieldFormula._id}`, `${quote.object_name}.${quote.field_name}`);
+            }
+            await metadata_registrar_1.Register.add(this.broker, { key: this.cacherKey(fieldFormula._id), data: fieldFormula }, {});
+        }
+        for (const deletedFieldName of diff) {
+            if (deletedFieldName) {
+                await metadata_registrar_1.Register.delete(this.broker, this.cacherKey(`${config.name}.${deletedFieldName}`));
             }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (!_e && !_a && (_b = dynamicCalcFormulaMap_1.return)) yield _b.call(dynamicCalcFormulaMap_1);
+        }
+        return true;
+    }
+    async getObjectDynamicCalcFormulaMap(objectApiName) {
+        return await metadata_registrar_1.Register.filter(this.broker, this.cacherKey(getDynamicCalcMapCacherKey(objectApiName, "*")));
+    }
+    async recalcObjectsFormulaMap(objectConfig) {
+        const recalcObjects = {};
+        const dynamicCalcFormulaMap = await this.getObjectDynamicCalcFormulaMap(objectConfig.name);
+        for await (const item of dynamicCalcFormulaMap) {
+            const recalcObjectApiName = item?.metadata?.objectApiName;
+            if (recalcObjectApiName) {
+                const recalcObjectConfig = await this.getObjectConfig(recalcObjectApiName);
+                if (recalcObjectConfig) {
+                    recalcObjects[recalcObjectApiName] = recalcObjectConfig;
                 }
-                finally { if (e_7) throw e_7.error; }
             }
-            for (const objectName in recalcObjects) {
-                if (Object.prototype.hasOwnProperty.call(recalcObjects, objectName)) {
-                    const recalcObjectConfig = recalcObjects[objectName];
-                    yield this.addFormulaMetadata(recalcObjectConfig, recalcObjectConfig.datasource);
-                    yield metadata_registrar_1.Register.delete(this.broker, this.cacherKey(getDynamicCalcMapCacherKey(objectConfig.name, objectName)));
-                }
+        }
+        for (const objectName in recalcObjects) {
+            if (Object.prototype.hasOwnProperty.call(recalcObjects, objectName)) {
+                const recalcObjectConfig = recalcObjects[objectName];
+                await this.addFormulaMetadata(recalcObjectConfig, recalcObjectConfig.datasource);
+                await metadata_registrar_1.Register.delete(this.broker, this.cacherKey(getDynamicCalcMapCacherKey(objectConfig.name, objectName)));
             }
-        });
+        }
     }
-    add(objectConfig) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.addFormulaMetadata(objectConfig, objectConfig.datasource);
-                return true;
-            }
-            catch (error) {
-                this.broker.logger.error(error);
-            }
-            return false;
-        });
+    async add(objectConfig) {
+        try {
+            await this.addFormulaMetadata(objectConfig, objectConfig.datasource);
+            return true;
+        }
+        catch (error) {
+            this.broker.logger.error(error);
+        }
+        return false;
     }
-    filter(ctx) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let { objectApiName, fieldApiName } = ctx.params;
-            if (!objectApiName) {
-                objectApiName = "*";
-            }
-            if (!fieldApiName) {
-                fieldApiName = "*";
-            }
-            const key = this.cacherKey(`${objectApiName}.${fieldApiName}`);
-            const configs = [];
-            const res = yield metadata_registrar_1.Register.filter(this.broker, key);
-            _.forEach(res, (item) => {
-                configs.push(item === null || item === void 0 ? void 0 : item.metadata);
-            });
-            return configs;
+    async filter(ctx) {
+        let { objectApiName, fieldApiName } = ctx.params;
+        if (!objectApiName) {
+            objectApiName = "*";
+        }
+        if (!fieldApiName) {
+            fieldApiName = "*";
+        }
+        const key = this.cacherKey(`${objectApiName}.${fieldApiName}`);
+        const configs = [];
+        const res = await metadata_registrar_1.Register.filter(this.broker, key);
+        _.forEach(res, (item) => {
+            configs.push(item?.metadata);
         });
+        return configs;
     }
-    get(ctx) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let { fieldApiFullName } = ctx.params;
-            const key = this.cacherKey(fieldApiFullName);
-            const res = yield metadata_registrar_1.Register.get(this.broker, key);
-            return res === null || res === void 0 ? void 0 : res.metadata;
-        });
+    async get(ctx) {
+        let { fieldApiFullName } = ctx.params;
+        const key = this.cacherKey(fieldApiFullName);
+        const res = await metadata_registrar_1.Register.get(this.broker, key);
+        return res?.metadata;
     }
-    verifyObjectFieldFormulaConfig(ctx) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, e_8, _b, _c;
-            let { fieldConfig, objectConfig } = ctx.params;
-            const fieldFormula = yield this.getObjectFieldFormulaConfig(fieldConfig, objectConfig);
-            let { metadata } = (yield this.getFormulaReferenceMaps(ctx.broker)) || [];
-            let maps = [];
-            if (metadata) {
-                maps = metadata;
-            }
-            try {
-                for (var _d = true, _e = tslib_1.__asyncValues(fieldFormula.quotes), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const quote = _c;
-                    let data = {
-                        key: fieldFormula._id,
-                        value: `${quote.object_name}.${quote.field_name}`,
-                    };
-                    this.checkRefMapData(maps, data);
-                }
-            }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_8) throw e_8.error; }
-            }
-            return yield this.getObjectFieldFormulaConfig(fieldConfig, objectConfig);
-        });
+    async verifyObjectFieldFormulaConfig(ctx) {
+        let { fieldConfig, objectConfig } = ctx.params;
+        const fieldFormula = await this.getObjectFieldFormulaConfig(fieldConfig, objectConfig);
+        let { metadata } = (await this.getFormulaReferenceMaps(ctx.broker)) || [];
+        let maps = [];
+        if (metadata) {
+            maps = metadata;
+        }
+        for await (const quote of fieldFormula.quotes) {
+            let data = {
+                key: fieldFormula._id,
+                value: `${quote.object_name}.${quote.field_name}`,
+            };
+            this.checkRefMapData(maps, data);
+        }
+        return await this.getObjectFieldFormulaConfig(fieldConfig, objectConfig);
     }
-    getFormulaVarsAndQuotes(ctx) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let { formula, objectConfig } = ctx.params;
-            return yield this.computeFormulaVarsAndQuotes(formula, objectConfig);
-        });
+    async getFormulaVarsAndQuotes(ctx) {
+        let { formula, objectConfig } = ctx.params;
+        return await this.computeFormulaVarsAndQuotes(formula, objectConfig);
     }
 }
 exports.FormulaActionHandler = FormulaActionHandler;