egg 3.26.0 → 4.0.0-beta.0

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

@@ -1,27 +1,17 @@
-'use strict';
+import path from 'node:path';
+import fs from 'node:fs';
+import http from 'node:http';
+import { Socket } from 'node:net';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import graceful from 'graceful';
+import { assign } from 'utility';
+import { utils as eggUtils } from '@eggjs/core';
+import { EggApplicationCore, EggContext, EggApplicationCoreOptions } from './egg.js';
+import { AppWorkerLoader } from './loader/index.js';
+import { BaseContextClass } from './core/base_context_class.js';
 
-const path = require('path');
-const fs = require('fs');
-const ms = require('ms');
-const is = require('is-type-of');
-const graceful = require('graceful');
-const http = require('http');
-const cluster = require('cluster-client');
-const onFinished = require('on-finished');
-const { assign } = require('utility');
-const eggUtils = require('egg-core').utils;
-const EggApplication = require('./egg');
-const AppWorkerLoader = require('./loader').AppWorkerLoader;
-
-const KEYS = Symbol('Application#keys');
-const HELPER = Symbol('Application#Helper');
-const LOCALS = Symbol('Application#locals');
-const BIND_EVENTS = Symbol('Application#bindEvents');
-const WARN_CONFUSED_CONFIG = Symbol('Application#warnConfusedConfig');
 const EGG_LOADER = Symbol.for('egg#loader');
-const EGG_PATH = Symbol.for('egg#eggPath');
-const CLUSTER_CLIENTS = Symbol.for('egg#clusterClients');
-const RESPONSE_RAW = Symbol('Application#responseRaw');
 
 // client error => 400 Bad Request
 // Refs: https://nodejs.org/dist/latest-v8.x/docs/api/http.html#http_event_clienterror
@@ -38,59 +28,60 @@ const DEFAULT_BAD_REQUEST_RESPONSE =
   `\r\n\r\n${DEFAULT_BAD_REQUEST_HTML}`;
 
 // Refs: https://github.com/nodejs/node/blob/b38c81/lib/_http_outgoing.js#L706-L710
