egg 3.29.0 → 4.0.0-beta.2

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

@@ -0,0 +1,127 @@
+import { debuglog } from 'node:util';
+import EventEmitter from 'node:events';
+const debug = debuglog('egg:lib:core:messenger:local');
+/**
+ * Communication between app worker and agent worker with EventEmitter
+ */
+export class Messenger extends EventEmitter {
+    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();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/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/esm/lib/core/singleton.js

@@ -0,0 +1,113 @@
+import assert from 'node:assert';
+import { isAsyncFunction } from 'is-type-of';
+export class Singleton {
+    clients = new Map();
+    app;
+    create;
+    name;
+    options;
+    constructor(options) {
+        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.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 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`);
+        // 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;
+        assert(!(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
+        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 = {
+            ...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) {
+        assert(!client.createInstance, 'singleton instance should not have createInstance method');
+        assert(!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);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/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;

package/dist/esm/lib/core/utils.js

@@ -0,0 +1,70 @@
+import util from 'node:util';
+import { isSymbol, isRegExp, isPrimitive, isClass, isFunction, isGeneratorFunction, isAsyncFunction, } from 'is-type-of';
+export 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 === 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) {
+    try {
+        return new URL(url);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/egg.d.ts

@@ -0,0 +1,271 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+import { EggCore, type EggCoreContext, type EggCoreOptions } from '@eggjs/core';
+import { EggContextLogger as ContextLogger, EggLoggers, EggLogger } from 'egg-logger';
+import { Cookies as ContextCookies } from '@eggjs/cookies';
+import type { Agent } from './agent.js';
+import type { Application } from './application.js';
+import type { EggAppConfig } from './type.js';
+import { IMessenger } from './core/messenger/index.js';
+import { ContextHttpClient } from './core/context_httpclient.js';
+import { HttpClient, type HttpClientRequestOptions, type HttpClientRequestURL, type HttpClientResponse } from './core/httpclient.js';
+import { type SingletonCreateMethod } from './core/singleton.js';
+import { BaseContextClass } from './core/base_context_class.js';
+import { BaseHookClass } from './core/base_hook_class.js';
+import type { EggApplicationLoader } from './loader/index.js';
+declare const EGG_PATH: unique symbol;
+export interface EggApplicationCoreOptions extends Omit<EggCoreOptions, 'baseDir'> {
+    mode?: 'cluster' | 'single';
+    clusterPort?: number;
+    baseDir?: string;
+}
+export interface EggContext extends EggCoreContext {
+    app: EggApplicationCore;
+    /**
+     * Request start time
+     * @member {Number} Context#starttime
+     */
+    starttime: number;
+    /**
+     * Request start timer using `performance.now()`
+     * @member {Number} Context#performanceStarttime
+     */
+    performanceStarttime: number;
+}
+/**
+ * Based on koa's Application
+ * @see https://github.com/eggjs/egg-core
+ * @see https://github.com/eggjs/koa/blob/master/src/application.ts
+ * @augments EggCore
+ */
+export declare class EggApplicationCore extends EggCore {
+    #private;
+    ContextCookies: typeof ContextCookies;
+    ContextLogger: typeof ContextLogger;
+    ContextHttpClient: typeof ContextHttpClient;
+    HttpClient: typeof HttpClient;
+    /**
+     * Retrieve base context class
+     * @member {BaseContextClass} BaseContextClass
+     * @since 1.0.0
+     */
+    BaseContextClass: typeof BaseContextClass;
+    /**
+     * Retrieve base controller
+     * @member {Controller} Controller
+     * @since 1.0.0
+     */
+    Controller: typeof BaseContextClass;
+    /**
+     * Retrieve base service
+     * @member {Service} Service
+     * @since 1.0.0
+     */
+    Service: typeof BaseContextClass;
+    /**
+     * Retrieve base subscription
+     * @member {Subscription} Subscription
+     * @since 2.12.0
+     */
+    Subscription: typeof BaseContextClass;
+    /**
+     * Retrieve base context class
+     * @member {BaseHookClass} BaseHookClass
+     */
+    BaseHookClass: typeof BaseHookClass;
+    /**
+     * Retrieve base boot
+     * @member {Boot}
+     */
+    Boot: typeof BaseHookClass;
+    options: Required<EggApplicationCoreOptions>;
+    readonly messenger: IMessenger;
+    agent?: Agent;
+    application?: Application;
+    loader: EggApplicationLoader;
+    /**
+     * @class
+     * @param {Object} options
+     *  - {Object} [type] - type of instance, Agent and Application both extend koa, type can determine what it is.
+     *  - {String} [baseDir] - app root dir, default is `process.cwd()`
+     *  - {Object} [plugins] - custom plugin config, use it in unittest
+     *  - {String} [mode] - process mode, can be cluster / single, default is `cluster`
+     */
+    constructor(options?: EggApplicationCoreOptions);
+    /**
+     * @deprecated please use `options` property instead
+     */
+    get _options(): Required<EggApplicationCoreOptions>;
+    protected loadConfig(): Promise<void>;
+    protected load(): Promise<void>;
+    /**
+     * Wrap the Client with Leader/Follower Pattern
+     *
+     * @description almost the same as Agent.cluster API, the only different is that this method create Follower.
+     *
+     * @see https://github.com/node-modules/cluster-client
+     * @param {Function} clientClass - client class function
+     * @param {Object} [options]
+     *   - {Boolean} [autoGenerate] - whether generate delegate rule automatically, default is true
+     *   - {Function} [formatKey] - a method to transform the subscription info into a string，default is JSON.stringify
+     *   - {Object} [transcode|JSON.stringify/parse]
+     *     - {Function} encode - custom serialize method
+     *     - {Function} decode - custom deserialize method
+     *   - {Boolean} [isBroadcast] - whether broadcast subscription result to all followers or just one, default is true
+     *   - {Number} [responseTimeout] - response timeout, default is 3 seconds
+     *   - {Number} [maxWaitTime|30000] - leader startup max time, default is 30 seconds
+     * @return {ClientWrapper} wrapper
+     */
+    cluster(clientClass: unknown, options: object): any;
+    /**
+     * print the information when console.log(app)
+     * @return {Object} inspected app.
+     * @since 1.0.0
+     * @example
+     * ```js
+     * console.log(app);
+     * =>
+     * {
+     *   name: 'mock-app',
+     *   env: 'test',
+     *   subdomainOffset: 2,
+     *   config: '<egg config>',
+     *   controller: '<egg controller>',
+     *   service: '<egg service>',
+     *   middlewares: '<egg middlewares>',
+     *   urllib: '<egg urllib>',
+     *   loggers: '<egg loggers>'
+     * }
+     * ```
+     */
+    inspect(): any;
+    toJSON(): any;
+    /**
+     * http request helper base on {@link httpclient}, it will auto save httpclient log.
+     * Keep the same api with `httpclient.request(url, args)`.
+     *
+     * See https://github.com/node-modules/urllib#api-doc for more details.
+     *
+     * @param {String} url request url address.
+     * @param {Object} options
+     * - method {String} - Request method, defaults to GET. Could be GET, POST, DELETE or PUT. Alias 'type'.
+     * - data {Object} - Data to be sent. Will be stringify automatically.
+     * - dataType {String} - String - Type of response data. Could be `text` or `json`.
+     *   If it's `text`, the callback data would be a String.
+     *   If it's `json`, the data of callback would be a parsed JSON Object.
+     *   Default callback data would be a Buffer.
+     * - headers {Object} - Request headers.
+     * - timeout {Number} - Request timeout in milliseconds. Defaults to exports.TIMEOUT.
+     *   Include remote server connecting timeout and response timeout.
+     *   When timeout happen, will return ConnectionTimeout or ResponseTimeout.
+     * - auth {String} - `username:password` used in HTTP Basic Authorization.
+     * - followRedirect {Boolean} - follow HTTP 3xx responses as redirects. defaults to false.
+     * - gzip {Boolean} - let you get the res object when request connected, default false. alias customResponse
+     * - nestedQuerystring {Boolean} - urllib default use querystring to stringify form data which don't
+     *   support nested object, will use qs instead of querystring to support nested object by set this option to true.
+     * - more options see https://github.com/node-modules/urllib
+     * @return {Object}
+     * - status {Number} - HTTP response status
+     * - headers {Object} - HTTP response headers
+     * - res {Object} - HTTP response meta
+     * - data {Object} - HTTP response body
+     *
+     * @example
+     * ```js
+     * const result = await app.curl('http://example.com/foo.json', {
+     *   method: 'GET',
+     *   dataType: 'json',
+     * });
+     * console.log(result.status, result.headers, result.data);
+     * ```
+     */
+    curl<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions): Promise<HttpClientResponse<T>>;
+    /**
+     * HttpClient instance
+     * @see https://github.com/node-modules/urllib
+     * @member {HttpClient}
+     */
+    get httpClient(): HttpClient;
+    /**
+     * @deprecated please use httpClient instead
+     * @alias httpClient
+     * @member {HttpClient}
+     */
+    get httpclient(): HttpClient;
+    /**
+     * All loggers contain logger, coreLogger and customLogger
+     * @member {Object}
+     * @since 1.0.0
+     */
+    get loggers(): EggLoggers;
+    /**
+     * Get logger by name, it's equal to app.loggers['name'],
+     * but you can extend it with your own logical.
+     * @param {String} name - logger name
+     * @return {Logger} logger
+     */
+    getLogger(name: string): EggLogger;
+    /**
+     * application logger, log file is `$HOME/logs/{appname}/{appname}-web`
+     * @member {Logger}
+     * @since 1.0.0
+     */
+    get logger(): EggLogger;
+    /**
+     * core logger for framework and plugins, log file is `$HOME/logs/{appname}/egg-web`
+     * @member {Logger}
+     * @since 1.0.0
+     */
+    get coreLogger(): EggLogger;
+    _unhandledRejectionHandler(err: any): void;
+    /**
+     * dump out the config and meta object
+     * @private
+     */
+    dumpConfigToObject(): {
+        config: Record<string, any>;
+        meta: Record<string, any>;
+    };
+    /**
+     * save app.config to `run/${type}_config.json`
+     * @private
+     */
+    dumpConfig(): void;
+    dumpTiming(): void;
+    get [EGG_PATH](): string;
+    get config(): EggAppConfig;
+    /**
+     * app.env delegate app.config.env
+     * @deprecated
+     */
+    get env(): string;
+    set env(_: string);
+    /**
+     * app.proxy delegate app.config.proxy
+     * @deprecated
+     */
+    get proxy(): boolean;
+    set proxy(_: boolean);
+    /**
+     * create a singleton instance
+     * @param {String} name - unique name for singleton
+     * @param {Function|AsyncFunction} create - method will be invoked when singleton instance create
+     */
+    addSingleton(name: string, create: SingletonCreateMethod): void;
+    /**
+     * Create an anonymous context, the context isn't request level, so the request is mocked.
+     * then you can use context level API like `ctx.service`
+     * @member {String} EggApplication#createAnonymousContext
+     * @param {Request} [req] - if you want to mock request like querystring, you can pass an object to this function.
+     * @return {Context} context
+     */
+    createAnonymousContext(req?: any): EggCoreContext;
+    /**
+     * Create egg context
+     * @function EggApplication#createContext
+     * @param  {Req} req - node native Request object
+     * @param  {Res} res - node native Response object
+     * @return {Context} context object
+     */
+    createContext(req: IncomingMessage, res: ServerResponse): EggContext;
+}
+export {};