@midwayjs/core 4.0.0-alpha.1 → 4.0.0-beta.1

package/dist/common/serviceDiscovery/healthCheck.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceDiscoveryHealthCheckFactory = exports.TCPHealthCheck = exports.HTTPHealthCheck = exports.TTLHealthCheck = exports.AbstractHealthCheck = void 0;
+const httpclient_1 = require("../../util/httpclient");
+const error_1 = require("../../error");
+const net = require("net");
+/**
+ * 抽象健康检查类
+ */
+class AbstractHealthCheck {
+    constructor(options) {
+        this.lastCheckTime = 0;
+        this.lastCheckResult = null;
+        // 设置默认值
+        const defaultOptions = {
+            interval: 10000, // 默认10秒
+            timeout: 5000, // 默认5秒
+            maxRetries: 3, // 默认3次
+            retryInterval: 1000, // 默认1秒
+        };
+        // 合并默认值和传入的选项
+        this.options = {
+            ...defaultOptions,
+            ...options,
+        };
+    }
+    /**
+     * 是否需要检查
+     * 根据检查间隔判断是否需要执行新的检查
+     */
+    shouldCheck() {
+        const now = Date.now();
+        return now - this.lastCheckTime >= this.options.interval;
+    }
+    /**
+     * 获取最后一次检查结果
+     */
+    getLastCheckResult() {
+        return this.lastCheckResult;
+    }
+    /**
+     * 更新检查结果
+     */
+    updateCheckResult(result) {
+        this.lastCheckTime = Date.now();
+        this.lastCheckResult = result;
+    }
+}
+exports.AbstractHealthCheck = AbstractHealthCheck;
+/**
+ * TTL 健康检查实现
+ * 用于 Redis/ETCD 等基于 TTL 的服务发现
+ */
+class TTLHealthCheck extends AbstractHealthCheck {
+    constructor(options) {
+        super(options);
+        this.ttl = options?.ttl;
+    }
+    async check(instance) {
+        const now = Date.now();
+        const lastUpdate = instance.getMetadata()?.lastUpdate || 0;
+        const timeSinceLastUpdate = now - lastUpdate;
+        if (timeSinceLastUpdate > this.ttl * 1000) {
+            return {
+                status: 'critical',
+                message: 'Service instance TTL expired',
+                timestamp: now,
+            };
+        }
+        return {
+            status: 'passing',
+            timestamp: now,
+        };
+    }
+}
+exports.TTLHealthCheck = TTLHealthCheck;
+/**
+ * HTTP 健康检查实现
+ * 用于支持 HTTP 检查的服务发现
+ */
+class HTTPHealthCheck extends AbstractHealthCheck {
+    constructor(options) {
+        super(options);
+        this.checkUrl = options.url;
+        this.httpOptions = options;
+        this.httpClient = new httpclient_1.HttpClient({
+            timeout: options.timeout || 5000,
+        });
+    }
+    async check(instance) {
+        const now = Date.now();
+        let retries = 0;
+        let lastError = null;
+        while (retries < this.httpOptions.maxRetries) {
+            try {
+                const response = await this.httpClient.request(this.checkUrl, {
+                    method: this.httpOptions.method || 'GET',
+                    headers: this.httpOptions.headers,
+                    timeout: this.httpOptions.timeout,
+                });
+                if (response.status === (this.httpOptions.expectedStatus || 200)) {
+                    return {
+                        status: 'passing',
+                        timestamp: now,
+                    };
+                }
+                lastError = new error_1.MidwayCommonError(`HTTP health check failed with status ${response.status}`);
+                retries++;
+                if (retries < this.httpOptions.maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, this.httpOptions.retryInterval));
+                }
+            }
+            catch (error) {
+                lastError = new error_1.MidwayCommonError(`HTTP health check error: ${error.message}`);
+                retries++;
+                if (retries < this.httpOptions.maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, this.httpOptions.retryInterval));
+                }
+            }
+        }
+        return {
+            status: 'critical',
+            message: lastError?.message || 'Health check failed after all retries',
+            timestamp: now,
+        };
+    }
+}
+exports.HTTPHealthCheck = HTTPHealthCheck;
+/**
+ * TCP 健康检查实现
+ * 用于支持 TCP 检查的服务发现
+ */
+class TCPHealthCheck extends AbstractHealthCheck {
+    constructor(options) {
+        super(options);
+        this.host = options.host;
+        this.port = options.port;
+        this.tcpOptions = options;
+    }
+    async check(instance) {
+        const now = Date.now();
+        let retries = 0;
+        let lastError = null;
+        while (retries < this.tcpOptions.maxRetries) {
+            try {
+                const socket = new Promise((resolve, reject) => {
+                    const client = net.createConnection(this.port, this.host, () => {
+                        client.end();
+                        resolve(true);
+                    });
+                    client.on('error', error => {
+                        client.end();
+                        reject(new error_1.MidwayCommonError(`TCP connection failed: ${error.message}`));
+                    });
+                    client.setTimeout(this.tcpOptions.timeout, () => {
+                        client.end();
+                        reject(new error_1.MidwayCommonError('TCP connection timeout'));
+                    });
+                });
+                await socket;
+                return {
+                    status: 'passing',
+                    timestamp: now,
+                };
+            }
+            catch (error) {
+                lastError =
+                    error instanceof error_1.MidwayCommonError
+                        ? error
+                        : new error_1.MidwayCommonError(`TCP health check error: ${error.message}`);
+                retries++;
+                if (retries < this.tcpOptions.maxRetries) {
+                    await new Promise(resolve => setTimeout(resolve, this.tcpOptions.retryInterval));
+                }
+            }
+        }
+        return {
+            status: 'critical',
+            message: lastError?.message || 'TCP health check failed after all retries',
+            timestamp: now,
+        };
+    }
+}
+exports.TCPHealthCheck = TCPHealthCheck;
+/**
+ * 健康检查工厂
+ */
+class ServiceDiscoveryHealthCheckFactory {
+    static create(type, options) {
+        switch (type) {
+            case 'self':
+                return undefined;
+            case 'ttl':
+                return new TTLHealthCheck(options);
+            case 'http':
+                return new HTTPHealthCheck(options);
+            case 'tcp':
+                return new TCPHealthCheck(options);
+            case 'custom':
+                return options;
+            default:
+                throw new error_1.MidwayCommonError(`Unsupported health check type: ${type}`);
+        }
+    }
+}
+exports.ServiceDiscoveryHealthCheckFactory = ServiceDiscoveryHealthCheckFactory;
+//# sourceMappingURL=healthCheck.js.map

