@eggjs/core 6.4.1 → 6.6.0-beta.10

package/dist/egg.js

@@ -0,0 +1,358 @@
+import utils_default from "./utils/index.js";
+import { BaseContextClass } from "./base_context_class.js";
+import { Timing } from "./utils/timing.js";
+import { Lifecycle } from "./lifecycle.js";
+import { EggLoader } from "./loader/egg_loader.js";
+import { Singleton } from "./singleton.js";
+import { debuglog } from "node:util";
+import assert from "node:assert";
+import { Application as KoaApplication, Context as KoaContext, Request as KoaRequest, Response as KoaResponse } from "@eggjs/koa";
+import { EggConsoleLogger } from "egg-logger";
+import { EggRouter as Router } from "@eggjs/router";
+
+//#region src/egg.ts
+const debug = debuglog("egg/core/egg");
+const EGG_LOADER = Symbol.for("egg#loader");
+var Request$1 = class extends KoaRequest {};
+var Response$1 = class extends KoaResponse {};
+var Context$1 = class extends KoaContext {
+	/**
+	* Returns map of URL parameters for given `path` and `paramNames`.
+	* @example
+	* ##### ctx.params.id {string}
+	*
+	* `GET /api/users/1` => `'1'`
+	*
+	* ##### ctx.params.per_page {string}
+	*
+	* The number of every page, `GET /api/users?per_page=20` => `20`
+	*/
+	params;
+	/**
+	* Returns array of router regexp url path captures.
+	*/
+	captures;
+	/**
+	* Returns the name of the matched router.
+	*/
+	routerName;
+	/**
+	* Returns the path of the matched router.
+	*/
+	routerPath;
+};
+var EggCore = class EggCore extends KoaApplication {
+	options;
+	timing;
+	console;
+	BaseContextClass;
+	Controller;
+	Service;
+	Helper;
+	lifecycle;
+	loader;
+	#closePromise;
+	#router;
+	/** auto inject on loadService() */
+	serviceClasses = {};
+	/** auto inject on loadController() */
+	controller = {};
+	/** auto inject on loadMiddleware() */
+	middlewares = {};
+	/**
+	* @class
+	* @param {Object} options - options
+	* @param {String} [options.baseDir] - the directory of application
+	* @param {String} [options.type] - whether it's running in app worker or agent worker
+	* @param {Object} [options.plugins] - custom plugins
+	* @since 1.0.0
+	*/
+	constructor(options = {}) {
+		options.baseDir = options.baseDir ?? process.cwd();
+		options.type = options.type ?? "application";
+		assert(typeof options.baseDir === "string", "options.baseDir required, and must be a string");
+		assert(options.type === "application" || options.type === "agent", "options.type should be application or agent");
+		super();
+		this.timing = new Timing();
+		/**
+		* @member {Object} EggCore#options
+		* @private
+		* @since 1.0.0
+		*/
+		this.options = options;
+		/**
+		* logging for EggCore, avoid using console directly
+		* @member {Logger} EggCore#console
+		* @private
+		* @since 1.0.0
+		*/
+		this.console = new EggConsoleLogger();
+		/**
+		* @member {BaseContextClass} EggCore#BaseContextClass
+		* @since 1.0.0
+		*/
+		this.BaseContextClass = BaseContextClass;
+		/**
+		* Retrieve base controller
+		* @member {Controller} EggCore#Controller
+		* @since 1.0.0
+		*/
+		this.Controller = this.BaseContextClass;
+		/**
+		* Retrieve base service
+		* @member {Service} EggCore#Service
+		* @since 1.0.0
+		*/
+		this.Service = this.BaseContextClass;
+		this.lifecycle = new Lifecycle({
+			baseDir: options.baseDir,
+			app: this,
+			logger: this.console
+		});
+		this.lifecycle.on("error", (err) => this.emit("error", err));
+		this.lifecycle.on("ready_timeout", (id) => this.emit("ready_timeout", id));
+		this.lifecycle.on("ready_stat", (data) => this.emit("ready_stat", data));
+		/**
+		* The loader instance, the default class is {@link EggLoader}.
+		* If you want define
+		* @member {EggLoader} EggCore#loader
+		* @since 1.0.0
+		*/
+		const Loader = this[EGG_LOADER];
+		assert(Loader, "Symbol.for('egg#loader') is required");
+		this.loader = new Loader({
+			baseDir: options.baseDir,
+			app: this,
+			plugins: options.plugins,
+			logger: this.console,
+			serverScope: options.serverScope,
+			env: options.env ?? "",
+			EggCoreClass: EggCore
+		});
+	}
+	get logger() {
+		return this.console;
+	}
+	get coreLogger() {
+		return this.console;
+	}
+	/**
+	* 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, create) {
+		const initPromise = new Singleton({
+			name,
+			create,
+			app: this
+		}).init();
+		if (initPromise) this.lifecycle.registerBeforeStart(async () => {
+			await initPromise;
+		}, `${name}-singleton-init`);
+	}
+	/**
+	* override koa's app.use, support generator function
+	* @since 1.0.0
+	*/
+	use(fn) {
+		assert(typeof fn === "function", "app.use() requires a function");
+		debug("[use] add middleware: %o", fn._name || fn.name || "-");
+		this.middleware.push(fn);
+		return this;
+	}
+	/**
+	* Whether `application` or `agent`
+	* @member {String}
+	* @since 1.0.0
+	*/
+	get type() {
+		return this.options.type;
+	}
+	/**
+	* The current directory of application
+	* @member {String}
+	* @see {@link AppInfo#baseDir}
+	* @since 1.0.0
+	*/
+	get baseDir() {
+		return this.options.baseDir;
+	}
+	/**
+	* Alias to {@link https://npmjs.com/package/depd}
+	* @member {Function}
+	* @since 1.0.0
+	*/
+	get deprecate() {
+		return utils_default.deprecated;
+	}
+	/**
+	* The name of application
+	* @member {String}
+	* @see {@link AppInfo#name}
+	* @since 1.0.0
+	*/
+	get name() {
+		return this.loader ? this.loader.pkg.name : "";
+	}
+	/**
+	* Retrieve enabled plugins
+	* @member {Object}
+	* @since 1.0.0
+	*/
+	get plugins() {
+		return this.loader ? this.loader.plugins : {};
+	}
+	/**
+	* The configuration of application
+	* @member {Config}
+	* @since 1.0.0
+	*/
+	get config() {
+		return this.loader ? this.loader.config : {};
+	}
+	/**
+	* Execute scope after loaded and before app start.
+	*
+	* Notice:
+	* This method is now NOT recommended and regarded as a deprecated one,
+	* For plugin development, we should use `didLoad` instead.
+	* For application development, we should use `willReady` instead.
+	*
+	* @see https://eggjs.org/en/advanced/loader.html#beforestart
+	*
+	* @param  {Function} scope function will execute before app start
+	* @param {string} [name] scope name, default is empty string
+	*/
+	beforeStart(scope, name) {
+		this.deprecate("`beforeStart` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		this.lifecycle.registerBeforeStart(scope, name ?? "");
+	}
+	ready(flagOrFunction) {
+		if (flagOrFunction === void 0) return this.lifecycle.ready();
+		return this.lifecycle.ready(flagOrFunction);
+	}
+	/**
+	* If a client starts asynchronously, you can register `readyCallback`,
+	* then the application will wait for the callback to ready
+	*
+	* It will log when the callback is not invoked after 10s
+	*
+	* Recommend to use {@link EggCore#beforeStart}
+	* @since 1.0.0
+	*
+	* @param {String} name - readyCallback task name
+	* @param {object} opts -
+	*   - {Number} [timeout=10000] - emit `ready_timeout` when it doesn't finish but reach the timeout
+	*   - {Boolean} [isWeakDep=false] - whether it's a weak dependency
+	* @returns {Function} - a callback
+	* @example
+	* const done = app.readyCallback('mysql');
+	* mysql.ready(done);
+	*/
+	readyCallback(name, opts) {
+		this.deprecate("`readyCallback` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		return this.lifecycle.legacyReadyCallback(name, opts);
+	}
+	/**
+	* Register a function that will be called when app close.
+	*
+	* Notice:
+	* This method is now NOT recommended directly used,
+	* Developers SHOULDN'T use app.beforeClose directly now,
+	* but in the form of class to implement beforeClose instead.
+	*
+	* @see https://eggjs.org/en/advanced/loader.html#beforeclose
+	*
+	* @param {Function} fn - the function that can be generator function or async function.
+	*/
+	beforeClose(fn, name) {
+		this.deprecate("`beforeClose` was deprecated, please use \"Life Cycles\" instead, see https://www.eggjs.org/advanced/loader#life-cycles");
+		this.lifecycle.registerBeforeClose(fn, name);
+	}
+	/**
+	* Close all, it will close
+	* - callbacks registered by beforeClose
+	* - emit `close` event
+	* - remove add listeners
+	*
+	* If error is thrown when it's closing, the promise will reject.
+	* It will also reject after following call.
+	* @returns {Promise} promise
+	* @since 1.0.0
+	*/
+	async close() {
+		if (this.#closePromise) return this.#closePromise;
+		this.#closePromise = this.lifecycle.close();
+		return this.#closePromise;
+	}
+	/**
+	* get router
+	* @member {Router} EggCore#router
+	* @since 1.0.0
+	*/
+	get router() {
+		if (this.#router) return this.#router;
+		this.#router = new Router({ sensitive: true }, this);
+		return this.#router;
+	}
+	/**
+	* Alias to {@link Router#url}
+	* @param {String} name - Router name
+	* @param {Object} params - more parameters
+	* @returns {String} url
+	*/
+	url(name, params) {
+		return this.router.url(name, params);
+	}
+	head(...args) {
+		this.router.head.apply(this.router, args);
+		return this;
+	}
+	get(...args) {
+		this.router.get.apply(this.router, args);
+		return this;
+	}
+	put(...args) {
+		this.router.put.apply(this.router, args);
+		return this;
+	}
+	patch(...args) {
+		this.router.patch.apply(this.router, args);
+		return this;
+	}
+	post(...args) {
+		this.router.post.apply(this.router, args);
+		return this;
+	}
+	delete(...args) {
+		this.router.delete.apply(this.router, args);
+		return this;
+	}
+	del(...args) {
+		this.router.del.apply(this.router, args);
+		return this;
+	}
+	all(...args) {
+		this.router.all.apply(this.router, args);
+		return this;
+	}
+	resources(...args) {
+		this.router.resources.apply(this.router, args);
+		return this;
+	}
+	redirect(source, destination, status = 301) {
+		this.router.redirect(source, destination, status);
+		return this;
+	}
+	register(path, methods, middleware, opts) {
+		this.router.register(path, methods, middleware, opts);
+		return this;
+	}
+	get [EGG_LOADER]() {
+		return EggLoader;
+	}
+};
+
+//#endregion
+export { Context$1 as Context, EGG_LOADER, EggCore, KoaApplication, KoaContext, KoaRequest, KoaResponse, Request$1 as Request, Response$1 as Response, Router };

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { _default } from "./utils/index.js";
+import { CustomLoaderConfigItem, EggAppConfig, EggAppInfo, EggPluginInfo } from "./types.js";
+import { BaseContextClass } from "./base_context_class.js";
+import { Timing, TimingItem } from "./utils/timing.js";
+import { BootImplClass, FunWithFullPath, ILifecycleBoot, Lifecycle, LifecycleOptions } from "./lifecycle.js";
+import { CaseStyle, CaseStyleFunction, EXPORTS, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem } from "./loader/file_loader.js";
+import { ClassLoader, ClassLoaderOptions, ContextLoader, ContextLoaderOptions } from "./loader/context_loader.js";
+import { EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions } from "./loader/egg_loader.js";
+import { Singleton, SingletonCreateMethod, SingletonOptions } from "./singleton.js";
+import { Context, EGG_LOADER, EggCore, EggCoreInitOptions, EggCoreOptions, KoaApplication, KoaContext, KoaMiddlewareFunc, KoaRequest, KoaResponse, MiddlewareFunc, Next, Request, Response, Router } from "./egg.js";
+import { SequencifyResult, SequencifyTask, sequencify } from "./utils/sequencify.js";
+export { BaseContextClass, BootImplClass, CaseStyle, CaseStyleFunction, ClassLoader, ClassLoaderOptions, Context, ContextLoader, ContextLoaderOptions, CustomLoaderConfigItem, EGG_LOADER, EXPORTS, EggAppConfig, EggAppInfo, EggCore, EggCoreInitOptions, EggCoreOptions, EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions, EggPluginInfo, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem, FunWithFullPath, ILifecycleBoot, KoaApplication, KoaContext, KoaMiddlewareFunc, KoaRequest, KoaResponse, Lifecycle, LifecycleOptions, MiddlewareFunc, Next, Request, Response, Router, SequencifyResult, SequencifyTask, Singleton, SingletonCreateMethod, SingletonOptions, Timing, TimingItem, sequencify, _default as utils };

package/dist/index.js

@@ -0,0 +1,12 @@
+import utils_default from "./utils/index.js";
+import { BaseContextClass } from "./base_context_class.js";
+import { Timing } from "./utils/timing.js";
+import { Lifecycle } from "./lifecycle.js";
+import { CaseStyle, EXPORTS, FULLPATH, FileLoader } from "./loader/file_loader.js";
+import { ClassLoader, ContextLoader } from "./loader/context_loader.js";
+import { sequencify } from "./utils/sequencify.js";
+import { EggLoader } from "./loader/egg_loader.js";
+import { Singleton } from "./singleton.js";
+import { Context, EGG_LOADER, EggCore, KoaApplication, KoaContext, KoaRequest, KoaResponse, Request, Response, Router } from "./egg.js";
+
+export { BaseContextClass, CaseStyle, ClassLoader, Context, ContextLoader, EGG_LOADER, EXPORTS, EggCore, EggLoader, FULLPATH, FileLoader, KoaApplication, KoaContext, KoaRequest, KoaResponse, Lifecycle, Request, Response, Router, Singleton, Timing, sequencify, utils_default as utils };

package/dist/lifecycle.d.ts

@@ -0,0 +1,84 @@
+import { Fun } from "./utils/index.js";
+import { Timing } from "./utils/timing.js";
+import { EggCore } from "./egg.js";
+import * as egg_logger0 from "egg-logger";
+import { EggConsoleLogger } from "egg-logger";
+import { EventEmitter } from "node:events";
+import { ReadyFunctionArg } from "get-ready";
+import { Ready as Ready$1 } from "ready-callback";
+
+//#region src/lifecycle.d.ts
+interface ILifecycleBoot {
+  fullPath?: string;
+  /**
+   * Ready to call configDidLoad,
+   * Config, plugin files are referred,
+   * this is the last chance to modify the config.
+   */
+  configWillLoad?(): void;
+  /**
+   * Config, plugin files have loaded
+   */
+  configDidLoad?(): void;
+  /**
+   * All files have loaded, start plugin here
+   */
+  didLoad?(): Promise<void>;
+  /**
+   * All plugins have started, can do some thing before app ready
+   */
+  willReady?(): Promise<void>;
+  /**
+   * Worker is ready, can do some things,
+   * don't need to block the app boot
+   */
+  didReady?(err?: Error): Promise<void>;
+  /**
+   * Server is listening
+   */
+  serverDidReady?(): Promise<void>;
+  /**
+   * Do some thing before app close
+   */
+  beforeClose?(): Promise<void>;
+}
+type BootImplClass<T = ILifecycleBoot> = new (...args: any[]) => T;
+interface LifecycleOptions {
+  baseDir: string;
+  app: EggCore;
+  logger: EggConsoleLogger;
+}
+type FunWithFullPath = Fun & {
+  fullPath?: string;
+};
+declare class Lifecycle extends EventEmitter {
+  #private;
+  loadReady: Ready$1;
+  bootReady: Ready$1;
+  options: LifecycleOptions;
+  readyTimeout: number;
+  constructor(options: Partial<LifecycleOptions>);
+  ready(): Promise<void>;
+  ready(flagOrFunction: ReadyFunctionArg): void;
+  get app(): EggCore;
+  get logger(): EggConsoleLogger<egg_logger0.LoggerOptions>;
+  get timing(): Timing;
+  legacyReadyCallback(name: string, opt?: object): (...args: unknown[]) => void;
+  addBootHook(bootHootOrBootClass: BootImplClass | ILifecycleBoot): void;
+  addFunctionAsBootHook<T = EggCore>(hook: (app: T) => void, fullPath?: string): void;
+  /**
+   * init boots and trigger config did config
+   */
+  init(): void;
+  registerBeforeStart(scope: Fun, name: string): void;
+  registerBeforeClose(fn: FunWithFullPath, fullPath?: string): void;
+  close(): Promise<void>;
+  triggerConfigWillLoad(): void;
+  triggerConfigDidLoad(): void;
+  triggerDidLoad(): void;
+  triggerWillReady(): void;
+  triggerDidReady(err?: Error): Promise<void>;
+  triggerServerDidReady(): Promise<void>;
+}
+//#endregion
+export { BootImplClass, FunWithFullPath, ILifecycleBoot, Lifecycle, LifecycleOptions };