egg 3.26.1 → 4.0.0-beta.0

package/dist/commonjs/lib/core/messenger/IMessenger.d.ts

@@ -0,0 +1,50 @@
+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/dist/commonjs/lib/core/messenger/IMessenger.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSU1lc3Nlbmdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9tZXNzZW5nZXIvSU1lc3Nlbmdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

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

@@ -0,0 +1,7 @@
+import type { IMessenger } from './IMessenger.js';
+import type { EggApplicationCore } from '../../egg.js';
+export type { IMessenger } from './IMessenger.js';
+/**
+ * @class Messenger
+ */
+export declare function create(egg: EggApplicationCore): IMessenger;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+const local_js_1 = require("./local.js");
+const ipc_js_1 = require("./ipc.js");
+/**
+ * @class Messenger
+ */
+function create(egg) {
+    return egg.options.mode === 'single'
+        ? new local_js_1.Messenger(egg)
+        : new ipc_js_1.Messenger();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvbWVzc2VuZ2VyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBVUEsd0JBSUM7QUFkRCx5Q0FBeUQ7QUFDekQscUNBQXFEO0FBTXJEOztHQUVHO0FBQ0gsU0FBZ0IsTUFBTSxDQUFDLEdBQXVCO0lBQzVDLE9BQU8sR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEtBQUssUUFBUTtRQUNsQyxDQUFDLENBQUMsSUFBSSxvQkFBYyxDQUFDLEdBQUcsQ0FBQztRQUN6QixDQUFDLENBQUMsSUFBSSxrQkFBWSxFQUFFLENBQUM7QUFDekIsQ0FBQyJ9

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

@@ -0,0 +1,57 @@
+import { EventEmitter } from 'node:events';
+import type { IMessenger } from './IMessenger.js';
+/**
+ * Communication between app worker and agent worker by IPC channel
+ */
+export declare class Messenger extends EventEmitter implements IMessenger {
+    readonly pid: string;
+    opids: string[];
+    constructor();
+    /**
+     * 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} 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): 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;
+}

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

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Messenger = void 0;
+const node_events_1 = require("node:events");
+const node_util_1 = require("node:util");
+const node_worker_threads_1 = __importDefault(require("node:worker_threads"));
+const sendmessage_1 = __importDefault(require("sendmessage"));
+const debug = (0, node_util_1.debuglog)('egg:lib:core:messenger:ipc');
+/**
+ * Communication between app worker and agent worker by IPC channel
+ */
+class Messenger extends node_events_1.EventEmitter {
+    pid;
+    opids = [];
+    constructor() {
+        super();
+        this.pid = String(process.pid);
+        // 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', pids => {
+            this.opids = pids;
+        });
+        this.onMessage = this.onMessage.bind(this);
+        process.on('message', this.onMessage);
+        if (!node_worker_threads_1.default.isMainThread) {
+            node_worker_threads_1.default.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] broadcast %s with %j', this.pid, action, data);
+        this.send(action, data, 'app');
+        this.send(action, data, 'agent');
+        return this;
+    }
+    /**
+     * 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, action, data) {
+        debug('[%s] send %s with %j to %s', this.pid, action, data, pid);
+        (0, sendmessage_1.default)(process, {
+            action,
+            data,
+            receiverPid: String(pid),
+        });
+        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) {
+        /* istanbul ignore if */
+        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;
+    }
+    /**
+     * send message to app
+     * @param {String} action - message key
+     * @param {Object} data - message value
+     * @return {Messenger} this
+     */
+    sendToApp(action, data) {
+        debug('[%s] send %s with %j to all app', 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] send %s with %j to all agent', 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) {
+        (0, sendmessage_1.default)(process, {
+            action,
+            data,
+            to,
+        });
+        return this;
+    }
+    onMessage(message) {
+        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);
+        }
+    }
+    close() {
+        process.removeListener('message', this.onMessage);
+        this.removeAllListeners();
+    }
+}
+exports.Messenger = Messenger;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,61 @@
+import EventEmitter from 'node:events';
+import type { IMessenger } from './IMessenger.js';
+import type { EggApplicationCore } from '../../egg.js';
+/**
+ * Communication between app worker and agent worker with EventEmitter
+ */
+export declare class Messenger extends EventEmitter implements IMessenger {
+    readonly pid: string;
+    readonly egg: EggApplicationCore;
+    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} 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): 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 | undefined, to: string): Messenger;
+    onMessage(message: any): void;
+    close(): void;
+}

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

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Messenger = void 0;
+const node_util_1 = require("node:util");
+const node_events_1 = __importDefault(require("node:events"));
+const debug = (0, node_util_1.debuglog)('egg:lib:core:messenger:local');
+/**
+ * Communication between app worker and agent worker with EventEmitter
+ */
+class Messenger extends node_events_1.default {
+    pid;
+    egg;
+    constructor(egg) {
+        super();
+        this.egg = 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] broadcast %s with %j', 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} pid - the process id 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 (String(pid) !== 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] send %s with %j to opposite', 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] send %s with %j to all app', 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] send %s with %j to all agent', 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) {
+        // use nextTick to keep it async as IPC messenger
+        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] got message %s with %j', this.pid, message.action, message.data);
+            this.emit(message.action, message.data);
+        }
+    }
+    close() {
+        this.removeAllListeners();
+    }
+}
+exports.Messenger = Messenger;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commonjs/lib/core/singleton.d.ts

