@steedos/metadata-registrar 3.0.13-beta.9 → 3.0.13

package/lib/index.js

@@ -59,69 +59,74 @@ tslib_1.__exportStar(require("./metadata-register/dashboard"), exports);
 tslib_1.__exportStar(require("./metadata-register/print"), exports);
 let savePackageServicesTimeoutID = null;
 const useScan = true;
-function redisScanKeys(redisClient_1, match_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (redisClient, match, count = 10000) {
-        if (!useScan) {
-            return yield redisClient.keys(match);
-        }
-        else {
-            return yield new Promise((resolve, reject) => {
-                if (_.isFunction(redisClient.scanStream)) {
-                    var stream = redisClient.scanStream({
-                        match: match,
-                        count: count,
-                    });
-                    var keys = [];
-                    stream.on("data", function (resultKeys) {
-                        for (var i = 0; i < resultKeys.length; i++) {
-                            keys.push(resultKeys[i]);
-                        }
-                    });
-                    stream.on("end", function () {
-                        resolve(keys);
-                    });
-                }
-                else {
-                    let nodes = redisClient.nodes("master");
-                    let allPromises = [];
-                    for (let index = 0; index < nodes.length; index++) {
-                        const node = nodes[index];
-                        allPromises.push(new Promise((res, reject) => {
-                            var keys = [];
-                            node
-                                .scanStream({
-                                match: match,
-                                count: count,
-                            })
-                                .on("data", (resultKeys) => {
-                                for (var i = 0; i < resultKeys.length; i++) {
-                                    keys.push(resultKeys[i]);
-                                }
-                            })
-                                .on("end", () => {
-                                res(keys);
-                            });
-                        }));
+async function redisScanKeys(redisClient, match, count = 10000) {
+    if (!useScan) {
+        return await redisClient.keys(match);
+    }
+    else {
+        return await new Promise((resolve, reject) => {
+            if (_.isFunction(redisClient.scanStream)) {
+                var stream = redisClient.scanStream({
+                    match: match,
+                    count: count,
+                });
+                var keys = [];
+                stream.on("data", function (resultKeys) {
+                    for (var i = 0; i < resultKeys.length; i++) {
+                        keys.push(resultKeys[i]);
                     }
-                    Promise.all(allPromises).then((values) => {
-                        let joinedKeys = [];
-                        for (const keys of values) {
-                            joinedKeys = joinedKeys.concat(keys);
-                        }
-                        resolve(joinedKeys);
-                    });
+                });
+                stream.on("end", function () {
+                    resolve(keys);
+                });
+            }
+            else {
+                let nodes = redisClient.nodes("master");
+                let allPromises = [];
+                for (let index = 0; index < nodes.length; index++) {
+                    const node = nodes[index];
+                    allPromises.push(new Promise((res, reject) => {
+                        var keys = [];
+                        node
+                            .scanStream({
+                            match: match,
+                            count: count,
+                        })
+                            .on("data", (resultKeys) => {
+                            for (var i = 0; i < resultKeys.length; i++) {
+                                keys.push(resultKeys[i]);
+                            }
+                        })
+                            .on("end", () => {
+                            res(keys);
+                        });
+                    }));
                 }
-            });
-        }
-    });
+                Promise.all(allPromises).then((values) => {
+                    let joinedKeys = [];
+                    for (const keys of values) {
+                        joinedKeys = joinedKeys.concat(keys);
+                    }
+                    resolve(joinedKeys);
+                });
+            }
+        });
+    }
 }
 function transformMetadata(params, meta) {
-    return Object.assign(Object.assign({}, meta.caller), { metadata: params.data, timestamp: new Date().getTime() });
+    return {
+        ...meta.caller,
+        metadata: params.data,
+        timestamp: new Date().getTime(),
+    };
 }
 function transformMetadatas(params, meta) {
     const data = {};
     (0, lodash_1.map)(params.data, (value, key) => {
-        data[key] = Object.assign(Object.assign({}, meta.caller), { metadata: value });
+        data[key] = {
+            ...meta.caller,
+            metadata: value,
+        };
     });
     return data;
 }
@@ -131,550 +136,431 @@ function getKey(key, keyPrefix) {
 function getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName) {
     return `$${nodeID}.${SERVICE_METADATA_PREFIX}.${serviceName}.${metadataType}.${metadataApiName}`;
 }
-function addServiceMetadata(broker, params, meta) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { nodeID } = meta.caller || { nodeID: undefined };
-        if (!nodeID) {
-            console.log(`addServiceMetadata meta`, meta);
-        }
-        const { metadataType, metadataApiName, metadataServiceName } = meta || {
-            metadataType: undefined,
-            metadataApiName: undefined,
-            metadataServiceName: undefined,
-        };
-        if (!metadataServiceName) {
-            return;
-        }
-        const key = getServiceMetadataCacherKey(nodeID, metadataServiceName, metadataType, metadataApiName);
-        yield broker.cacher.set(key, {
+async function addServiceMetadata(broker, params, meta) {
+    const { nodeID } = meta.caller || { nodeID: undefined };
+    if (!nodeID) {
+        console.log(`addServiceMetadata meta`, meta);
+    }
+    const { metadataType, metadataApiName, metadataServiceName } = meta || {
+        metadataType: undefined,
+        metadataApiName: undefined,
+        metadataServiceName: undefined,
+    };
+    if (!metadataServiceName) {
+        return;
+    }
+    const key = getServiceMetadataCacherKey(nodeID, metadataServiceName, metadataType, metadataApiName);
+    await broker.cacher.set(key, {
+        nodeIds: [nodeID],
+        metadataType,
+        metadataApiName,
+        metadataServiceName,
+        metadata: params.data,
+        timestamp: new Date().getTime(),
+    });
+}
+async function maddServiceMetadata(broker, params, meta) {
+    const { nodeID } = meta.caller || { nodeID: undefined };
+    if (!nodeID) {
+        console.log(`addServiceMetadata meta`, meta);
+    }
+    const { metadataType, metadataServiceName } = meta || {
+        metadataType: undefined,
+        metadataServiceName: undefined,
+    };
+    const { data } = params;
+    if (!metadataServiceName || !data) {
+        return;
+    }
+    const mdata = {};
+    (0, lodash_1.map)(data, (value, metadataApiName) => {
+        mdata[getServiceMetadataCacherKey(nodeID, metadataServiceName, metadataType, metadataApiName)] = {
             nodeIds: [nodeID],
             metadataType,
             metadataApiName,
             metadataServiceName,
-            metadata: params.data,
-            timestamp: new Date().getTime(),
-        });
-    });
-}
-function maddServiceMetadata(broker, params, meta) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { nodeID } = meta.caller || { nodeID: undefined };
-        if (!nodeID) {
-            console.log(`addServiceMetadata meta`, meta);
-        }
-        const { metadataType, metadataServiceName } = meta || {
-            metadataType: undefined,
-            metadataServiceName: undefined,
+            metadata: value,
         };
-        const { data } = params;
-        if (!metadataServiceName || !data) {
-            return;
-        }
-        const mdata = {};
-        (0, lodash_1.map)(data, (value, metadataApiName) => {
-            mdata[getServiceMetadataCacherKey(nodeID, metadataServiceName, metadataType, metadataApiName)] = {
-                nodeIds: [nodeID],
-                metadataType,
-                metadataApiName,
-                metadataServiceName,
-                metadata: value,
-            };
-        });
-        yield mset(broker, mdata);
     });
+    await mset(broker, mdata);
 }
