egg 3.29.0 → 4.0.0-beta.10

package/{lib/egg.js → src/lib/egg.ts}

@@ -1,37 +1,150 @@
-const { performance } = require('perf_hooks');
-const path = require('path');
-const fs = require('fs');
-const ms = require('ms');
-const http = require('http');
-const EggCore = require('egg-core').EggCore;
-const cluster = require('cluster-client');
-const extend = require('extend2');
-const ContextLogger = require('egg-logger').EggContextLogger;
-const ContextCookies = require('egg-cookies');
-const CircularJSON = require('circular-json-for-egg');
-const ContextHttpClient = require('./core/context_httpclient');
-const Messenger = require('./core/messenger');
-const DNSCacheHttpClient = require('./core/dnscache_httpclient');
-const HttpClient = require('./core/httpclient');
-const HttpClientNext = require('./core/httpclient_next');
-const createLoggers = require('./core/logger');
-const Singleton = require('./core/singleton');
-const utils = require('./core/utils');
-const BaseContextClass = require('./core/base_context_class');
-const BaseHookClass = require('./core/base_hook_class');
-
-const HTTPCLIENT = Symbol('EggApplication#httpclient');
-const LOGGERS = Symbol('EggApplication#loggers');
+import { performance } from 'node:perf_hooks';
+import path from 'node:path';
+import fs from 'node:fs';
+import http, { type IncomingMessage, type ServerResponse } from 'node:http';
+import inspector from 'node:inspector';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import {
+  EggCore,
+  Request as EggCoreRequest,
+  Response as EggCoreResponse,
+  Router,
+} from '@eggjs/core';
+import type {
+  EggCoreOptions,
+  Next, MiddlewareFunc as EggCoreMiddlewareFunc,
+  ILifecycleBoot,
+} from '@eggjs/core';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import createClusterClient, { close as closeClusterClient } from 'cluster-client';
+import { extend } from 'extend2';
+import { EggContextLogger as ContextLogger, EggLoggers, EggLogger } from 'egg-logger';
+import { Cookies as ContextCookies } from '@eggjs/cookies';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import CircularJSON from 'circular-json-for-egg';
+import type { Agent } from './agent.js';
+import type { Application } from './application.js';
+import Context, { type ContextDelegation } from '../app/extend/context.js';
+import type { EggAppConfig } from './type.js';
+import { create as createMessenger, IMessenger } from './core/messenger/index.js';
+import { ContextHttpClient } from './core/context_httpclient.js';
+import {
+  HttpClient, type HttpClientRequestOptions, type HttpClientRequestURL, type HttpClientResponse,
+} from './core/httpclient.js';
+import { createLoggers } from './core/logger.js';
+import {
+  Singleton, type SingletonCreateMethod, type SingletonOptions,
+} from './core/singleton.js';
+import { convertObject } from './core/utils.js';
+import { BaseContextClass } from './core/base_context_class.js';
+import { BaseHookClass } from './core/base_hook_class.js';
+import type { EggApplicationLoader } from './loader/index.js';
+import { getSourceDirname } from './utils.js';
+
+import './egg.types.js';
+
 const EGG_PATH = Symbol.for('egg#eggPath');
-const CLUSTER_CLIENTS = Symbol.for('egg#clusterClients');
+
+export interface EggApplicationCoreOptions extends Omit<EggCoreOptions, 'baseDir'> {
+  mode?: 'cluster' | 'single';
+  clusterPort?: number;
+  baseDir?: string;
+}
+
+// export egg classes
+export {
+  Context,
+  Router,
+  EggLogger,
+};
+
+export class Request extends EggCoreRequest {
+  declare app: EggCore;
+  declare response: Response;
+  declare ctx: ContextDelegation;
+}
+
+export class Response extends EggCoreResponse {
+  declare app: EggCore;
+  declare request: Request;
+  declare ctx: ContextDelegation;
+}
+
+// export egg types
+export type {
+  ContextDelegation,
+  ILifecycleBoot,
+  Next,
+};
+// keep compatible with egg version 3.x
+export type EggContext = ContextDelegation;
+export type MiddlewareFunc<T extends ContextDelegation = ContextDelegation> = EggCoreMiddlewareFunc<T>;
 
 /**
  * Based on koa's Application
  * @see https://github.com/eggjs/egg-core
- * @see http://koajs.com/#application
+ * @see https://github.com/eggjs/koa/blob/master/src/application.ts
  * @augments EggCore
  */