@@ -0,0 +1,23 @@
+import type { EggApplicationCore } from '../egg.js';
+export type SingletonCreateMethod = (config: Record<string, any>, app: EggApplicationCore, clientName: string) => unknown | Promise<unknown>;
+export interface SingletonOptions {
+    name: string;
+    app: EggApplicationCore;
+    create: SingletonCreateMethod;
+}
+export declare class Singleton {
+    #private;
+    readonly clients: Map<string, any>;
+    readonly app: EggApplicationCore;
+    readonly create: SingletonCreateMethod;
+    readonly name: string;
+    readonly options: Record<string, any>;
+    constructor(options: SingletonOptions);
+    init(): void | Promise<void>;
+    initSync(): void;
+    initAsync(): Promise<void>;
+    get(id: string): any;
+    getSingletonInstance(id: string): any;
+    createInstance(config: Record<string, any>, clientName: string): unknown;
+    createInstanceAsync(config: Record<string, any>, clientName: string): Promise<unknown>;
+}

package/dist/commonjs/lib/core/singleton.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Singleton = void 0;
+const node_assert_1 = __importDefault(require("node:assert"));
+const is_type_of_1 = require("is-type-of");
+class Singleton {
+    clients = new Map();
+    app;
+    create;
+    name;
+    options;
+    constructor(options) {
+        (0, node_assert_1.default)(options.name, '[egg:singleton] Singleton#constructor options.name is required');
+        (0, node_assert_1.default)(options.app, '[egg:singleton] Singleton#constructor options.app is required');
+        (0, node_assert_1.default)(options.create, '[egg:singleton] Singleton#constructor options.create is required');
+        (0, node_assert_1.default)(!(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;
+        this.options = options.app.config[this.name] ?? {};
+    }
+    init() {
+        return (0, is_type_of_1.isAsyncFunction)(this.create) ? this.initAsync() : this.initSync();
+    }
+    initSync() {
+        const options = this.options;
+        (0, node_assert_1.default)(!(options.client && options.clients), `[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.#setClientToApp(client);
+            this.#extendDynamicMethods(client);
+            return;
+        }
+        // multi client, use app[name].getInstance(id)
+        if (options.clients) {
+            Object.keys(options.clients).forEach(id => {
+                const client = this.createInstance(options.clients[id], id);
+                this.clients.set(id, client);
+            });
+            this.#setClientToApp(this);
+            return;
+        }
+        // no config.clients and config.client
+        this.#setClientToApp(this);
+    }
+    async initAsync() {
+        const options = this.options;
+        (0, node_assert_1.default)(!(options.client && options.clients), `[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.#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) => {
+                return this.createInstanceAsync(options.clients[id], id)
+                    .then(client => this.clients.set(id, client));
+            }));
+            this.#setClientToApp(this);
+            return;
+        }
+        // no config.clients and config.client
+        this.#setClientToApp(this);
+    }
+    #setClientToApp(client) {
+        Reflect.set(this.app, this.name, client);
+    }
+    get(id) {
+        return this.clients.get(id);
+    }
+    // alias to `get(id)`
+    getSingletonInstance(id) {
+        return this.clients.get(id);
+    }
+    createInstance(config, clientName) {
+        // async creator only support createInstanceAsync
+        (0, node_assert_1.default)(!(0, is_type_of_1.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 = {
+            ...this.options.default,
+            ...config,
+        };
+        return this.create(config, this.app, clientName);
+    }
+    async createInstanceAsync(config, clientName) {
+        // options.default will be merge in to options.clients[id]
+        config = {
+            ...this.options.default,
+            ...config,
+        };
+        return await this.create(config, this.app, clientName);
+    }
+    #extendDynamicMethods(client) {
+        (0, node_assert_1.default)(!client.createInstance, 'singleton instance should not have createInstance method');
+        (0, node_assert_1.default)(!client.createInstanceAsync, 'singleton instance should not have createInstanceAsync method');
+        try {
+            let extendable = client;
+            // Object.preventExtensions() or Object.freeze()
+            if (!Object.isExtensible(client) || Object.isFrozen(client)) {
+                // eslint-disable-next-line no-proto
+                extendable = client.__proto__ || client;
+            }
+            extendable.createInstance = this.createInstance.bind(this);
+            extendable.createInstanceAsync = this.createInstanceAsync.bind(this);
+        }
+        catch (err) {
+            this.app.coreLogger.warn('[egg:singleton] %s dynamic create is disabled because of client is un-extendable', this.name);
+            this.app.coreLogger.warn(err);
+        }
+    }
+}
+exports.Singleton = Singleton;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export declare function convertObject(obj: any, ignore: string | RegExp | (string | RegExp)[]): any;
+export declare function safeParseURL(url: string): URL | null;