-function escapeHeaderValue(value) {
+function escapeHeaderValue(value: string) {
   // Protect against response splitting. The regex test is there to
   // minimize the performance impact in the common case.
   return /[\r\n]/.test(value) ? value.replace(/[\r\n]+[ \t]*/g, '') : value;
 }
 
-// Refs: https://github.com/nodejs/node/blob/b38c81/lib/_http_outgoing.js#L706-L710
 /**
- * Singleton instance in App Worker, extend {@link EggApplication}
- * @augments EggApplication
+ * The Helper class which can be used as utility function.
+ * We support developers to extend Helper through ${baseDir}/app/extend/helper.js ,
+ * then you can use all method on `ctx.helper` that is a instance of Helper.
  */
-class Application extends EggApplication {
+class HelperClass extends BaseContextClass {}
 
+/**
+ * Singleton instance in App Worker, extend {@link EggApplicationCore}
+ * @augments EggApplicationCore
+ */
+export class Application extends EggApplicationCore {
+  // will auto set after 'server' event emit
+  server?: http.Server;
+  #locals: Record<string, any> = {};
   /**
-   * @class
-   * @param {Object} options - see {@link EggApplication}
+   * reference to {@link Helper}
+   * @member {Helper} Application#Helper
    */
-  constructor(options = {}) {
-    options.type = 'application';
-    super(options);
-
-    // will auto set after 'server' event emit
-    this.server = null;
+  Helper = HelperClass;
 
-    try {
-      this.loader.load();
-    } catch (e) {
-      // close gracefully
-      this[CLUSTER_CLIENTS].forEach(cluster.close);
-      throw e;
-    }
-
-    // dump config after loaded, ensure all the dynamic modifications will be recorded
-    const dumpStartTime = Date.now();
-    this.dumpConfig();
-    this.coreLogger.info('[egg:core] dump config after load, %s', ms(Date.now() - dumpStartTime));
+  /**
+   * @class
+   * @param {Object} options - see {@link EggApplicationCore}
+   */
+  constructor(options?: Omit<EggApplicationCoreOptions, 'type'>) {
+    super({
+      ...options,
+      type: 'application',
+    });
+  }
 
-    this[WARN_CONFUSED_CONFIG]();
-    this[BIND_EVENTS]();
+  protected async load() {
+    await super.load();
+    this.#warnConfusedConfig();
+    this.#bindEvents();
   }
 
   get [EGG_LOADER]() {
     return AppWorkerLoader;
   }
 
-  get [EGG_PATH]() {
-    return path.join(__dirname, '..');
-  }
-
-  [RESPONSE_RAW](socket, raw) {
+  #responseRaw(socket: Socket, raw?: any) {
     /* istanbul ignore next */
     if (!socket.writable) return;
-    if (!raw) return socket.end(DEFAULT_BAD_REQUEST_RESPONSE);
+    if (!raw) {
+      return socket.end(DEFAULT_BAD_REQUEST_RESPONSE);
+    }
 
     const body = (raw.body == null) ? DEFAULT_BAD_REQUEST_HTML : raw.body;
     const headers = raw.headers || {};
@@ -114,10 +105,10 @@ class Application extends EggApplication {
     socket.end(`${firstLine}\r\n${responseHeaderLines}\r\n${body.toString()}`);
   }
 
-  onClientError(err, socket) {
+  onClientError(err: any, socket: Socket) {
     // ignore when there is no http body, it almost like an ECONNRESET
     if (err.rawPacket) {
-      this.logger.warn('A client (%s:%d) error [%s] occurred: %s',
+      this.logger.warn('[egg:application] A client (%s:%d) error [%s] occurred: %s',
         socket.remoteAddress,
         socket.remotePort,
         err.code,
@@ -143,19 +134,19 @@ class Application extends EggApplication {
       // + headers: {}
       // + status: 400
       p.then(ret => {
-        this[RESPONSE_RAW](socket, ret || {});
+        this.#responseRaw(socket, ret || {});
       }).catch(err => {
         this.logger.error(err);
-        this[RESPONSE_RAW](socket);
+        this.#responseRaw(socket);
       });
     } else {
       // because it's a raw socket object, we should return the raw HTTP response
       // packet.
-      this[RESPONSE_RAW](socket);
+      this.#responseRaw(socket);
     }
   }
 
-  onServer(server) {
+  onServer(server: http.Server) {
     // expose app.server
     this.server = server;
     // set ignore code
@@ -164,14 +155,14 @@ class Application extends EggApplication {
     /* istanbul ignore next */
     graceful({
       server: [ server ],
-      error: (err, throwErrorCount) => {
+      error: (err: Error, throwErrorCount: number) => {
         const originMessage = err.message;
         if (originMessage) {
           // shouldjs will override error property but only getter
           // https://github.com/shouldjs/should.js/blob/889e22ebf19a06bc2747d24cf34b25cc00b37464/lib/assertion-error.js#L26
           Object.defineProperty(err, 'message', {
             get() {
-              return originMessage + ' (uncaughtException throw ' + throwErrorCount + ' times on pid:' + process.pid + ')';
+              return `${originMessage} (uncaughtException throw ${throwErrorCount} times on pid: ${process.pid})`;
             },
             configurable: true,
             enumerable: false,
@@ -182,10 +173,12 @@ class Application extends EggApplication {
       ignoreCode: serverGracefulIgnoreCode,
     });
 
-    server.on('clientError', (err, socket) => this.onClientError(err, socket));
+    server.on('clientError', (err, socket) => this.onClientError(err, socket as Socket));
 
     // server timeout
-    if (is.number(this.config.serverTimeout)) server.setTimeout(this.config.serverTimeout);
+    if (typeof this.config.serverTimeout === 'number') {
+      server.setTimeout(this.config.serverTimeout);
+    }
   }
 
   /**
@@ -194,24 +187,11 @@ class Application extends EggApplication {
    * @see Context#locals
    */
   get locals() {
-    if (!this[LOCALS]) {
-      this[LOCALS] = {};
-    }
-    return this[LOCALS];
+    return this.#locals;
   }
 
-  set locals(val) {
-    if (!this[LOCALS]) {
-      this[LOCALS] = {};
-    }
-
-    assign(this[LOCALS], val);
-  }
-
-  handleRequest(ctx, fnMiddleware) {
-    this.emit('request', ctx);
-    onFinished(ctx.res, () => this.emit('response', ctx));
-    return super.handleRequest(ctx, fnMiddleware);
+  set locals(val: Record<string, any>) {
+    assign(this.#locals, val);
   }
 
   /**
@@ -234,11 +214,11 @@ class Application extends EggApplication {
           paramNames: layer.paramNames,
           path: layer.path,
           regexp: layer.regexp.toString(),
-          stack: layer.stack.map(stack => stack[FULLPATH] || stack._name || stack.name || 'anonymous'),
+          stack: layer.stack.map((stack: any) => stack[FULLPATH] || stack._name || stack.name || 'anonymous'),
         });
       }
       fs.writeFileSync(dumpRouterFile, JSON.stringify(routers, null, 2));
-    } catch (err) {
+    } catch (err: any) {
       this.coreLogger.warn(`dumpConfig router.json error: ${err.message}`);
     }
   }
@@ -248,9 +228,11 @@ class Application extends EggApplication {
    * @see Context#runInBackground
    * @param {Function} scope - the first args is an anonymous ctx
    */
-  runInBackground(scope) {
+  runInBackground(scope: (ctx: EggContext) => void) {
     const ctx = this.createAnonymousContext();
-    if (!scope.name) scope._name = eggUtils.getCalleeFromStack(true);
+    if (!scope.name) {
+      Reflect.set(scope, '_name', eggUtils.getCalleeFromStack(true));
+    }
     this.ctxStorage.run(ctx, () => {
       ctx.runInBackground(scope);
     });
@@ -262,11 +244,13 @@ class Application extends EggApplication {
    * @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) {
+  async runInAnonymousContextScope(scope: (ctx: EggContext) => Promise<void>, req?: unknown) {
     const ctx = this.createAnonymousContext(req);
-    if (!scope.name) scope._name = eggUtils.getCalleeFromStack(true);
+    if (!scope.name) {
+      Reflect.set(scope, '_name', eggUtils.getCalleeFromStack(true));
+    }
     return await this.ctxStorage.run(ctx, async () => {
-      return await scope(ctx);
+      return await scope(ctx as EggContext);
     });
   }
 
@@ -275,7 +259,7 @@ class Application extends EggApplication {
    * @member {String} Application#keys
    */
   get keys() {
-    if (!this[KEYS]) {
+    if (!this._keys) {
       if (!this.config.keys) {
         if (this.config.env === 'local' || this.config.env === 'unittest') {
           const configPath = path.join(this.config.baseDir, 'config/config.default.js');
@@ -284,31 +268,9 @@ class Application extends EggApplication {
         }
         throw new Error('Please set config.keys first');
       }
-
-      this[KEYS] = this.config.keys.split(',').map(s => s.trim());
-    }
-    return this[KEYS];
-  }
-
-  set keys(_) {
-    // ignore
-  }
-
-  /**
-   * reference to {@link Helper}
-   * @member {Helper} Application#Helper
-   */
-  get Helper() {
-    if (!this[HELPER]) {
-      /**
-       * The Helper class which can be used as utility function.
-       * We support developers to extend Helper through ${baseDir}/app/extend/helper.js ,
-       * then you can use all method on `ctx.helper` that is a instance of Helper.
-       */
-      class Helper extends this.BaseContextClass {}
-      this[HELPER] = Helper;
+      this._keys = this.config.keys.split(',').map(s => s.trim());
     }
-    return this[HELPER];
+    return this._keys;
   }
 
   /**
@@ -316,17 +278,15 @@ class Application extends EggApplication {
    *
    * @private
    */
-  [BIND_EVENTS]() {
+  #bindEvents() {
     // Browser Cookie Limits: http://browsercookielimits.squawky.net/
     this.on('cookieLimitExceed', ({ name, value, ctx }) => {
       const err = new Error(`cookie ${name}'s length(${value.length}) exceed the limit(4093)`);
       err.name = 'CookieLimitExceedError';
-      err.key = name;
-      err.cookie = value;
       ctx.coreLogger.error(err);
     });
     // expose server to support websocket
-    this.once('server', server => this.onServer(server));
+    this.once('server', (server: http.Server) => this.onServer(server));
   }
 
   /**
@@ -334,15 +294,14 @@ class Application extends EggApplication {
    *
    * @private
    */
-  [WARN_CONFUSED_CONFIG]() {
+  #warnConfusedConfig() {
     const confusedConfigurations = this.config.confusedConfigurations;
     Object.keys(confusedConfigurations).forEach(key => {
       if (this.config[key] !== undefined) {
-        this.logger.warn('Unexpected config key `%s` exists, Please use `%s` instead.',
+        this.logger.warn('[egg:application] Unexpected config key `%o` exists, Please use `%o` instead.',
           key, confusedConfigurations[key]);
       }
     });
   }
 }
 
-module.exports = Application;

package/src/lib/core/base_context_class.ts

@@ -0,0 +1,21 @@
+import { BaseContextClass as EggCoreBaseContextClass } from '@eggjs/core';
+import type { EggContext } from '../egg.js';
+import { BaseContextLogger } from './base_context_logger.js';
+
+/**
+ * BaseContextClass is a base class that can be extended,
+ * it's instantiated in context level,
+ * {@link Helper}, {@link Service} is extending it.
+ */
+export class BaseContextClass extends EggCoreBaseContextClass {
+  declare ctx: EggContext;
+  protected pathName?: string;
+  #logger?: BaseContextLogger;
+
+  get logger() {
+    if (!this.#logger) {
+      this.#logger = new BaseContextLogger(this.ctx, this.pathName);
+    }
+    return this.#logger;
+  }
+}

package/src/lib/core/base_context_logger.ts

@@ -0,0 +1,67 @@
+import type { EggContext } from '../egg.js';
+
+export class BaseContextLogger {
+  readonly #ctx: EggContext;
+  readonly #pathName?: string;
+
+  /**
+   * @class
+   * @param {Context} ctx - context instance
+   * @param {String} pathName - class path name
+   * @since 1.0.0
+   */
+  constructor(ctx: EggContext, pathName?: string) {
+    /**
+     * @member {Context} BaseContextLogger#ctx
+     * @since 1.2.0
+     */
+    this.#ctx = ctx;
+    this.#pathName = pathName;
+  }
+
+  protected _log(method: 'info' | 'warn' | 'error' | 'debug', args: any[]) {
+    // add `[${pathName}]` in log
+    if (this.#pathName && typeof args[0] === 'string') {
+      args[0] = `[${this.#pathName}] ${args[0]}`;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this.#ctx.app.logger[method](...args);
+  }
+
+  /**
+   * @member {Function} BaseContextLogger#debug
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  debug(...args: any[]) {
+    this._log('debug', args);
+  }
+
+  /**
+   * @member {Function} BaseContextLogger#info
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  info(...args: any[]) {
+    this._log('info', args);
+  }
+
+  /**
+   * @member {Function} BaseContextLogger#warn
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  warn(...args: any[]) {
+    this._log('warn', args);
+  }
+
+  /**
+   * @member {Function} BaseContextLogger#error
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  error(...args: any[]) {
+    this._log('error', args);
+  }
+}

package/src/lib/core/base_hook_class.ts

@@ -0,0 +1,30 @@
+import assert from 'node:assert';
+import type { ILifecycleBoot } from '@eggjs/core';
+import type { Application, Agent } from '../../index.js';
+
+export class BaseHookClass implements ILifecycleBoot {
+  fullPath?: string;
+  #instance: Application | Agent;
+
+  constructor(instance: Application | Agent) {
+    this.#instance = instance;
+  }
+
+  get logger() {
+    return this.#instance.logger;
+  }
+
+  get config() {
+    return this.#instance.config;
+  }
+
+  get app() {
+    assert(this.#instance.type === 'application', 'agent boot should not use app instance');
+    return this.#instance as Application;
+  }
+
+  get agent() {
+    assert(this.#instance.type === 'agent', 'app boot should not use agent instance');
+    return this.#instance as Agent;
+  }
+}

package/src/lib/core/context_httpclient.ts

@@ -0,0 +1,33 @@
+import type { EggContext, EggApplicationCore } from '../egg.js';
+import type {
+  HttpClientRequestURL, HttpClientRequestOptions,
+} from './httpclient.js';
+
+export class ContextHttpClient {
+  ctx: EggContext;
+  app: EggApplicationCore;
+
+  constructor(ctx: EggContext) {
+    this.ctx = ctx;
+    this.app = ctx.app;
+  }
+
+  /**
+   * http request helper base on {@link HttpClient}, it will auto save httpclient log.
+   * Keep the same api with {@link Application#curl}.
+   *
+   * @param {String|Object} url - request url address.
+   * @param {Object} [options] - options for request.
+   */
+  async curl<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions) {
+    options = {
+      ...options,
+      ctx: this.ctx,
+    };
+    return await this.app.curl<T>(url, options);
+  }
+
+  async request<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions) {
+    return await this.curl<T>(url, options);
+  }
+}

package/src/lib/core/httpclient.ts

@@ -0,0 +1,52 @@
+import { EggCoreContext } from '@eggjs/core';
+import {
+  HttpClient as RawHttpClient,
+  RequestURL as HttpClientRequestURL,
+  RequestOptions,
+} from 'urllib';
+import ms from 'ms';
+import type { EggApplicationCore } from '../egg.js';
+
+export type {
+  HttpClientResponse,
+  RequestURL as HttpClientRequestURL,
+} from 'urllib';
+
+export interface HttpClientRequestOptions extends RequestOptions {
+  ctx?: EggCoreContext;
+  tracer?: unknown;
+}
+
+export class HttpClient extends RawHttpClient {
+  readonly #app: EggApplicationCore & { tracer?: unknown };
+
+  constructor(app: EggApplicationCore) {
+    normalizeConfig(app);
+    const config = app.config.httpclient;
+    super({
+      defaultArgs: config.request,
+    });
+    this.#app = app;
+  }
+
+  async request<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions) {
+    options = options ?? {};
+    if (options.ctx?.tracer) {
+      options.tracer = options.ctx.tracer;
+    } else {
+      options.tracer = options.tracer ?? this.#app.tracer;
+    }
+    return await super.request<T>(url, options);
+  }
+
+  async curl<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions) {
+    return await this.request<T>(url, options);
+  }
+}
+
+function normalizeConfig(app: EggApplicationCore) {
+  const config = app.config.httpclient;
+  if (typeof config.request?.timeout === 'string') {
+    config.request.timeout = ms(config.request.timeout as string);
+  }
+}

package/src/lib/core/logger.ts

@@ -0,0 +1,42 @@
+import { EggLoggers, EggLoggersOptions } from 'egg-logger';
+import { setCustomLogger } from 'onelogger';
+import type { EggApplicationCore } from '../egg.js';
+
+export function createLoggers(app: EggApplicationCore) {
+  const loggerOptions = {
+    ...app.config.logger,
+    type: app.type,
+    localStorage: app.ctxStorage,
+  } as EggLoggersOptions;
+
+  // set DEBUG level into INFO on prod env
+  if (app.config.env === 'prod' && loggerOptions.level === 'DEBUG' && !app.config.logger.allowDebugAtProd) {
+    loggerOptions.level = 'INFO';
+  }
+
+  const loggers = new EggLoggers({
+    logger: loggerOptions,
+    customLogger: app.config.customLogger,
+  });
+
+  // won't print to console after started, except for local and unittest
+  app.ready(() => {
+    if (app.config.logger.disableConsoleAfterReady) {
+      loggers.disableConsole();
+      loggers.coreLogger.info('[egg:lib:core:logger] disable console log after app ready');
+    }
+  });
+
+  // set global logger
+  for (const loggerName of Object.keys(loggers)) {
+    setCustomLogger(loggerName, loggers[loggerName]);
+  }
+  // reset global logger on beforeClose hook
+  app.lifecycle.registerBeforeClose(() => {
+    for (const loggerName of Object.keys(loggers)) {
+      setCustomLogger(loggerName, undefined);
+    }
+  });
+  loggers.coreLogger.info('[egg:lib:core:logger] init all loggers with options: %j', loggerOptions);
+  return loggers;
+}

package/src/lib/core/messenger/IMessenger.ts

@@ -0,0 +1,58 @@
+import type { EventEmitter } from 'node:events';
+
+export interface IMessenger extends EventEmitter {
+  /**
+   * Send message to all agent and app
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  broadcast(action: string, data?: unknown): IMessenger;
+
+  /**
+   * send message to the specified process
+   * @param {String} pid - the process id of the receiver
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  sendTo(pid: string, action: string, data?: unknown): IMessenger;
+
+  /**
+   * 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: string, data?: unknown): IMessenger;
+
+  /**
+   * send message to app
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  sendToApp(action: string, data?: unknown): IMessenger;
+
+  /**
+   * send message to agent
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  sendToAgent(action: string, data?: unknown): IMessenger;
+
+  /**
+   * @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: string, data: unknown | undefined, to: string): IMessenger;
+
+  close(): void;
+
+  onMessage(message: any): void;
+}

package/src/lib/core/messenger/index.ts

@@ -0,0 +1,15 @@
+import { Messenger as LocalMessenger } from './local.js';
+import { Messenger as IPCMessenger } from './ipc.js';
+import type { IMessenger } from './IMessenger.js';
+import type { EggApplicationCore } from '../../egg.js';
+
+export type { IMessenger } from './IMessenger.js';
+
+/**
+ * @class Messenger
+ */
+export function create(egg: EggApplicationCore): IMessenger {
+  return egg.options.mode === 'single'
+    ? new LocalMessenger(egg)
+    : new IPCMessenger();
+}