@midwayjs/consul 3.20.5 → 4.0.0-beta.1

package/dist/configuration.d.ts

@@ -1,28 +1,6 @@
 import { ILifeCycle, IMidwayApplication, IMidwayContainer } from '@midwayjs/core';
-import { IConsulProviderInfoOptions, IConsulRegisterInfoOptions } from './interface';
-import { ConsulProvider } from './lib/provider';
 export declare class ConsulConfiguration implements ILifeCycle {
-    /**
-     * 有关 consul server 的配置
-     */
-    consulProviderConfig: IConsulProviderInfoOptions;
-    /**
-     * 有关 service registry 注册的信息
-     */
-    consulRegisterConfig: IConsulRegisterInfoOptions;
-    get consulProvider(): ConsulProvider;
-    /**
-     * 注册自己的条件
-     * 由于环境的复杂性(多网卡、自动端口冲突) address 和 port 必须提供
-     */
-    get shouldBeRegisterMe(): boolean;
-    /**
-     * 注册 consul 服务
-     * @param container 容器 IoC
-     * @param app 应用 App
-     */
-    registerConsul(container: IMidwayContainer, app: IMidwayApplication): Promise<void>;
-    onServerReady(container: IMidwayContainer, app?: IMidwayApplication): Promise<void>;
-    onStop(): Promise<void>;
+    onReady(container: IMidwayContainer, app?: IMidwayApplication): Promise<void>;
+    onStop(container: IMidwayContainer): Promise<void>;
 }
 //# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -5,85 +5,35 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsulConfiguration = void 0;
 const core_1 = require("@midwayjs/core");