package/dist/common/serviceDiscovery/loadBalancer.d.ts

@@ -0,0 +1,21 @@
+import { ILoadBalancer, LoadBalancerType } from '../../interface';
+/**
+ * 随机负载均衡策略
+ */
+export declare class RandomLoadBalance<ServiceInstance> implements ILoadBalancer<ServiceInstance> {
+    select(instances: ServiceInstance[]): ServiceInstance;
+}
+/**
+ * 轮询负载均衡策略
+ */
+export declare class RoundRobinLoadBalancer<ServiceInstance> implements ILoadBalancer<ServiceInstance> {
+    private currentIndex;
+    select(instances: ServiceInstance[]): ServiceInstance;
+}
+/**
+ * 负载均衡工厂
+ */
+export declare class LoadBalancerFactory {
+    static create<ServiceInstance>(type: LoadBalancerType): ILoadBalancer<ServiceInstance>;
+}
+//# sourceMappingURL=loadBalancer.d.ts.map

package/dist/common/serviceDiscovery/loadBalancer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancerFactory = exports.RoundRobinLoadBalancer = exports.RandomLoadBalance = void 0;
+const interface_1 = require("../../interface");
+/**
+ * 随机负载均衡策略
+ */
+class RandomLoadBalance {
+    select(instances) {
+        if (!instances.length) {
+            throw new Error('No available instances');
+        }
+        const index = Math.floor(Math.random() * instances.length);
+        return instances[index];
+    }
+}
+exports.RandomLoadBalance = RandomLoadBalance;
+/**
+ * 轮询负载均衡策略
+ */
+class RoundRobinLoadBalancer {
+    constructor() {
+        this.currentIndex = 0;
+    }
+    select(instances) {
+        if (!instances.length) {
+            throw new Error('No available instances');
+        }
+        const instance = instances[this.currentIndex];
+        this.currentIndex = (this.currentIndex + 1) % instances.length;
+        return instance;
+    }
+}
+exports.RoundRobinLoadBalancer = RoundRobinLoadBalancer;
+/**
+ * 负载均衡工厂
+ */
+class LoadBalancerFactory {
+    static create(type) {
+        switch (type) {
+            case interface_1.LoadBalancerType.RANDOM:
+                return new RandomLoadBalance();
+            case interface_1.LoadBalancerType.ROUND_ROBIN:
+                return new RoundRobinLoadBalancer();
+            default:
+                throw new Error(`Unsupported load balancer type: ${type}`);
+        }
+    }
+}
+exports.LoadBalancerFactory = LoadBalancerFactory;
+//# sourceMappingURL=loadBalancer.js.map