-function mget(broker, keys) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        if (!keys || keys.length == 0) {
-            return [];
+async function mget(broker, keys) {
+    if (!keys || keys.length == 0) {
+        return [];
+    }
+    const keyPrefix = broker.cacher?.prefix || "";
+    const values = await broker.cacher.client.mget(...(0, lodash_1.map)(keys, (key) => {
+        if (key && !key.startsWith(keyPrefix)) {
+            return `${keyPrefix}${key}`;
+        }
+        else {
+            return key;
         }
-        const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-        const values = yield broker.cacher.client.mget(...(0, lodash_1.map)(keys, (key) => {
-            if (key && !key.startsWith(keyPrefix)) {
-                return `${keyPrefix}${key}`;
+    }));
+    const results = [];
+    _.map(values, (item) => {
+        try {
+            if (item) {
+                results.push(JSON.parse(item));
             }
             else {
-                return key;
-            }
-        }));
-        const results = [];
-        _.map(values, (item) => {
-            try {
-                if (item) {
-                    results.push(JSON.parse(item));
-                }
-                else {
-                    results.push(item);
-                }
-            }
-            catch (error) {
                 results.push(item);
             }
-        });
-        return results;
-    });
-}
-function mset(broker, data) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        if (_.isEmpty(data)) {
-            return;
-        }
-        const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-        const mdata = {};
-        _.map(data, (v, k) => {
-            mdata[`${keyPrefix}${k}`] = JSON.stringify(v);
-        });
-        return yield broker.cacher.client.mset(mdata);
-    });
-}
-function query(broker, queryKey) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        try {
-            const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const keys = yield redisScanKeys(broker.cacher.client, `${keyPrefix}${queryKey}`);
-            const values = _.compact(yield mget(broker, keys));
-            return values;
         }
         catch (error) {
+            results.push(item);
         }
