egg 3.29.0 → 4.0.0-beta.10

package/src/lib/core/httpclient.ts

@@ -0,0 +1,51 @@
+import {
+  HttpClient as RawHttpClient,
+  RequestURL as HttpClientRequestURL,
+  RequestOptions,
+} from 'urllib';
+import { ms } from 'humanize-ms';
+import type { EggApplicationCore, ContextDelegation } from '../egg.js';
+
+export type {
+  HttpClientResponse,
+  RequestURL as HttpClientRequestURL,
+} from 'urllib';
+
+export interface HttpClientRequestOptions extends RequestOptions {
+  ctx?: ContextDelegation;
+  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);
+  }
+}

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} workerId - the workerId of the receiver
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  sendTo(workerId: 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(egg);
+}

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

@@ -0,0 +1,148 @@
+import { EventEmitter } from 'node:events';
+import { debuglog } from 'node:util';
+import workerThreads from 'node:worker_threads';
+import { sendmessage } from 'sendmessage';
+import type { IMessenger } from './IMessenger.js';
+import type { EggApplicationCore } from '../../egg.js';
+
+const debug = debuglog('egg/lib/core/messenger/ipc');
+
+/**
+ * Communication between app worker and agent worker by IPC channel
+ */
+export class Messenger extends EventEmitter implements IMessenger {
+  readonly pid: string;
+  readonly egg: EggApplicationCore;
+  opids: string[] = [];
+
+  constructor(egg: EggApplicationCore) {
+    super();
+    this.pid = String(process.pid);
+    this.egg = egg;
+    // pids of agent or app managed by master
+    // - retrieve app worker pids when it's an agent worker
+    // - retrieve agent worker pids when it's an app worker
+    this.on('egg-pids', workerIds => {
+      debug('[%s:%s] got egg-pids %j', this.egg.type, this.pid, workerIds);
+      this.opids = workerIds.map((workerId: number) => String(workerId));
+    });
+    this.onMessage = this.onMessage.bind(this);
+    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: string, data?: unknown): Messenger {
+    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: string, action: string, data?: unknown): Messenger {
+    debug('[%s:%s] send %s with %j to workerId:%s', this.egg.type, this.pid, action, data, workerId);
+    sendmessage(process, {
+      action,
+      data,
+      /**
+       * @deprecated Keep compatible, please use receiverWorkerId instead
+       */
+      receiverPid: String(workerId),
+      receiverWorkerId: String(workerId),
+    });
+    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: string, data?: unknown): Messenger {
+    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: string, data?: unknown): Messenger {
+    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: string, data?: unknown): Messenger {
+    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: string, data: unknown | undefined, to?: string): Messenger {
+    sendmessage(process, {
+      action,
+      data,
+      to,
+    });
+    return this;
+  }
+
+  onMessage(message: any) {
+    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 {
+      debug('[%s:%s] got an invalid message %j', this.egg.type, this.pid, message);
+    }
+  }
+
+  close() {
+    process.removeListener('message', this.onMessage);
+    this.removeAllListeners();
+  }
+
+  /**
+   * @function Messenger#on
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   */
+}

package/{lib/core/messenger/local.js → src/lib/core/messenger/local.ts}

@@ -1,17 +1,21 @@
-'use strict';
+import { debuglog } from 'node:util';
+import EventEmitter from 'node:events';
+import type { IMessenger } from './IMessenger.js';
+import type { EggApplicationCore } from '../../egg.js';
 
-const debug = require('util').debuglog('egg:util:messenger:local');
-const is = require('is-type-of');
-const EventEmitter = require('events');
+const debug = debuglog('egg/lib/core/messenger/local');
 
 /**
  * Communication between app worker and agent worker with EventEmitter
  */
