egg 4.0.10 → 4.1.0-beta.10

package/dist/lib/core/messenger/base.d.ts

@@ -0,0 +1,12 @@
+import { EggApplicationCore } from "../../egg.js";
+import { EventEmitter, captureRejectionSymbol } from "node:events";
+
+//#region src/lib/core/messenger/base.d.ts
+declare class BaseMessenger extends EventEmitter {
+  protected readonly egg: EggApplicationCore;
+  constructor(egg: EggApplicationCore);
+  [captureRejectionSymbol](err: Error, event: string | symbol, ...args: any[]): void;
+  emit(eventName: string | symbol, ...args: any[]): boolean;
+}
+//#endregion
+export { BaseMessenger };

package/dist/lib/core/messenger/base.js

@@ -0,0 +1,29 @@
+import { MessageUnhandledRejectionError } from "../../error/MessageUnhandledRejectionError.js";
+import "../../egg.js";
+import { EventEmitter, captureRejectionSymbol } from "node:events";
+
+//#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
+export { BaseMessenger };

package/dist/lib/core/messenger/index.d.ts

@@ -0,0 +1,11 @@
+import { IMessenger } from "./IMessenger.js";
+import { EggApplicationCore } from "../../egg.js";
+
+//#region src/lib/core/messenger/index.d.ts
+
+/**
+ * @class Messenger
+ */
+declare function create(egg: EggApplicationCore): IMessenger;
+//#endregion
+export { type IMessenger, create };

package/dist/lib/core/messenger/index.js

@@ -0,0 +1,13 @@
+import { Messenger } from "./local.js";
+import { Messenger as Messenger$1 } from "./ipc.js";
+
+//#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
+export { create };

package/dist/lib/core/messenger/ipc.d.ts

@@ -0,0 +1,63 @@
+import { IMessenger } from "./IMessenger.js";
+import { EggApplicationCore } from "../../egg.js";
+import { BaseMessenger } from "./base.js";
+
+//#region src/lib/core/messenger/ipc.d.ts
+
+/**
+ * Communication between app worker and agent worker by IPC channel
+ */
+declare class Messenger extends BaseMessenger implements IMessenger {
+  readonly pid: string;
+  opids: string[];
+  constructor(egg: EggApplicationCore);
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * send message to app
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  sendToApp(action: string, data?: unknown): Messenger;
+  /**
+   * send message to agent
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  sendToAgent(action: string, data?: unknown): Messenger;
+  /**
+   * @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;
+  onMessage(message: any): void;
+  close(): void;
+}
+//#endregion
+export { Messenger };

package/dist/lib/core/messenger/ipc.js

@@ -0,0 +1,122 @@
+import { BaseMessenger } from "./base.js";
+import { debuglog } from "node:util";
+import workerThreads from "node:worker_threads";
+import { sendmessage } from "sendmessage";
+
+//#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 = 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);
+		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);
+		sendmessage(process, {
+			action,
+			data,
+			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, 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) {
+		sendmessage(process, {
+			action,
+			data,
+			to
+		});
+		return this;
+	}
+	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
+export { Messenger };

package/dist/lib/core/messenger/local.d.ts

@@ -0,0 +1,65 @@
+import { IMessenger } from "./IMessenger.js";
+import { EggApplicationCore } from "../../egg.js";
+import { BaseMessenger } from "./base.js";
+
+//#region src/lib/core/messenger/local.d.ts
+
+/**
+ * Communication between app worker and agent worker with EventEmitter
+ */
+declare class Messenger extends BaseMessenger implements IMessenger {
+  readonly pid: string;
+  constructor(egg: EggApplicationCore);
+  /**
+   * 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;
+  /**
+   * 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: string, action: string, data?: unknown): Messenger;
+  /**
+   * 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: string, data?: unknown): Messenger;
+  /**
+   * send message to app
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  sendToApp(action: string, data?: unknown): Messenger;
+  /**
+   * send message to agent
+   * @param {String} action - message key
+   * @param {Object} data - message value
+   * @return {Messenger} this
+   */
+  sendToAgent(action: string, data?: unknown): Messenger;
+  /**
+   * @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, to?: string): Messenger;
+  onMessage(message: any): void;
+  close(): void;
+}
+//#endregion
+export { Messenger };

package/dist/lib/core/messenger/local.js

@@ -0,0 +1,126 @@
+import { BaseMessenger } from "./base.js";
+import { debuglog } from "node:util";
+
+//#region src/lib/core/messenger/local.ts
+const debug = 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("[%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("[%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("[%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("[%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("[%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("[%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);
+	}
+	close() {
+		this.removeAllListeners();
+	}
+};
+
+//#endregion
+export { Messenger };

package/dist/lib/core/utils.d.ts

@@ -0,0 +1,5 @@
+//#region src/lib/core/utils.d.ts
+declare function convertObject(obj: any, ignore?: string | RegExp | (string | RegExp)[]): any;
+declare function safeParseURL(url: string): URL | null;
+//#endregion
+export { convertObject, safeParseURL };

package/dist/lib/core/utils.js

@@ -0,0 +1,48 @@
+import util from "node:util";
+import { isAsyncFunction, isClass, isFunction, isGeneratorFunction, isPrimitive, isRegExp, isSymbol } from "is-type-of";
+
+//#region src/lib/core/utils.ts
+function convertObject(obj, ignore = []) {
+	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, value, ignore) {
+	if (value === null || value === void 0) 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) || value instanceof URL) return value.toString();
+		if (isPrimitive(value) || Array.isArray(value)) return value;
+	}
+	if (Object.getPrototypeOf(value) === Object.prototype) return convertObject(value, ignore);
+	const name = value.name || "anonymous";
+	if (isClass(value)) return `<Class ${name}>`;
+	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);
+}
+function safeParseURL(url) {
+	try {
+		return new URL(url);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { convertObject, safeParseURL };