egg 3.26.0 → 4.0.0-beta.0

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

@@ -1,15 +1,18 @@
-'use strict';
 
-const debug = require('util').debuglog('egg:util:messenger:ipc');
-const is = require('is-type-of');
-const workerThreads = require('worker_threads');
-const sendmessage = require('sendmessage');
-const EventEmitter = require('events');
+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';
+
+const debug = debuglog('egg:lib:core:messenger:ipc');
 
 /**
  * Communication between app worker and agent worker by IPC channel
  */
-class Messenger extends EventEmitter {
+export class Messenger extends EventEmitter implements IMessenger {
+  readonly pid: string;
+  opids: string[] = [];
 
   constructor() {
     super();
@@ -17,14 +20,13 @@ class Messenger extends EventEmitter {
     // 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.opids = [];
     this.on('egg-pids', pids => {
       this.opids = pids;
     });
-    this._onMessage = this._onMessage.bind(this);
-    process.on('message', this._onMessage);
+    this.onMessage = this.onMessage.bind(this);
+    process.on('message', this.onMessage);
     if (!workerThreads.isMainThread) {
-      workerThreads.parentPort.on('message', this._onMessage);
+      workerThreads.parentPort!.on('message', this.onMessage);
     }
   }
 
@@ -34,7 +36,7 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  broadcast(action, data) {
+  broadcast(action: string, data?: unknown): Messenger {
     debug('[%s] broadcast %s with %j', this.pid, action, data);
     this.send(action, data, 'app');
     this.send(action, data, 'agent');
@@ -48,7 +50,7 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendTo(pid, action, data) {
+  sendTo(pid: string, action: string, data?: unknown): Messenger {
     debug('[%s] send %s with %j to %s', this.pid, action, data, pid);
     sendmessage(process, {
       action,
@@ -66,10 +68,11 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendRandom(action, data) {
+  sendRandom(action: string, data?: unknown): Messenger {
     /* istanbul ignore if */
-    if (!this.opids.length) return this;
-    const pid = random(this.opids);
+    if (this.opids.length === 0) return this;
+    const index = Math.floor(Math.random() * this.opids.length);
+    const pid = this.opids[index];
     this.sendTo(String(pid), action, data);
     return this;
   }
@@ -80,7 +83,7 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendToApp(action, data) {
+  sendToApp(action: string, data?: unknown): Messenger {
     debug('[%s] send %s with %j to all app', this.pid, action, data);
     this.send(action, data, 'app');
     return this;
@@ -92,7 +95,7 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendToAgent(action, data) {
+  sendToAgent(action: string, data?: unknown): Messenger {
     debug('[%s] send %s with %j to all agent', this.pid, action, data);
     this.send(action, data, 'agent');
     return this;
@@ -104,7 +107,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 {
     sendmessage(process, {
       action,
       data,
@@ -113,8 +116,8 @@ class Messenger extends EventEmitter {
     return this;
   }
 
-  _onMessage(message) {
-    if (message && is.string(message.action)) {
+  onMessage(message: any) {
+    if (typeof message?.action === 'string') {
       debug('[%s] got message %s with %j, receiverPid: %s',
         this.pid, message.action, message.data, message.receiverPid);
       this.emit(message.action, message.data);
@@ -122,7 +125,7 @@ class Messenger extends EventEmitter {
   }
 
   close() {
-    process.removeListener('message', this._onMessage);
+    process.removeListener('message', this.onMessage);
     this.removeAllListeners();
   }
 
@@ -132,10 +135,3 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    */
 }
-
-module.exports = Messenger;
-
-function random(arr) {
-  const index = Math.floor(Math.random() * arr.length);
-  return arr[index];
-}

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,7 +24,7 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  broadcast(action, data) {
+  broadcast(action: string, data?: unknown): Messenger {
     debug('[%s] broadcast %s with %j', this.pid, action, data);
     this.send(action, data, 'both');
     return this;
@@ -35,9 +39,11 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendTo(pid, action, data) {
+  sendTo(pid: string, action: string, data?: unknown): Messenger {
     debug('[%s] send %s with %j to %s', this.pid, action, data, pid);
-    if (pid !== process.pid) return this;
+    if (String(pid) !== this.pid) {
+      return this;
+    }
     this.send(action, data, 'both');
     return this;
   }
@@ -51,7 +57,7 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendRandom(action, data) {
+  sendRandom(action: string, data?: unknown): Messenger {
     debug('[%s] send %s with %j to opposite', this.pid, action, data);
     this.send(action, data, 'opposite');
     return this;
@@ -63,7 +69,7 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendToApp(action, data) {
+  sendToApp(action: string, data?: unknown): Messenger {
     debug('[%s] send %s with %j to all app', this.pid, action, data);
     this.send(action, data, 'application');
     return this;
@@ -75,7 +81,7 @@ class Messenger extends EventEmitter {
    * @param {Object} data - message value
    * @return {Messenger} this
    */
-  sendToAgent(action, data) {
+  sendToAgent(action: string, data?: unknown): Messenger {
     debug('[%s] send %s with %j to all agent', 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,24 +110,26 @@ 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)) {
+  onMessage(message: any) {
+    if (typeof message?.action === 'string') {
       debug('[%s] got message %s with %j', this.pid, message.action, message.data);
       this.emit(message.action, message.data);
     }
@@ -137,5 +145,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;

package/src/lib/core/utils.ts

@@ -0,0 +1,77 @@
+import util from 'node:util';
+import {
+  isSymbol, isRegExp, isPrimitive,
+  isClass, isFunction, isGeneratorFunction, isAsyncFunction,
+} from 'is-type-of';
+
+export function convertObject(obj: any, ignore: string | RegExp | (string | RegExp)[]) {
+  if (!Array.isArray(ignore)) {
+    ignore = [ ignore ];
+  }
+  for (const key of Object.keys(obj)) {
+    obj[key] = convertValue(key, obj[key], ignore);
+  }
+  return obj;
+}
+
+function convertValue(key: string, value: any, ignore: (string | RegExp)[]) {
+  if (value === null || value === undefined) {
+    return value;
+  }
+
+  let hit = false;
+  for (const matchKey of ignore) {
+    if (typeof matchKey === 'string' && matchKey === key) {
+      hit = true;
+      break;
+    } else if (isRegExp(matchKey) && matchKey.test(key)) {
+      hit = true;
+      break;
+    }
+  }
+  if (!hit) {
+    if (isSymbol(value) || isRegExp(value)) {
+      return value.toString();
+    }
+    if (isPrimitive(value) || Array.isArray(value)) {
+      return value;
+    }
+  }
+
+  // only convert recursively when it's a plain object,
+  // o = {}
+  if (Object.getPrototypeOf(value) === Object.prototype) {
+    return convertObject(value, ignore);
+  }
+
+  // support class
+  const name = value.name || 'anonymous';
+  if (isClass(value)) {
+    return `<Class ${name}>`;
+  }
+
+  // support generator function
+  if (isFunction(value)) {
+    if (isGeneratorFunction(value)) return `<GeneratorFunction ${name}>`;
+    if (isAsyncFunction(value)) return `<AsyncFunction ${name}>`;
+    return `<Function ${name}>`;
+  }
+
+  const typeName = value.constructor.name;
+  if (typeName) {
+    if (Buffer.isBuffer(value) || typeof value === 'string') {
+      return `<${typeName} len: ${value.length}>`;
+    }
+    return `<${typeName}>`;
+  }
+
+  return util.format(value);
+}
+
+export function safeParseURL(url: string) {
+  try {
+    return new URL(url);
+  } catch {
+    return null;
+  }
+}