-const provider_1 = require("./lib/provider");
-const DefaultConfig = require("./config/config.default");
+const manager_1 = require("./manager");
 let ConsulConfiguration = class ConsulConfiguration {
-    get consulProvider() {
-        const symbol = Symbol('consulProvider');
-        this[symbol] =
-            this[symbol] || new provider_1.ConsulProvider(this.consulProviderConfig);
-        return this[symbol];
-    }
-    /**
-     * 注册自己的条件
-     * 由于环境的复杂性(多网卡、自动端口冲突) address 和 port 必须提供
-     */
-    get shouldBeRegisterMe() {
-        const { address, port } = this.consulRegisterConfig;
-        return this.consulProviderConfig.register && address.length > 0 && port > 0;
-    }
-    /**
-     * 注册 consul 服务
-     * @param container 容器 IoC
-     * @param app 应用 App
-     */
-    async registerConsul(container, app) {
-        const config = this.consulRegisterConfig;
-        const { address, port } = this.consulRegisterConfig;
-        // 把原始的 consul 对象注入到容器
-        container.registerObject('consul:consul', this.consulProvider.getConsul());
-        if (this.shouldBeRegisterMe) {
-            config.name = config.name || app.getProjectName();
-            config.id = config.id || `${config.name}:${address}:${port}`;
-            if (!config.check && config.check !== false) {
-                config.check = ['egg', 'koa', 'express'].includes(app.getNamespace())
-                    ? {
-                        http: `http://${address}:${port}/consul/health/self/check`,
-                        interval: '3s',
-                    }
-                    : {
-                        tcp: `${address}:${port}`,
-                        interval: '3s',
-                    };
-            }
-            Object.assign(this.consulRegisterConfig, config);
-            await this.consulProvider.registerService(this.consulRegisterConfig);
-        }
+    async onReady(container, app) {
+        await container.getAsync(manager_1.ConsulServiceFactory);
     }
-    async onServerReady(container, app) {
-        await this.registerConsul(container, app);
-    }
-    async onStop() {
-        if (this.consulProviderConfig.register &&
-            this.consulProviderConfig.deregister) {
-            const { id } = this.consulRegisterConfig;
-            await this.consulProvider.deregisterService({ id });
-        }
+    async onStop(container) {
+        const factory = await container.getAsync(manager_1.ConsulServiceFactory);
+        await factory.stop();
     }
 };
-__decorate([
-    (0, core_1.Config)('consul.provider'),
-    __metadata("design:type", Object)
-], ConsulConfiguration.prototype, "consulProviderConfig", void 0);
-__decorate([
-    (0, core_1.Config)('consul.service'),
-    __metadata("design:type", Object)
-], ConsulConfiguration.prototype, "consulRegisterConfig", void 0);
-ConsulConfiguration = __decorate([
+exports.ConsulConfiguration = ConsulConfiguration;
+exports.ConsulConfiguration = ConsulConfiguration = __decorate([
     (0, core_1.Configuration)({
         namespace: 'consul',
         importConfigs: [
             {
-                default: DefaultConfig,
+                default: {
+                    consul: {
+                        serviceDiscovery: {
+                            loadBalancer: 'roundRobin',
+                            healthCheckType: 'self',
+                        },
+                    },
+                },
             },
         ],
     })
 ], ConsulConfiguration);
-exports.ConsulConfiguration = ConsulConfiguration;
 //# sourceMappingURL=configuration.js.map

package/dist/extension/helper.d.ts

@@ -0,0 +1,81 @@
+import { ILogger } from '@midwayjs/core';
+/**
+ * Consul 服务实例 TTL 心跳上报工具类
+ */
+interface TTLHeartbeatOptions {
+    consul: any;
+    checkId: string;
+    interval?: number;
+    logger?: ILogger;
+}
+export declare class TTLHeartbeat {
+    private consul;
+    private checkId;
+    private interval;
+    private timer;
+    private logger;
+    /**
+     * @param {TTLHeartbeatOptions} options - 配置项
+     */
+    constructor(options: TTLHeartbeatOptions);
+    /**
+     * 启动心跳
+     */
+    start(): void;
+    /**
+     * 停止心跳
+     */
+    stop(): void;
+}
+/**
+ * 计算 Consul 健康检查 TTL 毫秒值
+ * @param ttl 用户传入的 ttl，支持字符串（如 "30s"、"1m"、"1m30s"）或数字（秒）
+ * @returns {number} 毫秒数，最小 1000ms
+ */
+export declare function calculateTTL(ttl: string): number;
+/**
+ * HTTP 健康检查工具类
+ * 传入 http url，自动启动一个健康检查服务
+ */
+export declare class HTTPHealthCheck {
+    private server;
+    private port;
+    private path;
+    private message;
+    /**
+     * @param httpUrl 形如 'http://127.0.0.1:3000/health'
+     * @param message 健康时返回的内容，默认 'ok'
+     */
+    constructor(httpUrl: string, message?: string);
+    /**
+     * 启动健康检查 HTTP 服务
+     */
+    start(): void;
+    /**
+     * 停止健康检查 HTTP 服务
+     */
+    stop(): void;
+}
+/**
+ * TCP 健康检查工具类
+ * 传入 tcp url，自动启动一个 TCP 服务
+ */
+export declare class TCPHealthCheck {
+    private server;
+    private port;
+    private host;
+    /**
+     * @param tcpUrl 形如 'tcp://127.0.0.1:3000'
+     */
+    constructor(tcpUrl: string);
+    /**
+     * 启动 TCP 健康检查服务
+     */
+    start(): void;
+    /**
+     * 停止 TCP 健康检查服务
+     */
+    stop(): void;
+}
+export {};
+//# sourceMappingURL=helper.d.ts.map

package/dist/extension/helper.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TCPHealthCheck = exports.HTTPHealthCheck = exports.calculateTTL = exports.TTLHeartbeat = void 0;
+const ms_1 = require("ms");
+const http_1 = require("http");
+const url_1 = require("url");
+const net_1 = require("net");
+class TTLHeartbeat {
+    /**
+     * @param {TTLHeartbeatOptions} options - 配置项
+     */
+    constructor(options) {
+        this.timer = null;
+        this.consul = options.consul;
+        this.checkId = options.checkId;
+        this.interval = options.interval ?? 5000;
+        this.logger = options.logger;
+    }
+    /**
+     * 启动心跳
+     */
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(async () => {
+            try {
+                await this.consul.agent.check.pass(this.checkId);
+                // this.logger.info?.(`[TTL] ${this.checkId} 心跳上报成功`);
+            }
+            catch (err) {
+                this.logger.error(`[TTL] ${this.checkId} 心跳上报失败:`, err);
+            }
+        }, this.interval);
+    }
+    /**
+     * 停止心跳
+     */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+}
+exports.TTLHeartbeat = TTLHeartbeat;
+/**
+ * 计算 Consul 健康检查 TTL 毫秒值
+ * @param ttl 用户传入的 ttl，支持字符串（如 "30s"、"1m"、"1m30s"）或数字（秒）
+ * @returns {number} 毫秒数，最小 1000ms
+ */
+function calculateTTL(ttl) {
+    const ttlMs = (0, ms_1.default)(ttl);
+    // 最小不能低于 1 秒
+    return Math.max(ttlMs, 1000);
+}
+exports.calculateTTL = calculateTTL;
+/**
+ * HTTP 健康检查工具类
+ * 传入 http url，自动启动一个健康检查服务
+ */
+class HTTPHealthCheck {
+    /**
+     * @param httpUrl 形如 'http://127.0.0.1:3000/health'
+     * @param message 健康时返回的内容，默认 'ok'
+     */
+    constructor(httpUrl, message = 'ok') {
+        this.server = null;
+        const url = new url_1.URL(httpUrl);
+        this.port = Number(url.port) || 80;
+        this.path = url.pathname;
+        this.message = message;
+    }
+    /**
+     * 启动健康检查 HTTP 服务
+     */
+    start() {
+        if (this.server)
+            return;
+        this.server = (0, http_1.createServer)((req, res) => {
+            if (req.url === this.path && req.method === 'GET') {
+                res.statusCode = 200;
+                res.end(this.message);
+            }
+            else {
+                res.statusCode = 404;
+                res.end('not found');
+            }
+        });
+        this.server.listen(this.port, () => {
+            console.log(`[health] 健康检查服务已启动: http://127.0.0.1:${this.port}${this.path}`);
+        });
+    }
+    /**
+     * 停止健康检查 HTTP 服务
+     */
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+}
+exports.HTTPHealthCheck = HTTPHealthCheck;
+/**
+ * TCP 健康检查工具类
+ * 传入 tcp url，自动启动一个 TCP 服务
+ */
+class TCPHealthCheck {
+    /**
+     * @param tcpUrl 形如 'tcp://127.0.0.1:3000'
+     */
+    constructor(tcpUrl) {
+        this.server = null;
+        const url = new url_1.URL(tcpUrl);
+        this.port = Number(url.port) || 80;
+        this.host = url.hostname || '0.0.0.0';
+    }
+    /**
+     * 启动 TCP 健康检查服务
+     */
+    start() {
+        if (this.server)
+            return;
+        this.server = (0, net_1.createServer)(socket => {
+            // 只要能建立连接就立即关闭
+            socket.end();
+        });
+        this.server.listen(this.port, this.host, () => {
+            console.log(`[tcp-health] TCP 健康检查服务已启动: tcp://${this.host}:${this.port}`);
+        });
+    }
+    /**
+     * 停止 TCP 健康检查服务
+     */
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+}
+exports.TCPHealthCheck = TCPHealthCheck;
+//# sourceMappingURL=helper.js.map

package/dist/extension/serviceDiscovery.d.ts

@@ -0,0 +1,45 @@
+import { ServiceDiscovery, ServiceDiscoveryClient, ILogger, MidwayWebRouterService, MidwayApplicationManager } from '@midwayjs/core';
+import { ConsulServiceDiscoveryOptions, ConsulClient, ConsulInstanceMetadata, ConsulHealthItem, GetHealthServiceOptions } from '../interface';
+/**
+ * The adapter for consul service discovery
+ * @since 4.0.0
+ */
+export declare class ConsulServiceDiscoverClient extends ServiceDiscoveryClient<ConsulClient, ConsulServiceDiscoveryOptions, ConsulInstanceMetadata, ConsulHealthItem> {
+    protected consul: ConsulClient;
+    protected readonly applicationManager: MidwayApplicationManager;
+    protected readonly webRouterService: MidwayWebRouterService;
+    protected readonly logger: ILogger;
+    private ttlHeartbeat?;
+    private httpHealthCheck?;
+    private tcpHealthCheck?;
+    constructor(consul: ConsulClient, serviceDiscoveryOptions: ConsulServiceDiscoveryOptions, applicationManager: MidwayApplicationManager, webRouterService: MidwayWebRouterService, logger: ILogger);
+    register(instance: ConsulInstanceMetadata): Promise<void>;
+    deregister(instance?: ConsulInstanceMetadata): Promise<void>;
+    private transformDefaultMetaToConsulInstance;
+    private updateStatus;
+    online(): Promise<void>;
+    offline(): Promise<void>;
+    beforeStop(): Promise<void>;
+}
+/**
+ * The service discovery for consul
+ * @since 4.0.0
+ */
+export declare class ConsulServiceDiscovery extends ServiceDiscovery<ConsulClient, ConsulServiceDiscoveryOptions, ConsulInstanceMetadata, ConsulHealthItem, GetHealthServiceOptions> {
+    private consulServiceFactory;
+    private consulServiceDiscoveryOptions;
+    private applicationManager;
+    private webRouterService;
+    private coreLogger;
+    private defaultServiceClient;
+    private listenerStore;
+    private configService;
+    init(): Promise<void>;
+    protected getServiceClient(): import("consul/lib/consul").Consul;
+    protected createServiceDiscoverClientImpl(options: ConsulServiceDiscoveryOptions): ConsulServiceDiscoverClient;
+    protected getDefaultServiceDiscoveryOptions(): ConsulServiceDiscoveryOptions;
+    private getListener;
+    getInstances(options: GetHealthServiceOptions): Promise<ConsulHealthItem[]>;
+    beforeStop(): Promise<void>;
+}
+//# sourceMappingURL=serviceDiscovery.d.ts.map

package/dist/extension/serviceDiscovery.js

@@ -0,0 +1,245 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsulServiceDiscovery = exports.ConsulServiceDiscoverClient = void 0;
+const core_1 = require("@midwayjs/core");
+const manager_1 = require("../manager");
+const utils_1 = require("../utils");
+const helper_1 = require("./helper");
+/**
+ * The data listener for consul service discovery
+ * @since 4.0.0
+ */
+class ConsulDataListener extends core_1.DataListener {
+    constructor(client, options, logger) {
+        super();
+        this.client = client;
+        this.options = options;
+        this.logger = logger;
+    }
+    async init() {
+        await super.init();
+    }
+    // 初始化数据
+    async initData() {
+        const services = await this.client.health.service(this.options);
+        if (services && (0, utils_1.isObjectError)(services)) {
+            throw (0, utils_1.formatObjectErrorToError)(services);
+        }
+        return services;
+    }
+    // 更新数据
+    onData(setData) {
+        this.watcher = this.client.watch({
+            method: this.client.health.service,
+            options: this.options,
+        });
+        this.watcher.on('change', (healthItems, res) => {
+            setData(healthItems);
+        });
+        this.watcher.on('error', err => {
+            this.logger.error('[midway:consul] Error watching service:', err);
+        });
+    }
+    async destroyListener() {
+        if (this.watcher) {
+            await this.watcher.end();
+        }
+    }
+}
+/**
+ * The adapter for consul service discovery
+ * @since 4.0.0
+ */
+class ConsulServiceDiscoverClient extends core_1.ServiceDiscoveryClient {
+    constructor(consul, serviceDiscoveryOptions, applicationManager, webRouterService, logger) {
+        super(consul, serviceDiscoveryOptions);
+        this.consul = consul;
+        this.applicationManager = applicationManager;
+        this.webRouterService = webRouterService;
+        this.logger = logger;
+    }
+    async register(instance) {
+        instance = this.transformDefaultMetaToConsulInstance(instance);
+        this.instance = instance;
+        if (!instance.name) {
+            throw new core_1.MidwayParameterError('instance.name is required when register service in consul');
+        }
+        const res = await this.client.agent.service.register(instance);
+        if (res && (0, utils_1.isObjectError)(res)) {
+            throw (0, utils_1.formatObjectErrorToError)(res);
+        }
+        this.logger.info(`[midway:consul] register instance: ${instance.id} for service: ${instance.name}`);
+        // set status to UP
+        await this.online();
+        this.logger.info(`[midway:consul] set status to UP for instance: ${instance.id} and service: ${instance.name}`);
+        if (this.options.autoHealthCheck) {
+            if (instance['check']?.['ttl']) {
+                this.ttlHeartbeat = new helper_1.TTLHeartbeat({
+                    consul: this.client,
+                    checkId: `service:${instance.id}`,
+                    interval: (0, helper_1.calculateTTL)(instance['check']['ttl']),
+                });
+                this.ttlHeartbeat.start();
+            }
+            else if (instance['check']?.['http']) {
+                // 这里要判断下是否启动了 http 服务
+                const applications = this.applicationManager.getApplications([
+                    'egg',
+                    'koa',
+                    'express',
+                ]);
+                if (applications.length !== 0) {
+                    const url = new URL(instance['check']['http']);
+                    this.webRouterService.addRouter(async (_) => {
+                        return 'success';
+                    }, {
+                        url: url.pathname,
+                        requestMethod: 'GET',
+                    });
+                }
+                else {
+                    this.httpHealthCheck = new helper_1.HTTPHealthCheck(instance['check']['http']);
+                    this.httpHealthCheck.start();
+                }
+            }
+            else if (instance['check']?.['tcp']) {
+                this.tcpHealthCheck = new helper_1.TCPHealthCheck(instance['check']['tcp']);
+                this.tcpHealthCheck.start();
+            }
+        }
+    }
+    async deregister(instance) {
+        instance = instance ?? this.instance;
+        if (instance) {
+            const res = await this.client.agent.service.deregister(instance.id);
+            if (res && (0, utils_1.isObjectError)(res)) {
+                throw (0, utils_1.formatObjectErrorToError)(res);
+            }
+            this.logger.info(`[midway:consul] deregister instance: ${instance.id} for service: ${instance.name}`);
+            this.instance = undefined;
+        }
+    }
+    transformDefaultMetaToConsulInstance(instance) {
+        return {
+            name: instance?.serviceName,
+            address: instance?.host,
+            meta: instance?.metadata,
+            ...instance,
+        };
+    }
+    async updateStatus(instance, status) {
+        const checkId = `service:${instance.id}`;
+        if (status === 'UP') {
+            await this.client.agent.check.pass(checkId);
+        }
+        else {
+            await this.client.agent.check.fail(checkId);
+        }
+    }
+    async online() {
+        await this.updateStatus(this.instance, 'UP');
+    }
+    async offline() {
+        await this.updateStatus(this.instance, 'DOWN');
+    }
+    async beforeStop() {
+        await this.deregister();
+        if (this.ttlHeartbeat) {
+            this.ttlHeartbeat.stop();
+        }
+        if (this.httpHealthCheck) {
+            this.httpHealthCheck.stop();
+        }
+        if (this.tcpHealthCheck) {
+            this.tcpHealthCheck.stop();
+        }
+    }
+}
+exports.ConsulServiceDiscoverClient = ConsulServiceDiscoverClient;
+/**
+ * The service discovery for consul
+ * @since 4.0.0
+ */
+let ConsulServiceDiscovery = class ConsulServiceDiscovery extends core_1.ServiceDiscovery {
+    constructor() {
+        super(...arguments);
+        this.listenerStore = new Map();
+    }
+    async init() {
+        this.consulServiceDiscoveryOptions = this.configService.getConfiguration('consul.serviceDiscovery', {});
+    }
+    getServiceClient() {
+        if (!this.defaultServiceClient) {
+            this.defaultServiceClient = this.consulServiceFactory.get(this.consulServiceDiscoveryOptions.serviceDiscoveryClient ||
+                this.consulServiceFactory.getDefaultClientName() ||
+                'default');
+        }
+        return this.defaultServiceClient;
+    }
+    createServiceDiscoverClientImpl(options) {
+        return new ConsulServiceDiscoverClient(this.getServiceClient(), options, this.applicationManager, this.webRouterService, this.coreLogger);
+    }
+    getDefaultServiceDiscoveryOptions() {
+        return this.consulServiceDiscoveryOptions;
+    }
+    async getListener(options) {
+        const cacheKey = (0, utils_1.hashServiceOptions)(options);
+        if (!this.listenerStore.has(cacheKey)) {
+            const listener = new ConsulDataListener(this.getServiceClient(), options, this.coreLogger);
+            this.listenerStore.set(cacheKey, listener);
+            await listener.init();
+        }
+        return this.listenerStore.get(cacheKey);
+    }
+    async getInstances(options) {
+        const listener = await this.getListener({
+            passing: true,
+            ...options,
+        });
+        return listener.getData();
+    }
+    async beforeStop() {
+        await Promise.all(Array.from(this.listenerStore.values()).map(listener => listener.destroyListener()));
+        this.listenerStore.clear();
+    }
+};
+exports.ConsulServiceDiscovery = ConsulServiceDiscovery;
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", manager_1.ConsulServiceFactory)
+], ConsulServiceDiscovery.prototype, "consulServiceFactory", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayApplicationManager)
+], ConsulServiceDiscovery.prototype, "applicationManager", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayWebRouterService)
+], ConsulServiceDiscovery.prototype, "webRouterService", void 0);
+__decorate([
+    (0, core_1.Logger)(),
+    __metadata("design:type", Object)
+], ConsulServiceDiscovery.prototype, "coreLogger", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayConfigService)
+], ConsulServiceDiscovery.prototype, "configService", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ConsulServiceDiscovery.prototype, "init", null);
+exports.ConsulServiceDiscovery = ConsulServiceDiscovery = __decorate([
+    (0, core_1.Singleton)()
+], ConsulServiceDiscovery);
+//# sourceMappingURL=serviceDiscovery.js.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { ConsulConfiguration as Configuration } from './configuration';
-export * from './controller/consul';
-export * from './service/balancer';
 export * from './interface';
