@steedos/service-metadata 2.2.38 → 2.2.41

package/lib/actionsHandler.js

@@ -1,712 +1,120 @@
 "use strict";
+/*
+ * @Author: baozhoutao@steedos.com
+ * @Date: 2022-06-10 18:35:07
+ * @LastEditors: baozhoutao@steedos.com
+ * @LastEditTime: 2022-06-10 23:50:45
+ * @Description:
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionHandlers = exports.stopped = exports.started = void 0;
+exports.ActionHandlers = void 0;
 const tslib_1 = require("tslib");
-const SERVICE_METADATA_PREFIX = '$METADATA';
-const PACKAGE_SERVICES_KEY = '$PACKAGE-SERVICES';
-const PACKAGE_SERVICE_PREFIX = '~packages-';
-const METADATA_SERVICES_PERFIX = '$METADATA-SERVICES';
-const _ = require("underscore");
-const lodash_1 = require("lodash");
-let savePackageServicesTimeoutID = null;
-const useScan = true;
-function redisScanKeys(redisClient, match, count = 10000) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        if (!useScan) {
-            return yield redisClient.keys(match);
-        }
-        else {
-            return yield new Promise((resolve, reject) => {
-                if (_.isFunction(redisClient.scanStream)) {
-                    var stream = redisClient.scanStream({
-                        // only returns keys following the pattern of `user:*`
-                        match: match,
-                        // returns approximately 100 elements per call
-                        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({
-                                // only returns keys following the pattern of `user:*`
-                                match: match,
-                                // returns approximately 100 elements per call
-                                count: count
-                            }).on('data', resultKeys => {
-                                for (var i = 0; i < resultKeys.length; i++) {
-                                    keys.push(resultKeys[i]);
-                                }
-                            }).on('end', () => {
-                                // console.info("scan end, node %s:%d", node.options.host, node.options.port);
-                                res(keys);
-                            });
-                        }));
-                    }
-                    Promise.all(allPromises).then((values) => {
-                        let joinedKeys = [];
-                        for (const keys of values) {
-                            joinedKeys = joinedKeys.concat(keys);
-                        }
-                        resolve(joinedKeys);
-                    });
-                }
-            });
-        }
-    });
-}
-//////////////// mock for redis cacher ////////////////
-// let mockCacherData: string[] = [];
-// let mock_prefix = "";
-// async function mockCacherGet(ctx: any, key: string): Promise<any> { // cacher.get
-// 	return await ctx.broker.cacher.get(key);
-// }
-// // 支持 * 通配符
-// async function mockCacherKeys(ctx: any, key: string): Promise<string[]> { // cacher.client.keys
-// 	// // 原来是：
-// 	// const broker_res = await ctx.broker.cacher.client.keys(key);
-// 	const regex_key = "^"+ key.split(".").join("\\.").split("*").join(".+").split("$").join("\\$") + "$";
-// 	const reg = new RegExp(regex_key);
-// 	const keys = mockCacherData.filter(item => reg.test(item));
-// 	// const diff_d = _.difference(broker_res, keys); // 差错 diff 代码
-// 	// if (diff_d.length > 0) {
-// 	// 	console.log("diff is",key, diff_d);
-// 	// 	console.log("* is", key,await ctx.broker.cacher.client.keys("*"));
-// 	// 	console.log("my is",key, mockCacherData);
-// 	// 	process.exit();
-// 	// }
-// 	return keys;
-// }
-// async function mockCacherSet(ctx: any, key: string, data: any): Promise<any> {
-//     // cacher.set
-//     const finalKey = mock_prefix + key;
-//     // const item = mockCacherData.find(item => item === finalKey);
-//     // if (!item) {
-//     // 	mockCacherData.push(finalKey);
-//     // }
-//     await ctx.broker.cacher.set(key, data);
-// }
-// // 支持 * 通配符
-// async function mockCacherClean(ctx: any, key: string): Promise<any> {
-//     // cacher.clean
-//     if (key == "**") {
-//         mockCacherData = [];
-//     } else {
-//         const regex_key =
-//             "^" +
-//             key
-//                 .split(".")
-//                 .join("\\.")
-//                 .split("*")
-//                 .join(".+")
-//                 .split("$")
-//                 .join("\\$") +
-//             "$";
-//         const reg = new RegExp(regex_key);
-//         mockCacherData = mockCacherData.filter((item) => !reg.test(item));
-//     }
-//     await ctx.broker.cacher.clean(key);
-// }
-// async function mockCacherDel(ctx: any, key: string): Promise<any> {
-//     // cacher.del
-//     const finalKey = mock_prefix + key;
-//     mockCacherData = mockCacherData.filter((item) => item !== finalKey);
-//     await ctx.broker.cacher.del(key);
-// }
-////////////////////////////////////////////////
-function transformMetadata(ctx) {
-    return Object.assign(Object.assign({}, ctx.meta.caller), { metadata: ctx.params.data });
-}
-function transformMetadatas(ctx) {
-    const data = {};
-    (0, lodash_1.map)(ctx.params.data, (value, key) => {
-        data[key] = Object.assign(Object.assign({}, ctx.meta.caller), { metadata: value });
-    });
-    return data;
-}
-function getKey(key, keyPrefix) {
-    return key.replace(keyPrefix, "");
-}
-function getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName) {
-    return `$${nodeID}.${SERVICE_METADATA_PREFIX}.${serviceName}.${metadataType}.${metadataApiName}`;
-}
-function addServiceMetadata(ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        const { nodeID } = ctx.meta.caller || { nodeID: undefined };
-        if (!nodeID) {
-            console.log(`addServiceMetadata ctx.meta`, ctx.meta);
-        }
-        const { metadataType, metadataApiName, metadataServiceName } = ctx.meta || { metadataType: undefined, metadataApiName: undefined, metadataServiceName: undefined };
-        if (!metadataServiceName) {
-            return;
-        }
-        const key = getServiceMetadataCacherKey(nodeID, metadataServiceName, metadataType, metadataApiName);
-        yield ctx.broker.cacher.set(key, {
-            nodeIds: [nodeID],
-            metadataType,
-            metadataApiName,
-            metadataServiceName,
-            metadata: ctx.params.data,
-        });
-    });
-}
-function maddServiceMetadata(ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        const { nodeID } = ctx.meta.caller || { nodeID: undefined };
-        if (!nodeID) {
-            console.log(`addServiceMetadata ctx.meta`, ctx.meta);
-        }
-        const { metadataType, metadataServiceName } = ctx.meta || { metadataType: undefined, metadataServiceName: undefined };
-        //data: {k1:v1, k2:v2}
-        const { data } = ctx.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(ctx, mdata);
-    });
-}
-function mget(ctx, keys) {
-    var _a;
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        if (!keys || keys.length == 0) {
-            return [];
-        }
-        const keyPrefix = ((_a = ctx.broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-        const values = yield ctx.broker.cacher.client.mget(...(0, lodash_1.map)(keys, (key) => {
-            if (key && !key.startsWith(keyPrefix)) {
-                return `${keyPrefix}${key}`;
-            }
-            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(ctx, data) {
-    var _a;
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        if (_.isEmpty(data)) {
-            return;
-        }
-        const keyPrefix = ((_a = ctx.broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-        const mdata = {};
-        _.map(data, (v, k) => {
-            mdata[`${keyPrefix}${k}`] = JSON.stringify(v);
-        });
-        return yield ctx.broker.cacher.client.mset(mdata);
-    });
-}
-// 这里需要更改
-function query(ctx, queryKey) {
-    var _a;
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        try {
-            // const s = new Date().getTime();
-            const keyPrefix = ((_a = ctx.broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            // const sk = new Date().getTime();
-            const keys = yield redisScanKeys(ctx.broker.cacher.client, `${keyPrefix}${queryKey}`); //ctx.broker.cacher.client.keys(`${keyPrefix}${queryKey}`); //TODO 此功能仅支持redis cache
-            // const dk = new Date().getTime() - sk;
-            // const sv = new Date().getTime();
-            // REPLACE: const keys = await mockCacherKeys(ctx, `${keyPrefix}${queryKey}`) //TODO 此功能仅支持redis cache
-            const values = _.compact(yield mget(ctx, keys));
-            // const dv = new Date().getTime() - sv;
-            // const d = new Date().getTime() - s;
-            // if (d > Number(process.env.STEEDOS_DURATION)) {
-            // console.log(`query`, d, dk, dv, `${keyPrefix}${queryKey}`);
-            // }
-            return values;
-        }
-        catch (error) {
-            // console.error(`error`, error)
-        }
-        return [];
-    });
-}
-function getPackageServiceCacherKey(nodeID, serviceName) {
-    return `$${nodeID}.${PACKAGE_SERVICES_KEY}.${serviceName}`;
-}
-function setPackageServices(ctx, packageServices) {
-    var packageServices_1, packageServices_1_1;
-    var e_1, _a;
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        try {
-            for (packageServices_1 = (0, tslib_1.__asyncValues)(packageServices); packageServices_1_1 = yield packageServices_1.next(), !packageServices_1_1.done;) {
-                const packageService = packageServices_1_1.value;
-                ctx.broker.cacher.set(getPackageServiceCacherKey(packageService.nodeID, packageService.name), { service: packageService });
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (packageServices_1_1 && !packageServices_1_1.done && (_a = packageServices_1.return)) yield _a.call(packageServices_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    });
-}
-function clearPackageServices(ctx, packageServices) {
-    var packageServices_2, packageServices_2_1;
-    var e_2, _a;
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        try {
-            for (packageServices_2 = (0, tslib_1.__asyncValues)(packageServices); packageServices_2_1 = yield packageServices_2.next(), !packageServices_2_1.done;) {
-                const packageService = packageServices_2_1.value;
-                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;
-                }
-                // console.log(`clearPackageServices del ===== `, getPackageServiceCacherKey(nodeID, name))
-                yield ctx.broker.cacher.del(getPackageServiceCacherKey(nodeID, name));
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (packageServices_2_1 && !packageServices_2_1.done && (_a = packageServices_2.return)) yield _a.call(packageServices_2);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-    });
-}
-function getLastPackageServices(ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        const packageServices = yield query(ctx, getPackageServiceCacherKey("*", "*"));
-        const services = [];
-        packageServices.forEach((element) => {
-            if (element) {
-                services.push(element.service);
-            }
-        });
-        return services;
-    });
-}
-function getPackageServices(ctx) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        const packageServices = [];
-        const services = ctx.broker.registry.getServiceList({ withActions: true });
-        _.each(services, (serviceItem) => {
-            const { name, nodeID } = serviceItem; //, version, fullName, settings, local, available, nodeID
-            if (name.startsWith(PACKAGE_SERVICE_PREFIX)) {
-                // console.log(`serviceItem`, serviceItem)
-                packageServices.push(Object.assign({}, serviceItem, { apiName: `${nodeID}.${name}` }));
-            }
-        });
-        return packageServices;
-        // const servicesName = _.pluck(services, "name");
-        // let packageServicesName = _.filter(servicesName, (serviceName) => {
-        //     return serviceName.startsWith(PACKAGE_SERVICE_PREFIX);
-        // });
-        // packageServicesName = _.uniq(packageServicesName);
-        // return packageServicesName;
-    });
-}
-function clearPackageServiceMetadatas(ctx, nodeID, packageServiceName) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        const key = getServiceMetadataCacherKey(nodeID, packageServiceName, "*", "*");
-        const clearMetadatas = yield query(ctx, key);
-        yield ctx.broker.cacher.clean(key);
-        // REPLACE: await mockCacherClean(ctx, key);
-        return clearMetadatas;
-    });
-}
-function clearPackageServicesMetadatas(ctx, offlinePackageServices) {
-    var offlinePackageServices_1, offlinePackageServices_1_1;
-    var e_3, _a;
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        let clearMetadatas = [];
-        try {
-            for (offlinePackageServices_1 = (0, tslib_1.__asyncValues)(offlinePackageServices); offlinePackageServices_1_1 = yield offlinePackageServices_1.next(), !offlinePackageServices_1_1.done;) {
-                const packageService = offlinePackageServices_1_1.value;
-                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(ctx, nodeID, name);
-                clearMetadatas = clearMetadatas.concat(clearPackageMetadatas);
-            }
-        }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-        finally {
-            try {
-                if (offlinePackageServices_1_1 && !offlinePackageServices_1_1.done && (_a = offlinePackageServices_1.return)) yield _a.call(offlinePackageServices_1);
-            }
-            finally { if (e_3) throw e_3.error; }
-        }
-        _.each(_.groupBy(clearMetadatas, "metadataType"), function (data, metadataType) {
-            ctx.broker.emit(`${SERVICE_METADATA_PREFIX}.${metadataType}.clear`, { metadataType, metadataApiNames: _.pluck(data, "metadataApiName"), isClear: true });
-        });
-    });
-}
-function getMetadataServices(broker) {
-    var _a;
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        const queryKey = `${METADATA_SERVICES_PERFIX}.*`;
-        const keyPrefix = ((_a = broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-        const keys = yield redisScanKeys(broker.cacher.client, `${keyPrefix}${queryKey}`); // broker.cacher.client.keys(`${keyPrefix}${queryKey}`); //TODO 此功能仅支持redis cache
-        // REPLACE: const keys = await mockCacherKeys({broker,}, `${keyPrefix}${queryKey}`) //TODO 此功能仅支持redis cache
-        const values = [];
-        for (const key of keys) {
-            values.push(yield broker.cacher.get(getKey(key, keyPrefix)));
-            // REPLACE: values.push(await mockCacherGet({ broker }, getKey(key, keyPrefix)));
-        }
-        return values;
-    });
-}
-function lrange(ctx, key, start = 0, end = -1) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        return yield ctx.broker.cacher.client.lrange(key, start, end);
-    });
-}
-function started(broker) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        // mock_prefix = broker.cacher?.prefix || "";
-        yield broker.cacher.set(`${METADATA_SERVICES_PERFIX}.${broker.nodeID}`, {});
-        // REPLACE: await mockCacherSet({broker, }, `${METADATA_SERVICES_PERFIX}.${broker.nodeID}`, {});
-    });
-}
-exports.started = started;
-function stopped(broker) {
-    return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-        yield broker.cacher.del(`${METADATA_SERVICES_PERFIX}.${broker.nodeID}`);
-        // REPLACE: await mockCacherDel({broker}, `${METADATA_SERVICES_PERFIX}.${broker.nodeID}`);
-        const services = yield getMetadataServices(broker);
-        if (!services || services.length === 0) {
-            yield broker.cacher.clean(`**`);
-            //REPLACE:  await mockCacherClean({broker}, `**`);
-        }
-    });
-}
-exports.stopped = stopped;
+const metadata_registrar_1 = require("@steedos/metadata-registrar");
 exports.ActionHandlers = {
-    clearPackageServices,
-    clearPackageServicesMetadatas,
+    clearPackageServices: metadata_registrar_1.Register.clearPackageServices,
+    clearPackageServicesMetadatas: metadata_registrar_1.Register.clearPackageServicesMetadatas,
     get(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             try {
-                return yield ctx.broker.cacher.get(ctx.params.key);
+                return yield metadata_registrar_1.Register.get(ctx.broker, ctx.params.key);
             }
             catch (error) {
             }
-            // REPLACE: return await mockCacherGet(ctx, ctx.params.key)
         });
     },
     mget(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             try {
-                return yield mget(ctx, ctx.params.keys);
+                return yield metadata_registrar_1.Register.mget(ctx.broker, ctx.params.keys);
             }
             catch (error) {
             }
-            // REPLACE: return await mockCacherGet(ctx, ctx.params.key)
         });
     },
     filter(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return yield query(ctx, ctx.params.key);
-            // const keyPrefix = ctx.broker.cacher.prefix
-            // const keys = await ctx.broker.cacher.client.keys(`${keyPrefix}${ctx.params.key}`) //TODO 此功能仅支持redis cache
-            // const values = [];
-            // for (const key of keys) {
-            //     values.push(await ctx.broker.cacher.get(getKey(key, keyPrefix)))
-            // }
-            // return values;
+            return yield metadata_registrar_1.Register.filter(ctx.broker, ctx.params.key);
         });
     },
     mfilter(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            const values = [];
-            for (const key of ctx.params.keys) {
-                values.push(yield query(ctx, key));
-            }
-            return values;
+            return yield metadata_registrar_1.Register.mfilter(ctx.broker, ctx.params.keys);
         });
     },
     add(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return yield ctx.broker.cacher.set(ctx.params.key, transformMetadata(ctx));
-            // REPLACE: return await mockCacherSet(ctx, ctx.params.key, transformMetadata(ctx));
+            return yield metadata_registrar_1.Register.add(ctx.broker, ctx.params, ctx.meta);
         });
     },
     madd(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return yield mset(ctx, transformMetadatas(ctx));
+            return yield metadata_registrar_1.Register.madd(ctx.broker, ctx.params, ctx.meta);
         });
     },
     addServiceMetadata(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return yield addServiceMetadata(ctx);
+            return yield metadata_registrar_1.Register.addServiceMetadata(ctx.broker, ctx.params, ctx.meta);
         });
     },
     maddServiceMetadata(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return yield maddServiceMetadata(ctx);
+            return yield metadata_registrar_1.Register.maddServiceMetadata(ctx.broker, ctx.params, ctx.meta);
         });
     },
     fuzzyDelete(ctx) {
-        var _a;
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             const { key } = ctx.params;
-            const keyPrefix = ((_a = ctx.broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const keys = yield redisScanKeys(ctx.broker.cacher.client, `${keyPrefix}${key}`); // await ctx.broker.cacher.client.keys(`${keyPrefix}${key}`);
-            for (const _key of keys) {
-                yield ctx.broker.cacher.del(getKey(_key, keyPrefix));
-            }
+            return yield metadata_registrar_1.Register.fuzzyDelete(ctx.broker, key);
         });
     },
     delete(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            try {
-                yield ctx.broker.cacher.del(ctx.params.key);
-            }
-            catch (error) {
-                ctx.broker.logger.info(error.message);
-            }
-            return true;
+            return yield metadata_registrar_1.Register.delete(ctx.broker, ctx.params.key);
         });
     },
     deleteServiceMetadata(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            try {
-                let { nodeID, serviceName, metadataType, metadataApiName } = ctx.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 ctx.broker.cacher.del(key);
-            }
-            catch (error) {
-                ctx.broker.logger.info(error.message);
-            }
-            return true;
+            return yield metadata_registrar_1.Register.deleteServiceMetadata(ctx.broker, ctx.params);
         });
     },
     getServiceMetadatas(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            let { nodeID, serviceName, metadataType, metadataApiName } = ctx.params;
-            if (!nodeID) {
-                nodeID = "*";
-            }
-            if (!serviceName) {
-                serviceName = "*";
-            }
-            if (!metadataType) {
-                metadataType = "*";
-            }
-            if (!metadataApiName) {
-                metadataApiName = "*";
-            }
-            const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
-            return yield query(ctx, key);
+            return yield metadata_registrar_1.Register.getServiceMetadatas(ctx.broker, ctx.params);
         });
     },
     getServiceMetadata(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            let { serviceName, metadataType, metadataApiName } = ctx.params;
-            const { nodeID } = ctx.meta.caller || { nodeID: undefined };
-            if (!nodeID) {
-                console.log(`getServiceMetadata ctx.meta`, ctx.meta);
-            }
-            const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
-            return yield ctx.broker.cacher.get(key);
-            // REPLACE: return await mockCacherGet(ctx, key);
+            return yield metadata_registrar_1.Register.getServiceMetadata(ctx.broker, ctx.params, ctx.meta);
         });
     },
     removeServiceMetadata(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            let { serviceName, metadataType, metadataApiName } = ctx.params;
-            const { nodeID } = ctx.meta.caller || { nodeID: undefined };
-            if (!nodeID) {
-                console.log(`getServiceMetadata ctx.meta`, ctx.meta);
-            }
-            const key = getServiceMetadataCacherKey(nodeID, serviceName, metadataType, metadataApiName);
-            return yield ctx.broker.cacher.del(key);
+            return yield metadata_registrar_1.Register.removeServiceMetadata(ctx.broker, ctx.params, ctx.meta);
         });
     },
     refreshServiceMetadatas(ctx) {
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            const { offlinePackageServices: _offlinePackageServices } = ctx.params || { offlinePackageServices: undefined };
-            const offlinePackageServicesListString = [];
-            if (_offlinePackageServices && _offlinePackageServices.length > 0) {
-                // 检查 offlinePackageServices 中的每一项必须包含nodeID、name
-                _.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; //, instanceID
-                        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}`);
-                    }
-                });
-                yield ctx.broker.call('metadata.clearPackageServices', { offlinePackageServicesName: _offlinePackageServices });
-                // ctx.broker.broadcast(`$metadata.clearPackageServices`, { offlinePackageServicesName: _offlinePackageServices });
-            }
-            let packageServices = yield getPackageServices(ctx);
-            const packageServicesName = _.pluck(packageServices, "apiName");
-            const lastPackageServices = yield getLastPackageServices(ctx);
-            const lastPackageServicesNames = _.pluck(lastPackageServices, "apiName");
-            let offlinePackageServicesName = _.difference(lastPackageServicesNames, packageServicesName);
-            let timeoutOfflinePackageServices = _.filter(lastPackageServices, (lastPackageService) => {
-                return lastPackageService && _.include(offlinePackageServicesName, lastPackageService.apiName);
-            });
-            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 (timeoutOfflinePackageServices.length > 0) {
-            //     ctx.broker.broadcast(`$metadata.clearPackageServices`, { offlinePackageServicesName: timeoutOfflinePackageServices });
-            // }
-            //使用延时方式存储软件包记录， 防止多服务之间服务发现延时导致数据清理异常。延时来自moleculer内部的服务发现机制(broker.registry.getServiceList)
-            //清理数据无需做到实时，延时30秒
-            if (savePackageServicesTimeoutID) {
-                clearTimeout(savePackageServicesTimeoutID);
-                savePackageServicesTimeoutID = null;
-            }
-            if (!savePackageServicesTimeoutID) {
-                savePackageServicesTimeoutID = setTimeout(() => {
-                    setPackageServices(ctx, packageServices);
-                }, 30 * 1000);
-            }
+            return yield metadata_registrar_1.Register.refreshServiceMetadatas(ctx.broker, ctx.params);
         });
     },
     lpush(ctx) {
-        var _a;
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            const keyPrefix = ((_a = ctx.broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const key = ctx.params.key;
-            const data = ctx.params.data;
-            if (!_.isArray(data)) {
-                throw new Error('data must be an array.');
-            }
-            const _data = [];
-            _.each(data, (item) => {
-                _data.push(JSON.stringify(item));
-            });
-            return yield ctx.broker.cacher.client.lpush(`${keyPrefix}${key}`, ..._data);
+            return yield metadata_registrar_1.Register.lpush(ctx.broker, ctx.params);
         });
     },
     rpush(ctx) {
-        var _a;
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            const keyPrefix = ((_a = ctx.broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const key = ctx.params.key;
-            const data = ctx.params.data;
-            if (!_.isArray(data)) {
-                throw new Error('data must be an array.');
-            }
-            const _data = [];
-            _.each(data, (item) => {
-                _data.push(JSON.stringify(item));
-            });
-            return yield ctx.broker.cacher.client.rpush(`${keyPrefix}${key}`, ..._data);
+            return yield metadata_registrar_1.Register.rpush(ctx.broker, ctx.params);
         });
     },
     lrange(ctx) {
-        var _a;
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            const keyPrefix = ((_a = ctx.broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const { key, start = 0, end = -1 } = ctx.params.key;
-            return yield lrange(ctx, `${keyPrefix}${key}`, start, end);
+            return yield metadata_registrar_1.Register.lrange(ctx.broker, ctx.params);
         });
     },
     filterList(ctx) {
-        var _a;
         return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            const keyPrefix = ((_a = ctx.broker.cacher) === null || _a === void 0 ? void 0 : _a.prefix) || "";
-            const { key } = ctx.params;
-            const keys = yield redisScanKeys(ctx.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(ctx, itemKey);
-                        if (itemList && _.isArray(itemList)) {
-                            _.each(itemList, (item) => {
-                                results.push(JSON.parse(item));
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`error`, error);
-                }
-            }
-            return results;
+            return yield metadata_registrar_1.Register.filterList(ctx.broker, ctx.params);
         });
     }
 };