-        return [];
     });
+    return results;
+}
+async function mset(broker, data) {
+    if (_.isEmpty(data)) {
+        return;
+    }
+    const keyPrefix = broker.cacher?.prefix || "";
+    const mdata = {};
+    _.map(data, (v, k) => {
+        mdata[`${keyPrefix}${k}`] = JSON.stringify(v);
+    });
+    return await broker.cacher.client.mset(mdata);
+}
+async function query(broker, queryKey) {
+    try {
+        const keyPrefix = broker.cacher?.prefix || "";
+        const keys = await redisScanKeys(broker.cacher.client, `${keyPrefix}${queryKey}`);
+        const values = _.compact(await mget(broker, keys));
+        return values;
+    }
+    catch (error) {
+    }
+    return [];
 }
 function getPackageServiceCacherKey(nodeID, serviceName) {
     return `$${nodeID}.${PACKAGE_SERVICES_KEY}.${serviceName}`;
 }
-function setPackageServices(broker, packageServices) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, packageServices_1, packageServices_1_1;
-        var _b, e_1, _c, _d;
-        try {
-            for (_a = true, packageServices_1 = tslib_1.__asyncValues(packageServices); packageServices_1_1 = yield packageServices_1.next(), _b = packageServices_1_1.done, !_b; _a = true) {
-                _d = packageServices_1_1.value;
-                _a = false;
-                const packageService = _d;
-                broker.cacher.set(getPackageServiceCacherKey(packageService.nodeID, packageService.name), { service: packageService });
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_a && !_b && (_c = packageServices_1.return)) yield _c.call(packageServices_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    });
+async function setPackageServices(broker, packageServices) {
+    for await (const packageService of packageServices) {
+        broker.cacher.set(getPackageServiceCacherKey(packageService.nodeID, packageService.name), { service: packageService });
+    }
 }
-function clearPackageServices(broker, packageServices) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, packageServices_2, packageServices_2_1;
-        var _b, e_2, _c, _d;
-        try {
-            for (_a = true, packageServices_2 = tslib_1.__asyncValues(packageServices); packageServices_2_1 = yield packageServices_2.next(), _b = packageServices_2_1.done, !_b; _a = true) {
-                _d = packageServices_2_1.value;
-                _a = false;
-                const packageService = _d;
-                let nodeID = null;
-                let name = null;
-                if (_.isString(packageService)) {
-                    let foo = packageService.split(".");
-                    nodeID = foo.splice(0, foo.length - 1).join(".");
-                    name = foo.join(".");
-                }
-                else if (_.isObject(packageService)) {
-                    nodeID = packageService.nodeID;
-                    name = packageService.name;
-                }
-                yield broker.cacher.del(getPackageServiceCacherKey(nodeID, name));
-            }
+async function clearPackageServices(broker, packageServices) {
+    for await (const packageService of packageServices) {
+        let nodeID = null;
+        let name = null;
+        if (_.isString(packageService)) {
+            let foo = packageService.split(".");
+            nodeID = foo.splice(0, foo.length - 1).join(".");
+            name = foo.join(".");
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (!_a && !_b && (_c = packageServices_2.return)) yield _c.call(packageServices_2);
-            }
-            finally { if (e_2) throw e_2.error; }
+        else if (_.isObject(packageService)) {
+            nodeID = packageService.nodeID;
+            name = packageService.name;
         }
-    });
+        await broker.cacher.del(getPackageServiceCacherKey(nodeID, name));
+    }
 }