package/dist/common/serviceDiscovery/serviceDiscovery.d.ts

@@ -0,0 +1,59 @@
+import { IServiceDiscoveryClient, ServiceDiscoveryOptions, ILoadBalancer, DefaultInstanceMetadata } from '../../interface';
+import { LoadBalancerType } from '../../interface';
+export declare abstract class ServiceDiscoveryClient<Client, ServiceDiscoveryConfigOptions extends ServiceDiscoveryOptions<QueryServiceInstance>, RegisterServiceInstance, QueryServiceInstance = RegisterServiceInstance> implements IServiceDiscoveryClient<QueryServiceInstance> {
+    protected options: ServiceDiscoveryConfigOptions;
+    protected instance?: RegisterServiceInstance;
+    protected client: Client;
+    protected constructor(client: Client, serviceDiscoveryOptions: ServiceDiscoveryConfigOptions);
+    private _defaultMeta;
+    get defaultMeta(): DefaultInstanceMetadata;
+    private getDefaultInstanceMeta;
+    getSelfInstance(): RegisterServiceInstance;
+    abstract beforeStop(): Promise<void>;
+    /**
+     * 停止服务发现
+     */
+    stop(): Promise<void>;
+    /**
+     * 注册服务实例
+     */
+    abstract register(instance: RegisterServiceInstance): Promise<void>;
+    /**
+     * 注销服务实例
+     */
+    abstract deregister(): Promise<void>;
+    /**
+     * 上线服务实例
+     */
+    abstract online(): Promise<void>;
+    /**
+     * 下线服务实例
+     */
+    abstract offline(): Promise<void>;
+}
+/**
+ * 服务发现抽象类
+ */
+export declare abstract class ServiceDiscovery<Client, ServiceDiscoveryConfigOptions extends ServiceDiscoveryOptions<QueryServiceInstance>, RegisterServiceInstance, QueryServiceInstance = RegisterServiceInstance, GetInstanceOptions = RegisterServiceInstance> {
+    protected serviceDiscoveryClientStore: Set<ServiceDiscoveryClient<Client, ServiceDiscoveryConfigOptions, RegisterServiceInstance, QueryServiceInstance>>;
+    protected abstract getServiceClient(): Client;
+    protected loadBalancer: ILoadBalancer<QueryServiceInstance>;
+    createClient(options?: ServiceDiscoveryOptions<QueryServiceInstance>): ServiceDiscoveryClient<Client, ServiceDiscoveryConfigOptions, RegisterServiceInstance, QueryServiceInstance>;
+    protected abstract createServiceDiscoverClientImpl(options: ServiceDiscoveryOptions<QueryServiceInstance>): ServiceDiscoveryClient<Client, ServiceDiscoveryConfigOptions, RegisterServiceInstance, QueryServiceInstance>;
+    protected abstract getDefaultServiceDiscoveryOptions(): ServiceDiscoveryConfigOptions;
+    protected beforeStop(): Promise<void>;
+    /**
+     * 获取可用服务列表
+     */
+    abstract getInstances(options: GetInstanceOptions): Promise<QueryServiceInstance[]>;
+    /**
+     * 获取一个可用服务实例（带负载均衡）
+     */
+    getInstance(options: GetInstanceOptions): Promise<QueryServiceInstance>;
+    /**
+     * 设置负载均衡策略
+     */
+    setLoadBalancer(type: LoadBalancerType | ILoadBalancer<QueryServiceInstance>): void;
+    protected destroy(): Promise<void>;
+}
+//# sourceMappingURL=serviceDiscovery.d.ts.map

