@midwayjs/core 3.0.0-alpha.43 → 3.0.0-beta.10

package/dist/service/environmentService.js

@@ -1,8 +1,15 @@
 "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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayEnvironmentService = void 0;
 const util_1 = require("../util");
-class MidwayEnvironmentService {
+const decorator_1 = require("@midwayjs/decorator");
+let MidwayEnvironmentService = class MidwayEnvironmentService {
     getCurrentEnvironment() {
         if (!this.environment) {
             this.environment = (0, util_1.getCurrentEnvironment)();
@@ -15,6 +22,10 @@ class MidwayEnvironmentService {
     isDevelopmentEnvironment() {
         return (0, util_1.isDevelopmentEnvironment)(this.environment);
     }
-}
+};
+MidwayEnvironmentService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], MidwayEnvironmentService);
 exports.MidwayEnvironmentService = MidwayEnvironmentService;
 //# sourceMappingURL=environmentService.js.map

package/dist/service/frameworkService.d.ts

@@ -0,0 +1,26 @@
+import { MidwayFrameworkType } from '@midwayjs/decorator';
+import { IMidwayContainer, IMidwayFramework } from '../interface';
+import { MidwayConfigService } from './configService';
+import { MidwayLoggerService } from './loggerService';
+import { MidwayDecoratorService } from './decoratorService';
+import { MidwayAspectService } from './aspectService';
+import { MidwayApplicationManager } from '../common/applicationManager';
+export declare class MidwayFrameworkService {
+    readonly applicationContext: IMidwayContainer;
+    readonly globalOptions: any;
+    configService: MidwayConfigService;
+    loggerService: MidwayLoggerService;
+    aspectService: MidwayAspectService;
+    decoratorService: MidwayDecoratorService;
+    applicationManager: MidwayApplicationManager;
+    constructor(applicationContext: IMidwayContainer, globalOptions: any);
+    private mainFramework;
+    private globalFrameworkList;
+    protected init(): Promise<void>;
+    getMainApp(): any;
+    getMainFramework(): IMidwayFramework<any, any, any, unknown, unknown>;
+    getFramework(namespaceOrFrameworkType: string | MidwayFrameworkType): IMidwayFramework<any, any, any, unknown, unknown>;
+    runFramework(): Promise<void>;
+    stopFramework(): Promise<void>;
+}
+//# sourceMappingURL=frameworkService.d.ts.map

package/dist/service/frameworkService.js

@@ -0,0 +1,176 @@
+"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.MidwayFrameworkService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const interface_1 = require("../interface");
+const configService_1 = require("./configService");
+const loggerService_1 = require("./loggerService");
+const baseFramework_1 = require("../baseFramework");
+const pipelineService_1 = require("./pipelineService");
+const decoratorService_1 = require("./decoratorService");
+const aspectService_1 = require("./aspectService");
+const applicationManager_1 = require("../common/applicationManager");
+const util = require("util");
+const error_1 = require("../error");
+const debug = util.debuglog('midway:debug');
+let MidwayFrameworkService = class MidwayFrameworkService {
+    constructor(applicationContext, globalOptions) {
+        this.applicationContext = applicationContext;
+        this.globalOptions = globalOptions;
+        this.globalFrameworkList = [];
+    }
+    async init() {
+        var _a;
+        // register base config hook
+        this.decoratorService.registerPropertyHandler(decorator_1.CONFIG_KEY, (propertyName, meta) => {
+            var _a;
+            if (meta.identifier === decorator_1.ALL) {
+                return this.configService.getConfiguration();
+            }
+            else {
+                return this.configService.getConfiguration((_a = meta.identifier) !== null && _a !== void 0 ? _a : propertyName);
+            }
+        });
+        // register @Logger decorator handler
+        this.decoratorService.registerPropertyHandler(decorator_1.LOGGER_KEY, (propertyName, meta) => {
+            var _a;
+            return this.loggerService.getLogger((_a = meta.identifier) !== null && _a !== void 0 ? _a : propertyName);
+        });
+        this.decoratorService.registerPropertyHandler(decorator_1.PIPELINE_IDENTIFIER, (key, meta, instance) => {
+            var _a, _b;
+            return new pipelineService_1.MidwayPipelineService((_b = (_a = instance[interface_1.REQUEST_OBJ_CTX_KEY]) === null || _a === void 0 ? void 0 : _a.requestContext) !== null && _b !== void 0 ? _b : this.applicationContext, meta.valves);
+        });
+        let frameworks = (0, decorator_1.listModule)(decorator_1.FRAMEWORK_KEY);
+        // filter proto
+        frameworks = filterProtoFramework(frameworks);
+        debug(`[core]: Found Framework length = ${frameworks.length}`);
+        if (frameworks.length) {
+            for (const frameworkClz of frameworks) {
+                const frameworkInstance = await this.applicationContext.getAsync(frameworkClz, [this.applicationContext]);
+                // if enable, just init framework
+                if (frameworkInstance.isEnable()) {
+                    // app init
+                    await frameworkInstance.initialize({
+                        applicationContext: this.applicationContext,
+                        ...this.globalOptions,
+                    });
+                    debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and initialize.`);
+                }
+                else {
+                    debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and delay initialize.`);
+                }
+                // app init
+                const definition = this.applicationContext.registry.getDefinition((0, decorator_1.getProviderUUId)(frameworkClz));
+                this.applicationManager.addFramework((_a = definition === null || definition === void 0 ? void 0 : definition.namespace) !== null && _a !== void 0 ? _a : frameworkInstance.getFrameworkName(), frameworkInstance);
+                this.globalFrameworkList.push(frameworkInstance);
+            }
+            // register @App decorator handler
+            this.decoratorService.registerPropertyHandler(decorator_1.APPLICATION_KEY, (propertyName, mete) => {
+                if (mete.type) {
+                    const framework = this.applicationManager.getApplication(mete.type);
+                    if (!framework) {
+                        throw new error_1.MidwayCommonError(`Framework ${mete.type} not Found`);
+                    }
+                    return framework;
+                }
+                else {
+                    return this.getMainApp();
+                }
+            });
+            this.decoratorService.registerPropertyHandler(decorator_1.PLUGIN_KEY, (key, target) => {
+                return this.getMainApp()[key];
+            });
+            global['MIDWAY_MAIN_FRAMEWORK'] = this.mainFramework =
+                this.globalFrameworkList[0];
+        }
+        // init aspect module
+        await this.aspectService.loadAspect();
+        // some preload module init
+        const modules = (0, decorator_1.listPreloadModule)();
+        for (const module of modules) {
+            // preload init context
+            await this.applicationContext.getAsync(module);
+        }
+    }
+    getMainApp() {
+        var _a;
+        return (_a = this.mainFramework) === null || _a === void 0 ? void 0 : _a.getApplication();
+    }
+    getMainFramework() {
+        return this.mainFramework;
+    }
+    getFramework(namespaceOrFrameworkType) {
+        return this.applicationManager.getFramework(namespaceOrFrameworkType);
+    }
+    async runFramework() {
+        for (const frameworkInstance of this.globalFrameworkList) {
+            // if enable, just init framework
+            if (frameworkInstance.isEnable()) {
+                // app init
+                await frameworkInstance.run();
+                debug(`[core]: Found Framework "${frameworkInstance.getFrameworkName()}" and run.`);
+            }
+        }
+    }
+    async stopFramework() {
+        await Promise.all(Array.from(this.globalFrameworkList).map(frameworkInstance => {
+            return frameworkInstance.stop();
+        }));
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", configService_1.MidwayConfigService)
+], MidwayFrameworkService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", loggerService_1.MidwayLoggerService)
+], MidwayFrameworkService.prototype, "loggerService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", aspectService_1.MidwayAspectService)
+], MidwayFrameworkService.prototype, "aspectService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", decoratorService_1.MidwayDecoratorService)
+], MidwayFrameworkService.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", applicationManager_1.MidwayApplicationManager)
+], MidwayFrameworkService.prototype, "applicationManager", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayFrameworkService.prototype, "init", null);
+MidwayFrameworkService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object, Object])
+], MidwayFrameworkService);
+exports.MidwayFrameworkService = MidwayFrameworkService;
+function filterProtoFramework(frameworks) {
+    const frameworkProtoArr = [];
+    // 这里把继承的框架父类都找出来，然后排除掉，只取第一层
+    for (const framework of frameworks) {
+        let proto = Object.getPrototypeOf(framework);
+        while (proto.name && proto.name !== baseFramework_1.BaseFramework.name) {
+            frameworkProtoArr.push(proto);
+            proto = Object.getPrototypeOf(proto);
+        }
+    }
+    return frameworks.filter(framework => {
+        return !frameworkProtoArr.includes(framework);
+    });
+}
+//# sourceMappingURL=frameworkService.js.map

