egg 3.29.0 → 4.0.0-beta.10

package/{config/plugin.js → src/config/plugin.ts}

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports = {
+export default {
   // enable plugins
 
   /**
@@ -43,7 +41,7 @@ module.exports = {
    */
   watcher: {
     enable: true,
-    package: 'egg-watcher',
+    package: '@eggjs/watcher',
   },
 
   /**
@@ -98,7 +96,7 @@ module.exports = {
    */
   schedule: {
     enable: true,
-    package: 'egg-schedule',
+    package: '@eggjs/schedule',
   },
 
   /**

package/src/index.ts

@@ -0,0 +1,80 @@
+/**
+ * @namespace Egg
+ */
+
+import { BaseContextClass } from './lib/core/base_context_class.js';
+import { startEgg } from './lib/start.js';
+import Helper from './app/extend/helper.js';
+
+// export extends
+export { Helper };
+
+// export types
+export * from './lib/egg.js';
+export * from './lib/type.js';
+export * from './lib/start.js';
+
+/**
+ * Start egg application with cluster mode
+ * @since 1.0.0
+ */
+export * from '@eggjs/cluster';
+
+/**
+ * Start egg application with single process mode
+ * @since 1.0.0
+ */
+export const start = startEgg;
+
+/**
+ * @member {Application} Egg#Application
+ * @since 1.0.0
+ */
+export { Application } from './lib/application.js';
+
+/**
+ * @member {Agent} Egg#Agent
+ * @since 1.0.0
+ */
+export { Agent } from './lib/agent.js';
+
+/**
+ * @member {AppWorkerLoader} Egg#AppWorkerLoader
+ * @since 1.0.0
+ */
+
+/**
+ * @member {AgentWorkerLoader} Egg#AgentWorkerLoader
+ * @since 1.0.0
+ */
+
+export { AppWorkerLoader, AgentWorkerLoader } from './lib/loader/index.js';
+
+/**
+ * @member {Controller} Egg#Controller
+ * @since 1.1.0
+ */
+export const Controller = BaseContextClass;
+
+/**
+ * @member {Service} Egg#Service
+ * @since 1.1.0
+ */
+export const Service = BaseContextClass;
+
+/**
+ * @member {Subscription} Egg#Subscription
+ * @since 1.10.0
+ */
+export const Subscription = BaseContextClass;
+
+/**
+ * @member {BaseContextClass} Egg#BaseContextClass
+ * @since 1.2.0
+ */
+export { BaseContextClass } from './lib/core/base_context_class.js';
+
+/**
+ * @member {Boot} Egg#Boot
+ */
+export { BaseHookClass as Boot } from './lib/core/base_hook_class.js';

package/src/lib/agent.ts

@@ -0,0 +1,66 @@
+import { EggLogger } from 'egg-logger';
+import { EggApplicationCore, EggApplicationCoreOptions } from './egg.js';
+import { AgentWorkerLoader } from './loader/index.js';
+
+const EGG_LOADER = Symbol.for('egg#loader');
+
+/**
+ * Singleton instance in Agent Worker, extend {@link EggApplicationCore}
+ * @augments EggApplicationCore
+ */
+export class Agent extends EggApplicationCore {
+  readonly #agentAliveHandler: NodeJS.Timeout;
+
+  /**
+   * @class
+   * @param {Object} options - see {@link EggApplicationCore}
+   */
+  constructor(options?: Omit<EggApplicationCoreOptions, 'type'>) {
+    super({
+      ...options,
+      type: 'agent',
+    });
+
+    // keep agent alive even it doesn't have any io tasks
+    this.#agentAliveHandler = setInterval(() => {
+      this.coreLogger.info('[]');
+    }, 24 * 60 * 60 * 1000);
+  }
+
+  get [EGG_LOADER]() {
+    return AgentWorkerLoader;
+  }
+
+  _wrapMessenger() {
+    for (const methodName of [
+      'broadcast',
+      'sendTo',
+      'sendToApp',
+      'sendToAgent',
+      'sendRandom',
+    ]) {
+      wrapMethod(methodName, this.messenger, this.coreLogger);
+    }
+
+    function wrapMethod(methodName: string, messenger: any, logger: EggLogger) {
+      const originMethod = messenger[methodName];
+      messenger[methodName] = function(...args: any[]) {
+        const stack = new Error().stack!.split('\n').slice(1).join('\n');
+        logger.warn(
+          "agent can't call %s before server started\n%s",
+          methodName,
+          stack,
+        );
+        originMethod.apply(this, args);
+      };
+      messenger.prependOnceListener('egg-ready', () => {
+        messenger[methodName] = originMethod;
+      });
+    }
+  }
+
+  async close() {
+    clearInterval(this.#agentAliveHandler);
+    await super.close();
+  }
+}

package/{lib/application.js → src/lib/application.ts}

@@ -1,27 +1,19 @@
-'use strict';
+import path from 'node:path';
+import fs from 'node:fs';
+import http from 'node:http';
+import { Socket } from 'node:net';
+import { graceful } from 'graceful';
+import { assign } from 'utility';
+import { utils as eggUtils } from '@eggjs/core';
+import {
+  EggApplicationCore,
+  type EggApplicationCoreOptions,
+  type ContextDelegation,
+} from './egg.js';
+import { AppWorkerLoader } from './loader/index.js';
+import Helper from '../app/extend/helper.js';
 
-const path = require('path');
-const fs = require('fs');
-const ms = require('ms');
-const is = require('is-type-of');
-const graceful = require('graceful');
-const http = require('http');
-const cluster = require('cluster-client');
-const onFinished = require('on-finished');
-const { assign } = require('utility');
-const eggUtils = require('egg-core').utils;
-const EggApplication = require('./egg');
-const AppWorkerLoader = require('./loader').AppWorkerLoader;
-
-const KEYS = Symbol('Application#keys');
-const HELPER = Symbol('Application#Helper');
-const LOCALS = Symbol('Application#locals');
-const BIND_EVENTS = Symbol('Application#bindEvents');
-const WARN_CONFUSED_CONFIG = Symbol('Application#warnConfusedConfig');
 const EGG_LOADER = Symbol.for('egg#loader');
-const EGG_PATH = Symbol.for('egg#eggPath');
-const CLUSTER_CLIENTS = Symbol.for('egg#clusterClients');
-const RESPONSE_RAW = Symbol('Application#responseRaw');
 
 // client error => 400 Bad Request
 // Refs: https://nodejs.org/dist/latest-v8.x/docs/api/http.html#http_event_clienterror
@@ -38,59 +30,52 @@ const DEFAULT_BAD_REQUEST_RESPONSE =
   `\r\n\r\n${DEFAULT_BAD_REQUEST_HTML}`;
 
 // Refs: https://github.com/nodejs/node/blob/b38c81/lib/_http_outgoing.js#L706-L710
-function escapeHeaderValue(value) {
+function escapeHeaderValue(value: string) {
   // Protect against response splitting. The regex test is there to
   // minimize the performance impact in the common case.
   return /[\r\n]/.test(value) ? value.replace(/[\r\n]+[ \t]*/g, '') : value;
 }
 
-// Refs: https://github.com/nodejs/node/blob/b38c81/lib/_http_outgoing.js#L706-L710
 /**
- * Singleton instance in App Worker, extend {@link EggApplication}
- * @augments EggApplication
+ * Singleton instance in App Worker, extend {@link EggApplicationCore}
+ * @augments EggApplicationCore
  */
-class Application extends EggApplication {
+export class Application extends EggApplicationCore {
+  // will auto set after 'server' event emit
+  server?: http.Server;
+  #locals: Record<string, any> = {};
+  /**
+   * reference to {@link Helper}
+   * @member {Helper} Application#Helper
+   */
+  Helper = Helper;
 
   /**
    * @class
-   * @param {Object} options - see {@link EggApplication}
+   * @param {Object} options - see {@link EggApplicationCore}
    */
-  constructor(options = {}) {
-    options.type = 'application';
-    super(options);
-
-    // will auto set after 'server' event emit
-    this.server = null;
-
-    try {
-      this.loader.load();
-    } catch (e) {
-      // close gracefully
-      this[CLUSTER_CLIENTS].forEach(cluster.close);
-      throw e;
-    }
-
-    // dump config after loaded, ensure all the dynamic modifications will be recorded
-    const dumpStartTime = Date.now();
-    this.dumpConfig();
-    this.coreLogger.info('[egg:core] dump config after load, %s', ms(Date.now() - dumpStartTime));
+  constructor(options?: Omit<EggApplicationCoreOptions, 'type'>) {
+    super({
+      ...options,
+      type: 'application',
+    });
+  }
 
-    this[WARN_CONFUSED_CONFIG]();
-    this[BIND_EVENTS]();
+  protected async load() {
+    await super.load();
+    this.#warnConfusedConfig();
+    this.#bindEvents();
   }
 
   get [EGG_LOADER]() {
     return AppWorkerLoader;
   }
 
-  get [EGG_PATH]() {
-    return path.join(__dirname, '..');
-  }
-
-  [RESPONSE_RAW](socket, raw) {
-    /* istanbul ignore next */
-    if (!socket.writable) return;
-    if (!raw) return socket.end(DEFAULT_BAD_REQUEST_RESPONSE);
+  #responseRaw(socket: Socket, raw?: any) {
+    if (!socket?.writable) return;
+    if (!raw) {
+      return socket.end(DEFAULT_BAD_REQUEST_RESPONSE);
+    }
 
     const body = (raw.body == null) ? DEFAULT_BAD_REQUEST_HTML : raw.body;
     const headers = raw.headers || {};
@@ -114,10 +99,10 @@ class Application extends EggApplication {
     socket.end(`${firstLine}\r\n${responseHeaderLines}\r\n${body.toString()}`);
   }
 
-  onClientError(err, socket) {
+  onClientError(err: any, socket: Socket) {
     // ignore when there is no http body, it almost like an ECONNRESET
     if (err.rawPacket) {
-      this.logger.warn('A client (%s:%d) error [%s] occurred: %s',
+      this.logger.warn('[egg:application] A client (%s:%d) error [%s] occurred: %s',
         socket.remoteAddress,
         socket.remotePort,
         err.code,
@@ -143,35 +128,34 @@ class Application extends EggApplication {
       // + headers: {}
       // + status: 400
       p.then(ret => {
-        this[RESPONSE_RAW](socket, ret || {});
+        this.#responseRaw(socket, ret || {});
       }).catch(err => {
         this.logger.error(err);
-        this[RESPONSE_RAW](socket);
+        this.#responseRaw(socket);
       });
     } else {
       // because it's a raw socket object, we should return the raw HTTP response
       // packet.
-      this[RESPONSE_RAW](socket);
+      this.#responseRaw(socket);
     }
   }
 
-  onServer(server) {
+  onServer(server: http.Server) {
     // expose app.server
     this.server = server;
     // set ignore code
     const serverGracefulIgnoreCode = this.config.serverGracefulIgnoreCode || [];
 
-    /* istanbul ignore next */
     graceful({
       server: [ server ],
-      error: (err, throwErrorCount) => {
+      error: (err: Error, throwErrorCount: number) => {
         const originMessage = err.message;
         if (originMessage) {
           // shouldjs will override error property but only getter
           // https://github.com/shouldjs/should.js/blob/889e22ebf19a06bc2747d24cf34b25cc00b37464/lib/assertion-error.js#L26
           Object.defineProperty(err, 'message', {
             get() {
-              return originMessage + ' (uncaughtException throw ' + throwErrorCount + ' times on pid:' + process.pid + ')';
+              return `${originMessage} (uncaughtException throw ${throwErrorCount} times on pid: ${process.pid})`;
             },
             configurable: true,
             enumerable: false,
@@ -182,10 +166,12 @@ class Application extends EggApplication {
       ignoreCode: serverGracefulIgnoreCode,
     });
 
-    server.on('clientError', (err, socket) => this.onClientError(err, socket));
+    server.on('clientError', (err, socket) => this.onClientError(err, socket as Socket));
 
     // server timeout
-    if (is.number(this.config.serverTimeout)) server.setTimeout(this.config.serverTimeout);
+    if (typeof this.config.serverTimeout === 'number') {
+      server.setTimeout(this.config.serverTimeout);
+    }
   }
 
   /**
@@ -194,24 +180,11 @@ class Application extends EggApplication {
    * @see Context#locals
    */
   get locals() {
-    if (!this[LOCALS]) {
-      this[LOCALS] = {};
-    }
-    return this[LOCALS];
+    return this.#locals;
   }
 
-  set locals(val) {
-    if (!this[LOCALS]) {
-      this[LOCALS] = {};
-    }
-
-    assign(this[LOCALS], val);
-  }
-
-  handleRequest(ctx, fnMiddleware) {
-    this.emit('request', ctx);
-    onFinished(ctx.res, () => this.emit('response', ctx));
-    return super.handleRequest(ctx, fnMiddleware);
+  set locals(val: Record<string, any>) {
+    assign(this.#locals, val);
   }
 
   /**
@@ -234,11 +207,11 @@ class Application extends EggApplication {
           paramNames: layer.paramNames,
           path: layer.path,
           regexp: layer.regexp.toString(),
-          stack: layer.stack.map(stack => stack[FULLPATH] || stack._name || stack.name || 'anonymous'),
+          stack: layer.stack.map((stack: any) => stack[FULLPATH] || stack._name || stack.name || 'anonymous'),
         });
       }
       fs.writeFileSync(dumpRouterFile, JSON.stringify(routers, null, 2));
-    } catch (err) {
+    } catch (err: any) {
       this.coreLogger.warn(`dumpConfig router.json error: ${err.message}`);
     }
   }
@@ -248,11 +221,13 @@ class Application extends EggApplication {
    * @see Context#runInBackground
    * @param {Function} scope - the first args is an anonymous ctx
    */
-  runInBackground(scope) {
-    const ctx = this.createAnonymousContext();
-    if (!scope.name) scope._name = eggUtils.getCalleeFromStack(true);
+  runInBackground(scope: (ctx: ContextDelegation) => Promise<void>, req?: unknown) {
+    const ctx = this.createAnonymousContext(req);
+    if (!scope.name) {
+      Reflect.set(scope, '_name', eggUtils.getCalleeFromStack(true));
+    }
     this.ctxStorage.run(ctx, () => {
-      ctx.runInBackground(scope);
+      return ctx.runInBackground(scope);
     });
   }
 
@@ -262,9 +237,11 @@ class Application extends EggApplication {
    * @param {Function} scope - the first args is an anonymous ctx, scope should be async function
    * @param {Request} [req] - if you want to mock request like querystring, you can pass an object to this function.
    */
-  async runInAnonymousContextScope(scope, req) {
+  async runInAnonymousContextScope(scope: (ctx: ContextDelegation) => Promise<void>, req?: unknown) {
     const ctx = this.createAnonymousContext(req);
-    if (!scope.name) scope._name = eggUtils.getCalleeFromStack(true);
+    if (!scope.name) {
+      Reflect.set(scope, '_name', eggUtils.getCalleeFromStack(true));
+    }
     return await this.ctxStorage.run(ctx, async () => {
       return await scope(ctx);
     });
@@ -275,7 +252,7 @@ class Application extends EggApplication {
    * @member {String} Application#keys
    */
   get keys() {
-    if (!this[KEYS]) {
+    if (!this._keys) {
       if (!this.config.keys) {
         if (this.config.env === 'local' || this.config.env === 'unittest') {
           const configPath = path.join(this.config.baseDir, 'config/config.default.js');
@@ -284,31 +261,9 @@ class Application extends EggApplication {
         }
         throw new Error('Please set config.keys first');
       }
-
-      this[KEYS] = this.config.keys.split(',').map(s => s.trim());
-    }
-    return this[KEYS];
-  }
-
-  set keys(_) {
-    // ignore
-  }
-
-  /**
-   * reference to {@link Helper}
-   * @member {Helper} Application#Helper
-   */
-  get Helper() {
-    if (!this[HELPER]) {
-      /**
-       * The Helper class which can be used as utility function.
-       * We support developers to extend Helper through ${baseDir}/app/extend/helper.js ,
-       * then you can use all method on `ctx.helper` that is a instance of Helper.
-       */
-      class Helper extends this.BaseContextClass {}
-      this[HELPER] = Helper;
+      this._keys = this.config.keys.split(',').map(s => s.trim());
     }
-    return this[HELPER];
+    return this._keys;
   }
 
   /**
@@ -316,17 +271,15 @@ class Application extends EggApplication {
    *
    * @private
    */
-  [BIND_EVENTS]() {
+  #bindEvents() {
     // Browser Cookie Limits: http://browsercookielimits.squawky.net/
     this.on('cookieLimitExceed', ({ name, value, ctx }) => {
       const err = new Error(`cookie ${name}'s length(${value.length}) exceed the limit(4093)`);
       err.name = 'CookieLimitExceedError';
-      err.key = name;
-      err.cookie = value;
       ctx.coreLogger.error(err);
     });
     // expose server to support websocket
-    this.once('server', server => this.onServer(server));
+    this.once('server', (server: http.Server) => this.onServer(server));
   }
 
   /**
@@ -334,15 +287,14 @@ class Application extends EggApplication {
    *
    * @private
    */
-  [WARN_CONFUSED_CONFIG]() {
+  #warnConfusedConfig() {
     const confusedConfigurations = this.config.confusedConfigurations;
     Object.keys(confusedConfigurations).forEach(key => {
       if (this.config[key] !== undefined) {
-        this.logger.warn('Unexpected config key `%s` exists, Please use `%s` instead.',
+        this.logger.warn('[egg:application] Unexpected config key `%o` exists, Please use `%o` instead.',
           key, confusedConfigurations[key]);
       }
     });
   }
 }
 
-module.exports = Application;

package/src/lib/core/base_context_class.ts

@@ -0,0 +1,21 @@
+import { BaseContextClass as EggCoreBaseContextClass } from '@eggjs/core';
+import type { ContextDelegation } from '../egg.js';
+import { BaseContextLogger } from './base_context_logger.js';
+
+/**
+ * BaseContextClass is a base class that can be extended,
+ * it's instantiated in context level,
+ * {@link Helper}, {@link Service} is extending it.
+ */
+export class BaseContextClass extends EggCoreBaseContextClass {
+  declare ctx: ContextDelegation;
+  protected pathName?: string;
+  #logger?: BaseContextLogger;
+
+  get logger() {
+    if (!this.#logger) {
+      this.#logger = new BaseContextLogger(this.ctx, this.pathName);
+    }
+    return this.#logger;
+  }
+}

package/src/lib/core/base_context_logger.ts

@@ -0,0 +1,67 @@
+import type { EggContext } from '../egg.js';
+
+export class BaseContextLogger {
+  readonly #ctx: EggContext;
+  readonly #pathName?: string;
+
+  /**
+   * @class
+   * @param {Context} ctx - context instance
+   * @param {String} pathName - class path name
+   * @since 1.0.0
+   */
+  constructor(ctx: EggContext, pathName?: string) {
+    /**
+     * @member {Context} BaseContextLogger#ctx
+     * @since 1.2.0
+     */
+    this.#ctx = ctx;
+    this.#pathName = pathName;
+  }
+
+  protected _log(method: 'info' | 'warn' | 'error' | 'debug', args: any[]) {
+    // add `[${pathName}]` in log
+    if (this.#pathName && typeof args[0] === 'string') {
+      args[0] = `[${this.#pathName}] ${args[0]}`;
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    this.#ctx.app.logger[method](...args);
+  }
+
+  /**
+   * @member {Function} BaseContextLogger#debug
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  debug(...args: any[]) {
+    this._log('debug', args);
+  }
+
+  /**
+   * @member {Function} BaseContextLogger#info
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  info(...args: any[]) {
+    this._log('info', args);
+  }
+
+  /**
+   * @member {Function} BaseContextLogger#warn
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  warn(...args: any[]) {
+    this._log('warn', args);
+  }
+
+  /**
+   * @member {Function} BaseContextLogger#error
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  error(...args: any[]) {
+    this._log('error', args);
+  }
+}

package/src/lib/core/base_hook_class.ts

@@ -0,0 +1,30 @@
+import assert from 'node:assert';
+import type { ILifecycleBoot } from '@eggjs/core';
+import type { Application, Agent } from '../../index.js';
+
+export class BaseHookClass implements ILifecycleBoot {
+  fullPath?: string;
+  #instance: Application | Agent;
+
+  constructor(instance: Application | Agent) {
+    this.#instance = instance;
+  }
+
+  get logger(): any {
+    return this.#instance.logger;
+  }
+
+  get config() {
+    return this.#instance.config;
+  }
+
+  get app() {
+    assert(this.#instance.type === 'application', 'agent boot should not use app instance');
+    return this.#instance as Application;
+  }
+
+  get agent() {
+    assert(this.#instance.type === 'agent', 'app boot should not use agent instance');
+    return this.#instance as Agent;
+  }
+}

package/src/lib/core/context_httpclient.ts

@@ -0,0 +1,33 @@
+import type { ContextDelegation, EggApplicationCore } from '../egg.js';
+import type {
+  HttpClientRequestURL, HttpClientRequestOptions,
+} from './httpclient.js';
+
+export class ContextHttpClient {
+  ctx: ContextDelegation;
+  app: EggApplicationCore;
+
+  constructor(ctx: ContextDelegation) {
+    this.ctx = ctx;
+    this.app = ctx.app;
+  }
+
+  /**
+   * http request helper base on {@link HttpClient}, it will auto save httpclient log.
+   * Keep the same api with {@link Application#curl}.
+   *
+   * @param {String|Object} url - request url address.
+   * @param {Object} [options] - options for request.
+   */
+  async curl<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions) {
+    options = {
+      ...options,
+      ctx: this.ctx,
+    };
+    return await this.app.curl<T>(url, options);
+  }
+
+  async request<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions) {
+    return await this.curl<T>(url, options);
+  }
+}