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

package/README.md

@@ -9,4 +9,4 @@ Document: [https://midwayjs.org](https://midwayjs.org)
 
 ## License
 
-[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))
+[MIT]((https://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/baseFramework.d.ts

@@ -14,10 +14,8 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     app: APP;
     configurationOptions: OPT;
     protected logger: ILogger;
-    protected appLogger: ILogger;
+    protected frameworkLoggerName: string;
     protected defaultContext: {};
-    protected contextLoggerApplyLogger: string;
-    protected contextLoggerFormat: any;
     protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected guardManager: GuardManager<CTX>;
@@ -32,7 +30,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
     mockService: MidwayMockService;
     constructor(applicationContext: IMidwayGlobalContainer);
-    init(): Promise<this>;
+    protected init(): Promise<this>;
     abstract configure(options?: OPT): OPT;
     abstract applicationInitialize(options: IMidwayBootstrapOptions): void | Promise<void>;
     abstract run(): Promise<void>;
@@ -64,5 +62,10 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected createGuardManager(): GuardManager<CTX>;
     setNamespace(namespace: string): void;
     getNamespace(): string;
+    /**
+     * Set the default framework logger name
+     * @since 4.0.0
+     */
+    setFrameworkLoggerName(loggerName: string): void;
 }
 //# sourceMappingURL=baseFramework.d.ts.map

package/dist/baseFramework.js

@@ -29,6 +29,7 @@ const debug = util.debuglog('midway:debug');
 class BaseFramework {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
+        this.frameworkLoggerName = 'appLogger';
         this.defaultContext = {};
         this.middlewareManager = this.createMiddlewareManager();
         this.filterManager = this.createFilterManager();
@@ -37,11 +38,7 @@ class BaseFramework {
     }
     async init() {
         this.configurationOptions = this.configure() ?? {};
-        this.contextLoggerApplyLogger =
-            this.configurationOptions.contextLoggerApplyLogger ?? 'appLogger';
-        this.contextLoggerFormat = this.configurationOptions.contextLoggerFormat;
         this.logger = this.loggerService.getLogger('coreLogger');
-        this.appLogger = this.loggerService.getLogger('appLogger');
         return this;
     }
     isEnable() {
@@ -74,7 +71,7 @@ class BaseFramework {
         return this.app;
     }
     createContextLogger(ctx, name) {
-        if (name && name !== 'appLogger') {
+        if (name && name !== this.frameworkLoggerName) {
             const appLogger = this.getLogger(name);
             let ctxLoggerCache = ctx.getAttr(constants_1.REQUEST_CTX_LOGGER_CACHE_KEY);
             if (!ctxLoggerCache) {
@@ -91,14 +88,12 @@ class BaseFramework {
             return ctxLogger;
         }
         else {
-            const appLogger = this.getLogger(name ?? this.contextLoggerApplyLogger);
             // avoid maximum call stack size exceeded
             if (ctx['_logger']) {
                 return ctx['_logger'];
             }
-            ctx['_logger'] = this.loggerService.createContextLogger(ctx, appLogger, {
-                contextFormat: this.contextLoggerFormat,
-            });
+            const appLogger = this.getLogger(name);
+            ctx['_logger'] = this.loggerService.createContextLogger(ctx, appLogger);
             return ctx['_logger'];
         }
     }
@@ -258,7 +253,7 @@ class BaseFramework {
         return this.composeMiddleware;
     }
     getLogger(name) {
-        return this.loggerService.getLogger(name) ?? this.appLogger;
+        return this.loggerService.getLogger(name ?? this.frameworkLoggerName);
     }
     getCoreLogger() {
         return this.logger;
@@ -302,6 +297,13 @@ class BaseFramework {
     getNamespace() {
         return this.namespace;
     }
+    /**
+     * Set the default framework logger name
+     * @since 4.0.0
+     */
+    setFrameworkLoggerName(loggerName) {
+        this.frameworkLoggerName = loggerName;
+    }
 }
 exports.BaseFramework = BaseFramework;
 __decorate([

package/dist/common/applicationManager.js

@@ -33,8 +33,12 @@ let MidwayApplicationManager = class MidwayApplicationManager {
     }
     getApplications(frameworkNameOrNamespace) {
         if (!frameworkNameOrNamespace) {
-            return Array.from(this.globalFrameworkMap.values()).map(framework => {
+            return Array.from(this.globalFrameworkMap.values())
+                .map(framework => {
                 return framework.getApplication();
+            })
+                .filter(app => {
+                return !!app;
             });
         }
         else {

package/dist/common/dataListener.d.ts

@@ -1,10 +1,12 @@
-export declare abstract class DataListener<T> {
-    private innerData;
+export declare abstract class DataListener<T, U = T> {
+    protected innerData: T;
+    private isReady;
     protected init(): Promise<void>;
     abstract initData(): T | Promise<T>;
     abstract onData(callback: (data: T) => void): any;
     protected setData(data: T): void;
-    getData(): T;
+    getData(): U;
+    protected transformData(data: T): U;
     stop(): Promise<void>;
     protected destroyListener(): Promise<void>;
 }

package/dist/common/dataListener.js

@@ -12,15 +12,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataListener = void 0;
 const decorator_1 = require("../decorator");
 class DataListener {
+    constructor() {
+        this.isReady = false;
+    }
     async init() {
-        this.innerData = await this.initData();
-        await this.onData(this.setData.bind(this));
+        if (!this.isReady) {
+            this.innerData = await this.initData();
+            await this.onData(this.setData.bind(this));
+            this.isReady = true;
+        }
     }
     setData(data) {
         this.innerData = data;
     }
     getData() {
-        return this.innerData;
+        return this.transformData(this.innerData);
+    }
+    transformData(data) {
+        return data;
     }
     async stop() {
         await this.destroyListener();

package/dist/common/dataSourceManager.d.ts

@@ -1,18 +1,20 @@
-import { ModuleLoadType, DataSourceManagerConfigOption } from '../interface';
+import { ModuleLoadType, DataSourceManagerConfigOption, IDataSourceManager, BaseDataSourceManagerConfigOption } from '../interface';
 import { MidwayEnvironmentService } from '../service/environmentService';
 import { MidwayPriorityManager } from './priorityManager';
-export declare abstract class DataSourceManager<T, ConnectionOpts extends Record<string, any> = Record<string, any>> {
+export declare abstract class DataSourceManager<T, ConnectionOpts extends BaseDataSourceManagerConfigOption<Record<string, any>, ENTITY_CONFIG_KEY> = BaseDataSourceManagerConfigOption<Record<string, any>, 'entities'>, ENTITY_CONFIG_KEY extends string = 'entities'> implements IDataSourceManager<T, ConnectionOpts> {
     protected dataSource: Map<string, T>;
-    protected options: DataSourceManagerConfigOption<ConnectionOpts>;
+    protected options: DataSourceManagerConfigOption<ConnectionOpts, ENTITY_CONFIG_KEY>;
     protected modelMapping: WeakMap<object, any>;
     private innerDefaultDataSourceName;
     protected dataSourcePriority: Record<string, string>;
-    protected appDir: string;
+    private creatingDataSources;
+    protected baseDir: string;
     protected environmentService: MidwayEnvironmentService;
     protected priorityManager: MidwayPriorityManager;
-    protected initDataSource(dataSourceConfig: DataSourceManagerConfigOption<ConnectionOpts>, baseDirOrOptions: {
-        baseDir: string;
+    protected initDataSource(dataSourceConfig: DataSourceManagerConfigOption<ConnectionOpts, ENTITY_CONFIG_KEY>, baseDirOrOptions: {
+        baseDir?: string;
         entitiesConfigKey?: string;
+        concurrent?: boolean;
     } | string): Promise<void>;
     /**
      * get a data source instance
@@ -31,8 +33,15 @@ export declare abstract class DataSourceManager<T, ConnectionOpts extends Record
      * @param dataSourceName
      */
     isConnected(dataSourceName: string): Promise<boolean>;
-    createInstance(config: any, clientName: any, options?: {
+    createInstance(config: ConnectionOpts): Promise<T | void>;
+    createInstance(config: ConnectionOpts, clientName: string, options?: {
+        /**
+         * @deprecated
+         */
         validateConnection?: boolean;
+        /**
+         * @deprecated
+         */
         cacheInstance?: boolean | undefined;
     }): Promise<T | void>;
     /**
@@ -53,7 +62,7 @@ export declare abstract class DataSourceManager<T, ConnectionOpts extends Record
     isHighPriority(name: string): boolean;
     isMediumPriority(name: string): boolean;
     isLowPriority(name: string): boolean;
+    static formatGlobString(globString: string): string[];
+    static globModels(globString: string, baseDir: string, loadMode?: ModuleLoadType): Promise<any[]>;
 }
-export declare function formatGlobString(globString: string): string[];
-export declare function globModels(globString: string, appDir: string, loadMode?: ModuleLoadType): Promise<any[]>;
 //# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/common/dataSourceManager.js

@@ -9,7 +9,7 @@ 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.globModels = exports.formatGlobString = exports.DataSourceManager = void 0;
+exports.DataSourceManager = void 0;
 /**
  * 数据源管理器实现
  */
@@ -31,6 +31,8 @@ class DataSourceManager {
         this.options = {};
         this.modelMapping = new WeakMap();
         this.dataSourcePriority = {};
+        // for multi client with initialization
+        this.creatingDataSources = new Map();
     }
     async initDataSource(dataSourceConfig, baseDirOrOptions) {
         this.options = dataSourceConfig;
@@ -41,18 +43,18 @@ class DataSourceManager {
             baseDirOrOptions = {
                 baseDir: baseDirOrOptions,
                 entitiesConfigKey: 'entities',
+                concurrent: false,
             };
         }
-        for (const dataSourceName in dataSourceConfig.dataSource) {
-            const dataSourceOptions = dataSourceConfig.dataSource[dataSourceName];
-            const userEntities = dataSourceOptions[baseDirOrOptions.entitiesConfigKey];
+        const { baseDir = this.baseDir, entitiesConfigKey = 'entities', concurrent, } = baseDirOrOptions;
+        const processDataSource = async (dataSourceName, dataSourceOptions) => {
+            const userEntities = dataSourceOptions[entitiesConfigKey];
             if (userEntities) {
                 const entities = new Set();
-                // loop entities and glob files to model
-                for (const entity of userEntities) {
+                const processEntity = async (entity) => {
                     if (typeof entity === 'string') {
                         // string will be glob file
-                        const models = await globModels(entity, baseDirOrOptions.baseDir, this.environmentService?.getModuleLoadType());
+                        const models = await DataSourceManager.globModels(entity, baseDir, this.environmentService?.getModuleLoadType());
                         for (const model of models) {
                             entities.add(model);
                             this.modelMapping.set(model, dataSourceName);
@@ -63,17 +65,33 @@ class DataSourceManager {
                         entities.add(entity);
                         this.modelMapping.set(entity, dataSourceName);
                     }
+                };
+                if (concurrent) {
+                    await Promise.all(userEntities.map(processEntity));
                 }
-                dataSourceOptions[baseDirOrOptions.entitiesConfigKey] =
-                    Array.from(entities);
-                debug(`[core]: DataManager load ${dataSourceOptions[baseDirOrOptions.entitiesConfigKey].length} models from ${dataSourceName}.`);
+                else {
+                    for (const entity of userEntities) {
+                        await processEntity(entity);
+                    }
+                }
+                dataSourceOptions[entitiesConfigKey] = Array.from(entities);
+                debug(`[core]: DataManager load ${dataSourceOptions[entitiesConfigKey].length} models from ${dataSourceName}.`);
             }
             // create data source
             const opts = {
-                cacheInstance: dataSourceConfig.cacheInstance, // will default true
+                cacheInstance: dataSourceConfig.cacheInstance,
                 validateConnection: dataSourceConfig.validateConnection,
             };
-            await this.createInstance(dataSourceOptions, dataSourceName, opts);
+            return this.createInstance(dataSourceOptions, dataSourceName, opts);
+        };
+        const entries = Object.entries(dataSourceConfig.dataSource);
+        if (concurrent) {
+            await Promise.all(entries.map(([name, options]) => processDataSource(name, options)));
+        }
+        else {
+            for (const [name, options] of entries) {
+                await processDataSource(name, options);
+            }
         }
     }
     /**
@@ -105,26 +123,59 @@ class DataSourceManager {
         return inst ? this.checkConnected(inst) : false;
     }
     async createInstance(config, clientName, options) {
-        const cache = options && typeof options.cacheInstance === 'boolean'
-            ? options.cacheInstance
-            : true;
-        const validateConnection = (options && options.validateConnection) || false;
-        // options.clients[id] will be merged with options.default
-        const configNow = (0, extend_1.extend)(true, {}, this.options['default'], config);
-        const client = await this.createDataSource(configNow, clientName);
-        if (cache && clientName && client) {
-            this.dataSource.set(clientName, client);
+        if (clientName && typeof clientName !== 'string') {
+            options = clientName;
+            clientName = undefined;
+        }
+        if (clientName && options && options.cacheInstance === false) {
+            // 后面就用传不传 clientName 来判断是否缓存
+            clientName = undefined;
         }
-        if (validateConnection) {
-            if (!client) {
-                throw new error_1.MidwayCommonError(`[DataSourceManager] ${clientName} initialization failed.`);
+        if (clientName) {
+            if (this.dataSource.has(clientName)) {
+                return this.dataSource.get(clientName);
+            }
+            if (this.creatingDataSources.has(clientName)) {
+                return this.creatingDataSources.get(clientName);
             }
-            const connected = await this.checkConnected(client);
-            if (!connected) {
-                throw new error_1.MidwayCommonError(`[DataSourceManager] ${clientName} is not connected.`);
+        }
+        const validateConnection = config.validateConnection ??
+            (options && options.validateConnection) ??
+            false;
+        // options.clients[id] will be merged with options.default
+        const configNow = (0, extend_1.extend)(true, {}, this.options['default'], config);
+        const clientCreatingPromise = this.createDataSource(configNow, clientName);
+        if (clientCreatingPromise && types_1.Types.isPromise(clientCreatingPromise)) {
+            if (clientName) {
+                this.creatingDataSources.set(clientName, clientCreatingPromise);
             }
+            return clientCreatingPromise
+                .then(async (client) => {
+                if (clientName) {
+                    this.dataSource.set(clientName, client);
+                }
+                if (validateConnection) {
+                    if (!client) {
+                        throw new error_1.MidwayCommonError(`[DataSourceManager] ${clientName} initialization failed.`);
+                    }
+                    const connected = await this.checkConnected(client);
+                    if (!connected) {
+                        throw new error_1.MidwayCommonError(`[DataSourceManager] ${clientName} is not connected.`);
+                    }
+                }
+                return client;
+            })
+                .finally(() => {
+                if (clientName) {
+                    this.creatingDataSources.delete(clientName);
+                }
+            });
         }
-        return client;
+        // 处理同步返回的情况
+        if (clientName) {
+            this.dataSource.set(clientName, clientCreatingPromise);
+        }
+        return clientCreatingPromise;
     }
     /**
      * get data source name by model or repository
@@ -171,12 +222,53 @@ class DataSourceManager {
     isLowPriority(name) {
         return this.priorityManager.isLowPriority(this.dataSourcePriority[name]);
     }
+    static formatGlobString(globString) {
+        let pattern;
+        if (!/^\*/.test(globString)) {
+            globString = '/' + globString;
+        }
+        const parsePattern = (0, path_1.parse)(globString);
+        if (parsePattern.base &&
+            (/\*/.test(parsePattern.base) || parsePattern.ext)) {
+            pattern = [globString];
+        }
+        else {
+            pattern = [...constants_1.DEFAULT_PATTERN.map(p => (0, path_1.join)(globString, p))];
+        }
+        return pattern;
+    }
+    static async globModels(globString, baseDir, loadMode) {
+        const pattern = this.formatGlobString(globString);
+        const models = [];
+        // string will be glob file
+        const files = (0, glob_1.run)(pattern, {
+            cwd: baseDir,
+            ignore: constants_1.IGNORE_PATTERN,
+        });
+        for (const file of files) {
+            const exports = await (0, util_2.loadModule)(file, {
+                loadMode,
+            });
+            if (types_1.Types.isClass(exports)) {
+                models.push(exports);
+            }
+            else {
+                for (const m in exports) {
+                    const module = exports[m];
+                    if (types_1.Types.isClass(module)) {
+                        models.push(module);
+                    }
+                }
+            }
+        }
+        return models;
+    }
 }
 exports.DataSourceManager = DataSourceManager;
 __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", String)
-], DataSourceManager.prototype, "appDir", void 0);
+], DataSourceManager.prototype, "baseDir", void 0);
 __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", environmentService_1.MidwayEnvironmentService)
@@ -185,46 +277,4 @@ __decorate([
     (0, decorator_1.Inject)(),
     __metadata("design:type", priorityManager_1.MidwayPriorityManager)
 ], DataSourceManager.prototype, "priorityManager", void 0);
-function formatGlobString(globString) {
-    let pattern;
-    if (!/^\*/.test(globString)) {
-        globString = '/' + globString;
-    }
-    const parsePattern = (0, path_1.parse)(globString);
-    if (parsePattern.base && (/\*/.test(parsePattern.base) || parsePattern.ext)) {
-        pattern = [globString];
-    }
-    else {
-        pattern = [...constants_1.DEFAULT_PATTERN.map(p => (0, path_1.join)(globString, p))];
-    }
-    return pattern;
-}
-exports.formatGlobString = formatGlobString;
-async function globModels(globString, appDir, loadMode) {
-    const pattern = formatGlobString(globString);
-    const models = [];
-    // string will be glob file
-    const files = (0, glob_1.run)(pattern, {
-        cwd: appDir,
-        ignore: constants_1.IGNORE_PATTERN,
-    });
-    for (const file of files) {
-        const exports = await (0, util_2.loadModule)(file, {
-            loadMode,
-        });
-        if (types_1.Types.isClass(exports)) {
-            models.push(exports);
-        }
-        else {
-            for (const m in exports) {
-                const module = exports[m];
-                if (types_1.Types.isClass(module)) {
-                    models.push(module);
-                }
-            }
-        }
-    }
-    return models;
-}
-exports.globModels = globModels;
 //# sourceMappingURL=dataSourceManager.js.map

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

@@ -0,0 +1,66 @@
+import { HTTPServiceDiscoveryHealthCheckOptions, IServiceDiscoveryHealthCheck, ServiceDiscoveryHealthCheckOptions, ServiceDiscoveryHealthCheckResult, ServiceDiscoveryHealthCheckType, TCPServiceDiscoveryHealthCheckOptions, TTLServiceDiscoveryHealthCheckOptions } from '../../interface';
+/**
+ * 抽象健康检查类
+ */
+export declare abstract class AbstractHealthCheck<ServiceInstance> implements IServiceDiscoveryHealthCheck<ServiceInstance> {
+    protected options: ServiceDiscoveryHealthCheckOptions;
+    protected lastCheckTime: number;
+    protected lastCheckResult: ServiceDiscoveryHealthCheckResult | null;
+    constructor(options: ServiceDiscoveryHealthCheckOptions);
+    /**
+     * 执行健康检查
+     * @param instance 服务实例
+     */
+    abstract check(instance: ServiceInstance): Promise<ServiceDiscoveryHealthCheckResult>;
+    /**
+     * 是否需要检查
+     * 根据检查间隔判断是否需要执行新的检查
+     */
+    shouldCheck(): boolean;
+    /**
+     * 获取最后一次检查结果
+     */
+    getLastCheckResult(): ServiceDiscoveryHealthCheckResult | null;
+    /**
+     * 更新检查结果
+     */
+    protected updateCheckResult(result: ServiceDiscoveryHealthCheckResult): void;
+}
+/**
+ * TTL 健康检查实现
+ * 用于 Redis/ETCD 等基于 TTL 的服务发现
+ */
+export declare class TTLHealthCheck<ServiceInstance> extends AbstractHealthCheck<ServiceInstance> {
+    private ttl;
+    constructor(options?: TTLServiceDiscoveryHealthCheckOptions);
+    check(instance: ServiceInstance): Promise<ServiceDiscoveryHealthCheckResult>;
+}
+/**
+ * HTTP 健康检查实现
+ * 用于支持 HTTP 检查的服务发现
+ */
+export declare class HTTPHealthCheck<ServiceInstance> extends AbstractHealthCheck<ServiceInstance> {
+    private checkUrl;
+    private httpClient;
+    private httpOptions;
+    constructor(options: HTTPServiceDiscoveryHealthCheckOptions);
+    check(instance: ServiceInstance): Promise<ServiceDiscoveryHealthCheckResult>;
+}
+/**
+ * TCP 健康检查实现
+ * 用于支持 TCP 检查的服务发现
+ */
+export declare class TCPHealthCheck<ServiceInstance> extends AbstractHealthCheck<ServiceInstance> {
+    private host;
+    private port;
+    private tcpOptions;
+    constructor(options: TCPServiceDiscoveryHealthCheckOptions);
+    check(instance: ServiceInstance): Promise<ServiceDiscoveryHealthCheckResult>;
+}
+/**
+ * 健康检查工厂
+ */
+export declare class ServiceDiscoveryHealthCheckFactory {
+    static create<ServiceInstance>(type: ServiceDiscoveryHealthCheckType, options: ServiceDiscoveryHealthCheckOptions | IServiceDiscoveryHealthCheck<ServiceInstance>): IServiceDiscoveryHealthCheck<ServiceInstance>;
+}
+//# sourceMappingURL=healthCheck.d.ts.map