package/dist/service/informationService.d.ts

@@ -1,12 +1,9 @@
 import { IInformationService } from '../interface';
 export declare class MidwayInformationService implements IInformationService {
-    protected pkg: Record<string, unknown>;
-    private readonly appDir;
-    private readonly baseDir;
-    constructor(options: {
-        baseDir?: string;
-        appDir?: string;
-    });
+    private pkg;
+    protected appDir: string;
+    protected baseDir: string;
+    protected init(): void;
     getAppDir(): string;
     getBaseDir(): string;
     getHome(): string;

package/dist/service/informationService.js

@@ -1,16 +1,29 @@
 "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.MidwayInformationService = void 0;
 const util_1 = require("../util");
 const path_1 = require("path");
-class MidwayInformationService {
-    constructor(options) {
-        this.baseDir = options.baseDir;
-        this.appDir = options.appDir;
-        if (!this.appDir) {
-            this.appDir = (0, path_1.dirname)(this.baseDir);
+const decorator_1 = require("@midwayjs/decorator");
+let MidwayInformationService = class MidwayInformationService {
+    init() {
+        if (this.baseDir) {
+            if (!this.appDir) {
+                this.appDir = (0, path_1.dirname)(this.baseDir);
+            }
+            this.pkg = (0, util_1.safeRequire)((0, path_1.join)(this.appDir, 'package.json')) || {};
+        }
+        else {
+            this.pkg = {};
         }
-        this.pkg = (0, util_1.safeRequire)((0, path_1.join)(this.appDir, 'package.json')) || {};
     }
     getAppDir() {
         return this.appDir;
@@ -32,6 +45,24 @@ class MidwayInformationService {
         const isDevelopmentEnv = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
         return isDevelopmentEnv ? this.getAppDir() : this.getHome();
     }
-}
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", String)
+], MidwayInformationService.prototype, "appDir", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", String)
+], MidwayInformationService.prototype, "baseDir", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], MidwayInformationService.prototype, "init", null);
+MidwayInformationService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], MidwayInformationService);
 exports.MidwayInformationService = MidwayInformationService;
 //# sourceMappingURL=informationService.js.map