package/dist/common/serviceDiscovery/serviceDiscovery.js

@@ -0,0 +1,104 @@
+"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.ServiceDiscovery = exports.ServiceDiscoveryClient = void 0;
+const decorator_1 = require("../../decorator");
+const loadBalancer_1 = require("./loadBalancer");
+const interface_1 = require("../../interface");
+const network_1 = require("../../util/network");
+const extend_1 = require("../../util/extend");
+class ServiceDiscoveryClient {
+    constructor(client, serviceDiscoveryOptions) {
+        this.client = client;
+        this.options =
+            serviceDiscoveryOptions ?? {};
+    }
+    get defaultMeta() {
+        if (!this._defaultMeta) {
+            this._defaultMeta = this.getDefaultInstanceMeta();
+        }
+        return this._defaultMeta;
+    }
+    getDefaultInstanceMeta() {
+        return {
+            id: `${network_1.NetworkUtils.getHostname()}-${process.pid}`,
+            serviceName: `${network_1.NetworkUtils.getHostname()}`,
+            host: network_1.NetworkUtils.getIpv4Address(),
+            port: 0,
+            metadata: {},
+        };
+    }
+    getSelfInstance() {
+        return this.instance;
+    }
+    /**
+     * 停止服务发现
+     */
+    async stop() {
+        await this.beforeStop();
+        if (this.instance) {
+            return this.deregister();
+        }
+    }
+}
+exports.ServiceDiscoveryClient = ServiceDiscoveryClient;
+/**
+ * 服务发现抽象类
+ */
+class ServiceDiscovery {
+    constructor() {
+        this.serviceDiscoveryClientStore = new Set();
+    }
+    createClient(options) {
+        const serviceDiscoveryOption = (0, extend_1.extend)({}, options, this.getDefaultServiceDiscoveryOptions());
+        const client = this.createServiceDiscoverClientImpl(serviceDiscoveryOption);
+        this.serviceDiscoveryClientStore.add(client);
+        return client;
+    }
+    async beforeStop() { }
+    /**
+     * 获取一个可用服务实例（带负载均衡）
+     */
+    async getInstance(options) {
+        const instances = await this.getInstances(options);
+        if (!this.loadBalancer) {
+            this.setLoadBalancer(this.getDefaultServiceDiscoveryOptions()?.loadBalancer ??
+                interface_1.LoadBalancerType.ROUND_ROBIN);
+        }
+        return this.loadBalancer.select(instances);
+    }
+    /**
+     * 设置负载均衡策略
+     */
+    setLoadBalancer(type) {
+        if (typeof type === 'string') {
+            this.loadBalancer = loadBalancer_1.LoadBalancerFactory.create(type);
+        }
+        else {
+            this.loadBalancer = type;
+        }
+    }
+    async destroy() {
+        await this.beforeStop();
+        for (const client of this.serviceDiscoveryClientStore) {
+            await client.stop();
+        }
+        this.serviceDiscoveryClientStore.clear();
+    }
+}
+exports.ServiceDiscovery = ServiceDiscovery;
+__decorate([
+    (0, decorator_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ServiceDiscovery.prototype, "destroy", null);
+//# sourceMappingURL=serviceDiscovery.js.map

package/dist/common/serviceFactory.d.ts

@@ -8,10 +8,13 @@ export declare abstract class ServiceFactory<T> implements IServiceFactory<T> {
     protected clientPriority: Record<string, string>;
     protected options: {};
     protected priorityManager: MidwayPriorityManager;
-    protected initClients(options?: any): Promise<void>;
+    private creatingClients;
+    protected initClients(options?: any, initOptions?: {
+        concurrent?: boolean;
+    }): Promise<void>;
     get<U = T>(id?: string): U;
     has(id: string): boolean;
-    createInstance(config: any, clientName?: any): Promise<T | undefined>;
+    createInstance(config: any, clientName?: string): Promise<any>;
     abstract getName(): string;
     protected abstract createClient(config: any, clientName: any): Promise<T | void> | (T | void);
     protected destroyClient(client: T, clientName?: string): Promise<void>;

package/dist/common/serviceFactory.js

@@ -13,6 +13,7 @@ exports.ServiceFactory = void 0;
 const extend_1 = require("../util/extend");
 const priorityManager_1 = require("./priorityManager");
 const decorator_1 = require("../decorator");
+const types_1 = require("../util/types");
 /**
  * 多客户端工厂实现
  */
@@ -20,8 +21,10 @@ class ServiceFactory {
     constructor() {
         this.clients = new Map();
         this.options = {};
+        // for multi client with initialization
+        this.creatingClients = new Map();
     }
-    async initClients(options = {}) {
+    async initClients(options = {}, initOptions = {}) {
         this.options = options;
         // merge options.client to options.clients['default']
         if (options.client) {
@@ -29,10 +32,17 @@ class ServiceFactory {
             options.clients['default'] = options.clients['default'] || {};
             (0, extend_1.extend)(true, options.clients['default'], options.client);
         }
-        // multi client
         if (options.clients) {
-            for (const id of Object.keys(options.clients)) {
-                await this.createInstance(options.clients[id], id);
+            const entries = Object.entries(options.clients);
+            if (initOptions.concurrent) {
+                // multi client with concurrent initialization
+                await Promise.all(entries.map(([id, config]) => this.createInstance(config, id)));
+            }
+            else {
+                // multi client with serial initialization
+                for (const [id, config] of entries) {
+                    await this.createInstance(config, id);
+                }
             }
         }
         // set priority
@@ -45,21 +55,46 @@ class ServiceFactory {
         return this.clients.has(id);
     }
     async createInstance(config, clientName) {
+        if (clientName) {
+            if (this.has(clientName)) {
+                return this.get(clientName);
+            }
+            if (this.creatingClients.has(clientName)) {
+                return this.creatingClients.get(clientName);
+            }
+        }
         // options.default will be merge in to options.clients[id]
         config = (0, extend_1.extend)(true, {}, this.options['default'], config);
-        const client = await this.createClient(config, clientName);
-        if (client) {
+        const clientCreatingPromise = this.createClient(config, clientName);
+        if (clientCreatingPromise && types_1.Types.isPromise(clientCreatingPromise)) {
             if (clientName) {
-                this.clients.set(clientName, client);
+                this.creatingClients.set(clientName, clientCreatingPromise);
             }
-            return client;
+            return clientCreatingPromise
+                .then(client => {
+                if (clientName) {
+                    this.clients.set(clientName, client);
+                }
+                return client;
+            })
+                .finally(() => {
+                if (clientName) {
+                    this.creatingClients.delete(clientName);
+                }
+            });
+        }
+        // 处理同步返回的情况
+        if (clientName) {
+            this.clients.set(clientName, clientCreatingPromise);
         }
+        return clientCreatingPromise;
     }
     async destroyClient(client, clientName) { }
     async stop() {
         for (const [name, value] of this.clients.entries()) {
             await this.destroyClient(value, name);
         }
+        this.clients.clear();
     }
     getDefaultClientName() {
         return this.options['defaultClientName'];

package/dist/config/config.default.js

@@ -6,6 +6,9 @@ exports.default = (appInfo) => {
     return {
         core: {
             healthCheckTimeout: 1000,
+            configLoadTimeout: 10000,
+            readyTimeout: 30000,
+            serverReadyTimeout: 30000,
         },
         asyncContextManager: {
             enable: true,

package/dist/context/container.d.ts

@@ -21,9 +21,9 @@ export declare class MidwayContainer implements IMidwayGlobalContainer {
     get identifierMapping(): IIdentifierRelationShip;
     addNamespace(ns: string): void;
     bindClass(exports: any, options?: Partial<IObjectDefinition>): void;
-    bind<T>(target: T, options?: Partial<IObjectDefinition>): void;
-    bind<T>(identifier: ObjectIdentifier, target: T, options?: Partial<IObjectDefinition>): void;
-    protected bindModule(module: any, options: Partial<IObjectDefinition>): void;
+    bind<T>(target: T, options?: Partial<IObjectDefinition>): IObjectDefinition | undefined;
+    bind<T>(identifier: ObjectIdentifier, target: T, options?: Partial<IObjectDefinition>): IObjectDefinition | undefined;
+    protected bindModule(module: any, options: Partial<IObjectDefinition>): IObjectDefinition | undefined;
     setAttr(key: string, value: any): void;
     getAttr<T>(key: string): T;
     getIdentifier(identifier: ClassType | string): string;
@@ -37,6 +37,7 @@ export declare class MidwayContainer implements IMidwayGlobalContainer {
      * @param target
      */
     registerObject(identifier: ObjectIdentifier, target: any): void;
+    removeObject(identifier: ObjectIdentifier): void;
     onBeforeBind(fn: (Clzz: any, options: {
         context: IMidwayContainer;
         definition: IObjectDefinition;

package/dist/context/container.js

@@ -162,13 +162,14 @@ class MidwayContainer {
         if (definition) {
             this.registry.registerDefinition(definition.id, definition);
         }
+        return definition;
     }
     bindModule(module, options) {
         if (types_1.Types.isClass(module)) {
             const providerId = decorator_1.DecoratorManager.getProviderUUId(module);
             if (providerId) {
                 this.identifierMapping.saveClassRelation(module, options?.namespace);
-                this.bind(providerId, module, options);
+                return this.bind(providerId, module, options);
             }
             else {
                 // no provide or js class must be skip
@@ -182,7 +183,7 @@ class MidwayContainer {
                 }
                 const uuid = util_1.Utils.generateRandomId();
                 this.identifierMapping.saveFunctionRelation(info.id, uuid);
-                this.bind(uuid, module, {
+                return this.bind(uuid, module, {
                     scope: info.scope,
                     namespace: options.namespace,
                     srcPath: options.srcPath,
@@ -231,6 +232,9 @@ class MidwayContainer {
     registerObject(identifier, target) {
         this.registry.registerObject(identifier, target);
     }
+    removeObject(identifier) {
+        this.registry.removeObject(identifier);
+    }
     onBeforeBind(fn) {
         this.objectCreateEventTarget.on(interface_1.ObjectLifeCycleEvent.BEFORE_BIND, fn);
     }

package/dist/context/definitionRegistry.d.ts

@@ -5,6 +5,7 @@ import { IIdentifierRelationShip, IObjectDefinition, IObjectDefinitionRegistry,
 export declare class ObjectDefinitionRegistry extends Map implements IObjectDefinitionRegistry {
     private singletonIds;
     private _identifierRelation;
+    private objectCache;
     get identifierRelation(): IIdentifierRelationShip;
     set identifierRelation(identifierRelation: IIdentifierRelationShip);
     get identifiers(): any[];
@@ -18,6 +19,7 @@ export declare class ObjectDefinitionRegistry extends Map implements IObjectDefi
     clearAll(): void;
     hasObject(identifier: ObjectIdentifier): boolean;
     registerObject(identifier: ObjectIdentifier, target: any): void;
+    removeObject(identifier: ObjectIdentifier): void;
     getObject(identifier: ObjectIdentifier): any;
     getIdentifierRelation(): IIdentifierRelationShip;
     setIdentifierRelation(identifierRelation: IIdentifierRelationShip): void;