egg 3.26.1 → 4.0.0-beta.0

package/index.js

@@ -1,68 +0,0 @@
-/**
- * @namespace Egg
- */
-
-/**
- * Start egg application with cluster mode
- * @since 1.0.0
- */
-exports.startCluster = require('egg-cluster').startCluster;
-
-/**
- * Start egg application with single process mode
- * @since 1.0.0
- */
-exports.start = require('./lib/start');
-
-/**
- * @member {Application} Egg#Application
- * @since 1.0.0
- */
-exports.Application = require('./lib/application');
-
-/**
- * @member {Agent} Egg#Agent
- * @since 1.0.0
- */
-exports.Agent = require('./lib/agent');
-
-/**
- * @member {AppWorkerLoader} Egg#AppWorkerLoader
- * @since 1.0.0
- */
-exports.AppWorkerLoader = require('./lib/loader').AppWorkerLoader;
-
-/**
- * @member {AgentWorkerLoader} Egg#AgentWorkerLoader
- * @since 1.0.0
- */
-exports.AgentWorkerLoader = require('./lib/loader').AgentWorkerLoader;
-
-/**
- * @member {Controller} Egg#Controller
- * @since 1.1.0
- */
-exports.Controller = require('./lib/core/base_context_class');
-
-/**
- * @member {Service} Egg#Service
- * @since 1.1.0
- */
-exports.Service = require('./lib/core/base_context_class');
-
-/**
- * @member {Subscription} Egg#Subscription
- * @since 1.10.0
- */
-exports.Subscription = require('./lib/core/base_context_class');
-
-/**
- * @member {BaseContextClass} Egg#BaseContextClass
- * @since 1.2.0
- */
-exports.BaseContextClass = require('./lib/core/base_context_class');
-
-/**
- * @member {Boot} Egg#Boot
- */
-exports.Boot = require('./lib/core/base_hook_class');

package/lib/agent.js

@@ -1,95 +0,0 @@
-'use strict';
-
-const path = require('path');
-const ms = require('ms');
-const EggApplication = require('./egg');
-const AgentWorkerLoader = require('./loader').AgentWorkerLoader;
-
-const EGG_LOADER = Symbol.for('egg#loader');
-const EGG_PATH = Symbol.for('egg#eggPath');
-
-/**
- * Singleton instance in Agent Worker, extend {@link EggApplication}
- * @augments EggApplication
- */
-class Agent extends EggApplication {
-  /**
-   * @class
-   * @param {Object} options - see {@link EggApplication}
-   */
-  constructor(options = {}) {
-    options.type = 'agent';
-    super(options);
-
-    this.loader.load();
-
-    // 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)
-    );
-
-    // keep agent alive even it doesn't have any io tasks
-    this.agentAliveHandler = setInterval(() => {}, 24 * 60 * 60 * 1000);
-
-    this._uncaughtExceptionHandler = this._uncaughtExceptionHandler.bind(this);
-    process.on('uncaughtException', this._uncaughtExceptionHandler);
-  }
-
-  _uncaughtExceptionHandler(err) {
-    if (!(err instanceof Error)) {
-      err = new Error(String(err));
-    }
-    /* istanbul ignore else */
-    if (err.name === 'Error') {
-      err.name = 'unhandledExceptionError';
-    }
-    this.coreLogger.error(err);
-  }
-
-  get [EGG_LOADER]() {
-    return AgentWorkerLoader;
-  }
-
-  get [EGG_PATH]() {
-    return path.join(__dirname, '..');
-  }
-
-  _wrapMessenger() {
-    for (const methodName of [
-      'broadcast',
-      'sendTo',
-      'sendToApp',
-      'sendToAgent',
-      'sendRandom',
-    ]) {
-      wrapMethod(methodName, this.messenger, this.coreLogger);
-    }
-
-    function wrapMethod(methodName, messenger, logger) {
-      const originMethod = messenger[methodName];
-      messenger[methodName] = function() {
-        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, arguments);
-      };
-      messenger.prependOnceListener('egg-ready', () => {
-        messenger[methodName] = originMethod;
-      });
-    }
-  }
-
-  close() {
-    process.removeListener('uncaughtException', this._uncaughtExceptionHandler);
-    clearInterval(this.agentAliveHandler);
-    return super.close();
-  }
-}
-
-module.exports = Agent;