package/dist/service/lifeCycleService.d.ts

@@ -0,0 +1,14 @@
+import { IMidwayContainer } from '../interface';
+import { MidwayFrameworkService } from './frameworkService';
+import { MidwayConfigService } from './configService';
+export declare class MidwayLifeCycleService {
+    readonly applicationContext: IMidwayContainer;
+    protected frameworkService: MidwayFrameworkService;
+    protected configService: MidwayConfigService;
+    constructor(applicationContext: IMidwayContainer);
+    protected init(): Promise<void>;
+    stop(): Promise<void>;
+    private runContainerLifeCycle;
+    private runObjectLifeCycle;
+}
+//# sourceMappingURL=lifeCycleService.d.ts.map

package/dist/service/lifeCycleService.js

@@ -0,0 +1,130 @@
+"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.MidwayLifeCycleService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const configuration_1 = require("../functional/configuration");
+const frameworkService_1 = require("./frameworkService");
+const configService_1 = require("./configService");
+const util_1 = require("util");
+const debug = (0, util_1.debuglog)('midway:debug');
+let MidwayLifeCycleService = class MidwayLifeCycleService {
+    constructor(applicationContext) {
+        this.applicationContext = applicationContext;
+    }
+    async init() {
+        // run lifecycle
+        const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
+        debug(`[core]: Found Configuration length = ${cycles.length}`);
+        const lifecycleInstanceList = [];
+        for (const cycle of cycles) {
+            if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
+                // 函数式写法
+                cycle.instance = cycle.target;
+            }
+            else {
+                // 普通类写法
+                debug(`[core]: run ${cycle.target.name} init`);
+                cycle.instance = await this.applicationContext.getAsync(cycle.target);
+            }
+            cycle.instance && lifecycleInstanceList.push(cycle);
+        }
+        // bind object lifecycle
+        await Promise.all([
+            this.runObjectLifeCycle(lifecycleInstanceList, 'onBeforeObjectCreated'),
+            this.runObjectLifeCycle(lifecycleInstanceList, 'onObjectCreated'),
+            this.runObjectLifeCycle(lifecycleInstanceList, 'onObjectInit'),
+            this.runObjectLifeCycle(lifecycleInstanceList, 'onBeforeObjectDestroy'),
+        ]);
+        // bind framework lifecycle
+        // onAppError
+        // exec onConfigLoad()
+        await this.runContainerLifeCycle(lifecycleInstanceList, 'onConfigLoad', configData => {
+            if (configData) {
+                this.configService.addObject(configData);
+            }
+        });
+        // exec onReady()
+        await this.runContainerLifeCycle(lifecycleInstanceList, 'onReady');
+        // exec framework.run()
+        await this.frameworkService.runFramework();
+        // exec onServerReady()
+        await this.runContainerLifeCycle(lifecycleInstanceList, 'onServerReady');
+    }
+    async stop() {
+        // stop lifecycle
+        const cycles = (0, decorator_1.listModule)(decorator_1.CONFIGURATION_KEY);
+        for (const cycle of cycles) {
+            let inst;
+            if (cycle.target instanceof configuration_1.FunctionalConfiguration) {
+                // 函数式写法
+                inst = cycle.target;
+            }
+            else {
+                inst = await this.applicationContext.getAsync(cycle.target);
+            }
+            await this.runContainerLifeCycle(inst, 'onStop');
+        }
+        // stop framework
+        await this.frameworkService.stopFramework();
+    }
+    async runContainerLifeCycle(lifecycleInstanceOrList, lifecycle, resultHandler) {
+        if (Array.isArray(lifecycleInstanceOrList)) {
+            for (const cycle of lifecycleInstanceOrList) {
+                if (typeof cycle.instance[lifecycle] === 'function') {
+                    debug(`[core]: run ${cycle.instance.constructor.name} ${lifecycle}`);
+                    const result = await cycle.instance[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
+                    if (resultHandler) {
+                        resultHandler(result);
+                    }
+                }
+            }
+        }
+        else {
+            if (typeof lifecycleInstanceOrList[lifecycle] === 'function') {
+                debug(`[core]: run ${lifecycleInstanceOrList.constructor.name} ${lifecycle}`);
+                const result = await lifecycleInstanceOrList[lifecycle](this.applicationContext, this.frameworkService.getMainApp());
+                if (resultHandler) {
+                    resultHandler(result);
+                }
+            }
+        }
+    }
+    async runObjectLifeCycle(lifecycleInstanceList, lifecycle) {
+        for (const cycle of lifecycleInstanceList) {
+            if (typeof cycle.instance[lifecycle] === 'function') {
+                debug(`[core]: run ${cycle.instance.constructor.name} ${lifecycle}`);
+                return this.applicationContext[lifecycle](cycle.instance[lifecycle].bind(cycle.instance));
+            }
+        }
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", frameworkService_1.MidwayFrameworkService)
+], MidwayLifeCycleService.prototype, "frameworkService", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", configService_1.MidwayConfigService)
+], MidwayLifeCycleService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayLifeCycleService.prototype, "init", null);
+MidwayLifeCycleService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayLifeCycleService);
+exports.MidwayLifeCycleService = MidwayLifeCycleService;
+//# sourceMappingURL=lifeCycleService.js.map

