@eggjs/core 6.4.1 → 6.6.0-beta.2

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