-class EggApplication extends EggCore {
+export class EggApplicationCore extends EggCore {
+  declare ctxStorage: AsyncLocalStorage<ContextDelegation>;
+  // export context base classes, let framework can impl sub class and over context extend easily.
+  ContextCookies = ContextCookies;
+  ContextLogger = ContextLogger;
+  ContextHttpClient = ContextHttpClient;
+  HttpClient = HttpClient;
+  /**
+   * Retrieve base context class
+   * @member {BaseContextClass} BaseContextClass
+   * @since 1.0.0
+   */
+  BaseContextClass = BaseContextClass;
+
+  /**
+   * Retrieve base controller
+   * @member {Controller} Controller
+   * @since 1.0.0
+   */
+  Controller = BaseContextClass;
+
+  /**
+   * Retrieve base service
+   * @member {Service} Service
+   * @since 1.0.0
+   */
+  Service = BaseContextClass;
+
+  /**
+   * Retrieve base subscription
+   * @member {Subscription} Subscription
+   * @since 2.12.0
+   */
+  Subscription = BaseContextClass;
+
+  /**
+   * Retrieve base context class
+   * @member {BaseHookClass} BaseHookClass
+   */
+  BaseHookClass = BaseHookClass;
+
+  /**
+   * Retrieve base boot
+   * @member {Boot}
+   */
+  Boot = BaseHookClass;
+
+  declare options: Required<EggApplicationCoreOptions>;
+
+  #httpClient?: HttpClient;
+  #loggers?: EggLoggers;
+  #clusterClients: any[] = [];
+
+  readonly messenger: IMessenger;
+  agent?: Agent;
+  application?: Application;
+  declare loader: EggApplicationLoader;
 
   /**
    * @class
@@ -41,91 +154,73 @@ class EggApplication extends EggCore {
    *  - {Object} [plugins] - custom plugin config, use it in unittest
    *  - {String} [mode] - process mode, can be cluster / single, default is `cluster`
    */
-  constructor(options = {}) {
-    options.mode = options.mode || 'cluster';
+  constructor(options?: EggApplicationCoreOptions) {
+    options = {
+      mode: 'cluster',
+      type: 'application',
+      baseDir: process.cwd(),
+      ...options,
+    };
     super(options);
-
-    // export context base classes, let framework can impl sub class and over context extend easily.
-    this.ContextCookies = ContextCookies;
-    this.ContextLogger = ContextLogger;
-    this.ContextHttpClient = ContextHttpClient;
-    this.HttpClient = HttpClient;
-    this.HttpClientNext = HttpClientNext;
-
-    this.loader.loadConfig();
-
     /**
      * messenger instance
      * @member {Messenger}
      * @since 1.0.0
      */
-    this.messenger = Messenger.create(this);
+    this.messenger = createMessenger(this);
 
     // trigger `serverDidReady` hook when all the app workers
     // and agent worker are ready
     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;
+  }
 
+  protected async loadConfig() {
+    await this.loader.loadConfig();
+  }
+
+  protected async load() {
+    await this.loadConfig();
     // dump config after ready, ensure all the modifications during start will be recorded
     // make sure dumpConfig is the last ready callback
     this.ready(() => process.nextTick(() => {
       const dumpStartTime = Date.now();
       this.dumpConfig();
       this.dumpTiming();
-      this.coreLogger.info('[egg:core] dump config after ready, %s', ms(Date.now() - dumpStartTime));
+      this.coreLogger.info('[egg] dump config after ready, %sms', Date.now() - dumpStartTime);
     }));
-    this._setupTimeoutTimer();
+    this.#setupTimeoutTimer();
 
-    this.console.info('[egg:core] App root: %s', this.baseDir);
-    this.console.info('[egg:core] All *.log files save on %j', this.config.logger.dir);
-    this.console.info('[egg:core] Loaded enabled plugin %j', this.loader.orderPlugins);
+    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);
 
     // Listen the error that promise had not catch, then log it in common-error
     this._unhandledRejectionHandler = this._unhandledRejectionHandler.bind(this);
     process.on('unhandledRejection', this._unhandledRejectionHandler);
 
-    this[CLUSTER_CLIENTS] = [];
-
-    /**
-     * 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 tranform 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 subscrption 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
-     */
-    this.cluster = (clientClass, options) => {
-      options = Object.assign({}, this.config.clusterClient, options, {
-        singleMode: this.options.mode === 'single',
-        // cluster need a port that can't conflict on the environment
-        port: this.options.clusterPort,
-        // agent worker is leader, app workers are follower
-        isLeader: this.type === 'agent',
-        logger: this.coreLogger,
-        // debug mode does not check heartbeat
-        isCheckHeartbeat: this.config.env === 'prod' ? true : require('inspector').url() === undefined,
-      });
-      const client = cluster(clientClass, options);
-      this._patchClusterClient(client);
-      return client;
-    };
-
     // register close function
-    this.beforeClose(async () => {
+    this.lifecycle.registerBeforeClose(async () => {
+      // close all cluster clients
+      for (const clusterClient of this.#clusterClients) {
+        await closeClusterClient(clusterClient);
+      }
+      this.#clusterClients = [];
+
       // single process mode will close agent before app close
       if (this.type === 'application' && this.options.mode === 'single') {
-        await this.agent.close();
+        await this.agent!.close();
       }
 
       for (const logger of this.loggers.values()) {
@@ -135,45 +230,43 @@ class EggApplication extends EggCore {
       process.removeListener('unhandledRejection', this._unhandledRejectionHandler);
     });
 
-    /**
-     * Retreive base context class
-     * @member {BaseContextClass} BaseContextClass
-     * @since 1.0.0
-     */
-    this.BaseContextClass = BaseContextClass;
-
-    /**
-     * Retreive base controller
-     * @member {Controller} Controller
-     * @since 1.0.0
-     */
-    this.Controller = BaseContextClass;
-
-    /**
-     * Retreive base service
-     * @member {Service} Service
-     * @since 1.0.0
-     */
-    this.Service = BaseContextClass;
-
-    /**
-     * Retreive base subscription
-     * @member {Subscription} Subscription
-     * @since 2.12.0
-     */
-    this.Subscription = BaseContextClass;
-
-    /**
-     * Retreive base context class
-     * @member {BaseHookClass} BaseHookClass
-     */
-    this.BaseHookClass = BaseHookClass;
+    await this.loader.load();
+  }
 
-    /**
-     * Retreive base boot
-     * @member {Boot}
-     */
-    this.Boot = BaseHookClass;
+  /**
+   * 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
+   */
+  cluster(clientClass: unknown, options?: object) {
+    const clientClassOptions = {
+      ...this.config.clusterClient,
+      ...options,
+      singleMode: this.options.mode === 'single',
+      // cluster need a port that can't conflict on the environment
+      port: this.options.clusterPort,
+      // agent worker is leader, app workers are follower
+      isLeader: this.type === 'agent',
+      logger: this.coreLogger,
+      // debug mode does not check heartbeat
+      isCheckHeartbeat: this.config.env === 'prod' ? true : inspector.url() === undefined,
+    };
+    const client = createClusterClient(clientClass, clientClassOptions);
+    this.#patchClusterClient(client);
+    return client;
   }
 
   /**
@@ -185,7 +278,7 @@ class EggApplication extends EggCore {
    * console.log(app);
    * =>
    * {
-   *   name: 'mockapp',
+   *   name: 'mock-app',
    *   env: 'test',
    *   subdomainOffset: 2,
    *   config: '<egg config>',
@@ -197,23 +290,21 @@ class EggApplication extends EggCore {
    * }
    * ```
    */
-  inspect() {
+  inspect(): any {
     const res = {
       env: this.config.env,
     };
 
-    function delegate(res, app, keys) {
+    function delegate(res: any, app: any, keys: string[]) {
       for (const key of keys) {
-        /* istanbul ignore else */
         if (app[key]) {
           res[key] = app[key];
         }
       }
     }
 
-    function abbr(res, app, keys) {
+    function abbr(res: any, app: any, keys: string[]) {
       for (const key of keys) {
-        /* istanbul ignore else */
         if (app[key]) {
           res[key] = `<egg ${key}>`;
         }
@@ -250,13 +341,13 @@ class EggApplication extends EggCore {
    * See https://github.com/node-modules/urllib#api-doc for more details.
    *
    * @param {String} url request url address.
-   * @param {Object} opts
+   * @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 callbacked data would be a String.
+   *   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 callbacked data would be a Buffer.
+   *   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.
@@ -266,10 +357,10 @@ class EggApplication extends EggCore {
    * - 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://www.npmjs.com/package/urllib
+   * - more options see https://github.com/node-modules/urllib
    * @return {Object}
    * - status {Number} - HTTP response status
-   * - headers {Object} - HTTP response seaders
+   * - headers {Object} - HTTP response headers
    * - res {Object} - HTTP response meta
    * - data {Object} - HTTP response body
    *
@@ -282,24 +373,8 @@ class EggApplication extends EggCore {
    * console.log(result.status, result.headers, result.data);
    * ```
    */
-  async curl(url, opts) {
-    return await this.httpclient.request(url, opts);
-  }
-
-  /**
-   * Create a new HttpClient instance with custom options
-   * @param {Object} [options] HttpClient init options
-   */
-  createHttpClient(options) {
-    let httpClient;
-    if (this.config.httpclient.useHttpClientNext || this.config.httpclient.allowH2) {
-      httpClient = new this.HttpClientNext(this, options);
-    } else if (this.config.httpclient.enableDNSCache) {
-      httpClient = new DNSCacheHttpClient(this, options);
-    } else {
-      httpClient = new this.HttpClient(this, options);
-    }
-    return httpClient;
+  async curl<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions): Promise<HttpClientResponse<T>> {
+    return await this.httpClient.request<T>(url, options);
   }
 
   /**
@@ -307,31 +382,32 @@ class EggApplication extends EggCore {
    * @see https://github.com/node-modules/urllib
    * @member {HttpClient}
    */
-  get httpclient() {
-    if (!this[HTTPCLIENT]) {
-      this[HTTPCLIENT] = this.createHttpClient();
+  get httpClient() {
+    if (!this.#httpClient) {
+      this.#httpClient = new this.HttpClient(this);
     }
-    return this[HTTPCLIENT];
+    return this.#httpClient;
   }
 
   /**
-   * @alias httpclient
+   * @deprecated please use httpClient instead
+   * @alias httpClient
    * @member {HttpClient}
    */
-  get httpClient() {
-    return this.httpclient;
+  get httpclient() {
+    return this.httpClient;
   }
 
   /**
-   *  All loggers contain logger, coreLogger and customLogger
+   * All loggers contain logger, coreLogger and customLogger
    * @member {Object}
    * @since 1.0.0
    */
   get loggers() {
-    if (!this[LOGGERS]) {
-      this[LOGGERS] = createLoggers(this);
+    if (!this.#loggers) {
+      this.#loggers = createLoggers(this);
     }
-    return this[LOGGERS];
+    return this.#loggers;
   }
 
   /**
@@ -340,7 +416,7 @@ class EggApplication extends EggCore {
    * @param {String} name - logger name
    * @return {Logger} logger
    */
-  getLogger(name) {
+  getLogger(name: string): EggLogger {
     return this.loggers[name] || null;
   }
 
@@ -362,11 +438,10 @@ class EggApplication extends EggCore {
     return this.getLogger('coreLogger');
   }
 
-  _unhandledRejectionHandler(err) {
+  _unhandledRejectionHandler(err: any) {
     if (!(err instanceof Error)) {
       const newError = new Error(String(err));
       // err maybe an object, try to copy the name, message and stack to the new error instance
-      /* istanbul ignore else */
       if (err) {
         if (err.name) newError.name = err.name;
         if (err.message) newError.message = err.message;
@@ -374,7 +449,6 @@ class EggApplication extends EggCore {
       }
       err = newError;
     }
-    /* istanbul ignore else */
     if (err.name === 'Error') {
       err.name = 'unhandledRejectionError';
     }
@@ -384,21 +458,23 @@ class EggApplication extends EggCore {
   /**
    * dump out the config and meta object
    * @private
-   * @return {Object} the result
    */
   dumpConfigToObject() {
-    let ignoreList;
+    let ignoreList: (string | RegExp)[];
     try {
       // support array and set
       ignoreList = Array.from(this.config.dump.ignore);
     } catch (_) {
       ignoreList = [];
     }
-
-    const json = extend(true, {}, { config: this.config, plugins: this.loader.allPlugins, appInfo: this.loader.appInfo });
-    utils.convertObject(json, ignoreList);
+    const config = extend(true, {}, {
+      config: this.config,
+      plugins: this.loader.allPlugins,
+      appInfo: this.loader.appInfo,
+    });
+    convertObject(config, ignoreList);
     return {
-      config: json,
+      config,
       meta: this.loader.configMeta,
     };
   }
@@ -410,10 +486,11 @@ class EggApplication extends EggCore {
   dumpConfig() {
     const rundir = this.config.rundir;
     try {
-      /* istanbul ignore if */
-      if (!fs.existsSync(rundir)) fs.mkdirSync(rundir);
+      if (!fs.existsSync(rundir)) {
+        fs.mkdirSync(rundir);
+      }
 
-      // get dumpped object
+      // get dumped object
       const { config, meta } = this.dumpConfigToObject();
 
       // dump config
@@ -423,8 +500,8 @@ class EggApplication extends EggCore {
       // dump config meta
       const dumpMetaFile = path.join(rundir, `${this.type}_config_meta.json`);
       fs.writeFileSync(dumpMetaFile, CircularJSON.stringify(meta, null, 2));
-    } catch (err) {
-      this.coreLogger.warn(`dumpConfig error: ${err.message}`);
+    } catch (err: any) {
+      this.coreLogger.warn(`[egg] dumpConfig error: ${err.message}`);
     }
   }
 
@@ -437,24 +514,24 @@ class EggApplication extends EggCore {
       this.coreLogger.info(this.timing.toString());
       // only disable, not clear bootstrap timing data.
       this.timing.disable();
-      // show duration >= ${slowBootActionMinDuration}ms action to warnning log
+      // show duration >= ${slowBootActionMinDuration}ms action to warning log
       for (const item of items) {
         // ignore #0 name: Process Start
-        if (item.index > 0 && item.duration >= this.config.dump.timing.slowBootActionMinDuration) {
-          this.coreLogger.warn('[egg:core][slow-boot-action] #%d %dms, name: %s',
+        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(`dumpTiming error: ${err.message}`);
+    } catch (err: any) {
+      this.coreLogger.warn(`[egg] dumpTiming error: ${err.message}`);
     }
   }
 
   get [EGG_PATH]() {
-    return path.join(__dirname, '..');
+    return getSourceDirname();
   }
 
-  _setupTimeoutTimer() {
+  #setupTimeoutTimer() {
     const startTimeoutTimer = setTimeout(() => {
       this.coreLogger.error(this.timing.toString());
       this.coreLogger.error(`${this.type} still doesn't ready after ${this.config.workerStartTimeout} ms.`);
@@ -464,7 +541,8 @@ class EggApplication extends EggCore {
         if (item.end) continue;
         this.coreLogger.error(`unfinished timing item: ${CircularJSON.stringify(item)}`);
       }
-      this.coreLogger.error(`check run/${this.type}_timing_${process.pid}.json for more details.`);
+      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();
@@ -472,6 +550,10 @@ class EggApplication extends EggCore {
     this.ready(() => clearTimeout(startTimeoutTimer));
   }
 
+  get config() {
+    return super.config as EggAppConfig;
+  }
+
   /**
    * app.env delegate app.config.env
    * @deprecated
@@ -488,7 +570,7 @@ class EggApplication extends EggCore {
    * @deprecated
    */
   get proxy() {
-    this.deprecate('please use app.config.proxy instead');
+    // this.deprecate('please use app.config.proxy instead');
     return this.config.proxy;
   }
   /* eslint no-empty-function: off */
@@ -499,11 +581,12 @@ class EggApplication extends EggCore {
    * @param {String} name - unique name for singleton
    * @param {Function|AsyncFunction} create - method will be invoked when singleton instance create
    */
-  addSingleton(name, create) {
-    const options = {};
-    options.name = name;
-    options.create = create;
-    options.app = this;
+  addSingleton(name: string, create: SingletonCreateMethod) {
+    const options: SingletonOptions = {
+      name,
+      create,
+      app: this,
+    };
     const singleton = new Singleton(options);
     const initPromise = singleton.init();
     if (initPromise) {
@@ -513,12 +596,11 @@ class EggApplication extends EggCore {
     }
   }
 
-  _patchClusterClient(client) {
-    const create = client.create;
-    client.create = (...args) => {
-      const realClient = create.apply(client, args);
-      this[CLUSTER_CLIENTS].push(realClient);
-      this.beforeClose(() => cluster.close(realClient));
+  #patchClusterClient(client: any) {
+    const rawCreate = client.create;
+    client.create = (...args: any) => {
+      const realClient = rawCreate.apply(client, args);
+      this.#clusterClients.push(realClient);
       return realClient;
     };
   }
@@ -530,8 +612,8 @@ class EggApplication extends EggCore {
    * @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 = {
+  createAnonymousContext(req?: any): EggContext {
+    const request: any = {
       headers: {
         host: '127.0.0.1',
         'x-forwarded-for': '127.0.0.1',
@@ -570,36 +652,20 @@ class EggApplication extends EggCore {
    * @param  {Res} res - node native Response object
    * @return {Context} context object
    */
-  createContext(req, res) {
-    const app = this;
-    const context = Object.create(app.context);
-    const request = context.request = Object.create(app.request);
-    const response = context.response = Object.create(app.response);
-    context.app = request.app = response.app = app;
+  createContext(req: IncomingMessage, res: ServerResponse): EggContext {
+    const context = Object.create(this.context) as EggContext;
+    const request = context.request = Object.create(this.request);
+    const response = context.response = Object.create(this.response);
+    context.app = request.app = response.app = this as any;
     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;
-
-    /**
-     * Request start time
-     * @member {Number} Context#starttime
-     */
+    context.originalUrl = request.originalUrl = req.url as string;
     context.starttime = Date.now();
-
-    if (this.config.logger.enablePerformanceTimer) {
-      /**
-       * Request start timer using `performance.now()`
-       * @member {Number} Context#performanceStarttime
-       */
-      context.performanceStarttime = performance.now();
-    }
+    context.performanceStarttime = performance.now();
     return context;
   }
-
 }
-
-module.exports = EggApplication;