package/dist/service/loggerService.d.ts

@@ -0,0 +1,27 @@
+import { MidwayConfigService } from './configService';
+import { ServiceFactory } from '../common/serviceFactory';
+import { ILogger } from '@midwayjs/logger';
+import { IMidwayContainer } from '../interface';
+export declare class MidwayLoggerService extends ServiceFactory<ILogger> {
+    readonly applicationContext: IMidwayContainer;
+    configService: MidwayConfigService;
+    constructor(applicationContext: IMidwayContainer);
+    protected init(): Promise<void>;
+    transformEggConfig(): {
+        midwayLogger: {
+            default: {};
+            clients: {};
+        };
+    };
+    protected createClient(config: any, name?: string): Promise<void>;
+    getName(): string;
+    createLogger(name: any, config: any): ILogger;
+    getLogger(name: string): ILogger;
+    transformEggLogger(options: any): {
+        midwayLogger: {
+            default: {};
+            clients: {};
+        };
+    };
+}
+//# sourceMappingURL=loggerService.d.ts.map

package/dist/service/loggerService.js

@@ -0,0 +1,132 @@
+"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.MidwayLoggerService = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const configService_1 = require("./configService");
+const serviceFactory_1 = require("../common/serviceFactory");
+const logger_1 = require("@midwayjs/logger");
+const levelTransform = level => {
+    if (!level) {
+        return undefined;
+    }
+    switch (level) {
+        case 'NONE':
+        case Infinity: // egg logger 的 none 是这个等级
+            return null;
+        case 0:
+        case 'DEBUG':
+        case 'debug':
+            return 'debug';
+        case 1:
+        case 'INFO':
+        case 'info':
+            return 'info';
+        case 2:
+        case 'WARN':
+        case 'warn':
+            return 'warn';
+        case 3:
+        case 'ERROR':
+        case 'error':
+            return 'error';
+        default:
+            return 'silly';
+    }
+};
+let MidwayLoggerService = class MidwayLoggerService extends serviceFactory_1.ServiceFactory {
+    constructor(applicationContext) {
+        super();
+        this.applicationContext = applicationContext;
+    }
+    async init() {
+        var _a;
+        const eggLoggerConfig = this.transformEggConfig();
+        if (eggLoggerConfig) {
+            this.configService.addObject(eggLoggerConfig);
+        }
+        await this.initClients(this.configService.getConfiguration('midwayLogger'));
+        // alias inject logger
+        (_a = this.applicationContext) === null || _a === void 0 ? void 0 : _a.registerObject('logger', this.getLogger('appLogger'));
+    }
+    transformEggConfig() {
+        if (this.configService.getConfiguration('customLogger')) {
+            // use egg module
+            return this.transformEggLogger(this.configService.getConfiguration());
+        }
+        else {
+            // it will be use other logger
+            return;
+        }
+    }
+    async createClient(config, name) {
+        logger_1.loggers.createLogger(name, config);
+    }
+    getName() {
+        return 'logger';
+    }
+    createLogger(name, config) {
+        return logger_1.loggers.createLogger(name, config);
+    }
+    getLogger(name) {
+        return logger_1.loggers.getLogger(name);
+    }
+    transformEggLogger(options) {
+        var _a, _b, _c;
+        const transformLoggerConfig = {
+            midwayLogger: {
+                default: {},
+                clients: {},
+            },
+        };
+        if (options.midwayLogger && !options.midwayLogger.default) {
+            transformLoggerConfig.midwayLogger.default = {
+                dir: options.logger.dir,
+                level: levelTransform(options.logger.level),
+                consoleLevel: levelTransform(options.logger.consoleLevel),
+            };
+        }
+        const eggCustomLogger = options['customLogger'];
+        for (const name in eggCustomLogger) {
+            transformLoggerConfig.midwayLogger.clients[name] = {
+                fileLogName: (_a = eggCustomLogger[name]) === null || _a === void 0 ? void 0 : _a.file,
+                level: levelTransform((_b = eggCustomLogger[name]) === null || _b === void 0 ? void 0 : _b.level),
+                consoleLevel: levelTransform((_c = eggCustomLogger[name]) === null || _c === void 0 ? void 0 : _c.consoleLevel),
+            };
+            cleanUndefinedProperty(transformLoggerConfig.midwayLogger.clients[name]);
+        }
+        return transformLoggerConfig;
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", configService_1.MidwayConfigService)
+], MidwayLoggerService.prototype, "configService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MidwayLoggerService.prototype, "init", null);
+MidwayLoggerService = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton),
+    __metadata("design:paramtypes", [Object])
+], MidwayLoggerService);
+exports.MidwayLoggerService = MidwayLoggerService;
+function cleanUndefinedProperty(obj) {
+    Object.keys(obj).forEach(key => {
+        if (obj[key] === undefined) {
+            delete obj[key];
+        }
+    });
+}
+//# sourceMappingURL=loggerService.js.map

package/dist/service/middlewareService.d.ts

@@ -0,0 +1,11 @@
+import { CommonMiddleware, IMidwayContainer, IMidwayApplication } from '../interface';
+export declare class MidwayMiddlewareService<T, R, N = unknown> {
+    readonly applicationContext: IMidwayContainer;
+    constructor(applicationContext: IMidwayContainer);
+    compose(middleware: Array<CommonMiddleware<T, R, N> | string>, app: IMidwayApplication, name?: string): Promise<{
+        (context: any, next?: any): Promise<any>;
+        _name: string;
+    }>;
+    getMiddlewareName(mw: any): any;
+}
+//# sourceMappingURL=middlewareService.d.ts.map