-function getLastPackageServices(broker) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const packageServices = yield query(broker, getPackageServiceCacherKey("*", "*"));
-        const services = [];
-        packageServices.forEach((element) => {
-            if (element) {
-                services.push(element.service);
-            }
-        });
-        return services;
+async function getLastPackageServices(broker) {
+    const packageServices = await query(broker, getPackageServiceCacherKey("*", "*"));
+    const services = [];
+    packageServices.forEach((element) => {
+        if (element) {
+            services.push(element.service);
+        }
     });
+    return services;
 }
-function getPackageServices(broker) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const packageServices = [];
-        const services = broker.registry.getServiceList({ withActions: true });
-        _.each(services, (serviceItem) => {
-            const { name, nodeID } = serviceItem;
-            if (name.startsWith(PACKAGE_SERVICE_PREFIX)) {
-                packageServices.push(Object.assign({}, serviceItem, { apiName: `${nodeID}.${name}` }));
-            }
-        });
-        return packageServices;
+async function getPackageServices(broker) {
+    const packageServices = [];
+    const services = broker.registry.getServiceList({ withActions: true });
+    _.each(services, (serviceItem) => {
+        const { name, nodeID } = serviceItem;
+        if (name.startsWith(PACKAGE_SERVICE_PREFIX)) {
+            packageServices.push(Object.assign({}, serviceItem, { apiName: `${nodeID}.${name}` }));
+        }
     });
+    return packageServices;
 }
-function clearPackageServiceMetadatas(broker, nodeID, packageServiceName) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const key = getServiceMetadataCacherKey(nodeID, packageServiceName, "*", "*");
-        const clearMetadatas = yield query(broker, key);
-        yield broker.cacher.clean(key);
-        return clearMetadatas;
-    });
+async function clearPackageServiceMetadatas(broker, nodeID, packageServiceName) {
+    const key = getServiceMetadataCacherKey(nodeID, packageServiceName, "*", "*");
+    const clearMetadatas = await query(broker, key);
+    await broker.cacher.clean(key);
+    return clearMetadatas;
 }
-function clearPackageServicesMetadatas(broker, offlinePackageServices) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a, offlinePackageServices_1, offlinePackageServices_1_1;
-        var _b, e_3, _c, _d;
-        let clearMetadatas = [];
-        try {
-            for (_a = true, offlinePackageServices_1 = tslib_1.__asyncValues(offlinePackageServices); offlinePackageServices_1_1 = yield offlinePackageServices_1.next(), _b = offlinePackageServices_1_1.done, !_b; _a = true) {
-                _d = offlinePackageServices_1_1.value;
-                _a = false;
-                const packageService = _d;
-                let nodeID = null;
-                let name = null;
-                if (_.isString(packageService)) {
-                    let foo = packageService.split(".");
-                    nodeID = foo.splice(0, foo.length - 1).join(".");
-                    name = foo.join(".");
-                }
-                else if (_.isObject(packageService)) {
-                    nodeID = packageService.nodeID;
-                    name = packageService.name;
-                }
-                const clearPackageMetadatas = yield clearPackageServiceMetadatas(broker, nodeID, name);
-                clearMetadatas = clearMetadatas.concat(clearPackageMetadatas);
-            }
+async function clearPackageServicesMetadatas(broker, offlinePackageServices) {
+    let clearMetadatas = [];
+    for await (const packageService of offlinePackageServices) {
+        let nodeID = null;
+        let name = null;
+        if (_.isString(packageService)) {
+            let foo = packageService.split(".");
+            nodeID = foo.splice(0, foo.length - 1).join(".");
+            name = foo.join(".");
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (!_a && !_b && (_c = offlinePackageServices_1.return)) yield _c.call(offlinePackageServices_1);
-            }
-            finally { if (e_3) throw e_3.error; }
+        else if (_.isObject(packageService)) {
+            nodeID = packageService.nodeID;
+            name = packageService.name;
         }
-        _.each(_.groupBy(clearMetadatas, "metadataType"), function (data, metadataType) {
-            broker.emit(`${SERVICE_METADATA_PREFIX}.${metadataType}.clear`, {
-                metadataType,
-                metadataApiNames: _.pluck(data, "metadataApiName"),
-                isClear: true,
-            });
+        const clearPackageMetadatas = await clearPackageServiceMetadatas(broker, nodeID, name);
+        clearMetadatas = clearMetadatas.concat(clearPackageMetadatas);
+    }
+    _.each(_.groupBy(clearMetadatas, "metadataType"), function (data, metadataType) {
+        broker.emit(`${SERVICE_METADATA_PREFIX}.${metadataType}.clear`, {
+            metadataType,
+            metadataApiNames: _.pluck(data, "metadataApiName"),
+            isClear: true,
         });
     });
 }
-function getMetadataServices(broker) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const queryKey = `${METADATA_SERVICES_PREFIX}.*`;
-        const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-        const keys = yield redisScanKeys(broker.cacher.client, `${keyPrefix}${queryKey}`);
-        const values = [];
-        for (const key of keys) {
-            values.push(yield broker.cacher.get(getKey(key, keyPrefix)));
-        }
-        return values;
-    });
+async function getMetadataServices(broker) {
+    const queryKey = `${METADATA_SERVICES_PREFIX}.*`;
+    const keyPrefix = broker.cacher?.prefix || "";
+    const keys = await redisScanKeys(broker.cacher.client, `${keyPrefix}${queryKey}`);
+    const values = [];
+    for (const key of keys) {
+        values.push(await broker.cacher.get(getKey(key, keyPrefix)));
+    }
+    return values;
 }
-function lrange(broker_1, key_1) {
-    return tslib_1.__awaiter(this, arguments, void 0, function* (broker, key, start = 0, end = -1) {
-        return yield broker.cacher.client.lrange(key, start, end);
-    });
+async function lrange(broker, key, start = 0, end = -1) {
+    return await broker.cacher.client.lrange(key, start, end);
 }
-function started(broker) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        return yield broker.cacher.set(`${METADATA_SERVICES_PREFIX}.${broker.nodeID}`, {});
-    });
+async function started(broker) {
+    return await broker.cacher.set(`${METADATA_SERVICES_PREFIX}.${broker.nodeID}`, {});
 }
