@midwayjs/web 3.0.0-alpha.9 → 3.0.0-beta.4

package/dist/framework/web.d.ts

@@ -1,35 +1,36 @@
-import { IMidwayBootstrapOptions, MidwayFrameworkType } from '@midwayjs/core';
+import { BaseFramework, IMidwayBootstrapOptions, RouterInfo, WebControllerGenerator } from '@midwayjs/core';
+import { MidwayFrameworkType } from '@midwayjs/decorator';
 import { IMidwayWebConfigurationOptions } from '../interface';
-import { MidwayKoaBaseFramework } from '@midwayjs/koa';
-import { Application, Context, Router, EggLogger } from 'egg';
-export declare class MidwayWebFramework extends MidwayKoaBaseFramework<Application, Context, IMidwayWebConfigurationOptions> {
-    app: Application;
-    configurationOptions: IMidwayWebConfigurationOptions;
-    prioritySortRouters: Array<{
-        priority: number;
-        router: Router;
-    }>;
+import { EggRouter } from '@eggjs/router';
+import { Application, Context, EggLogger } from 'egg';
+declare class EggControllerGenerator extends WebControllerGenerator<EggRouter> {
+    readonly app: any;
+    readonly applicationContext: any;
+    readonly logger: any;
+    constructor(app: any, applicationContext: any, logger: any);
+    createRouter(routerOptions: any): EggRouter;
+    generateController(routeInfo: RouterInfo): (ctx: any, next: any) => Promise<void>;
+}
+export declare class MidwayWebFramework extends BaseFramework<Application, Context, IMidwayWebConfigurationOptions> {
     protected loggers: {
         [name: string]: EggLogger;
     };
-    configure(options: IMidwayWebConfigurationOptions): MidwayWebFramework;
-    initialize(options: IMidwayBootstrapOptions): Promise<void>;
-    protected beforeContainerInitialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    protected initializeLogger(): Promise<void>;
+    generator: EggControllerGenerator;
+    private server;
+    private agent;
+    private isClusterMode;
+    appDir: any;
+    configure(): any;
+    initSingleProcessEgg(): Promise<void>;
     applicationInitialize(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    protected afterContainerReady(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    getApplication(): Application;
+    overwriteApplication(processType: any): void;
+    loadMidwayController(): Promise<void>;
     getFrameworkType(): MidwayFrameworkType;
-    getLogger(name?: string): any;
-    /**
-     * 这个方法 egg-cluster 不走，只有单进程模式使用 @midwayjs/bootstrap 才会执行
-     */
     run(): Promise<void>;
-    /**
-     * 这个方法 egg-cluster 不走，只有单进程模式使用 @midwayjs/bootstrap 才会执行
-     */
-    protected beforeStop(): Promise<void>;
-    protected createRouter(routerOptions: any): Router;
-    protected setContextLoggerClass(BaseContextLogger: any): void;
+    getLogger(name?: string): any;
+    setContextLoggerClass(BaseContextLogger: any): void;
+    generateMiddleware(middlewareId: string): Promise<any>;
+    beforeStop(): Promise<void>;
 }
+export {};
 //# sourceMappingURL=web.d.ts.map

package/dist/framework/web.js

@@ -1,132 +1,191 @@
 "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.MidwayWebFramework = void 0;
 const core_1 = require("@midwayjs/core");
 const decorator_1 = require("@midwayjs/decorator");
-const koa_1 = require("@midwayjs/koa");
 const router_1 = require("@eggjs/router");
 const logger_1 = require("@midwayjs/logger");
-class MidwayWebFramework extends koa_1.MidwayKoaBaseFramework {
+const path_1 = require("path");
+const util_1 = require("util");
+const logger_2 = require("../logger");
+const debug = (0, util_1.debuglog)('midway:debug');
+class EggControllerGenerator extends core_1.WebControllerGenerator {
+    constructor(app, applicationContext, logger) {
+        super(applicationContext, decorator_1.MidwayFrameworkType.WEB, logger);
+        this.app = app;
+        this.applicationContext = applicationContext;
+        this.logger = logger;
+    }
+    createRouter(routerOptions) {
+        const router = new router_1.EggRouter(routerOptions, this.app);
+        router.prefix(routerOptions.prefix);
+        return router;
+    }
+    generateController(routeInfo) {
+        return this.generateKoaController(routeInfo);
+    }
+}
+let MidwayWebFramework = class MidwayWebFramework extends core_1.BaseFramework {
     constructor() {
         super(...arguments);
-        this.prioritySortRouters = [];
+        this.isClusterMode = false;
     }
-    configure(options) {
+    configure() {
+        process.env.EGG_TYPESCRIPT = 'true';
+        if (process.env['EGG_CLUSTER_MODE'] === 'true') {
+            this.isClusterMode = true;
+        }
+        return this.configService.getConfiguration('egg');
+    }
+    async initSingleProcessEgg() {
+        const opts = {
+            baseDir: this.appDir,
+            framework: (0, path_1.resolve)(__dirname, '../application'),
+            plugins: this.configurationOptions.plugins,
+            mode: 'single',
+            isTsMode: true,
+            applicationContext: this.applicationContext,
+            midwaySingleton: true,
+        };
+        debug('[egg]: init single process egg agent');
+        const Agent = require(opts.framework).Agent;
+        const Application = require(opts.framework).Application;
+        const agent = (this.agent = new Agent(Object.assign({}, opts)));
+        await agent.ready();
+        debug('[egg]: init single process egg application');
+        const application = (this.app = new Application(Object.assign({}, opts)));
+        application.agent = agent;
+        agent.application = application;
+        debug('[egg]: init single process egg end');
+    }
+    async applicationInitialize(options) {
+        if (!this.isClusterMode) {
+            await this.initSingleProcessEgg();
+        }
+        // insert error handler
+        this.app.use(async (ctx, next) => {
+            // this.app.createAnonymousContext(ctx);
+            const { result, error } = await (await this.getMiddleware())(ctx, next);
+            if (error) {
+                throw error;
+            }
+            if (result) {
+                ctx.body = result;
+            }
+        });
+        this.generator = new EggControllerGenerator(this.app, this.applicationContext, this.appLogger);
+        this.overwriteApplication('app');
+        await new Promise(resolve => {
+            this.app.once('application-ready', () => {
+                debug('[egg]: web framework: init egg end');
+                resolve();
+            });
+            this.app.loader.loadOrigin();
+            // hack use method
+            this.app.originUse = this.app.use;
+            this.app.use = this.app.useMiddleware;
+            this.app.ready();
+        });
+    }
+    overwriteApplication(processType) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
-        this.configurationOptions = options;
-        // set default context logger
-        this.BaseContextLoggerClass =
-            options.ContextLoggerClass || this.getDefaultContextLoggerClass();
-        this.app = options.app;
-        this.defineApplicationProperties({
-            generateController: (controllerMapping) => {
-                return this.generateController(controllerMapping);
+        // 单进程下，先把egg的配置覆盖进来，有可能业务测没写 importConfigs
+        debug(`[egg]: overwrite egg config to configService in "${processType}"`);
+        this.configService.addObject(this.app.config);
+        Object.defineProperty(this.app, 'config', {
+            get() {
+                return self.getConfiguration();
+            },
+        });
+        debug(`[egg]: overwrite applicationContext config to "${processType}"`);
+        Object.defineProperty(this.app, 'applicationContext', {
+            get() {
+                return self.applicationContext;
             },
+        });
+        debug(`[egg]: overwrite properties to "${processType}"`);
+        this.defineApplicationProperties({
             generateMiddleware: async (middlewareId) => {
                 return this.generateMiddleware(middlewareId);
             },
             getProcessType: () => {
-                if (this.configurationOptions.processType === 'application') {
+                if (processType === 'app') {
                     return core_1.MidwayProcessTypeEnum.APPLICATION;
                 }
-                if (this.configurationOptions.processType === 'agent') {
+                if (processType === 'agent') {
                     return core_1.MidwayProcessTypeEnum.AGENT;
                 }
-                // TODO 单进程模式下区分进程类型??
-                return core_1.MidwayProcessTypeEnum.APPLICATION;
             },
         }, ['createAnonymousContext']);
-        if (this.app.config.midwayFeature['replaceEggLogger']) {
-            // if use midway logger will be use midway custom context logger
-            this.app.beforeStart(() => {
-                this.app.ContextLogger = self.BaseContextLoggerClass;
-            });
-        }
-        Object.defineProperty(this.app, 'applicationContext', {
-            get() {
-                return self.getApplicationContext();
-            },
-        });
-        return this;
-    }
-    async initialize(options) {
-        this.isMainFramework = options.isMainFramework;
-        /**
-         * before create MidwayContainer instance，can change init parameters
-         */
-        await this.beforeContainerInitialize(options);
-        /**
-         * initialize MidwayContainer instance
-         */
-        await this.containerInitialize(options);
-        /**
-         * before container load directory and bind
-         */
-        await this.afterContainerInitialize(options);
-        /**
-         * run container loadDirectoryLoad method to create object definition
-         */
-        await this.containerDirectoryLoad(options);
-        /**
-         * after container load directory and bind
-         */
-        await this.afterContainerDirectoryLoad(options);
-        /**
-         * Third party application initialization
-         */
-        await this.applicationInitialize(options);
-        /**
-         * EggJS 比较特殊，生命周期触发需要等到插件加载完才能加载
-         */
-        await this.applicationContext.ready();
-        /**
-         * after container refresh
-         */
-        await this.afterContainerReady(options);
-    }
-    async beforeContainerInitialize(options) {
-        options.ignore = options.ignore || [];
-        options.ignore.push('**/app/extend/**');
-    }
-    async initializeLogger() {
-        // 不需要在这里创建框架日志，从 egg 代理过来
-        this.logger = this.app.coreLogger;
-        this.appLogger = this.app.logger;
+        // if use midway logger will be use midway custom context logger
+        debug(`[egg]: overwrite BaseContextLoggerClass to "${processType}"`);
+        this.setContextLoggerClass(this.configService.getConfiguration('egg.ContextLoggerClass') ||
+            logger_2.MidwayEggContextLogger);
     }
-    async applicationInitialize(options) {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        process.env.EGG_TYPESCRIPT = 'true';
-        if (this.configurationOptions.globalConfig) {
-            this.getApplicationContext()
-                .getConfigService()
-                .addObject(this.configurationOptions.globalConfig);
-            Object.defineProperty(this.app, 'config', {
-                get() {
-                    return self.getConfiguration();
-                },
-            });
-        }
-        // register plugin
-        this.getApplicationContext().registerDataHandler(decorator_1.PLUGIN_KEY, (key, target) => {
-            return this.app[key];
-        });
-        // register config
-        this.getApplicationContext().registerDataHandler(decorator_1.CONFIG_KEY, key => {
-            return key ? core_1.safelyGet(key, this.app.config) : this.app.config;
-        });
-        // register logger
-        this.getApplicationContext().registerDataHandler(decorator_1.LOGGER_KEY, key => {
-            return this.getLogger(key);
+    async loadMidwayController() {
+        await this.generator.loadMidwayController(this.configurationOptions.globalPrefix, newRouter => {
+            this.app.use(newRouter.middleware());
         });
     }
-    async afterContainerReady(options) { }
-    getApplication() {
-        return this.app;
-    }
     getFrameworkType() {
-        return core_1.MidwayFrameworkType.WEB;
+        return decorator_1.MidwayFrameworkType.WEB;
+    }
+    async run() {
+        // load controller
+        await this.loadMidwayController();
+        // restore use method
+        this.app.use = this.app.originUse;
+        if (!this.isClusterMode) {
+            // https config
+            if (this.configurationOptions.key && this.configurationOptions.cert) {
+                this.configurationOptions.key = core_1.PathFileUtil.getFileContentSync(this.configurationOptions.key);
+                this.configurationOptions.cert = core_1.PathFileUtil.getFileContentSync(this.configurationOptions.cert);
+                this.configurationOptions.ca = core_1.PathFileUtil.getFileContentSync(this.configurationOptions.ca);
+                if (this.configurationOptions.http2) {
+                    this.server = require('http2').createSecureServer(this.configurationOptions, this.app.callback());
+                }
+                else {
+                    this.server = require('https').createServer(this.configurationOptions, this.app.callback());
+                }
+            }
+            else {
+                if (this.configurationOptions.http2) {
+                    this.server = require('http2').createServer(this.app.callback());
+                }
+                else {
+                    this.server = require('http').createServer(this.app.callback());
+                }
+            }
+            // emit egg-ready message in agent and application
+            this.app.messenger.broadcast('egg-ready', undefined);
+            // emit `server` event in app
+            this.app.emit('server', this.server);
+            // register httpServer to applicationContext
+            this.getApplicationContext().registerObject(core_1.HTTP_SERVER_KEY, this.server);
+            const eggConfig = this.configService.getConfiguration('egg');
+            if (this.configService.getConfiguration('egg')) {
+                new Promise(resolve => {
+                    const args = [eggConfig.port];
+                    if (eggConfig.hostname) {
+                        args.push(eggConfig.hostname);
+                    }
+                    args.push(() => {
+                        resolve();
+                    });
+                    this.server.listen(...args);
+                });
+            }
+        }
     }
     getLogger(name) {
         if (name) {
@@ -134,27 +193,30 @@ class MidwayWebFramework extends koa_1.MidwayKoaBaseFramework {
         }
         return this.appLogger;
     }
-    /**
-     * 这个方法 egg-cluster 不走，只有单进程模式使用 @midwayjs/bootstrap 才会执行
-     */
-    async run() { }
-    /**
-     * 这个方法 egg-cluster 不走，只有单进程模式使用 @midwayjs/bootstrap 才会执行
-     */
-    async beforeStop() { }
-    createRouter(routerOptions) {
-        const router = new router_1.EggRouter(routerOptions, this.app);
-        router.prefix(routerOptions.prefix);
-        this.prioritySortRouters.push({
-            priority: 0,
-            router,
-        });
-        return router;
-    }
     setContextLoggerClass(BaseContextLogger) {
         this.BaseContextLoggerClass = BaseContextLogger;
         this.app.ContextLogger = BaseContextLogger;
     }
-}
+    async generateMiddleware(middlewareId) {
+        const mwIns = await this.getApplicationContext().getAsync(middlewareId);
+        return mwIns.resolve();
+    }
+    async beforeStop() {
+        if (!this.isClusterMode) {
+            await new Promise(resolve => {
+                this.server.close(resolve);
+            });
+            await this.app.close();
+            await this.agent.close();
+        }
+    }
+};
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", Object)
+], MidwayWebFramework.prototype, "appDir", void 0);
+MidwayWebFramework = __decorate([
+    (0, decorator_1.Framework)()
+], MidwayWebFramework);
 exports.MidwayWebFramework = MidwayWebFramework;
 //# sourceMappingURL=web.js.map

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export * from './interface';
-export { MidwayWebSingleProcessFramework as Framework } from './framework/singleProcess';
-export { MidwayWebFramework } from './framework/web';
+export { MidwayWebFramework as Framework } from './framework/web';
 export { createEggApplication, createEggAgent, createAppWorkerLoader, createAgentWorkerLoader, } from './base';
 export { Application, Agent } from './application';
 export { startCluster } from 'egg';
+export { EggConfiguration as Configuration } from './configuration';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -10,12 +10,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startCluster = exports.Agent = exports.Application = exports.createAgentWorkerLoader = exports.createAppWorkerLoader = exports.createEggAgent = exports.createEggApplication = exports.MidwayWebFramework = exports.Framework = void 0;
+exports.Configuration = exports.startCluster = exports.Agent = exports.Application = exports.createAgentWorkerLoader = exports.createAppWorkerLoader = exports.createEggAgent = exports.createEggApplication = exports.Framework = void 0;
 __exportStar(require("./interface"), exports);
-var singleProcess_1 = require("./framework/singleProcess");
-Object.defineProperty(exports, "Framework", { enumerable: true, get: function () { return singleProcess_1.MidwayWebSingleProcessFramework; } });
 var web_1 = require("./framework/web");
-Object.defineProperty(exports, "MidwayWebFramework", { enumerable: true, get: function () { return web_1.MidwayWebFramework; } });
+Object.defineProperty(exports, "Framework", { enumerable: true, get: function () { return web_1.MidwayWebFramework; } });
 var base_1 = require("./base");
 Object.defineProperty(exports, "createEggApplication", { enumerable: true, get: function () { return base_1.createEggApplication; } });
 Object.defineProperty(exports, "createEggAgent", { enumerable: true, get: function () { return base_1.createEggAgent; } });
@@ -26,4 +24,6 @@ Object.defineProperty(exports, "Application", { enumerable: true, get: function
 Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return application_1.Agent; } });
 var egg_1 = require("egg");
 Object.defineProperty(exports, "startCluster", { enumerable: true, get: function () { return egg_1.startCluster; } });
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.EggConfiguration; } });
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -1,28 +1,27 @@
-import { Context as EggContext, Application as EggApplication, EggLogger } from 'egg';
-import { IMidwayContainer, IMidwayContext, Context as IMidwayBaseContext, IMidwayApplication, IMidwayBaseApplication } from '@midwayjs/core';
-import { IMidwayKoaConfigurationOptions, IMidwayKoaContext, IMidwayKoaNext } from '@midwayjs/koa';
+/// <reference types="node" />
+import { Context as EggContext, Application as EggApplication, EggAppConfig } from 'egg';
+import { IMidwayContainer, IMidwayContext, Context as IMidwayBaseContext, IMidwayApplication, IMidwayBaseApplication, IConfigurationOptions, NextFunction as BaseNextFunction } from '@midwayjs/core';
 import { DefaultState, Middleware } from 'koa';
 import { ILogger, LoggerOptions } from '@midwayjs/logger';
 export interface IMidwayWebBaseApplication {
     applicationContext: IMidwayContainer;
-    getLogger(name?: string): EggLogger & ILogger;
-    getCoreLogger(): EggLogger & ILogger;
-    generateController?(controllerMapping: string): any;
-    generateMiddleware?(middlewareId: string): Promise<Middleware<DefaultState, IMidwayKoaContext>>;
-    createLogger(name: string, options: LoggerOptions): EggLogger & ILogger;
+    getLogger(name?: string): ILogger;
+    getCoreLogger(): ILogger;
+    generateMiddleware?(middlewareId: string): Promise<Middleware<DefaultState, EggContext>>;
+    createLogger(name: string, options: LoggerOptions): ILogger;
 }
 declare module 'egg' {
     interface EggAppInfo {
         appDir: string;
     }
-    interface Application extends IMidwayBaseApplication, IMidwayWebBaseApplication {
+    interface Application extends IMidwayBaseApplication<Context>, IMidwayWebBaseApplication {
         createAnonymousContext(...args: any[]): EggContext;
         getCoreLogger(): EggLogger & ILogger;
         getLogger(name?: string): EggLogger & ILogger;
         createLogger(name: string, options: LoggerOptions): EggLogger & ILogger;
     }
     interface Context<ResponseBodyT = any> extends IMidwayBaseContext {
-        getLogger(name?: string): EggLogger & ILogger;
+        getLogger(name?: string): ILogger;
     }
     interface EggAppConfig {
         midwayFeature: {
@@ -36,8 +35,9 @@ export interface Application extends IMidwayWebApplication {
 export interface Context<ResponseBodyT = unknown> extends IMidwayWebContext<ResponseBodyT> {
 }
 export declare type IMidwayWebContext<ResponseBodyT = unknown> = IMidwayContext<EggContext<ResponseBodyT>>;
-export declare type IMidwayWebNext = IMidwayKoaNext;
-export interface IMidwayWebConfigurationOptions extends IMidwayKoaConfigurationOptions {
+export declare type IMidwayWebNext = BaseNextFunction;
+export declare type NextFunction = BaseNextFunction;
+export interface IMidwayWebConfigurationOptions extends IConfigurationOptions {
     app?: IMidwayWebApplication;
     plugins?: {
         [plugin: string]: {
@@ -49,9 +49,50 @@ export interface IMidwayWebConfigurationOptions extends IMidwayKoaConfigurationO
     typescript?: boolean;
     processType?: 'application' | 'agent';
     globalConfig?: any;
+    /**
+     * application http port
+     */
+    port?: number;
+    /**
+     * application hostname, 127.0.0.1 as default
+     */
+    hostname?: string;
+    /**
+     * https key
+     */
+    key?: string | Buffer | Array<Buffer | Object>;
+    /**
+     * https cert
+     */
+    cert?: string | Buffer | Array<string | Buffer>;
+    /**
+     * https ca
+     */
+    ca?: string | Buffer | Array<string | Buffer>;
+    /**
+     * http2 support
+     */
+    http2?: boolean;
+    /**
+     * http global prefix
+     */
+    globalPrefix?: string;
 }
+/**
+ * @deprecated since version 3.0.0
+ * Please use IMiddleware from @midwayjs/core
+ */
 export declare type MidwayWebMiddleware = Middleware<DefaultState, Context>;
+/**
+ * @deprecated since version 3.0.0
+ * Please use IMiddleware from @midwayjs/core
+ */
 export interface IWebMiddleware {
     resolve(): MidwayWebMiddleware;
 }
+declare module '@midwayjs/core/dist/interface' {
+    interface MidwayConfig extends EggAppConfig {
+        egg?: IMidwayWebConfigurationOptions;
+    }
+}
 //# sourceMappingURL=interface.d.ts.map

package/dist/logger.d.ts

@@ -1,3 +1,36 @@
-import { Application } from 'egg';
-export declare const createLoggers: (app: Application) => any;
+import { ILogger, MidwayContextLogger } from '@midwayjs/logger';
+import { Application, Context } from 'egg';
+declare class MidwayLoggers extends Map<string, ILogger> {
+    app: Application;
+    /**
+     * @constructor
+     * - logger
+     *   - {String} env - egg app runtime env string, detail please see `app.config.env`
+     *   - {String} type - current process type, `application` or `agent`
+     *   - {String} dir - log file dir
+     *   - {String} [encoding = utf8] - log string encoding
+     *   - {String} [level = INFO] - file log level
+     *   - {String} [consoleLevel = NONE] - console log level
+     *   - {Boolean} [outputJSON = false] - send JSON log or not
+     *   - {Boolean} [buffer = true] - use {@link FileBufferTransport} or not
+     *   - {String} appLogName - egg app file logger name
+     *   - {String} coreLogName - egg core file logger name
+     *   - {String} agentLogName - egg agent file logger name
+     *   - {String} errorLogName - err common error logger name
+     *   - {String} eol - end of line char
+     *   - {String} [concentrateError = duplicate] - whether write error logger to common-error.log, `duplicate` / `redirect` / `ignore`
+     * - customLogger
+     * @param options
+     * @param app
+     */
+    constructor(options: any, app: Application, processType: 'agent' | 'app');
+    createLogger(options: any, loggerKey: string): ILogger;
+    disableConsole(): void;
+    reload(): void;
+}
+export declare const createLoggers: (app: Application, processType: 'agent' | 'app') => MidwayLoggers;
+export declare class MidwayEggContextLogger extends MidwayContextLogger<Context> {
+    formatContextLabel(): string;
+}
+export {};
 //# sourceMappingURL=logger.d.ts.map