@midwayjs/core 3.20.4 → 4.0.0-beta.1

package/dist/baseFramework.d.ts

@@ -1,4 +1,4 @@
-import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond, CommonGuardUnion, ILogger, MidwayLoggerOptions } from './interface';
+import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond, CommonGuardUnion, ILogger, MidwayLoggerOptions, IMidwayGlobalContainer } from './interface';
 import { MidwayEnvironmentService } from './service/environmentService';
 import { MidwayConfigService } from './service/configService';
 import { MidwayInformationService } from './service/informationService';
@@ -10,14 +10,12 @@ import { MidwayMockService } from './service/mockService';
 import { AsyncContextManager } from './common/asyncContextManager';
 import { GuardManager } from './common/guardManager';
 export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, OPT extends IConfigurationOptions, ResOrNext = unknown, Next = unknown> implements IMidwayFramework<APP, CTX, OPT, ResOrNext, Next> {
-    readonly applicationContext: IMidwayContainer;
+    readonly applicationContext: IMidwayGlobalContainer;
     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>;
@@ -31,51 +29,23 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     informationService: MidwayInformationService;
     middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
     mockService: MidwayMockService;
-    constructor(applicationContext: IMidwayContainer);
-    init(): Promise<this>;
-    abstract configure(options?: OPT): any;
+    constructor(applicationContext: IMidwayGlobalContainer);
+    protected init(): Promise<this>;
+    abstract configure(options?: OPT): OPT;
+    abstract applicationInitialize(options: IMidwayBootstrapOptions): void | Promise<void>;
+    abstract run(): Promise<void>;
     isEnable(): boolean;
     initialize(options?: IMidwayBootstrapOptions): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected containerInitialize(options: IMidwayBootstrapOptions): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected containerDirectoryLoad(options: IMidwayBootstrapOptions): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected containerReady(options: IMidwayBootstrapOptions): Promise<void>;
-    getApplicationContext(): IMidwayContainer;
+    getApplicationContext(): IMidwayGlobalContainer;
     getConfiguration(key?: string): any;
     getCurrentEnvironment(): string;
     getApplication(): APP;
-    abstract applicationInitialize(options: IMidwayBootstrapOptions): any;
-    abstract run(): Promise<void>;
     protected createContextLogger(ctx: CTX, name?: string): ILogger;
     stop(): Promise<void>;
     getAppDir(): string;
     getBaseDir(): string;
     protected defineApplicationProperties(applicationProperties?: {}, whiteList?: string[]): void;
     protected beforeStop(): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected beforeContainerInitialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected afterContainerInitialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected afterContainerDirectoryLoad(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    /**
-     * @deprecated
-     */
-    protected afterContainerReady(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
     applyMiddleware<R, N>(lastMiddleware?: CommonMiddlewareUnion<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
     getLogger(name?: string): any;
     getCoreLogger(): ILogger;
@@ -92,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();
@@ -36,13 +37,8 @@ class BaseFramework {
         this.composeMiddleware = null;
     }
     async init() {
-        var _a, _b;
-        this.configurationOptions = (_a = this.configure()) !== null && _a !== void 0 ? _a : {};
-        this.contextLoggerApplyLogger =
-            (_b = this.configurationOptions.contextLoggerApplyLogger) !== null && _b !== void 0 ? _b : 'appLogger';
-        this.contextLoggerFormat = this.configurationOptions.contextLoggerFormat;
+        this.configurationOptions = this.configure() ?? {};
         this.logger = this.loggerService.getLogger('coreLogger');
-        this.appLogger = this.loggerService.getLogger('appLogger');
         return this;
     }
     isEnable() {
@@ -50,34 +46,17 @@ class BaseFramework {
     }
     async initialize(options) {
         this.bootstrapOptions = options;
-        await this.beforeContainerInitialize(options);
-        await this.containerInitialize(options);
-        await this.afterContainerInitialize(options);
-        await this.containerDirectoryLoad(options);
-        await this.afterContainerDirectoryLoad(options);
         /**
          * Third party application initialization
          */
         await this.applicationInitialize(options);
-        await this.containerReady(options);
-        await this.afterContainerReady(options);
-        await this.mockService.runSimulatorAppSetup(this.app);
-    }
-    /**
-     * @deprecated
-     */
-    async containerInitialize(options) { }
-    /**
-     * @deprecated
-     */
-    async containerDirectoryLoad(options) { }
-    /**
-     * @deprecated
-     */
-    async containerReady(options) {
+        /**
+         * define application properties if not exists
+         */
         if (!this.app.getApplicationContext) {
             this.defineApplicationProperties();
         }
+        await this.mockService.runSimulatorAppSetup(this.app);
     }
     getApplicationContext() {
         return this.applicationContext;
@@ -92,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) {
@@ -109,14 +88,12 @@ class BaseFramework {
             return ctxLogger;
         }
         else {
-            const appLogger = this.getLogger(name !== null && name !== void 0 ? 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'];
         }
     }
@@ -147,11 +124,6 @@ class BaseFramework {
             getConfig: (key) => {
                 return this.getConfiguration(key);
             },
-            getFrameworkType: () => {
-                if (this['getFrameworkType']) {
-                    return this['getFrameworkType']();
-                }
-            },
             getProcessType: () => {
                 return interface_1.MidwayProcessTypeEnum.APPLICATION;
             },
@@ -180,7 +152,6 @@ class BaseFramework {
                 }
                 if (!ctx.requestContext) {
                     ctx.requestContext = new requestContainer_1.MidwayRequestContainer(ctx, this.getApplicationContext());
-                    ctx.requestContext.ready();
                 }
                 if (!ctx.getLogger) {
                     ctx.getLogger = name => {
@@ -229,30 +200,13 @@ class BaseFramework {
         Object.assign(this.app, defaultApplicationProperties, applicationProperties);
     }
     async beforeStop() { }
-    /**
-     * @deprecated
-     */
-    async beforeContainerInitialize(options) { }
-    /**
-     * @deprecated
-     */
-    async afterContainerInitialize(options) { }
-    /**
-     * @deprecated
-     */
-    async afterContainerDirectoryLoad(options) { }
-    /**
-     * @deprecated
-     */
-    async afterContainerReady(options) { }
     async applyMiddleware(lastMiddleware) {
-        var _a;
         if (!this.composeMiddleware) {
             if (!this.applicationContext.hasObject(constants_1.ASYNC_CONTEXT_MANAGER_KEY)) {
                 const asyncContextManagerEnabled = this.configService.getConfiguration('asyncContextManager.enable') ||
                     false;
                 const contextManager = asyncContextManagerEnabled
-                    ? ((_a = this.bootstrapOptions) === null || _a === void 0 ? void 0 : _a.asyncContextManager) ||
+                    ? this.bootstrapOptions?.asyncContextManager ||
                         new asyncContextManager_1.NoopContextManager()
                     : new asyncContextManager_1.NoopContextManager();
                 if (asyncContextManagerEnabled) {
@@ -299,8 +253,7 @@ class BaseFramework {
         return this.composeMiddleware;
     }
     getLogger(name) {
-        var _a;
-        return (_a = this.loggerService.getLogger(name)) !== null && _a !== void 0 ? _a : this.appLogger;
+        return this.loggerService.getLogger(name ?? this.frameworkLoggerName);
     }
     getCoreLogger() {
         return this.logger;
@@ -344,7 +297,15 @@ 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([
     (0, decorator_1.Inject)(),
     __metadata("design:type", loggerService_1.MidwayLoggerService)
@@ -375,5 +336,4 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], BaseFramework.prototype, "init", null);
-exports.BaseFramework = BaseFramework;
 //# sourceMappingURL=baseFramework.js.map

package/dist/common/applicationManager.d.ts

@@ -1,10 +1,10 @@
-import { IMidwayApplication, IMidwayFramework, FrameworkType } from '../interface';
+import { IMidwayApplication, IMidwayFramework } from '../interface';
 export declare class MidwayApplicationManager {
     private globalFrameworkMap;
-    private globalFrameworkTypeMap;
-    addFramework(namespace: any, framework: IMidwayFramework<any, any, any>): void;
-    getFramework(namespaceOrFrameworkType: string | FrameworkType): IMidwayFramework<any, any, any, unknown, unknown>;
-    getApplication(namespaceOrFrameworkType: string | FrameworkType): IMidwayApplication;
-    getApplications(namespaces?: Array<string | FrameworkType>): IMidwayApplication[];
+    addFramework(frameworkNameOrNamespace: string, framework: IMidwayFramework<any, any, any>): void;
+    hasFramework(frameworkNameOrNamespace: string): boolean;
+    getFramework(frameworkNameOrNamespace: string): IMidwayFramework<any, any, any, unknown, unknown>;
+    getApplication(frameworkNameOrNamespace: string): IMidwayApplication;
+    getApplications(frameworkNameOrNamespace?: Array<string>): IMidwayApplication[];
 }
 //# sourceMappingURL=applicationManager.d.ts.map

package/dist/common/applicationManager.js

@@ -12,44 +12,27 @@ const decorator_1 = require("../decorator");
 let MidwayApplicationManager = class MidwayApplicationManager {
     constructor() {
         this.globalFrameworkMap = new Map();
-        this.globalFrameworkTypeMap = new WeakMap();
     }
-    addFramework(namespace, framework) {
-        this.globalFrameworkMap.set(namespace, framework);
-        if (framework['getFrameworkType']) {
-            this.globalFrameworkTypeMap.set(framework['getFrameworkType'](), framework);
-        }
+    addFramework(frameworkNameOrNamespace, framework) {
+        this.globalFrameworkMap.set(frameworkNameOrNamespace, framework);
     }
-    getFramework(namespaceOrFrameworkType) {
-        if (typeof namespaceOrFrameworkType === 'string') {
-            if (this.globalFrameworkMap.has(namespaceOrFrameworkType)) {
-                return this.globalFrameworkMap.get(namespaceOrFrameworkType);
-            }
-        }
-        else {
-            if (this.globalFrameworkTypeMap.has(namespaceOrFrameworkType)) {
-                return this.globalFrameworkTypeMap.get(namespaceOrFrameworkType);
-            }
-        }
+    hasFramework(frameworkNameOrNamespace) {
+        return this.globalFrameworkMap.has(frameworkNameOrNamespace);
     }
-    getApplication(namespaceOrFrameworkType) {
-        if (typeof namespaceOrFrameworkType === 'string') {
-            if (this.globalFrameworkMap.has(namespaceOrFrameworkType)) {
-                return this.globalFrameworkMap
-                    .get(namespaceOrFrameworkType)
-                    .getApplication();
-            }
+    getFramework(frameworkNameOrNamespace) {
+        if (this.globalFrameworkMap.has(frameworkNameOrNamespace)) {
+            return this.globalFrameworkMap.get(frameworkNameOrNamespace);
         }
-        else {
-            if (this.globalFrameworkTypeMap.has(namespaceOrFrameworkType)) {
-                return this.globalFrameworkTypeMap
-                    .get(namespaceOrFrameworkType)
-                    .getApplication();
-            }
+    }
+    getApplication(frameworkNameOrNamespace) {
+        if (this.globalFrameworkMap.has(frameworkNameOrNamespace)) {
+            return this.globalFrameworkMap
+                .get(frameworkNameOrNamespace)
+                .getApplication();
         }
     }
-    getApplications(namespaces) {
-        if (!namespaces) {
+    getApplications(frameworkNameOrNamespace) {
+        if (!frameworkNameOrNamespace) {
             return Array.from(this.globalFrameworkMap.values())
                 .map(framework => {
                 return framework.getApplication();
@@ -59,7 +42,7 @@ let MidwayApplicationManager = class MidwayApplicationManager {
             });
         }
         else {
-            return namespaces
+            return frameworkNameOrNamespace
                 .map(namespace => {
                 return this.getApplication(namespace);
             })
@@ -69,9 +52,9 @@ let MidwayApplicationManager = class MidwayApplicationManager {
         }
     }
 };
-MidwayApplicationManager = __decorate([
+exports.MidwayApplicationManager = MidwayApplicationManager;
+exports.MidwayApplicationManager = MidwayApplicationManager = __decorate([
     (0, decorator_1.Provide)(),
     (0, decorator_1.Scope)(interface_1.ScopeEnum.Singleton)
 ], MidwayApplicationManager);
-exports.MidwayApplicationManager = MidwayApplicationManager;
 //# sourceMappingURL=applicationManager.js.map

package/dist/common/asyncContextManager.d.ts

@@ -58,4 +58,19 @@ export declare class NoopContextManager implements AsyncContextManager {
     enable(): this;
     disable(): this;
 }
+export declare class AsyncLocalStorageContextManager implements AsyncContextManager {
+    private _asyncLocalStorage;
+    constructor();
+    active(): AsyncContext;
+    with<A extends unknown[], F extends (...args: A) => ReturnType<F>>(context: AsyncContext, fn: F, thisArg?: ThisParameterType<F>, ...args: A): ReturnType<F>;
+    enable(): this;
+    disable(): this;
+    /**
+     * Binds a the certain context or the active one to the target function and then returns the target
+     * @param context A context (span) to be bind to target
+     * @param target a function. When target or one of its callbacks is called,
+     *  the provided context will be used as the active context for the duration of the call.
+     */
+    bind<T>(context: AsyncContext, target: T): T;
+}
 //# sourceMappingURL=asyncContextManager.d.ts.map

package/dist/common/asyncContextManager.js

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLocalStorageContextManager = exports.NoopContextManager = exports.ASYNC_ROOT_CONTEXT = void 0;
 /*
  * Copyright The OpenTelemetry Authors
  *
@@ -14,8 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoopContextManager = exports.ASYNC_ROOT_CONTEXT = void 0;
+const async_hooks_1 = require("async_hooks");
 class AsyncBaseContext {
     /**
      * Construct a new context which inherits values from an optional parent context.
@@ -60,4 +61,52 @@ class NoopContextManager {
     }
 }
 exports.NoopContextManager = NoopContextManager;
+class AsyncLocalStorageContextManager {
+    constructor() {
+        this._asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
+    }
+    active() {
+        return this._asyncLocalStorage.getStore() ?? exports.ASYNC_ROOT_CONTEXT;
+    }
+    with(context, fn, thisArg, ...args) {
+        const cb = thisArg == null ? fn : fn.bind(thisArg);
+        return this._asyncLocalStorage.run(context, cb, ...args);
+    }
+    enable() {
+        return this;
+    }
+    disable() {
+        this._asyncLocalStorage.disable();
+        return this;
+    }
+    /**
+     * Binds a the certain context or the active one to the target function and then returns the target
+     * @param context A context (span) to be bind to target
+     * @param target a function. When target or one of its callbacks is called,
+     *  the provided context will be used as the active context for the duration of the call.
+     */
+    bind(context, target) {
+        if (typeof target === 'function') {
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const manager = this;
+            const contextWrapper = function (...args) {
+                return manager.with(context, () => target.apply(this, args));
+            };
+            Object.defineProperty(contextWrapper, 'length', {
+                enumerable: false,
+                configurable: true,
+                writable: false,
+                value: target.length,
+            });
+            /**
+             * It isn't possible to tell Typescript that contextWrapper is the same as T
+             * so we forced to cast as any here.
+             */
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return contextWrapper;
+        }
+        return target;
+    }
+}
+exports.AsyncLocalStorageContextManager = AsyncLocalStorageContextManager;
 //# sourceMappingURL=asyncContextManager.js.map

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,21 +12,31 @@ 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();
     }
     async destroyListener() { }
 }
+exports.DataListener = DataListener;
 __decorate([
     (0, decorator_1.Init)(),
     __metadata("design:type", Function),
@@ -39,5 +49,4 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], DataListener.prototype, "stop", null);
-exports.DataListener = DataListener;
 //# sourceMappingURL=dataListener.js.map

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