@eggjs/core 6.5.0 → 6.6.0-beta.3

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 };

package/dist/lifecycle.js

@@ -0,0 +1,280 @@
+import utils_default from "./utils/index.js";
+import { debuglog, format } from "node:util";
+import assert from "node:assert";
+import { EggConsoleLogger } from "egg-logger";
+import { EventEmitter } from "node:events";
+import { isClass } from "is-type-of";
+import { Ready } from "get-ready";
+import { Ready as Ready$1 } from "ready-callback";
+
+//#region src/lifecycle.ts
+const debug = debuglog("egg/core/lifecycle");
+var Lifecycle = class extends EventEmitter {
+	#init;
+	#readyObject;
+	#bootHooks;
+	#boots;
+	#isClosed;
+	#closeFunctionSet;
+	loadReady;
+	bootReady;
+	options;
+	readyTimeout;
+	constructor(options) {
+		super();
+		options.logger = options.logger ?? new EggConsoleLogger();
+		this.options = options;
+		this.#readyObject = new Ready();
+		this.#bootHooks = [];
+		this.#boots = [];
+		this.#closeFunctionSet = /* @__PURE__ */ new Set();
+		this.#isClosed = false;
+		this.#init = false;
+		this.timing.start(`${this.options.app.type} Start`);
+		const eggReadyTimeoutEnv = Number.parseInt(process.env.EGG_READY_TIMEOUT_ENV || "10000");
+		assert(Number.isInteger(eggReadyTimeoutEnv), `process.env.EGG_READY_TIMEOUT_ENV ${process.env.EGG_READY_TIMEOUT_ENV} should be able to parseInt.`);
+		this.readyTimeout = eggReadyTimeoutEnv;
+		this.#initReady();
+		this.on("ready_stat", (data) => {
+			this.logger.info("[egg/core/lifecycle:ready_stat] end ready task %s, remain %j", data.id, data.remain);
+		}).on("ready_timeout", (id) => {
+			this.logger.warn("[egg/core/lifecycle:ready_timeout] %s seconds later %s was still unable to finish.", this.readyTimeout / 1e3, id);
+		});
+		this.ready((err) => {
+			this.triggerDidReady(err);
+			debug("app ready");
+			this.timing.end(`${this.options.app.type} Start`);
+		});
+	}
+	ready(flagOrFunction) {
+		if (flagOrFunction === void 0) return this.#readyObject.ready();
+		return this.#readyObject.ready(flagOrFunction);
+	}
+	get app() {
+		return this.options.app;
+	}
+	get logger() {
+		return this.options.logger;
+	}
+	get timing() {
+		return this.app.timing;
+	}
+	legacyReadyCallback(name, opt) {
+		const timingKeyPrefix = "readyCallback";
+		const timing = this.timing;
+		const cb = this.loadReady.readyCallback(name, opt);
+		const timingKey = `${timingKeyPrefix} in ` + utils_default.getResolvedFilename(name, this.app.baseDir);
+		this.timing.start(timingKey);
+		debug("register legacyReadyCallback");
+		return function legacyReadyCallback(...args) {
+			timing.end(timingKey);
+			debug("end legacyReadyCallback");
+			cb(...args);
+		};
+	}
+	addBootHook(bootHootOrBootClass) {
+		assert(this.#init === false, "do not add hook when lifecycle has been initialized");
+		this.#bootHooks.push(bootHootOrBootClass);
+	}
+	addFunctionAsBootHook(hook, fullPath) {
+		assert(this.#init === false, "do not add hook when lifecycle has been initialized");
+		class Boot {
+			static fullPath;
+			app;
+			constructor(app) {
+				this.app = app;
+			}
+			configDidLoad() {
+				hook(this.app);
+			}
+		}
+		Boot.fullPath = fullPath;
+		this.#bootHooks.push(Boot);
+	}
+	/**
+	* init boots and trigger config did config
+	*/
+	init() {
+		debug("%s init lifecycle", this.app.type);
+		assert(this.#init === false, "lifecycle have been init");
+		this.#init = true;
+		this.#boots = this.#bootHooks.map((BootHootOrBootClass) => {
+			let instance = BootHootOrBootClass;
+			if (isClass(BootHootOrBootClass)) {
+				instance = new BootHootOrBootClass(this.app);
+				if (!instance.fullPath && "fullPath" in BootHootOrBootClass) instance.fullPath = BootHootOrBootClass.fullPath;
+			}
+			debug("[init] add boot instance: %o", instance.fullPath);
+			return instance;
+		});
+	}
+	registerBeforeStart(scope, name) {
+		debug("%s add registerBeforeStart, name: %o", this.options.app.type, name);
+		this.#registerReadyCallback({
+			scope,
+			ready: this.loadReady,
+			timingKeyPrefix: "Before Start",
+			scopeFullName: name
+		});
+	}
+	registerBeforeClose(fn, fullPath) {
+		assert(typeof fn === "function", "argument should be function");
+		assert(this.#isClosed === false, "app has been closed");
+		if (fullPath) fn.fullPath = fullPath;
+		this.#closeFunctionSet.add(fn);
+		debug("%s register beforeClose at %o, count: %d", this.app.type, fullPath, this.#closeFunctionSet.size);
+	}
+	async close() {
+		const closeFns = Array.from(this.#closeFunctionSet);
+		debug("%s start trigger %d beforeClose functions", this.app.type, closeFns.length);
+		for (const fn of closeFns.reverse()) {
+			debug("%s trigger beforeClose at %o", this.app.type, fn.fullPath);
+			await utils_default.callFn(fn);
+			this.#closeFunctionSet.delete(fn);
+		}
+		this.app.emit("close");
+		this.removeAllListeners();
+		this.app.removeAllListeners();
+		this.#isClosed = true;
+		debug("%s closed", this.app.type);
+	}
+	triggerConfigWillLoad() {
+		debug("trigger configWillLoad start");
+		for (const boot of this.#boots) if (typeof boot.configWillLoad === "function") {
+			debug("trigger configWillLoad at %o", boot.fullPath);
+			boot.configWillLoad();
+		}
+		debug("trigger configWillLoad end");
+		this.triggerConfigDidLoad();
+	}
+	triggerConfigDidLoad() {
+		debug("trigger configDidLoad start");
+		for (const boot of this.#boots) {
+			if (typeof boot.configDidLoad === "function") {
+				debug("trigger configDidLoad at %o", boot.fullPath);
+				boot.configDidLoad();
+			}
+			if (typeof boot.beforeClose === "function") {
+				const beforeClose = boot.beforeClose.bind(boot);
+				this.registerBeforeClose(beforeClose, boot.fullPath);
+			}
+		}
+		debug("trigger configDidLoad end");
+		this.triggerDidLoad();
+	}
+	triggerDidLoad() {
+		debug("trigger didLoad start");
+		debug("loadReady start");
+		this.loadReady.start();
+		for (const boot of this.#boots) if (typeof boot.didLoad === "function") {
+			const didLoad = boot.didLoad.bind(boot);
+			this.#registerReadyCallback({
+				scope: didLoad,
+				ready: this.loadReady,
+				timingKeyPrefix: "Did Load",
+				scopeFullName: boot.fullPath + ":didLoad"
+			});
+		}
+	}
+	triggerWillReady() {
+		debug("trigger willReady start");
+		debug("bootReady start");
+		this.bootReady.start();
+		for (const boot of this.#boots) if (typeof boot.willReady === "function") {
+			const willReady = boot.willReady.bind(boot);
+			this.#registerReadyCallback({
+				scope: willReady,
+				ready: this.bootReady,
+				timingKeyPrefix: "Will Ready",
+				scopeFullName: boot.fullPath + ":willReady"
+			});
+		}
+	}
+	triggerDidReady(err) {
+		debug("trigger didReady start");
+		return (async () => {
+			for (const boot of this.#boots) if (typeof boot.didReady === "function") {
+				debug("trigger didReady at %o", boot.fullPath);
+				try {
+					await boot.didReady(err);
+				} catch (err$1) {
+					debug("trigger didReady error at %o, error: %s", boot.fullPath, err$1);
+					this.emit("error", err$1);
+				}
+			}
+			debug("trigger didReady end");
+		})();
+	}
+	triggerServerDidReady() {
+		debug("trigger serverDidReady start");
+		return (async () => {
+			for (const boot of this.#boots) {
+				if (typeof boot.serverDidReady !== "function") continue;
+				debug("trigger serverDidReady at %o", boot.fullPath);
+				try {
+					await boot.serverDidReady();
+				} catch (err) {
+					debug("trigger serverDidReady error at %o, error: %s", boot.fullPath, err);
+					this.emit("error", err);
+				}
+			}
+			debug("trigger serverDidReady end");
+		})();
+	}
+	#initReady() {
+		debug("loadReady init");
+		this.loadReady = new Ready$1({
+			timeout: this.readyTimeout,
+			lazyStart: true
+		});
+		this.#delegateReadyEvent(this.loadReady);
+		this.loadReady.ready((err) => {
+			debug("loadReady end, err: %o", err);
+			debug("trigger didLoad end");
+			if (err) this.ready(err);
+			else this.triggerWillReady();
+		});
+		debug("bootReady init");
+		this.bootReady = new Ready$1({
+			timeout: this.readyTimeout,
+			lazyStart: true
+		});
+		this.#delegateReadyEvent(this.bootReady);
+		this.bootReady.ready((err) => {
+			debug("bootReady end, err: %o", err);
+			debug("trigger willReady end");
+			this.ready(err || true);
+		});
+	}
+	#delegateReadyEvent(ready) {
+		ready.once("error", (err) => ready.ready(err));
+		ready.on("ready_timeout", (id) => this.emit("ready_timeout", id));
+		ready.on("ready_stat", (data) => this.emit("ready_stat", data));
+		ready.on("error", (err) => this.emit("error", err));
+	}
+	#registerReadyCallback(args) {
+		const { scope, ready, timingKeyPrefix, scopeFullName } = args;
+		if (typeof scope !== "function") throw new TypeError("boot only support function");
+		const name = scopeFullName || utils_default.getCalleeFromStack(true, 4);
+		const timingKey = `${timingKeyPrefix} in ` + utils_default.getResolvedFilename(name, this.app.baseDir);
+		this.timing.start(timingKey);
+		debug("[registerReadyCallback] start name: %o", name);
+		const done = ready.readyCallback(name);
+		process.nextTick(async () => {
+			try {
+				await utils_default.callFn(scope);
+				debug("[registerReadyCallback] end name: %o", name);
+				done();
+				this.timing.end(timingKey);
+			} catch (e) {
+				let err = e;
+				if (!(err instanceof Error)) err = new Error(format("%s", err));
+				done(err);
+				this.timing.end(timingKey);
+			}
+		});
+	}
+};
+
+//#endregion
+export { Lifecycle };