package/lib/core/base_context_class.js

@@ -1,20 +0,0 @@
-'use strict';
-
-const EggCoreBaseContextClass = require('egg-core').BaseContextClass;
-const BaseContextLogger = require('./base_context_logger');
-
-const LOGGER = Symbol('BaseContextClass#logger');
-
-/**
- * BaseContextClass is a base class that can be extended,
- * it's instantiated in context level,
- * {@link Helper}, {@link Service} is extending it.
- */
-class BaseContextClass extends EggCoreBaseContextClass {
-  get logger() {
-    if (!this[LOGGER]) this[LOGGER] = new BaseContextLogger(this.ctx, this.pathName);
-    return this[LOGGER];
-  }
-}
-
-module.exports = BaseContextClass;

package/lib/core/base_context_logger.js

@@ -1,64 +0,0 @@
-const CALL = Symbol('BaseContextLogger#call');
-
-class BaseContextLogger {
-  /**
-   * @class
-   * @param {Context} ctx - context instance
-   * @param {String} pathName - class path name
-   * @since 1.0.0
-   */
-  constructor(ctx, pathName) {
-    /**
-     * @member {Context} BaseContextLogger#ctx
-     * @since 1.2.0
-     */
-    this.ctx = ctx;
-    this.pathName = pathName;
-  }
-
-  [CALL](method, args) {
-    // add `[${pathName}]` in log
-    if (this.pathName && typeof args[0] === 'string') {
-      args[0] = `[${this.pathName}] ${args[0]}`;
-    }
-    this.ctx.app.logger[method](...args);
-  }
-
-  /**
-   * @member {Function} BaseContextLogger#debug
-   * @param {...any} args - log msg
-   * @since 1.2.0
-   */
-  debug(...args) {
-    this[CALL]('debug', args);
-  }
-
-  /**
-   * @member {Function} BaseContextLogger#info
-   * @param {...any} args - log msg
-   * @since 1.2.0
-   */
-  info(...args) {
-    this[CALL]('info', args);
-  }
-
-  /**
-   * @member {Function} BaseContextLogger#warn
-   * @param {...any} args - log msg
-   * @since 1.2.0
-   */
-  warn(...args) {
-    this[CALL]('warn', args);
-  }
-
-  /**
-   * @member {Function} BaseContextLogger#error
-   * @param {...any} args - log msg
-   * @since 1.2.0
-   */
-  error(...args) {
-    this[CALL]('error', args);
-  }
-}
-
-module.exports = BaseContextLogger;

package/lib/core/base_hook_class.js

@@ -1,31 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const INSTANCE = Symbol('BaseHookClass#instance');
-
-class BaseHookClass {
-
-  constructor(instance) {
-    this[INSTANCE] = instance;
-  }
-
-  get logger() {
-    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];
-  }
-
-  get agent() {
-    assert(this[INSTANCE].type === 'agent', 'app boot should not use agent instance');
-    return this[INSTANCE];
-  }
-}
-
-module.exports = BaseHookClass;

package/lib/core/context_httpclient.js