-function stopped(broker) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        yield broker.cacher.del(`${METADATA_SERVICES_PREFIX}.${broker.nodeID}`);
-        const services = yield getMetadataServices(broker);
-        if (!services || services.length === 0) {
-            yield broker.cacher.clean(`**`);
-        }
-    });
+async function stopped(broker) {
+    await broker.cacher.del(`${METADATA_SERVICES_PREFIX}.${broker.nodeID}`);
+    const services = await getMetadataServices(broker);
+    if (!services || services.length === 0) {
+        await broker.cacher.clean(`**`);
+    }
 }
 exports.Register = {
     clearPackageServices,
     clearPackageServicesMetadatas,
-    get(broker, key) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield broker.cacher.get(key);
-            }
-            catch (error) { }
-        });
-    },
-    mget(broker, keys) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield mget(broker, keys);
-            }
-            catch (error) { }
-        });
+    async get(broker, key) {
+        try {
+            return await broker.cacher.get(key);
+        }
+        catch (error) { }
     },
-    filter(broker, key) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return yield query(broker, key);
-        });
+    async mget(broker, keys) {
+        try {
+            return await mget(broker, keys);
+        }
+        catch (error) { }
     },
-    mfilter(broker, keys) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const queryAll = [];
-            for (const key of keys) {
-                queryAll.push(query(broker, key));
-            }
-            return yield Promise.all(queryAll);
-        });
+    async filter(broker, key) {
+        return await query(broker, key);
     },
-    add(broker, params, meta) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const { key } = params;
-            return yield broker.cacher.set(key, transformMetadata(params, meta));
-        });
+    async mfilter(broker, keys) {
+        const queryAll = [];
+        for (const key of keys) {
+            queryAll.push(query(broker, key));
+        }
+        return await Promise.all(queryAll);
     },
-    madd(broker, params, meta) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return yield mset(broker, transformMetadatas(params, meta));
-        });
+    async add(broker, params, meta) {
+        const { key } = params;
+        return await broker.cacher.set(key, transformMetadata(params, meta));
     },
-    addServiceMetadata(broker, params, meta) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return yield addServiceMetadata(broker, params, meta);
-        });
+    async madd(broker, params, meta) {
+        return await mset(broker, transformMetadatas(params, meta));
     },
-    maddServiceMetadata(broker, params, meta) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return yield maddServiceMetadata(broker, params, meta);
-        });
+    async addServiceMetadata(broker, params, meta) {
+        return await addServiceMetadata(broker, params, meta);
     },