package/dist/loader/context_loader.d.ts

@@ -0,0 +1,39 @@
+import { FileLoader, FileLoaderOptions } from "./file_loader.js";
+import { Context } from "../egg.js";
+
+//#region src/loader/context_loader.d.ts
+interface ClassLoaderOptions {
+  ctx: Context;
+  properties: any;
+}
+declare class ClassLoader {
+  #private;
+  readonly _cache: Map<any, any>;
+  _ctx: Context;
+  constructor(options: ClassLoaderOptions);
+}
+interface ContextLoaderOptions extends Omit<FileLoaderOptions, 'target'> {
+  /** required inject */
+  inject: Record<string, any>;
+  /** property name defined to target */
+  property: string | symbol;
+  /** determine the field name of inject object. */
+  fieldClass?: string;
+}
+/**
+ * Same as {@link FileLoader}, but it will attach file to `inject[fieldClass]`.
+ * The exports will be lazy loaded, such as `ctx.group.repository`.
+ * @augments FileLoader
+ * @since 1.0.0
+ */
+declare class ContextLoader extends FileLoader {
+  #private;
+  /**
+   * @class
+   * @param {Object} options - options same as {@link FileLoader}
+   * @param {String} options.fieldClass - determine the field name of inject object.
+   */
+  constructor(options: ContextLoaderOptions);
+}
+//#endregion
+export { ClassLoader, ClassLoaderOptions, ContextLoader, ContextLoaderOptions };