+export * from './extension/serviceDiscovery';
+export * from './manager';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -17,7 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Configuration = void 0;
 var configuration_1 = require("./configuration");
 Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.ConsulConfiguration; } });
-__exportStar(require("./controller/consul"), exports);
-__exportStar(require("./service/balancer"), exports);
 __exportStar(require("./interface"), exports);
+__exportStar(require("./extension/serviceDiscovery"), exports);
+__exportStar(require("./manager"), exports);
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -1,72 +1,79 @@
-import * as Consul from 'consul';
-import type { ConsulOptions } from 'consul';
-import RegisterOptions = Consul.Agent.Service.RegisterOptions;
-export interface IServiceBalancer {
-    /**
-     * 根据服务名称选择实例
-     * @param serviceName 注册的服务名称
-     * @param passingOnly 只返回通过健康检查的实例，默认为 true
-     */
-    select(serviceName: string, passingOnly?: boolean): any | never;
+import { ServiceDiscoveryOptions, DefaultInstanceMetadata } from '@midwayjs/core';
+import Consul = require('consul');
+export type ConsulOptions = ConstructorParameters<typeof Consul>[0];
+export type ConsulClient = InstanceType<typeof Consul>;
+type GetRegisterFn<T> = T extends {
+    register(options: any): any;
+} ? T['register'] : never;
+type GetFirstParam<T> = T extends {
+    (options: infer P, ...args: any[]): any;
+    (name: string): any;
+} ? P : never;
+export type RegisterOptions = GetFirstParam<GetRegisterFn<ConsulClient['agent']['service']>>;
+/**
+ * From ConsulClient['health']['service']
+ */
+export type GetHealthServiceOptions = {
+    service: string;
+    dc?: string;
+    near?: string;
+    tag?: string;
+    passing?: boolean;
+    filter?: string;
+    peer?: string;
+    ns?: string;
+};
+export interface ConsulInstanceMetadata extends RegisterOptions {
 }
-export interface IConsulBalancer {
-    /**
-     * 根绝策略返回负载均衡器
-     * @param strategy 负载均衡策略
-     */
-    getServiceBalancer(strategy?: string): IServiceBalancer;
+export interface ConsulServiceDiscoveryOptions extends ServiceDiscoveryOptions<ConsulHealthItem> {
+    serviceOptions?: ConsulInstanceMetadata | ((meta: DefaultInstanceMetadata) => ConsulInstanceMetadata);
+    autoHealthCheck?: boolean;
 }
-export interface IConsulProviderInfoOptions extends ConsulOptions {
-    /**
-     * 本服务是否注册到 consul 服务器，默认是 NO 不会执行注册
-     */
-    register?: boolean;
-    /**
-     * 应用正常关闭的额时候自动反注册，默认是 YES 会执行反注册
-     * 如果 register=false 改参数无效
-     */
-    deregister?: boolean;
-    /**
-     * 调用服务负载均衡的策略(default、random)，默认是 random 随机
-     */
-    strategy?: string;
-}
-export interface IConsulRegisterInfoOptions extends RegisterOptions {
-    /**
-     * 注册 id 标识，默认是 name:address:port 的组合
-     */
-    id?: string;
-    /**
-     * 服务名称
-     */
-    name: string;
-    /**
-     * 服务地址
-     */
-    address: string;
-    /**
-     * 服务端口
-     */
-    port: number;
-    /**
-     * 服务标签
-     */
-    tags?: string[];
-    /**
-     * 健康检查配置，组件默认会配置一个(检查间隔是3秒)，如果指定 check=false 则关闭 consul 健康检查
-     */
-    check?: {
-        tcp?: string;
-        http?: string;
-        script?: string;
-        interval?: string;
-        ttl?: string;
-        notes?: string;
-        status?: string;
+export interface ConsulHealthItem {
+    Node: {
+        ID: string;
+        Node: string;
+        Address: string;
+        Datacenter: string;
+        TaggedAddresses: Record<string, any>;
+        Meta: Record<string, any>;
+        CreateIndex: number;
+        ModifyIndex: number;
     };
+    Service: {
+        ID: string;
+        Service: string;
+        Tags: string[];
+        Address: string;
+        TaggedAddresses: Record<string, any>;
+        Meta: Record<string, any>;
+        Port: number;
+        Weights: Record<string, any>;
+        EnableTagOverride: boolean;
+        Proxy: Record<string, any>;
+        Connect: Record<string, any>;
+        PeerName: string;
+        CreateIndex: number;
+        ModifyIndex: number;
+    };
+    Checks: Array<{
+        Node: string;
+        CheckID: string;
+        Name: string;
+        Status: 'passing' | 'warning' | 'critical';
+        Notes: string;
+        Output: string;
+        ServiceID: string;
+        ServiceName: string;
+        ServiceTags: string[];
+        Type: string;
+        Interval: string;
+        Timeout: string;
+        ExposedPort: number;
+        Definition: Record<string, any>;
+        CreateIndex: number;
+        ModifyIndex: number;
+    }>;
 }
-export interface ConsulConfig {
-    provider?: IConsulProviderInfoOptions;
-    service?: IConsulRegisterInfoOptions;
-}
+export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/manager.d.ts

@@ -0,0 +1,19 @@
+import { ServiceFactory, ServiceFactoryConfigOption, ILogger } from '@midwayjs/core';
+import Consul = require('consul');
+import { ConsulClient, ConsulOptions } from './interface';
+export declare class ConsulServiceFactory extends ServiceFactory<ConsulClient> {
+    consulConfig: ServiceFactoryConfigOption<ConsulOptions>;
+    init(): Promise<void>;
+    logger: ILogger;
+    createClient(config: ConsulOptions, clientName: string): Promise<InstanceType<typeof Consul>>;
+    getName(): string;
+    destroyClient(client: InstanceType<typeof Consul>, clientName: string): Promise<void>;
+}
+export declare class ConsulService implements InstanceType<typeof Consul> {
+    private serviceFactory;
+    private instance;
+    init(): Promise<void>;
+}
+export interface ConsulService extends InstanceType<typeof Consul> {
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/manager.js

@@ -0,0 +1,74 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsulService = exports.ConsulServiceFactory = void 0;
+const core_1 = require("@midwayjs/core");
+const Consul = require("consul");
+let ConsulServiceFactory = class ConsulServiceFactory extends core_1.ServiceFactory {
+    async init() {
+        await this.initClients(this.consulConfig, {
+            concurrent: true,
+        });
+    }
+    async createClient(config, clientName) {
+        this.logger.info('[midway:consul] init %s at %s:%s', clientName, config.host, config.port);
+        return new Consul(config);
+    }
+    getName() {
+        return 'consul';
+    }
+    async destroyClient(client, clientName) {
+        this.logger.info('[midway:consul] destroy %s', clientName);
+        client.destroy();
+    }
+};
+exports.ConsulServiceFactory = ConsulServiceFactory;
+__decorate([
+    (0, core_1.Config)('consul'),
+    __metadata("design:type", Object)
+], ConsulServiceFactory.prototype, "consulConfig", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ConsulServiceFactory.prototype, "init", null);
+__decorate([
+    (0, core_1.Logger)('coreLogger'),
+    __metadata("design:type", Object)
+], ConsulServiceFactory.prototype, "logger", void 0);
+exports.ConsulServiceFactory = ConsulServiceFactory = __decorate([
+    (0, core_1.Singleton)()
+], ConsulServiceFactory);
+let ConsulService = class ConsulService {
+    async init() {
+        this.instance = this.serviceFactory.get(this.serviceFactory.getDefaultClientName?.() || 'default');
+        if (!this.instance) {
+            throw new core_1.MidwayCommonError('consul default instance not found.');
+        }
+    }
+};
+exports.ConsulService = ConsulService;
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", ConsulServiceFactory)
+], ConsulService.prototype, "serviceFactory", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ConsulService.prototype, "init", null);
+exports.ConsulService = ConsulService = __decorate([
+    (0, core_1.Singleton)()
+], ConsulService);
+(0, core_1.delegateTargetAllPrototypeMethod)(ConsulService, Consul);
+//# sourceMappingURL=manager.js.map

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+import { MidwayCommonError } from '@midwayjs/core';
+import { GetHealthServiceOptions } from './interface';
+export declare function isObjectError(obj: any): boolean;
+export declare function formatObjectErrorToError(obj: any): MidwayCommonError;
+/**
+ * 对于 1 万个不同 ServiceOptions 组合，使用当前这个基于 DJB2 + base36 的方法，冲突概率大约是 0.1%，也就是理论上每 1 万个中只有 10 个左右可能冲突，而且这还是在完全随机分布的情况下估算的
+ * 适用于对象类型是扁平的，没有嵌套
+ *
+ * @param options
+ * @returns
+ */
+export declare function hashServiceOptions(options: GetHealthServiceOptions): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashServiceOptions = exports.formatObjectErrorToError = exports.isObjectError = void 0;
+const core_1 = require("@midwayjs/core");
+function isObjectError(obj) {
+    return obj && typeof obj === 'object' && 'errno' in obj;
+}
+exports.isObjectError = isObjectError;
+function formatObjectErrorToError(obj) {
+    const err = new Error(obj.message);
+    err.stack = obj.stack;
+    err.errno = obj.errno;
+    for (const key in obj) {
+        if (key !== 'errno' && key !== 'stack') {
+            err[key] = obj[key];
+        }
+    }
+    const commonErr = new core_1.MidwayCommonError(obj.message);
+    err.cause = commonErr;
+    return commonErr;
+}
+exports.formatObjectErrorToError = formatObjectErrorToError;
+/**
+ * 对于 1 万个不同 ServiceOptions 组合，使用当前这个基于 DJB2 + base36 的方法，冲突概率大约是 0.1%，也就是理论上每 1 万个中只有 10 个左右可能冲突，而且这还是在完全随机分布的情况下估算的
+ * 适用于对象类型是扁平的，没有嵌套
+ *
+ * @param options
+ * @returns
+ */
+function hashServiceOptions(options) {
+    const keys = Object.keys(options).sort();
+    let str = '';
+    for (const key of keys) {
+        const value = options[key];
+        str += `${key}:${String(value)}|`;
+    }
+    // 简单快速 hash 算法（DJB2 改进）
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash * 33) ^ str.charCodeAt(i);
+    }
+    return (hash >>> 0).toString(36); // 无符号，base36 更短
+}
+exports.hashServiceOptions = hashServiceOptions;
+//# sourceMappingURL=utils.js.map

package/index.d.ts

@@ -1,9 +1,9 @@
-import { ConsulConfig } from './dist';
+import { ConsulOptions } from './dist';
 
 export * from './dist/index';
 
 declare module '@midwayjs/core/dist/interface' {
   interface MidwayConfig {
-    consul?: ConsulConfig;
+    consul?: ServiceFactoryConfigOption<ConsulOptions>;
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@midwayjs/consul",
   "description": "midway consul",
-  "version": "3.20.5",
+  "version": "4.0.0-beta.1",
   "main": "dist/index.js",
   "typings": "index.d.ts",
   "files": [
@@ -10,15 +10,15 @@
     "index.d.ts"
   ],
   "devDependencies": {
-    "@midwayjs/core": "^3.20.4",
-    "@midwayjs/koa": "^3.20.5",
-    "@midwayjs/mock": "^3.20.4",
-    "@types/consul": "0.40.3",
+    "@midwayjs/core": "^4.0.0-beta.1",
+    "@midwayjs/koa": "^4.0.0-beta.1",
+    "@midwayjs/mock": "^4.0.0-beta.1",
     "@types/sinon": "17.0.3",
     "nock": "13.5.6"
   },
   "dependencies": {
-    "consul": "1.2.0"
+    "consul": "2.0.1",
+    "ms": "2.1.3"
   },
   "keywords": [
     "consul"
@@ -27,8 +27,8 @@
   "license": "MIT",
   "scripts": {
     "build": "tsc",
-    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
-    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit",
+    "test": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand",
+    "cov": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand --coverage --forceExit",
     "ci": "npm run test",
     "lint": "mwts check"
   },
@@ -39,5 +39,5 @@
     "type": "git",
     "url": "https://github.com/midwayjs/midway.git"
   },
-  "gitHead": "7ce57281bd3ef5d18dc50b47ff9bffb8a27c071e"
+  "gitHead": "832961ec3aff123c033197d8c00cb2bc9bad7ff8"
 }

package/dist/config/config.default.d.ts

@@ -1,19 +0,0 @@
-declare const _default: {
-    consul: {
-        provider: {
-            register: boolean;
-            host: string;
-            port: number;
-            strategy: string;
-        };
-        service: {
-            id: any;
-            name: any;
-            tags: any[];
-            address: any;
-            port: number;
-        };
-    };
-};
-export default _default;
-//# sourceMappingURL=config.default.d.ts.map

package/dist/config/config.default.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
-    consul: {
-        provider: {
-            register: false,
-            host: '127.0.0.1',
-            port: 8500,
-            strategy: 'random',
-        },
-        service: {
-            id: null,
-            name: null,
-            tags: [],
-            address: null,
-            port: 7001,
-        },
-    },
-};
-//# sourceMappingURL=config.default.js.map

package/dist/controller/consul.d.ts

@@ -1,4 +0,0 @@
-export declare class ConsulController {
-    healthCheck(): Promise<any>;
-}
-//# sourceMappingURL=consul.d.ts.map

package/dist/controller/consul.js

@@ -1,31 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsulController = void 0;
-const core_1 = require("@midwayjs/core");
-let ConsulController = class ConsulController {
-    async healthCheck() {
-        return {
-            status: 'success',
-        };
-    }
-};
-__decorate([
-    (0, core_1.Get)('/health/self/check'),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], ConsulController.prototype, "healthCheck", null);
-ConsulController = __decorate([
-    (0, core_1.Controller)('/consul')
-], ConsulController);
-exports.ConsulController = ConsulController;
-//# sourceMappingURL=consul.js.map

package/dist/lib/balancer.d.ts

@@ -1,8 +0,0 @@
-import * as Consul from 'consul';
-import { IServiceBalancer, IConsulBalancer } from '../interface';
-export declare class ConsulBalancer implements IConsulBalancer {
-    private consul;
-    constructor(consul: Consul.Consul);
-    getServiceBalancer(strategy?: string): IServiceBalancer;
-}
-//# sourceMappingURL=balancer.d.ts.map

package/dist/lib/balancer.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsulBalancer = void 0;
-class Balancer {
-    constructor(consul) {
-        this.consul = consul;
-        //
-    }
-    async select(serviceName, passingOnly = true) {
-        // throw new Error('not implemented');
-    }
-    async loadServices(serviceName, passingOnly = true) {
-        if (passingOnly)
-            return await this.loadPassing(serviceName);
-        return await this.loadAll(serviceName);
-    }
-    async loadAll(serviceName) {
-        return (await this.consul.catalog.service.nodes(serviceName));
-    }
-    async loadPassing(serviceName) {
-        const passingIds = [];
-        const checks = (await this.consul.health.checks(serviceName));
-        // 健康检查通过的
-        checks.forEach(check => {
-            if (check.Status === 'passing') {
-                passingIds.push(check.ServiceID);
-            }
-        });
-        const instances = await this.loadAll(serviceName);
-        return instances.filter(item => passingIds.includes(item.ServiceID));
-    }
-}
-class RandomBalancer extends Balancer {
-    constructor(consul) {
-        super(consul);
-    }
-    async select(serviceName, passingOnly = true) {
-        let instances = await this.loadServices(serviceName, passingOnly);
-        if (instances.length > 0) {
-            instances = this.shuffle(instances);
-            return instances[Math.floor(Math.random() * instances.length)];
-        }
-        throw new Error('no available instance named ' + serviceName);
-    }
-    /**
-     * shuff by fisher-yates
-     */
-    shuffle(instances) {
-        const result = [];
-        for (let i = 0; i < instances.length; i++) {
-            const j = Math.floor(Math.random() * (i + 1));
-            if (j !== i) {
-                result[i] = result[j];
-            }
-            result[j] = instances[i];
-        }
-        return result;
-    }
-}
-class ConsulBalancer {
-    constructor(consul) {
-        this.consul = consul;
-        //
-    }
-    getServiceBalancer(strategy) {
-        switch (strategy) {
-            case 'random':
-                return new RandomBalancer(this.consul);
-        }
-        throw new Error('invalid strategy balancer');
-    }
-}
-exports.ConsulBalancer = ConsulBalancer;
-//# sourceMappingURL=balancer.js.map

package/dist/lib/provider.d.ts

@@ -1,12 +0,0 @@
-import { IConsulProviderInfoOptions, IConsulRegisterInfoOptions } from '../interface';
-import * as Consul from 'consul';
-export declare class ConsulProvider {
-    private readonly consul;
-    constructor(providerOptions: IConsulProviderInfoOptions);
-    getConsul(): Consul.Consul;
-    registerService(registerOptions: IConsulRegisterInfoOptions): Promise<void>;
-    deregisterService(deregisterOptions: {
-        id: string;
-    }): Promise<void>;
-}
-//# sourceMappingURL=provider.d.ts.map

package/dist/lib/provider.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConsulProvider = void 0;
-const Consul = require("consul");
-class ConsulProvider {
-    constructor(providerOptions) {
-        // should be, ignore config
-        providerOptions.promisify = true;
-        this.consul = new Consul(providerOptions);
-    }
-    getConsul() {
-        return this.consul;
-    }
-    async registerService(registerOptions) {
-        await this.consul.agent.service.register(registerOptions);
-    }
-    async deregisterService(deregisterOptions) {
-        await this.consul.agent.service.deregister(deregisterOptions);
-    }
-}
-exports.ConsulProvider = ConsulProvider;
-//# sourceMappingURL=provider.js.map

package/dist/service/balancer.d.ts

@@ -1,9 +0,0 @@
-import * as Consul from 'consul';
-import { IServiceBalancer, IConsulBalancer } from '../interface';
-export declare class BalancerService implements IConsulBalancer {
-    consul: Consul.Consul;
-    private consulBalancer;
-    init(): void;
-    getServiceBalancer(strategy?: string): IServiceBalancer;
-}
-//# sourceMappingURL=balancer.d.ts.map

package/dist/service/balancer.js

@@ -1,39 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BalancerService = void 0;
-const core_1 = require("@midwayjs/core");
-const balancer_1 = require("../lib/balancer");
-const Consul = require("consul");
-let BalancerService = class BalancerService {
-    init() {
-        this.consulBalancer = new balancer_1.ConsulBalancer(this.consul);
-    }
-    getServiceBalancer(strategy = 'random') {
-        return this.consulBalancer.getServiceBalancer(strategy);
-    }
-};
-__decorate([
-    (0, core_1.Inject)('consul:consul'),
-    __metadata("design:type", Object)
-], BalancerService.prototype, "consul", void 0);
-__decorate([
-    (0, core_1.Init)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
-], BalancerService.prototype, "init", null);
-BalancerService = __decorate([
-    (0, core_1.Provide)(),
-    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
-], BalancerService);
-exports.BalancerService = BalancerService;
-//# sourceMappingURL=balancer.js.map