-    fuzzyDelete(broker, key) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const keys = yield redisScanKeys(broker.cacher.client, `${keyPrefix}${key}`);
-            for (const _key of keys) {
-                yield broker.cacher.del(getKey(_key, keyPrefix));
-            }
-        });
+    async maddServiceMetadata(broker, params, meta) {
+        return await maddServiceMetadata(broker, params, meta);
     },
-    delete(broker, key) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            try {
-                yield broker.cacher.del(key);
-            }
-            catch (error) {
-                broker.logger.info(error.message);
-            }
-            return true;
-        });
+    async fuzzyDelete(broker, key) {
+        const keyPrefix = broker.cacher?.prefix || "";
+        const keys = await redisScanKeys(broker.cacher.client, `${keyPrefix}${key}`);
+        for (const _key of keys) {
+            await broker.cacher.del(getKey(_key, keyPrefix));
+        }
     },
-    deleteServiceMetadata(broker, params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            try {
-                let { nodeID, serviceName, metadataType, metadataApiName } = params;
-                if (!nodeID) {
-                    throw new Error("nodeID is null");
-                }
-                if (!serviceName) {
-                    throw new Error("serviceName is null");
-                }
-                if (!metadataType) {
-                    throw new Error("metadataType is null");
-                }
-                if (!metadataApiName) {
-                    throw new Error("metadataApiName is null");
-                }
-                const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
-                yield broker.cacher.del(key);
-            }
-            catch (error) {
-                broker.logger.info(error.message);
-            }
-            return true;
-        });
+    async delete(broker, key) {
+        try {
+            await broker.cacher.del(key);
+        }
+        catch (error) {
+            broker.logger.info(error.message);
+        }
+        return true;
     },
-    getServiceMetadatas(broker, params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+    async deleteServiceMetadata(broker, params) {
+        try {
             let { nodeID, serviceName, metadataType, metadataApiName } = params;
             if (!nodeID) {
-                nodeID = "*";
+                throw new Error("nodeID is null");
             }
             if (!serviceName) {
-                serviceName = "*";
+                throw new Error("serviceName is null");
             }
             if (!metadataType) {
-                metadataType = "*";
+                throw new Error("metadataType is null");
             }
             if (!metadataApiName) {
-                metadataApiName = "*";
+                throw new Error("metadataApiName is null");
             }
             const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
-            const result = yield query(broker, key);
-            return result
-                ? (0, lodash_1.filter)(result, (item) => {
-                    return item && item.metadataType === metadataType;
-                })
-                : result;
-        });
+            await broker.cacher.del(key);
+        }
+        catch (error) {
+            broker.logger.info(error.message);
+        }
+        return true;
     },
-    getServiceMetadata(broker, params, meta) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let { serviceName, metadataType, metadataApiName } = params;
-            const { nodeID } = meta.caller || { nodeID: undefined };
-            if (!nodeID) {
-                console.log(`getServiceMetadata meta`, meta);
-            }
-            const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
-            return yield broker.cacher.get(key);
-        });
+    async getServiceMetadatas(broker, params) {
+        let { nodeID, serviceName, metadataType, metadataApiName } = params;
+        if (!nodeID) {
+            nodeID = "*";
+        }
+        if (!serviceName) {
+            serviceName = "*";
+        }
+        if (!metadataType) {
+            metadataType = "*";
+        }
+        if (!metadataApiName) {
+            metadataApiName = "*";
+        }
+        const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
+        const result = await query(broker, key);
+        return result
+            ? (0, lodash_1.filter)(result, (item) => {
+                return item && item.metadataType === metadataType;
+            })
+            : result;
     },
-    removeServiceMetadata(broker, params, meta) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            let { serviceName, metadataType, metadataApiName } = params;
-            const { nodeID } = meta.caller || { nodeID: undefined };
-            if (!nodeID) {
-                console.log(`getServiceMetadata meta`, meta);
-            }
-            const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
-            return yield broker.cacher.del(key);
-        });
+    async getServiceMetadata(broker, params, meta) {
+        let { serviceName, metadataType, metadataApiName } = params;
+        const { nodeID } = meta.caller || { nodeID: undefined };
+        if (!nodeID) {
+            console.log(`getServiceMetadata meta`, meta);
+        }
+        const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
+        return await broker.cacher.get(key);
     },
