egg 4.1.0-beta.19 → 4.1.0-beta.20

package/dist/egg-DVo5e_lr.js

@@ -0,0 +1,800 @@
+import { BaseHookClass } from "./base_hook_class-D0Gu2p8r.js";
+import { BaseContextClass as BaseContextClass$1 } from "./base_context_class-Xc1OZql9.js";
+import { MessageUnhandledRejectionError } from "./MessageUnhandledRejectionError-oD_E1Ewl.js";
+import { ContextHttpClient } from "./context_httpclient-BpRMdJhf.js";
+import { HttpClient } from "./httpclient-C1QPc_R7.js";
+import { createLoggers } from "./logger-C4tIcO3S.js";
+import { convertObject } from "./utils-B1Rjsoi9.js";
+import { getSourceDirname } from "./utils-BDoYg6z6.js";
+import { EggCore, Router as Router$1, utils } from "@eggjs/core";
+import path from "node:path";
+import { performance } from "node:perf_hooks";
+import fs from "node:fs";
+import http from "node:http";
+import inspector from "node:inspector";
+import { AsyncLocalStorage } from "node:async_hooks";
+import createClusterClient, { close } from "cluster-client";
+import { extend } from "@eggjs/extend2";
+import { EggContextLogger, EggLogger, EggLoggers } from "egg-logger";
+import { Cookies } from "@eggjs/cookies";
+import CircularJSON from "circular-json-for-egg";
+import { debuglog } from "node:util";
+import { EventEmitter, captureRejectionSymbol } from "node:events";
+import workerThreads from "node:worker_threads";
+import { sendmessage } from "sendmessage";
+
+//#region src/lib/core/messenger/base.ts
+var BaseMessenger = class extends EventEmitter {
+	egg;
+	constructor(egg) {
+		super({ captureRejections: true });
+		this.egg = egg;
+	}
+	[captureRejectionSymbol](err, event, ...args) {
+		this.egg.coreLogger.error(new MessageUnhandledRejectionError(err, event, args));
+	}
+	emit(eventName, ...args) {
+		const hasListeners = this.listenerCount(eventName) > 0;
+		try {
+			return super.emit(eventName, ...args);
+		} catch (e) {
+			let err = e;
+			if (!(err instanceof Error)) err = new Error(String(err));
+			this.egg.coreLogger.error(new MessageUnhandledRejectionError(err, eventName, args));
+			return hasListeners;
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/core/messenger/local.ts
+const debug$1 = debuglog("egg/lib/core/messenger/local");
+/**
+* Communication between app worker and agent worker with EventEmitter
+*/
+var Messenger = class extends BaseMessenger {
+	pid;
+	constructor(egg) {
+		super(egg);
+		this.pid = String(process.pid);
+	}
+	/**
+	* Send message to all agent and app
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	broadcast(action, data) {
+		debug$1("[%s:%s] broadcast %s with %j", this.egg.type, this.pid, action, data);
+		this.send(action, data, "both");
+		return this;
+	}
+	/**
+	* send message to the specified process
+	* Notice: in single process mode, it only can send to self process,
+	* and it will send to both agent and app's messengers.
+	* @param {String} workerId - the workerId of the receiver
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	sendTo(workerId, action, data) {
+		debug$1("[%s:%s] send %s with %j to %s", this.egg.type, this.pid, action, data, workerId);
+		if (String(workerId) !== this.pid) return this;
+		this.send(action, data, "both");
+		return this;
+	}
+	/**
+	* send message to one worker by random
+	* Notice: in single process mode, we only start one agent worker and one app worker
+	* - if it's running in agent, it will send to one of app workers
+	* - if it's running in app, it will send to agent
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	sendRandom(action, data) {
+		debug$1("[%s:%s] send %s with %j to opposite", this.egg.type, this.pid, action, data);
+		this.send(action, data, "opposite");
+		return this;
+	}
+	/**
+	* send message to app
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	sendToApp(action, data) {
+		debug$1("[%s:%s] send %s with %j to all app", this.egg.type, this.pid, action, data);
+		this.send(action, data, "application");
+		return this;
+	}
+	/**
+	* send message to agent
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	sendToAgent(action, data) {
+		debug$1("[%s:%s] send %s with %j to all agent", this.egg.type, this.pid, action, data);
+		this.send(action, data, "agent");
+		return this;
+	}
+	/**
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @param {String} to - let master know how to send message
+	* @return {Messenger} this
+	*/
+	send(action, data, to) {
+		process.nextTick(() => {
+			const { egg } = this;
+			let application;
+			let agent;
+			let opposite;
+			if (egg.type === "application") {
+				application = egg;
+				agent = egg.agent;
+				opposite = agent;
+			} else {
+				agent = egg;
+				application = egg.application;
+				opposite = application;
+			}
+			if (!to) to = egg.type === "application" ? "agent" : "application";
+			if (application && application.messenger && (to === "application" || to === "both")) application.messenger.onMessage({
+				action,
+				data
+			});
+			if (agent && agent.messenger && (to === "agent" || to === "both")) agent.messenger.onMessage({
+				action,
+				data
+			});
+			if (opposite && opposite.messenger && to === "opposite") opposite.messenger.onMessage({
+				action,
+				data
+			});
+		});
+		return this;
+	}
+	onMessage(message) {
+		if (typeof message?.action === "string") {
+			debug$1("[%s:%s] got message %s with %j", this.egg.type, this.pid, message.action, message.data);
+			this.emit(message.action, message.data);
+		} else debug$1("[%s:%s] got an invalid message %j", this.egg.type, this.pid, message);
+	}
+	close() {
+		this.removeAllListeners();
+	}
+};
+
+//#endregion
+//#region src/lib/core/messenger/ipc.ts
+const debug = debuglog("egg/lib/core/messenger/ipc");
+/**
+* Communication between app worker and agent worker by IPC channel
+*/
+var Messenger$1 = class extends BaseMessenger {
+	pid;
+	opids = [];
+	constructor(egg) {
+		super(egg);
+		this.pid = String(process.pid);
+		this.on("egg-pids", (workerIds) => {
+			debug("[%s:%s] got egg-pids %j", this.egg.type, this.pid, workerIds);
+			this.opids = workerIds.map((workerId) => String(workerId));
+		});
+		this.onMessage = this.onMessage.bind(this);
+		if (this.egg.options.mode === "all-in-one-process") process.on("sendmessage-to-self", this.onMessage);
+		else process.on("message", this.onMessage);
+		if (!workerThreads.isMainThread) workerThreads.parentPort.on("message", this.onMessage);
+	}
+	/**
+	* Send message to all agent and app
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	broadcast(action, data) {
+		debug("[%s:%s] broadcast %s with %j", this.egg.type, this.pid, action, data);
+		this.send(action, data, "app");
+		this.send(action, data, "agent");
+		return this;
+	}
+	/**
+	* send message to the specified process
+	* @param {String} workerId - the workerId of the receiver
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	sendTo(workerId, action, data) {
+		debug("[%s:%s] send %s with %j to workerId:%s", this.egg.type, this.pid, action, data, workerId);
+		const message = {
+			action,
+			data,
+			receiverPid: String(workerId),
+			receiverWorkerId: String(workerId)
+		};
+		this.#sendMessage(message);
+		return this;
+	}
+	/**
+	* send message to one app worker by random
+	* - if it's running in agent, it will send to one of app workers
+	* - if it's running in app, it will send to agent
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	sendRandom(action, data) {
+		if (this.opids.length === 0) {
+			debug("[%s:%s] no pids, ignore sendRandom %s with %j", this.egg.type, this.pid, action, data);
+			return this;
+		}
+		const index = Math.floor(Math.random() * this.opids.length);
+		const workerId = this.opids[index];
+		this.sendTo(workerId, action, data);
+		return this;
+	}
+	/**
+	* send message to app
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	sendToApp(action, data) {
+		debug("[%s:%s] send %s with %j to all app", this.egg.type, this.pid, action, data);
+		this.send(action, data, "app");
+		return this;
+	}
+	/**
+	* send message to agent
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @return {Messenger} this
+	*/
+	sendToAgent(action, data) {
+		debug("[%s:%s] send %s with %j to all agent", this.egg.type, this.pid, action, data);
+		this.send(action, data, "agent");
+		return this;
+	}
+	/**
+	* @param {String} action - message key
+	* @param {Object} data - message value
+	* @param {String} to - let master know how to send message
+	* @return {Messenger} this
+	*/
+	send(action, data, to) {
+		debug("send message %s with %j to %s", action, data, to);
+		this.#sendMessage({
+			action,
+			data,
+			to
+		});
+		return this;
+	}
+	#sendMessage(message) {
+		debug("[%s:%s] send message %j, mode: %s", this.egg.type, this.pid, message, this.egg.options.mode);
+		if (this.egg.options.mode === "all-in-one-process") process.emit("sendmessage-to-self", message);
+		else sendmessage(process, message);
+	}
+	onMessage(message) {
+		if (typeof message?.action === "string") {
+			debug("[%s:%s] got message %s with %j, receiverWorkerId: %s", this.egg.type, this.pid, message.action, message.data, message.receiverWorkerId ?? message.receiverPid);
+			this.emit(message.action, message.data);
+		} else if (message?.type === "Buffer") debug("[%s:%s] got an invalid message: %s", this.egg.type, this.pid, Buffer.from(message.data));
+		else debug("[%s:%s] got an invalid message %j", this.egg.type, this.pid, message);
+	}
+	close() {
+		process.removeListener("message", this.onMessage);
+		this.removeAllListeners();
+	}
+};
+
+//#endregion
+//#region src/lib/core/messenger/index.ts
+/**
+* @class Messenger
+*/
+function create(egg) {
+	return egg.options.mode === "single" ? new Messenger(egg) : new Messenger$1(egg);
+}
+
+//#endregion
+//#region src/lib/egg.ts
+const EGG_PATH = Symbol.for("egg#eggPath");
+/**
+* Based on koa's Application
+* @see https://github.com/eggjs/egg-core
+* @see https://github.com/eggjs/koa/blob/master/src/application.ts
+* @augments EggCore
+*/
+var EggApplicationCore = class extends EggCore {
+	/**
+	* Get the current request context from AsyncLocalStorage.
+	* This provides access to the context object for the current request lifecycle.
+	* @returns {Context | undefined} The current request context, or undefined if not in a request scope.
+	*/
+	get currentContext() {
+		return this.ctxStorage.getStore();
+	}
+	ContextCookies = Cookies;
+	ContextLogger = EggContextLogger;
+	ContextHttpClient = ContextHttpClient;
+	HttpClient = HttpClient;
+	HttpClientNext = HttpClient;
+	/**
+	* Retrieve base context class
+	* @member {BaseContextClass} BaseContextClass
+	* @since 1.0.0
+	*/
+	BaseContextClass = BaseContextClass$1;
+	/**
+	* Retrieve base controller
+	* @member {Controller} Controller
+	* @since 1.0.0
+	*/
+	Controller = BaseContextClass$1;
+	/**
+	* Retrieve base service
+	* @member {Service} Service
+	* @since 1.0.0
+	*/
+	Service = BaseContextClass$1;
+	/**
+	* Retrieve base subscription
+	* @member {Subscription} Subscription
+	* @since 2.12.0
+	*/
+	Subscription = BaseContextClass$1;
+	/**
+	* Retrieve base context class
+	* @member {BaseHookClass} BaseHookClass
+	*/
+	BaseHookClass = BaseHookClass;
+	/**
+	* Retrieve base boot
+	* @member {Boot}
+	* @alias BaseHookClass
+	*/
+	Boot = BaseHookClass;
+	#httpClient;
+	#loggers;
+	#clusterClients = [];
+	messenger;
+	agent;
+	application;
+	/**
+	* @class
+	* @param {Object} options
+	*  - {Object} [type] - type of instance, Agent and Application both extend koa, type can determine what it is.
+	*  - {String} [baseDir] - app root dir, default is `process.cwd()`
+	*  - {Object} [plugins] - custom plugin config, use it in unittest
+	*  - {String} [mode] - process mode, can be cluster / single, default is `cluster`
+	*/
+	constructor(options) {
+		options = {
+			mode: "cluster",
+			type: "application",
+			baseDir: process.cwd(),
+			...options
+		};
+		super(options);
+		/**
+		* messenger instance
+		* @member {Messenger}
+		* @since 1.0.0
+		*/
+		this.messenger = create(this);
+		this.messenger.once("egg-ready", () => {
+			this.lifecycle.triggerServerDidReady();
+		});
+		this.lifecycle.registerBeforeStart(async () => {
+			await this.load();
+		}, "load files");
+	}
+	/**
+	* @deprecated please use `options` property instead
+	*/
+	get _options() {
+		return this.options;
+	}
+	async loadConfig() {
+		await this.loader.loadConfig();
+	}
+	async load() {
+		await this.loadConfig();
+		this.ready(() => process.nextTick(() => {
+			const dumpStartTime = Date.now();
+			this.dumpConfig();
+			this.dumpTiming();
+			this.coreLogger.info("[egg] dump config after ready, %sms", Date.now() - dumpStartTime);
+		}));
+		this.#setupTimeoutTimer();
+		this.console.info("[egg] App root: %s", this.baseDir);
+		this.console.info("[egg] All *.log files save on %j", this.config.logger.dir);
+		this.console.info("[egg] Loaded enabled plugin %j", this.loader.orderPlugins);
+		this._unhandledRejectionHandler = this._unhandledRejectionHandler.bind(this);
+		process.on("unhandledRejection", this._unhandledRejectionHandler);
+		this.lifecycle.registerBeforeClose(async () => {
+			for (const clusterClient of this.#clusterClients) await close(clusterClient);
+			this.#clusterClients = [];
+			if (this.type === "application" && this.options.mode === "single") await this.agent.close();
+			for (const logger of this.loggers.values()) logger.close();
+			this.messenger.close();
+			process.removeListener("unhandledRejection", this._unhandledRejectionHandler);
+		});
+		await this.loader.load();
+	}
+	/**
+	* Usage: new ApiClient({ cluster: app.cluster })
+	*/
+	get cluster() {
+		return this.clusterWrapper.bind(this);
+	}
+	/**
+	* Wrap the Client with Leader/Follower Pattern
+	*
+	* @description almost the same as Agent.cluster API, the only different is that this method create Follower.
+	*
+	* @see https://github.com/node-modules/cluster-client
+	* @param {Function} clientClass - client class function
+	* @param {Object} [options]
+	*   - {Boolean} [autoGenerate] - whether generate delegate rule automatically, default is true
+	*   - {Function} [formatKey] - a method to transform the subscription info into a string，default is JSON.stringify
+	*   - {Object} [transcode|JSON.stringify/parse]
+	*     - {Function} encode - custom serialize method
+	*     - {Function} decode - custom deserialize method
+	*   - {Boolean} [isBroadcast] - whether broadcast subscription result to all followers or just one, default is true
+	*   - {Number} [responseTimeout] - response timeout, default is 3 seconds
+	*   - {Number} [maxWaitTime|30000] - leader startup max time, default is 30 seconds
+	* @return {ClientWrapper} wrapper
+	*/
+	clusterWrapper(clientClass, options) {
+		const clientClassOptions = {
+			...this.config.clusterClient,
+			...options,
+			singleMode: this.options.mode === "single",
+			port: this.options.clusterPort,
+			isLeader: this.type === "agent",
+			logger: this.coreLogger,
+			isCheckHeartbeat: this.config.env === "prod" ? true : inspector.url() === void 0
+		};
+		const client = createClusterClient(clientClass, clientClassOptions);
+		this.#patchClusterClient(client);
+		return client;
+	}
+	/**
+	* print the information when console.log(app)
+	* @return {Object} inspected app.
+	* @since 1.0.0
+	* @example
+	* ```js
+	* console.log(app);
+	* =>
+	* {
+	*   name: 'mock-app',
+	*   env: 'test',
+	*   subdomainOffset: 2,
+	*   config: '<egg config>',
+	*   controller: '<egg controller>',
+	*   service: '<egg service>',
+	*   middlewares: '<egg middlewares>',
+	*   urllib: '<egg urllib>',
+	*   loggers: '<egg loggers>'
+	* }
+	* ```
+	*/
+	inspect() {
+		const res = { env: this.config.env };
+		function delegate(res$1, app, keys) {
+			for (const key of keys) if (app[key]) res$1[key] = app[key];
+		}
+		function abbr(res$1, app, keys) {
+			for (const key of keys) if (app[key]) res$1[key] = `<egg ${key}>`;
+		}
+		delegate(res, this, [
+			"name",
+			"baseDir",
+			"subdomainOffset"
+		]);
+		abbr(res, this, [
+			"config",
+			"controller",
+			"httpclient",
+			"loggers",
+			"middlewares",
+			"router",
+			"serviceClasses"
+		]);
+		return res;
+	}
+	toJSON() {
+		return this.inspect();
+	}
+	/**
+	* http request helper base on {@link httpclient}, it will auto save httpclient log.
+	* Keep the same api with `httpclient.request(url, args)`.
+	*
+	* See https://github.com/node-modules/urllib#api-doc for more details.
+	*
+	* @param {String} url request url address.
+	* @param {Object} options
+	* - method {String} - Request method, defaults to GET. Could be GET, POST, DELETE or PUT. Alias 'type'.
+	* - data {Object} - Data to be sent. Will be stringify automatically.
+	* - dataType {String} - String - Type of response data. Could be `text` or `json`.
+	*   If it's `text`, the callback data would be a String.
+	*   If it's `json`, the data of callback would be a parsed JSON Object.
+	*   Default callback data would be a Buffer.
+	* - headers {Object} - Request headers.
+	* - timeout {Number} - Request timeout in milliseconds. Defaults to exports.TIMEOUT.
+	*   Include remote server connecting timeout and response timeout.
+	*   When timeout happen, will return ConnectionTimeout or ResponseTimeout.
+	* - auth {String} - `username:password` used in HTTP Basic Authorization.
+	* - followRedirect {Boolean} - follow HTTP 3xx responses as redirects. defaults to false.
+	* - gzip {Boolean} - let you get the res object when request connected, default false. alias customResponse
+	* - nestedQuerystring {Boolean} - urllib default use querystring to stringify form data which don't
+	*   support nested object, will use qs instead of querystring to support nested object by set this option to true.
+	* - more options see https://github.com/node-modules/urllib
+	* @return {Object}
+	* - status {Number} - HTTP response status
+	* - headers {Object} - HTTP response headers
+	* - res {Object} - HTTP response meta
+	* - data {Object} - HTTP response body
+	*
+	* @example
+	* ```js
+	* const result = await app.curl('http://example.com/foo.json', {
+	*   method: 'GET',
+	*   dataType: 'json',
+	* });
+	* console.log(result.status, result.headers, result.data);
+	* ```
+	*/
+	async curl(url, options) {
+		return await this.httpClient.request(url, options);
+	}
+	/**
+	* Create a new HttpClient instance with custom options
+	* @param {Object} [options] HttpClient init options
+	*/
+	createHttpClient(options) {
+		return new this.HttpClient(this, options);
+	}
+	/**
+	* HttpClient instance
+	* @see https://github.com/node-modules/urllib
+	* @member {HttpClient}
+	*/
+	get httpClient() {
+		if (!this.#httpClient) this.#httpClient = this.createHttpClient();
+		return this.#httpClient;
+	}
+	/**
+	* @deprecated please use httpClient instead
+	* @alias httpClient
+	* @member {HttpClient}
+	*/
+	get httpclient() {
+		return this.httpClient;
+	}
+	/**
+	* All loggers contain logger, coreLogger and customLogger
+	* @member {Object}
+	* @since 1.0.0
+	*/
+	get loggers() {
+		if (!this.#loggers) this.#loggers = createLoggers(this);
+		return this.#loggers;
+	}
+	/**
+	* Get logger by name, it's equal to app.loggers['name'],
+	* but you can extend it with your own logical.
+	* @param {String} name - logger name
+	* @return {Logger} logger
+	*/
+	getLogger(name) {
+		return this.loggers[name] || null;
+	}
+	/**
+	* application logger, log file is `$HOME/logs/{appname}/{appname}-web`
+	* @member {Logger}
+	* @since 1.0.0
+	*/
+	get logger() {
+		return this.getLogger("logger");
+	}
+	/**
+	* core logger for framework and plugins, log file is `$HOME/logs/{appname}/egg-web`
+	* @member {Logger}
+	* @since 1.0.0
+	*/
+	get coreLogger() {
+		return this.getLogger("coreLogger");
+	}
+	_unhandledRejectionHandler(err) {
+		this.coreLogger.error("[egg:unhandledRejection] %s", err && err.message || err);
+		if (!(err instanceof Error)) {
+			const newError = new Error(String(err));
+			if (err) {
+				if (err.name) newError.name = err.name;
+				if (err.message) newError.message = err.message;
+				if (err.stack) newError.stack = err.stack;
+			}
+			err = newError;
+		}
+		if (err.name === "Error") err.name = "unhandledRejectionError";
+		this.coreLogger.error(err);
+	}
+	/**
+	* dump out the config and meta object
+	* @private
+	*/
+	dumpConfigToObject() {
+		let ignoreList;
+		try {
+			ignoreList = Array.from(this.config.dump.ignore);
+		} catch {
+			ignoreList = [];
+		}
+		const config = extend(true, {}, {
+			config: this.config,
+			plugins: this.loader.allPlugins,
+			appInfo: this.loader.appInfo
+		});
+		convertObject(config, ignoreList);
+		return {
+			config,
+			meta: this.loader.configMeta
+		};
+	}
+	/**
+	* save app.config to `run/${type}_config.json`
+	* @private
+	*/
+	dumpConfig() {
+		const rundir = this.config.rundir;
+		try {
+			if (!fs.existsSync(rundir)) fs.mkdirSync(rundir);
+			const { config, meta } = this.dumpConfigToObject();
+			const dumpFile = path.join(rundir, `${this.type}_config.json`);
+			fs.writeFileSync(dumpFile, CircularJSON.stringify(config, null, 2));
+			const dumpMetaFile = path.join(rundir, `${this.type}_config_meta.json`);
+			fs.writeFileSync(dumpMetaFile, CircularJSON.stringify(meta, null, 2));
+		} catch (err) {
+			this.coreLogger.warn(`[egg] dumpConfig error: ${err.message}`);
+		}
+	}
+	dumpTiming() {
+		try {
+			const items = this.timing.toJSON();
+			const rundir = this.config.rundir;
+			const dumpFile = path.join(rundir, `${this.type}_timing_${process.pid}.json`);
+			fs.writeFileSync(dumpFile, CircularJSON.stringify(items, null, 2));
+			this.coreLogger.info(this.timing.toString());
+			this.timing.disable();
+			for (const item of items) if (item.index > 0 && item.duration && item.duration >= this.config.dump.timing.slowBootActionMinDuration) this.coreLogger.warn("[egg][dumpTiming][slow-boot-action] #%d %dms, name: %s", item.index, item.duration, item.name);
+		} catch (err) {
+			this.coreLogger.warn(`[egg] dumpTiming error: ${err.message}`);
+		}
+	}
+	get [EGG_PATH]() {
+		return getSourceDirname();
+	}
+	#setupTimeoutTimer() {
+		const startTimeoutTimer = setTimeout(() => {
+			this.coreLogger.error(this.timing.toString());
+			this.coreLogger.error(`${this.type} still doesn't ready after ${this.config.workerStartTimeout} ms.`);
+			const items = this.timing.toJSON();
+			for (const item of items) {
+				if (item.end) continue;
+				this.coreLogger.error(`unfinished timing item: ${CircularJSON.stringify(item)}`);
+			}
+			this.coreLogger.error("[egg][setupTimeoutTimer] check run/%s_timing_%s.json for more details.", this.type, process.pid);
+			this.emit("startTimeout");
+			this.dumpConfig();
+			this.dumpTiming();
+		}, this.config.workerStartTimeout);
+		this.ready(() => clearTimeout(startTimeoutTimer));
+	}
+	get config() {
+		return super.config;
+	}
+	/**
+	* app.env delegate app.config.env
+	* @deprecated
+	*/
+	get env() {
+		this.deprecate("please use app.config.env instead");
+		return this.config.env;
+	}
+	set env(_) {}
+	/**
+	* app.proxy delegate app.config.proxy
+	* @deprecated
+	*/
+	get proxy() {
+		return this.config.proxy;
+	}
+	set proxy(_) {}
+	#patchClusterClient(client) {
+		const rawCreate = client.create;
+		client.create = (...args) => {
+			const realClient = rawCreate.apply(client, args);
+			this.#clusterClients.push(realClient);
+			return realClient;
+		};
+	}
+	/**
+	* Create an anonymous context, the context isn't request level, so the request is mocked.
+	* then you can use context level API like `ctx.service`
+	* @member {String} EggApplication#createAnonymousContext
+	* @param {Request} [req] - if you want to mock request like querystring, you can pass an object to this function.
+	* @return {Context} context
+	*/
+	createAnonymousContext(req) {
+		const request = {
+			headers: {
+				host: "127.0.0.1",
+				"x-forwarded-for": "127.0.0.1"
+			},
+			query: {},
+			querystring: "",
+			host: "127.0.0.1",
+			hostname: "127.0.0.1",
+			protocol: "http",
+			secure: "false",
+			method: "GET",
+			url: "/",
+			path: "/",
+			socket: {
+				remoteAddress: "127.0.0.1",
+				remotePort: 7001
+			}
+		};
+		if (req) for (const key in req) if (key === "headers" || key === "query" || key === "socket") Object.assign(request[key], req[key]);
+		else request[key] = req[key];
+		const response = new http.ServerResponse(request);
+		return this.createContext(request, response);
+	}
+	/**
+	* Run async function in the anonymous context scope
+	* @see Context#runInAnonymousContextScope
+	* @param {Function} scope - the first args is an anonymous ctx, scope should be async function
+	* @param {Request} [req] - if you want to mock request like querystring, you can pass an object to this function.
+	*/
+	async runInAnonymousContextScope(scope, req) {
+		const ctx = this.createAnonymousContext(req);
+		if (!scope.name) Reflect.set(scope, "_name", utils.getCalleeFromStack(true));
+		return await this.ctxStorage.run(ctx, async () => {
+			return await scope(ctx);
+		});
+	}
+	/**
+	* Create egg context
+	* @function EggApplication#createContext
+	* @param  {Req} req - node native Request object
+	* @param  {Res} res - node native Response object
+	* @return {Context} context object
+	*/
+	createContext(req, res) {
+		const context = Object.create(this.context);
+		const request = context.request = Object.create(this.request);
+		const response = context.response = Object.create(this.response);
+		context.app = request.app = response.app = this;
+		context.req = request.req = response.req = req;
+		context.res = request.res = response.res = res;
+		request.ctx = response.ctx = context;
+		request.response = response;
+		response.request = request;
+		context.onerror = context.onerror.bind(context);
+		context.originalUrl = request.originalUrl = req.url;
+		context.starttime = Date.now();
+		context.performanceStarttime = performance.now();
+		return context;
+	}
+};
+
+//#endregion
+export { BaseMessenger, EggApplicationCore, Messenger$1 as Messenger, Messenger as Messenger$1, Router$1 as Router, create };