@@ -1,26 +0,0 @@
-class ContextHttpClient {
-  constructor(ctx) {
-    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.
-   * @return {Object} see {@link Application#curl}
-   */
-  async curl(url, options) {
-    options = options || {};
-    options.ctx = this.ctx;
-    return await this.app.curl(url, options);
-  }
-
-  async request(url, options) {
-    return await this.curl(url, options);
-  }
-}
-
-module.exports = ContextHttpClient;

package/lib/core/dnscache_httpclient.js

@@ -1,93 +0,0 @@
-const dns = require('node:dns').promises;
-const LRU = require('ylru');
-const { assign } = require('utility');
-const HttpClient = require('./httpclient');
-const utils = require('./utils');
-
-const IP_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
-const DNSLOOKUP = Symbol('DNSCacheHttpClient#dnslookup');
-const UPDATE_DNS = Symbol('DNSCacheHttpClient#updateDNS');
-
-class DNSCacheHttpClient extends HttpClient {
-  constructor(app) {
-    super(app);
-    this.dnsCacheLookupInterval = this.app.config.httpclient.dnsCacheLookupInterval;
-    this.dnsCache = new LRU(this.app.config.httpclient.dnsCacheMaxLength);
-  }
-
-  async request(url, args) {
-    // disable dns cache in request by args handle
-    if (args && args.enableDNSCache === false) {
-      return await super.request(url, args);
-    }
-    const result = await this[DNSLOOKUP](url, args);
-    return await super.request(result.url, result.args);
-  }
-
-  async [DNSLOOKUP](url, args) {
-    let parsed;
-    if (typeof url === 'string') {
-      parsed = utils.safeParseURL(url);
-      // invalid url or relative url
-      if (!parsed) return { url, args };
-    } else {
-      parsed = url;
-    }
-    // hostname must exists
-    const hostname = parsed.hostname;
-
-    // don't lookup when hostname is IP
-    if (hostname && IP_REGEX.test(hostname)) {
-      return { url, args };
-    }
-
-    args = args || {};
-    args.headers = args.headers || {};
-    // set when host header doesn't exist
-    if (!args.headers.host && !args.headers.Host) {
-      // host must combine with hostname:port, node won't use `parsed.host`
-      args.headers.host = parsed.port ? `${hostname}:${parsed.port}` : hostname;
-    }
-
-    const record = this.dnsCache.get(hostname);
-    const now = Date.now();
-    if (record) {
-      if (now - record.timestamp >= this.dnsCacheLookupInterval) {
-        // make sure the next request doesn't refresh dns query
-        record.timestamp = now;
-        this[UPDATE_DNS](hostname, args).catch(err => this.app.emit('error', err));
-      }
-
-      return { url: formatDnsLookupUrl(hostname, url, record.ip), args };
-    }
-
-    const address = await this[UPDATE_DNS](hostname, args);
-    return { url: formatDnsLookupUrl(hostname, url, address), args };
-  }
-
-  async [UPDATE_DNS](hostname, args) {
-    const logger = args.ctx ? args.ctx.coreLogger : this.app.coreLogger;
-    try {
-      const { address } = await dns.lookup(hostname, { family: 4 });
-      logger.info('[dnscache_httpclient] dns lookup success: %s => %s',
-        hostname, address);
-      this.dnsCache.set(hostname, { timestamp: Date.now(), ip: address });
-      return address;
-    } catch (err) {
-      err.message = `[dnscache_httpclient] dns lookup error: ${hostname} => ${err.message}`;
-      throw err;
-    }
-  }
-}
-
-module.exports = DNSCacheHttpClient;
-
-function formatDnsLookupUrl(host, url, address) {
-  if (typeof url === 'string') return url.replace(host, address);
-  const urlObj = assign({}, url);
-  urlObj.hostname = urlObj.hostname.replace(host, address);
-  if (urlObj.host) {
-    urlObj.host = urlObj.host.replace(host, address);
-  }
-  return urlObj;
-}

package/lib/core/httpclient.js

@@ -1,108 +0,0 @@
-const Agent = require('agentkeepalive');
-const HttpsAgent = require('agentkeepalive').HttpsAgent;
-const urllib = require('urllib');
-const ms = require('humanize-ms');
-const { FrameworkBaseError } = require('egg-errors');
-
-class HttpClientError extends FrameworkBaseError {
-  get module() {
-    return 'httpclient';
-  }
-}
-
-class HttpClient extends urllib.HttpClient2 {
-  constructor(app) {
-    normalizeConfig(app);
-    const config = app.config.httpclient;
-    super({
-      app,
-      defaultArgs: config.request,
-      agent: new Agent(config.httpAgent),
-      httpsAgent: new HttpsAgent(config.httpsAgent),
-    });
-    this.app = app;
-  }
-
-  async request(url, args) {
-    args = args || {};
-    if (args.ctx && args.ctx.tracer) {
-      args.tracer = args.ctx.tracer;
-    } else {
-      args.tracer = args.tracer || this.app.tracer;
-    }
-
-    try {
-      return await super.request(url, args);
-    } catch (err) {
-      if (err.code === 'ENETUNREACH') {
-        throw HttpClientError.create(err.message, err.code);
-      }
-      throw err;
-    }
-  }
-
-  async curl(...args) {
-    return await this.request(...args);
-  }
-}
-
-function normalizeConfig(app) {
-  const config = app.config.httpclient;
-
-  // compatibility
-  if (typeof config.keepAlive === 'boolean') {
-    config.httpAgent.keepAlive = config.keepAlive;
-    config.httpsAgent.keepAlive = config.keepAlive;
-  }
-  if (config.timeout) {
-    config.timeout = ms(config.timeout);
-    config.httpAgent.timeout = config.timeout;
-    config.httpsAgent.timeout = config.timeout;
-  }
-  // compatibility httpclient.freeSocketKeepAliveTimeout => httpclient.freeSocketTimeout
-  if (config.freeSocketKeepAliveTimeout && !config.freeSocketTimeout) {
-    config.freeSocketTimeout = config.freeSocketKeepAliveTimeout;
-    delete config.freeSocketKeepAliveTimeout;
-  }
-  if (config.freeSocketTimeout) {
-    config.freeSocketTimeout = ms(config.freeSocketTimeout);
-    config.httpAgent.freeSocketTimeout = config.freeSocketTimeout;
-    config.httpsAgent.freeSocketTimeout = config.freeSocketTimeout;
-  } else {
-    // compatibility agent.freeSocketKeepAliveTimeout
-    if (config.httpAgent.freeSocketKeepAliveTimeout && !config.httpAgent.freeSocketTimeout) {
-      config.httpAgent.freeSocketTimeout = config.httpAgent.freeSocketKeepAliveTimeout;
-      delete config.httpAgent.freeSocketKeepAliveTimeout;
-    }
-    if (config.httpsAgent.freeSocketKeepAliveTimeout && !config.httpsAgent.freeSocketTimeout) {
-      config.httpsAgent.freeSocketTimeout = config.httpsAgent.freeSocketKeepAliveTimeout;
-      delete config.httpsAgent.freeSocketKeepAliveTimeout;
-    }
-  }
-
-  if (typeof config.maxSockets === 'number') {
-    config.httpAgent.maxSockets = config.maxSockets;
-    config.httpsAgent.maxSockets = config.maxSockets;
-  }
-  if (typeof config.maxFreeSockets === 'number') {
-    config.httpAgent.maxFreeSockets = config.maxFreeSockets;
-    config.httpsAgent.maxFreeSockets = config.maxFreeSockets;
-  }
-
-  if (config.httpAgent.timeout < 30000) {
-    app.coreLogger.warn('[egg:httpclient] config.httpclient.httpAgent.timeout(%s) can\'t below 30000, auto reset to 30000',
-      config.httpAgent.timeout);
-    config.httpAgent.timeout = 30000;
-  }
-  if (config.httpsAgent.timeout < 30000) {
-    app.coreLogger.warn('[egg:httpclient] config.httpclient.httpsAgent.timeout(%s) can\'t below 30000, auto reset to 30000',
-      config.httpsAgent.timeout);
-    config.httpsAgent.timeout = 30000;
-  }
-
-  if (typeof config.request.timeout === 'string') {
-    config.request.timeout = ms(config.request.timeout);
-  }
-}
-
-module.exports = HttpClient;

package/lib/core/httpclient_next.js

@@ -1,45 +0,0 @@
-const { HttpClient } = require('urllib-next');
-const ms = require('humanize-ms');
-
-class HttpClientNext extends HttpClient {
-  constructor(app, options) {
-    normalizeConfig(app);
-    options = options || {};
-    options = {
-      ...app.config.httpclient,
-      ...options,
-    };
-    super({
-      app,
-      defaultArgs: options.request,
-      allowH2: options.allowH2,
-      // use on egg-security ssrf
-      // https://github.com/eggjs/egg-security/blob/master/lib/extend/safe_curl.js#L11
-      checkAddress: options.checkAddress,
-    });
-    this.app = app;
-  }
-
-  async request(url, options) {
-    options = options || {};
-    if (options.ctx && options.ctx.tracer) {
-      options.tracer = options.ctx.tracer;
-    } else {
-      options.tracer = options.tracer || this.app.tracer;
-    }
-    return await super.request(url, options);
-  }
-
-  async curl(...args) {
-    return await this.request(...args);
-  }
-}
-
-function normalizeConfig(app) {
-  const config = app.config.httpclient;
-  if (typeof config.request.timeout === 'string') {
-    config.request.timeout = ms(config.request.timeout);
-  }
-}
-
-module.exports = HttpClientNext;

package/lib/core/logger.js

@@ -1,35 +0,0 @@
-const { EggLoggers } = require('egg-logger');
-const { setCustomLogger } = require('onelogger');
-
-module.exports = function createLoggers(app) {
-  const loggerConfig = app.config.logger;
-  loggerConfig.type = app.type;
-  loggerConfig.localStorage = app.ctxStorage;
-
-  if (app.config.env === 'prod' && loggerConfig.level === 'DEBUG' && !loggerConfig.allowDebugAtProd) {
-    loggerConfig.level = 'INFO';
-  }
-
-  const loggers = new EggLoggers(app.config);
-
-  // won't print to console after started, except for local and unittest
-  app.ready(() => {
-    if (loggerConfig.disableConsoleAfterReady) {
-      loggers.disableConsole();
-    }
-  });
-
-  // set global logger
-  for (const loggerName of Object.keys(loggers)) {
-    setCustomLogger(loggerName, loggers[loggerName]);
-  }
-  // reset global logger on beforeClose hook
-  app.beforeClose(() => {
-    for (const loggerName of Object.keys(loggers)) {
-      setCustomLogger(loggerName, undefined);
-    }
-  });
-  loggers.coreLogger.info('[egg:logger] init all loggers with options: %j', loggerConfig);
-
-  return loggers;
-};

package/lib/core/messenger/index.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const LocalMessenger = require('./local');
-const IPCMessenger = require('./ipc');
-
-/**
- * @class Messenger
- */
-
-exports.create = egg => {
-  return egg.options.mode === 'single'
-    ? new LocalMessenger(egg)
-    : new IPCMessenger(egg);
-};

package/lib/core/utils.js

@@ -1,73 +0,0 @@
-'use strict';
-
-const util = require('util');
-const is = require('is-type-of');
-const URL = require('url').URL;
-
-module.exports = {
-  convertObject,
-  safeParseURL,
-};
-
-function convertObject(obj, ignore) {
-  if (!is.array(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 (is.nullOrUndefined(value)) return value;
-
-  let hit = false;
-  for (const matchKey of ignore) {
-    if (is.string(matchKey) && matchKey === key) {
-      hit = true;
-      break;
-    } else if (is.regExp(matchKey) && matchKey.test(key)) {
-      hit = true;
-      break;
-    }
-  }
-  if (!hit) {
-    if (is.symbol(value) || is.regExp(value)) return value.toString();
-    if (is.primitive(value) || is.array(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 (is.class(value)) {
-    return `<Class ${name}>`;
-  }
-
-  // support generator function
-  if (is.function(value)) {
-    if (is.generatorFunction(value)) return `<GeneratorFunction ${name}>`;
-    if (is.asyncFunction(value)) return `<AsyncFunction ${name}>`;
-    return `<Function ${name}>`;
-  }
-
-  const typeName = value.constructor.name;
-  if (typeName) {
-    if (is.buffer(value) || is.string(value)) return `<${typeName} len: ${value.length}>`;
-    return `<${typeName}>`;
-  }
-
-  /* istanbul ignore next */
-  return util.format(value);
-}
-
-function safeParseURL(url) {
-  try {
-    return new URL(url);
-  } catch (err) {
-    return null;
-  }
-}