-    refreshServiceMetadatas(broker, params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const { offlinePackageServices: _offlinePackageServices } = params || {
-                offlinePackageServices: undefined,
-            };
-            const offlinePackageServicesListString = [];
-            if (_offlinePackageServices && _offlinePackageServices.length > 0) {
-                _.each(_offlinePackageServices, (item) => {
-                    if (!item) {
-                        throw new Error("offlinePackageInfo is null");
-                    }
-                    if (_.isString(item)) {
-                        throw new Error("offlinePackageInfo cannot be string");
+    async removeServiceMetadata(broker, params, meta) {
+        let { serviceName, metadataType, metadataApiName } = params;
+        const { nodeID } = meta.caller || { nodeID: undefined };
+        if (!nodeID) {
+            console.log(`getServiceMetadata meta`, meta);
+        }
+        const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
+        return await broker.cacher.del(key);
+    },
+    async refreshServiceMetadatas(broker, params) {
+        const { offlinePackageServices: _offlinePackageServices } = params || {
+            offlinePackageServices: undefined,
+        };
+        const offlinePackageServicesListString = [];
+        if (_offlinePackageServices && _offlinePackageServices.length > 0) {
+            _.each(_offlinePackageServices, (item) => {
+                if (!item) {
+                    throw new Error("offlinePackageInfo is null");
+                }
+                if (_.isString(item)) {
+                    throw new Error("offlinePackageInfo cannot be string");
+                }
+                if (_.isObject(item)) {
+                    const { nodeID, name } = item;
+                    if (!_.isString(nodeID)) {
+                        throw new Error("offlinePackageInfo.nodeID must be string");
                     }
-                    if (_.isObject(item)) {
-                        const { nodeID, name } = item;
-                        if (!_.isString(nodeID)) {
-                            throw new Error("offlinePackageInfo.nodeID must be string");
-                        }
-                        if (!_.isString(name)) {
-                            throw new Error("offlinePackageInfo.name must be string");
-                        }
-                        offlinePackageServicesListString.push(`${nodeID}.${name}`);
+                    if (!_.isString(name)) {
+                        throw new Error("offlinePackageInfo.name must be string");
                     }
-                });
-                yield broker.call("metadata.clearPackageServices", {
-                    offlinePackageServicesName: _offlinePackageServices,
-                });
-            }
-            let packageServices = yield getPackageServices(broker);
-            const packageServicesName = _.pluck(packageServices, "apiName");
-            const lastPackageServices = yield getLastPackageServices(broker);
-            const lastPackageServicesNames = _.pluck(lastPackageServices, "apiName");
-            let offlinePackageServicesName = _.difference(lastPackageServicesNames, packageServicesName);
-            let timeoutOfflinePackageServices = _.filter(lastPackageServices, (lastPackageService) => {
-                return (lastPackageService &&
-                    _.include(offlinePackageServicesName, lastPackageService.apiName));
+                    offlinePackageServicesListString.push(`${nodeID}.${name}`);
+                }
             });
-            if (_offlinePackageServices && _offlinePackageServices.length > 0) {
-                timeoutOfflinePackageServices = timeoutOfflinePackageServices.concat(_offlinePackageServices);
-                const onlinePackageServicesName = _.difference(lastPackageServices, offlinePackageServicesListString);
-                packageServices = _.filter(packageServices, (packageService) => {
-                    return (packageService &&
-                        _.include(onlinePackageServicesName, packageService.apiName));
-                });
-            }
-            if (savePackageServicesTimeoutID) {
-                clearTimeout(savePackageServicesTimeoutID);
-                savePackageServicesTimeoutID = null;
-            }
-            if (!savePackageServicesTimeoutID) {
-                savePackageServicesTimeoutID = setTimeout(() => {
-                    setPackageServices(broker, packageServices);
-                }, 30 * 1000);
-            }
-        });
-    },
-    lpush(broker, params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const key = params.key;
-            const data = params.data;
-            if (!_.isArray(data)) {
-                throw new Error("data must be an array.");
-            }
-            const _data = [];
-            _.each(data, (item) => {
-                _data.push(JSON.stringify(item));
+            await broker.call("metadata.clearPackageServices", {
+                offlinePackageServicesName: _offlinePackageServices,
             });
-            return yield broker.cacher.client.lpush(`${keyPrefix}${key}`, ..._data);
+        }
+        let packageServices = await getPackageServices(broker);
+        const packageServicesName = _.pluck(packageServices, "apiName");
+        const lastPackageServices = await getLastPackageServices(broker);
+        const lastPackageServicesNames = _.pluck(lastPackageServices, "apiName");
+        let offlinePackageServicesName = _.difference(lastPackageServicesNames, packageServicesName);
+        let timeoutOfflinePackageServices = _.filter(lastPackageServices, (lastPackageService) => {
+            return (lastPackageService &&
+                _.include(offlinePackageServicesName, lastPackageService.apiName));
         });
-    },
-    rpush(broker, params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const key = params.key;
-            const data = params.data;
-            if (!_.isArray(data)) {
-                throw new Error("data must be an array.");
-            }
-            const _data = [];
-            _.each(data, (item) => {
-                _data.push(JSON.stringify(item));
+        if (_offlinePackageServices && _offlinePackageServices.length > 0) {
+            timeoutOfflinePackageServices = timeoutOfflinePackageServices.concat(_offlinePackageServices);
+            const onlinePackageServicesName = _.difference(lastPackageServices, offlinePackageServicesListString);
+            packageServices = _.filter(packageServices, (packageService) => {
+                return (packageService &&
+                    _.include(onlinePackageServicesName, packageService.apiName));
             });
-            return yield broker.cacher.client.rpush(`${keyPrefix}${key}`, ..._data);
+        }
+        if (savePackageServicesTimeoutID) {
+            clearTimeout(savePackageServicesTimeoutID);
+            savePackageServicesTimeoutID = null;
+        }
+        if (!savePackageServicesTimeoutID) {
+            savePackageServicesTimeoutID = setTimeout(() => {
+                setPackageServices(broker, packageServices);
+            }, 30 * 1000);
+        }
+    },
+    async lpush(broker, params) {
+        const keyPrefix = broker.cacher?.prefix || "";
+        const key = params.key;
+        const data = params.data;
+        if (!_.isArray(data)) {
+            throw new Error("data must be an array.");
+        }
+        const _data = [];
+        _.each(data, (item) => {
+            _data.push(JSON.stringify(item));
         });
+        return await broker.cacher.client.lpush(`${keyPrefix}${key}`, ..._data);
     },
-    lrange(broker, params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const { key, start = 0, end = -1 } = params.key;
-            return yield lrange(broker, `${keyPrefix}${key}`, start, end);
+    async rpush(broker, params) {
+        const keyPrefix = broker.cacher?.prefix || "";
+        const key = params.key;
+        const data = params.data;
+        if (!_.isArray(data)) {
+            throw new Error("data must be an array.");
+        }
+        const _data = [];
+        _.each(data, (item) => {
+            _data.push(JSON.stringify(item));
         });
+        return await broker.cacher.client.rpush(`${keyPrefix}${key}`, ..._data);
     },
-    filterList(broker, params) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const { key } = params;
-            const keys = yield redisScanKeys(broker.cacher.client, `${keyPrefix}${key}`);
-            if (!keys || keys.length == 0) {
-                return [];
-            }
-            const results = [];
-            for (const itemKey of keys) {
-                try {
-                    if (itemKey) {
-                        const itemList = yield lrange(broker, itemKey);
-                        if (itemList && _.isArray(itemList)) {
-                            _.each(itemList, (item) => {
-                                results.push(JSON.parse(item));
-                            });
-                        }
+    async lrange(broker, params) {
+        const keyPrefix = broker.cacher?.prefix || "";
+        const { key, start = 0, end = -1 } = params.key;
+        return await lrange(broker, `${keyPrefix}${key}`, start, end);
+    },
+    async filterList(broker, params) {
+        const keyPrefix = broker.cacher?.prefix || "";
+        const { key } = params;
+        const keys = await redisScanKeys(broker.cacher.client, `${keyPrefix}${key}`);
+        if (!keys || keys.length == 0) {
+            return [];
+        }
+        const results = [];
+        for (const itemKey of keys) {
+            try {
+                if (itemKey) {
+                    const itemList = await lrange(broker, itemKey);
+                    if (itemList && _.isArray(itemList)) {
+                        _.each(itemList, (item) => {
+                            results.push(JSON.parse(item));
+                        });
                     }
                 }
-                catch (error) {
-                    console.error(`error`, error);
-                }
             }
-            return results;
-        });
+            catch (error) {
+                console.error(`error`, error);
+            }
+        }
+        return results;
     },
 };
 //# sourceMappingURL=index.js.map