-class Messenger extends EventEmitter {
+export class Messenger extends EventEmitter implements IMessenger {
+  readonly pid: string;
+  readonly egg: EggApplicationCore;
 
-  constructor(egg) {
+  constructor(egg: EggApplicationCore) {
     super();
     this.egg = egg;
+    this.pid = String(process.pid);
   }
 
   /**
@@ -20,8 +24,8 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  broadcast(action, data) {
-    debug('[%s] broadcast %s with %j', this.pid, action, data);
+  broadcast(action: string, data?: unknown): Messenger {
+    debug('[%s:%s] broadcast %s with %j', this.egg.type, this.pid, action, data);
     this.send(action, data, 'both');
     return this;
   }
@@ -30,14 +34,16 @@ class Messenger extends EventEmitter {
    * 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} pid - the process id of the receiver
+   * @param {String} workerId - the workerId of the receiver
    * @param {String} action - message key
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendTo(pid, action, data) {
-    debug('[%s] send %s with %j to %s', this.pid, action, data, pid);
-    if (pid !== process.pid) return this;
+  sendTo(workerId: string, action: string, data?: unknown): Messenger {
+    debug('[%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;
   }
@@ -51,8 +57,8 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendRandom(action, data) {
-    debug('[%s] send %s with %j to opposite', this.pid, action, data);
+  sendRandom(action: string, data?: unknown): Messenger {
+    debug('[%s:%s] send %s with %j to opposite', this.egg.type, this.pid, action, data);
     this.send(action, data, 'opposite');
     return this;
   }
@@ -63,8 +69,8 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendToApp(action, data) {
-    debug('[%s] send %s with %j to all app', this.pid, action, data);
+  sendToApp(action: string, data?: unknown): Messenger {
+    debug('[%s:%s] send %s with %j to all app', this.egg.type, this.pid, action, data);
     this.send(action, data, 'application');
     return this;
   }
@@ -75,8 +81,8 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendToAgent(action, data) {
-    debug('[%s] send %s with %j to all agent', this.pid, action, data);
+  sendToAgent(action: string, data?: unknown): Messenger {
+    debug('[%s:%s] send %s with %j to all agent', this.egg.type, this.pid, action, data);
     this.send(action, data, 'agent');
     return this;
   }
@@ -87,7 +93,7 @@ class Messenger extends EventEmitter {
    * @param {String} to - let master know how to send message
    * @return {Messenger} this
    */
-  send(action, data, to) {
+  send(action: string, data: unknown | undefined, to?: string): Messenger {
     // use nextTick to keep it async as IPC messenger
     process.nextTick(() => {
       const { egg } = this;
@@ -104,26 +110,30 @@ class Messenger extends EventEmitter {
         application = egg.application;
         opposite = application;
       }
-      if (!to) to = egg.type === 'application' ? 'agent' : 'application';
+      if (!to) {
+        to = egg.type === 'application' ? 'agent' : 'application';
+      }
 
       if (application && application.messenger && (to === 'application' || to === 'both')) {
-        application.messenger._onMessage({ action, data });
+        application.messenger.onMessage({ action, data });
       }
       if (agent && agent.messenger && (to === 'agent' || to === 'both')) {
-        agent.messenger._onMessage({ action, data });
+        agent.messenger.onMessage({ action, data });
       }
       if (opposite && opposite.messenger && to === 'opposite') {
-        opposite.messenger._onMessage({ action, data });
+        opposite.messenger.onMessage({ action, data });
       }
     });
 
     return this;
   }
 
-  _onMessage(message) {
-    if (message && is.string(message.action)) {
-      debug('[%s] got message %s with %j', this.pid, message.action, message.data);
+  onMessage(message: any) {
+    if (typeof message?.action === 'string') {
+      debug('[%s:%s] got message %s with %j', this.egg.type, this.pid, message.action, message.data);
       this.emit(message.action, message.data);
+    } else {
+      debug('[%s:%s] got an invalid message %j', this.egg.type, this.pid, message);
     }
   }
 
@@ -137,5 +147,3 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    */
 }
-
-module.exports = Messenger;

package/{lib/core/singleton.js → src/lib/core/singleton.ts}

@@ -1,36 +1,48 @@
-'use strict';
+import assert from 'node:assert';
+import { isAsyncFunction } from 'is-type-of';
+import type { EggApplicationCore } from '../egg.js';
 
-const assert = require('assert');
-const is = require('is-type-of');
+export type SingletonCreateMethod =
+  (config: Record<string, any>, app: EggApplicationCore, clientName: string) => unknown | Promise<unknown>;
 
-class Singleton {
-  constructor(options = {}) {
+export interface SingletonOptions {
+  name: string;
+  app: EggApplicationCore;
+  create: SingletonCreateMethod;
+}
+
+export class Singleton {
+  readonly clients = new Map<string, any>();
+  readonly app: EggApplicationCore;
+  readonly create: SingletonCreateMethod;
+  readonly name: string;
+  readonly options: Record<string, any>;
+
+  constructor(options: SingletonOptions) {
     assert(options.name, '[egg:singleton] Singleton#constructor options.name is required');
     assert(options.app, '[egg:singleton] Singleton#constructor options.app is required');
     assert(options.create, '[egg:singleton] Singleton#constructor options.create is required');
-    assert(!options.app[options.name], `${options.name} is already exists in app`);
-    this.clients = new Map();
+    assert(!(options.name in options.app), `[egg:singleton] ${options.name} is already exists in app`);
     this.app = options.app;
     this.name = options.name;
     this.create = options.create;
-    /* istanbul ignore next */
-    this.options = options.app.config[this.name] || {};
+    this.options = options.app.config[this.name] ?? {};
   }
 
   init() {
-    return is.asyncFunction(this.create) ? this.initAsync() : this.initSync();
+    return isAsyncFunction(this.create) ? this.initAsync() : this.initSync();
   }
 
   initSync() {
     const options = this.options;
     assert(!(options.client && options.clients),
-      `egg:singleton ${this.name} can not set options.client and options.clients both`);
+      `[egg:singleton] ${this.name} can not set options.client and options.clients both`);
 
     // alias app[name] as client, but still support createInstance method
     if (options.client) {
       const client = this.createInstance(options.client, options.name);
-      this.app[this.name] = client;
-      this._extendDynamicMethods(client);
+      this.#setClientToApp(client);
+      this.#extendDynamicMethods(client);
       return;
     }
 
@@ -40,66 +52,76 @@ class Singleton {
         const client = this.createInstance(options.clients[id], id);
         this.clients.set(id, client);
       });
-      this.app[this.name] = this;
+      this.#setClientToApp(this);
       return;
     }
 
     // no config.clients and config.client
-    this.app[this.name] = this;
+    this.#setClientToApp(this);
   }
 
   async initAsync() {
     const options = this.options;
     assert(!(options.client && options.clients),
-      `egg:singleton ${this.name} can not set options.client and options.clients both`);
+      `[egg:singleton] ${this.name} can not set options.client and options.clients both`);
 
     // alias app[name] as client, but still support createInstance method
     if (options.client) {
       const client = await this.createInstanceAsync(options.client, options.name);
-      this.app[this.name] = client;
-      this._extendDynamicMethods(client);
+      this.#setClientToApp(client);
+      this.#extendDynamicMethods(client);
       return;
     }
 
     // multi client, use app[name].getInstance(id)
     if (options.clients) {
-      await Promise.all(Object.keys(options.clients).map(id => {
+      await Promise.all(Object.keys(options.clients).map((id: string) => {
         return this.createInstanceAsync(options.clients[id], id)
           .then(client => this.clients.set(id, client));
       }));
-      this.app[this.name] = this;
+      this.#setClientToApp(this);
       return;
     }
 
     // no config.clients and config.client
-    this.app[this.name] = this;
+    this.#setClientToApp(this);
   }
 
-  get(id) {
+  #setClientToApp(client: unknown) {
+    Reflect.set(this.app, this.name, client);
+  }
+
+  get(id: string) {
     return this.clients.get(id);
   }
 
   // alias to `get(id)`
-  getSingletonInstance(id) {
+  getSingletonInstance(id: string) {
     return this.clients.get(id);
   }
 
-  createInstance(config, clientName) {
+  createInstance(config: Record<string, any>, clientName: string) {
     // async creator only support createInstanceAsync
-    assert(!is.asyncFunction(this.create),
+    assert(!isAsyncFunction(this.create),
       `egg:singleton ${this.name} only support create asynchronous, please use createInstanceAsync`);
     // options.default will be merge in to options.clients[id]
-    config = Object.assign({}, this.options.default, config);
-    return this.create(config, this.app, clientName);
+    config = {
+      ...this.options.default,
+      ...config,
+    };
+    return (this.create as SingletonCreateMethod)(config, this.app, clientName);
   }
 
-  async createInstanceAsync(config, clientName) {
+  async createInstanceAsync(config: Record<string, any>, clientName: string) {
     // options.default will be merge in to options.clients[id]
-    config = Object.assign({}, this.options.default, config);
+    config = {
+      ...this.options.default,
+      ...config,
+    };
     return await this.create(config, this.app, clientName);
   }
 
-  _extendDynamicMethods(client) {
+  #extendDynamicMethods(client: any) {
     assert(!client.createInstance, 'singleton instance should not have createInstance method');
     assert(!client.createInstanceAsync, 'singleton instance should not have createInstanceAsync method');
 
@@ -113,9 +135,10 @@ class Singleton {
       extendable.createInstance = this.createInstance.bind(this);
       extendable.createInstanceAsync = this.createInstanceAsync.bind(this);
     } catch (err) {
-      this.app.logger.warn('egg:singleton %s dynamic create is disabled because of client is unextensible', this.name);
+      this.app.coreLogger.warn(
+        '[egg:singleton] %s dynamic create is disabled because of client is un-extendable',
+        this.name);
+      this.app.coreLogger.warn(err);
     }
   }
 }
-
-module.exports = Singleton;