package/dist/loader/context_loader.js

@@ -0,0 +1,79 @@
+import { EXPORTS, FileLoader } from "./file_loader.js";
+import assert from "node:assert";
+import { isClass, isPrimitive } from "is-type-of";
+
+//#region src/loader/context_loader.ts
+const CLASS_LOADER = Symbol("classLoader");
+var ClassLoader = class {
+	_cache = /* @__PURE__ */ new Map();
+	_ctx;
+	constructor(options) {
+		assert(options.ctx, "options.ctx is required");
+		const properties = options.properties;
+		this._ctx = options.ctx;
+		for (const property in properties) this.#defineProperty(property, properties[property]);
+	}
+	#defineProperty(property, values) {
+		Object.defineProperty(this, property, { get() {
+			let instance = this._cache.get(property);
+			if (!instance) {
+				instance = getInstance(values, this._ctx);
+				this._cache.set(property, instance);
+			}
+			return instance;
+		} });
+	}
+};
+/**
+* Same as {@link FileLoader}, but it will attach file to `inject[fieldClass]`.
+* The exports will be lazy loaded, such as `ctx.group.repository`.
+* @augments FileLoader
+* @since 1.0.0
+*/
+var ContextLoader = class extends FileLoader {
+	#inject;
+	/**
+	* @class
+	* @param {Object} options - options same as {@link FileLoader}
+	* @param {String} options.fieldClass - determine the field name of inject object.
+	*/
+	constructor(options) {
+		assert(options.property, "options.property is required");
+		assert(options.inject, "options.inject is required");
+		const target = {};
+		if (options.fieldClass) options.inject[options.fieldClass] = target;
+		super({
+			...options,
+			target
+		});
+		this.#inject = this.options.inject;
+		const app = this.#inject;
+		const property = options.property;
+		Object.defineProperty(app.context, property, { get() {
+			const ctx = this;
+			if (!ctx[CLASS_LOADER]) ctx[CLASS_LOADER] = /* @__PURE__ */ new Map();
+			const classLoader = ctx[CLASS_LOADER];
+			let instance = classLoader.get(property);
+			if (!instance) {
+				instance = getInstance(target, ctx);
+				classLoader.set(property, instance);
+			}
+			return instance;
+		} });
+	}
+};
+function getInstance(values, ctx) {
+	const Class = values[EXPORTS] ? values : null;
+	let instance;
+	if (Class) if (isClass(Class)) instance = new Class(ctx);
+	else instance = Class;
+	else if (isPrimitive(values)) instance = values;
+	else instance = new ClassLoader({
+		ctx,
+		properties: values
+	});
+	return instance;
+}
+
+//#endregion
+export { ClassLoader, ContextLoader };