@eggjs/tegg-plugin 4.0.0-beta.3 → 4.0.0-beta.5

package/dist/lib/CompatibleUtil.js

@@ -0,0 +1,96 @@
+import { EggPrototypeFactory } from "@eggjs/tegg-metadata";
+import { InitTypeQualifierAttribute, ObjectInitType } from "@eggjs/tegg";
+import { ProxyUtil } from "@eggjs/tegg-common-util";
+import { EggContainerFactory } from "@eggjs/tegg-runtime";
+import { Application, Context } from "egg";
+
+//#region src/lib/CompatibleUtil.ts
+var CompatibleUtil = class CompatibleUtil {
+	static singletonProtoCache = /* @__PURE__ */ new Map();
+	static requestProtoCache = /* @__PURE__ */ new Map();
+	static getSingletonProto(name) {
+		if (!this.singletonProtoCache.has(name)) {
+			const proto = EggPrototypeFactory.instance.getPrototype(name, void 0, [{
+				attribute: InitTypeQualifierAttribute,
+				value: ObjectInitType.SINGLETON
+			}]);
+			this.singletonProtoCache.set(name, proto);
+		}
+		return this.singletonProtoCache.get(name);
+	}
+	static getRequestProto(name) {
+		if (!this.requestProtoCache.has(name)) {
+			const proto = EggPrototypeFactory.instance.getPrototype(name, void 0, [{
+				attribute: InitTypeQualifierAttribute,
+				value: ObjectInitType.CONTEXT
+			}]);
+			this.requestProtoCache.set(name, proto);
+		}
+		return this.requestProtoCache.get(name);
+	}
+	static singletonModuleProxyFactory(app, loadUnitInstance) {
+		let deprecated = false;
+		return function(_, p) {
+			const proto = CompatibleUtil.getSingletonProto(p);
+			const eggObj = EggContainerFactory.getEggObject(proto);
+			if (!deprecated) {
+				deprecated = true;
+				app.deprecate(`[egg/module] Please use await app.getEggObject(clazzName) instead of app.${loadUnitInstance.name}.${String(p)}`);
+			}
+			return eggObj.obj;
+		};
+	}
+	static appCompatible(app, loadUnitInstance) {
+		const moduleLoadUnitProxy = ProxyUtil.safeProxy(loadUnitInstance, CompatibleUtil.singletonModuleProxyFactory(app, loadUnitInstance));
+		Reflect.defineProperty(app.module, loadUnitInstance.name, {
+			configurable: true,
+			value: moduleLoadUnitProxy
+		});
+	}
+	static contextModuleProxyFactory(holder, ctx, loadUnitInstance) {
+		const cacheKey = `_${loadUnitInstance.name}Proxy`;
+		if (!holder[cacheKey]) {
+			let deprecated = false;
+			const getter = function(_, p) {
+				const proto = CompatibleUtil.getRequestProto(p);
+				const eggObj = EggContainerFactory.getEggObject(proto, p);
+				if (!deprecated) {
+					deprecated = true;
+					ctx.app.deprecate(`[egg/module] Please use await ctx.getEggObject(clazzName) instead of ctx.${loadUnitInstance.name}.${String(p)}`);
+				}
+				return eggObj.obj;
+			};
+			holder[cacheKey] = ProxyUtil.safeProxy(loadUnitInstance, getter);
+		}
+		return holder[cacheKey];
+	}
+	static contextModuleCompatible(ctx, loadUnitInstances) {
+		const loadUnitInstanceMap = loadUnitInstances.reduce((p, c) => {
+			p[c.name] = c;
+			return p;
+		}, {});
+		Reflect.defineProperty(ctx, "module", {
+			configurable: true,
+			enumerable: true,
+			get() {
+				const ctx$1 = this;
+				if (!this._moduleProxy) {
+					const ctxModule = Object.create(loadUnitInstanceMap);
+					this._moduleProxy = ProxyUtil.safeProxy(ctxModule, (_, p) => {
+						const loadUnitInstance = Reflect.get(ctxModule, p);
+						if (!loadUnitInstance) return;
+						return CompatibleUtil.contextModuleProxyFactory(ctxModule, ctx$1, loadUnitInstance);
+					});
+				}
+				return this._moduleProxy;
+			}
+		});
+	}
+	static clean() {
+		this.singletonProtoCache.clear();
+		this.requestProtoCache.clear();
+	}
+};
+
+//#endregion
+export { CompatibleUtil };

package/dist/lib/ConfigSourceLoadUnitHook.d.ts

@@ -0,0 +1,15 @@
+import { LoadUnit, LoadUnitLifecycleContext } from "@eggjs/tegg-metadata";
+import { LifecycleHook } from "@eggjs/tegg";
+
+//#region src/lib/ConfigSourceLoadUnitHook.d.ts
+
+/**
+ * Copy from standalone/src/ConfigSourceLoadUnitHook
+ * Hook for inject moduleConfig.
+ * Add default qualifier value is current module name.
+ */
+declare class ConfigSourceLoadUnitHook implements LifecycleHook<LoadUnitLifecycleContext, LoadUnit> {
+  preCreate(ctx: LoadUnitLifecycleContext, loadUnit: LoadUnit): Promise<void>;
+}
+//#endregion
+export { ConfigSourceLoadUnitHook };

package/dist/lib/ConfigSourceLoadUnitHook.js

@@ -0,0 +1,22 @@
+import "@eggjs/tegg-metadata";
+import { ConfigSourceQualifier, ConfigSourceQualifierAttribute, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
+
+//#region src/lib/ConfigSourceLoadUnitHook.ts
+/**
+* Copy from standalone/src/ConfigSourceLoadUnitHook
+* Hook for inject moduleConfig.
+* Add default qualifier value is current module name.
+*/
+var ConfigSourceLoadUnitHook = class {
+	async preCreate(ctx, loadUnit) {
+		const classList = await ctx.loader.load();
+		for (const clazz of classList) {
+			const moduleConfigObject = PrototypeUtil.getInjectObjects(clazz).find((t) => t.objName === "moduleConfig");
+			const configSourceQualifier = QualifierUtil.getProperQualifier(clazz, "moduleConfig", ConfigSourceQualifierAttribute);
+			if (moduleConfigObject && !configSourceQualifier) ConfigSourceQualifier(loadUnit.name)(clazz.prototype, moduleConfigObject.refName);
+		}
+	}
+};
+
+//#endregion
+export { ConfigSourceLoadUnitHook };

package/dist/lib/EggAppLoader.d.ts

@@ -0,0 +1,20 @@
+import { Loader } from "@eggjs/tegg-metadata";
+import { EggProtoImplClass } from "@eggjs/tegg";
+import { Application } from "egg";
+
+//#region src/lib/EggAppLoader.d.ts
+declare const APP_CLAZZ_BLACK_LIST: string[];
+declare const CONTEXT_CLAZZ_BLACK_LIST: string[];
+declare const DEFAULT_APP_CLAZZ: string[];
+declare const DEFAULT_CONTEXT_CLAZZ: string[];
+declare class EggAppLoader implements Loader {
+  private readonly app;
+  private readonly moduleConfigLoader;
+  constructor(app: Application);
+  private buildClazz;
+  private buildAppLoggerClazz;
+  private getLoggerNames;
+  load(): Promise<EggProtoImplClass[]>;
+}
+//#endregion
+export { APP_CLAZZ_BLACK_LIST, CONTEXT_CLAZZ_BLACK_LIST, DEFAULT_APP_CLAZZ, DEFAULT_CONTEXT_CLAZZ, EggAppLoader };

package/dist/lib/EggAppLoader.js

@@ -0,0 +1,106 @@
+import { COMPATIBLE_PROTO_IMPLE_TYPE } from "./EggCompatibleProtoImpl.js";
+import { ModuleConfigLoader } from "./ModuleConfigLoader.js";
+import { TeggError } from "@eggjs/tegg-metadata";
+import { AccessLevel, EggQualifierAttribute, EggType, InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, ObjectInitType, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
+import { ObjectUtils } from "@eggjs/tegg-common-util";
+import { Application } from "egg";
+import { BackgroundTaskHelper as BackgroundTaskHelper$1 } from "@eggjs/tegg-background-task";
+import { EggObjectFactory } from "@eggjs/tegg-dynamic-inject-runtime";
+
+//#region src/lib/EggAppLoader.ts
+const APP_CLAZZ_BLACK_LIST = ["eggObjectFactory", "moduleConfigs"];
+const CONTEXT_CLAZZ_BLACK_LIST = ["logger"];
+const DEFAULT_APP_CLAZZ = [];
+const DEFAULT_CONTEXT_CLAZZ = ["user"];
+var EggAppLoader = class {
+	app;
+	moduleConfigLoader;
+	constructor(app) {
+		this.app = app;
+		this.moduleConfigLoader = new ModuleConfigLoader(this.app);
+	}
+	buildClazz(name, eggType) {
+		const app = this.app;
+		let func;
+		if (eggType === EggType.APP) func = function() {
+			return app[name];
+		};
+		else func = function() {
+			const ctx = app.currentContext;
+			if (!ctx) throw TeggError.create(`Can not read property \`${name}\` because egg ctx has been destroyed`, "read_after_ctx_destroyed");
+			return ctx[name];
+		};
+		Object.defineProperty(func, "name", {
+			value: name,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		PrototypeUtil.setIsEggPrototype(func);
+		PrototypeUtil.setFilePath(func, "mock_file_path");
+		PrototypeUtil.setProperty(func, {
+			name,
+			initType: ObjectInitType.SINGLETON,
+			accessLevel: AccessLevel.PUBLIC,
+			protoImplType: COMPATIBLE_PROTO_IMPLE_TYPE
+		});
+		QualifierUtil.addProtoQualifier(func, LoadUnitNameQualifierAttribute, "app");
+		QualifierUtil.addProtoQualifier(func, InitTypeQualifierAttribute, ObjectInitType.SINGLETON);
+		QualifierUtil.addProtoQualifier(func, EggQualifierAttribute, eggType);
+		return func;
+	}
+	buildAppLoggerClazz(name) {
+		const app = this.app;
+		const func = function() {
+			return app.getLogger(name);
+		};
+		Object.defineProperty(func, "name", {
+			value: name,
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		PrototypeUtil.setIsEggPrototype(func);
+		PrototypeUtil.setFilePath(func, "mock_file_path");
+		PrototypeUtil.setProperty(func, {
+			name,
+			initType: ObjectInitType.SINGLETON,
+			accessLevel: AccessLevel.PUBLIC,
+			protoImplType: COMPATIBLE_PROTO_IMPLE_TYPE
+		});
+		QualifierUtil.addProtoQualifier(func, LoadUnitNameQualifierAttribute, "app");
+		QualifierUtil.addProtoQualifier(func, InitTypeQualifierAttribute, ObjectInitType.SINGLETON);
+		QualifierUtil.addProtoQualifier(func, EggQualifierAttribute, EggType.APP);
+		return func;
+	}
+	getLoggerNames(ctxClazzNames, singletonClazzNames) {
+		return Array.from(this.app.loggers.keys()).filter((t) => !ctxClazzNames.includes(t) && !singletonClazzNames.includes(t));
+	}
+	async load() {
+		const app = this.app;
+		const appProperties = ObjectUtils.getProperties(app);
+		const contextProperties = ObjectUtils.getProperties(app.context);
+		const allSingletonClazzNameSet = new Set([...appProperties, ...DEFAULT_APP_CLAZZ]);
+		APP_CLAZZ_BLACK_LIST.forEach((t) => allSingletonClazzNameSet.delete(t));
+		const allSingletonClazzNames = Array.from(allSingletonClazzNameSet);
+		const allContextClazzNamesSet = new Set([...contextProperties, ...DEFAULT_CONTEXT_CLAZZ]);
+		CONTEXT_CLAZZ_BLACK_LIST.forEach((t) => allContextClazzNamesSet.delete(t));
+		const allContextClazzNames = Array.from(allContextClazzNamesSet);
+		const loggerNames = this.getLoggerNames(allContextClazzNames, allSingletonClazzNames);
+		const allSingletonClazzs = allSingletonClazzNames.map((name) => this.buildClazz(name, EggType.APP));
+		const allContextClazzs = allContextClazzNames.map((name) => this.buildClazz(name, EggType.CONTEXT));
+		const appLoggerClazzs = loggerNames.map((name) => this.buildAppLoggerClazz(name));
+		const moduleConfigList = this.moduleConfigLoader.loadModuleConfigList();
+		return [
+			...allSingletonClazzs,
+			...allContextClazzs,
+			...appLoggerClazzs,
+			...moduleConfigList,
+			BackgroundTaskHelper$1,
+			EggObjectFactory
+		];
+	}
+};
+
+//#endregion
+export { APP_CLAZZ_BLACK_LIST, CONTEXT_CLAZZ_BLACK_LIST, DEFAULT_APP_CLAZZ, DEFAULT_CONTEXT_CLAZZ, EggAppLoader };

package/dist/lib/EggCompatibleObject.d.ts

@@ -0,0 +1,21 @@
+import { EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl.js";
+import { EggPrototype } from "@eggjs/tegg-metadata";
+import { EggObjectName } from "@eggjs/tegg";
+import { EggObject } from "@eggjs/tegg-runtime";
+
+//#region src/lib/EggCompatibleObject.d.ts
+declare const OBJ: unique symbol;
+declare class EggCompatibleObject implements EggObject {
+  readonly isReady: boolean;
+  private [OBJ];
+  readonly proto: EggCompatibleProtoImpl;
+  readonly name: EggObjectName;
+  readonly id: string;
+  readonly isContext: boolean;
+  constructor(name: EggObjectName, proto: EggCompatibleProtoImpl);
+  get obj(): object;
+  injectProperty(): void;
+  static createObject(name: EggObjectName, proto: EggPrototype): Promise<EggCompatibleObject>;
+}
+//#endregion
+export { EggCompatibleObject };

package/dist/lib/EggCompatibleObject.js

@@ -0,0 +1,37 @@
+import { EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl.js";
+import "@eggjs/tegg-metadata";
+import { EggQualifierAttribute, EggType, IdenticalUtil } from "@eggjs/tegg";
+import { EggObjectFactory } from "@eggjs/tegg-runtime";
+
+//#region src/lib/EggCompatibleObject.ts
+const OBJ = Symbol("EggCompatibleObject#obj");
+var EggCompatibleObject = class EggCompatibleObject {
+	isReady = true;
+	[OBJ];
+	proto;
+	name;
+	id;
+	isContext;
+	constructor(name, proto) {
+		this.proto = proto;
+		this.name = name;
+		this.id = IdenticalUtil.createObjectId(this.proto.id);
+		this.isContext = this.proto.verifyQualifier({
+			value: EggType.CONTEXT,
+			attribute: EggQualifierAttribute
+		});
+	}
+	get obj() {
+		if (this.isContext) return this.proto.constructEggObject();
+		if (!this[OBJ]) this[OBJ] = this.proto.constructEggObject();
+		return this[OBJ];
+	}
+	injectProperty() {}
+	static async createObject(name, proto) {
+		return new EggCompatibleObject(name, proto);
+	}
+};
+EggObjectFactory.registerEggObjectCreateMethod(EggCompatibleProtoImpl, EggCompatibleObject.createObject);
+
+//#endregion
+export { EggCompatibleObject };

package/dist/lib/EggCompatibleProtoImpl.d.ts

@@ -0,0 +1,25 @@
+import { EggPrototype, EggPrototypeLifecycleContext, InjectObjectProto } from "@eggjs/tegg-metadata";
+import { AccessLevel, EggProtoImplClass, EggPrototypeName, Id, MetaDataKey, ObjectInitTypeLike, QualifierInfo, QualifierValue } from "@eggjs/tegg";
+
+//#region src/lib/EggCompatibleProtoImpl.d.ts
+declare const COMPATIBLE_PROTO_IMPLE_TYPE = "EGG_COMPATIBLE";
+declare class EggCompatibleProtoImpl implements EggPrototype {
+  [key: symbol]: PropertyDescriptor;
+  private readonly clazz;
+  private readonly qualifiers;
+  readonly id: string;
+  readonly name: EggPrototypeName;
+  readonly initType: ObjectInitTypeLike;
+  readonly accessLevel: AccessLevel;
+  readonly injectObjects: InjectObjectProto[];
+  readonly loadUnitId: Id;
+  constructor(id: string, name: EggPrototypeName, clazz: EggProtoImplClass, initType: ObjectInitTypeLike, loadUnitId: Id, qualifiers: QualifierInfo[]);
+  verifyQualifiers(qualifiers: QualifierInfo[]): boolean;
+  verifyQualifier(qualifier: QualifierInfo): boolean;
+  getQualifier(attribute: string): QualifierValue | undefined;
+  constructEggObject(): object;
+  getMetaData<T>(metadataKey: MetaDataKey): T | undefined;
+  static create(ctx: EggPrototypeLifecycleContext): EggPrototype;
+}
+//#endregion
+export { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl };

package/dist/lib/EggCompatibleProtoImpl.js

@@ -0,0 +1,50 @@
+import "@eggjs/tegg-metadata";
+import { AccessLevel, IdenticalUtil, MetadataUtil, QualifierUtil } from "@eggjs/tegg";
+
+//#region src/lib/EggCompatibleProtoImpl.ts
+const COMPATIBLE_PROTO_IMPLE_TYPE = "EGG_COMPATIBLE";
+var EggCompatibleProtoImpl = class EggCompatibleProtoImpl {
+	clazz;
+	qualifiers;
+	id;
+	name;
+	initType;
+	accessLevel;
+	injectObjects;
+	loadUnitId;
+	constructor(id, name, clazz, initType, loadUnitId, qualifiers) {
+		this.id = id;
+		this.clazz = clazz;
+		this.name = name;
+		this.initType = initType;
+		this.accessLevel = AccessLevel.PUBLIC;
+		this.injectObjects = [];
+		this.loadUnitId = loadUnitId;
+		this.qualifiers = qualifiers;
+	}
+	verifyQualifiers(qualifiers) {
+		for (const qualifier of qualifiers) if (!this.verifyQualifier(qualifier)) return false;
+		return true;
+	}
+	verifyQualifier(qualifier) {
+		return this.qualifiers.find((t) => t.attribute === qualifier.attribute)?.value === qualifier.value;
+	}
+	getQualifier(attribute) {
+		return this.qualifiers.find((t) => t.attribute === attribute)?.value;
+	}
+	constructEggObject() {
+		return Reflect.apply(this.clazz, null, []);
+	}
+	getMetaData(metadataKey) {
+		return MetadataUtil.getMetaData(metadataKey, this.clazz);
+	}
+	static create(ctx) {
+		const { clazz, loadUnit } = ctx;
+		const name = ctx.prototypeInfo.name;
+		const id = IdenticalUtil.createProtoId(loadUnit.id, name);
+		return new EggCompatibleProtoImpl(id, name, clazz, ctx.prototypeInfo.initType, loadUnit.id, QualifierUtil.mergeQualifiers(QualifierUtil.getProtoQualifiers(clazz), ctx.prototypeInfo.qualifiers ?? []));
+	}
+};
+
+//#endregion
+export { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl };

package/dist/lib/EggContextCompatibleHook.d.ts

@@ -0,0 +1,14 @@
+import { ModuleHandler } from "./ModuleHandler.js";
+import { LifecycleHook } from "@eggjs/tegg";
+import { EggContext, EggContextLifecycleContext } from "@eggjs/tegg-runtime";
+
+//#region src/lib/EggContextCompatibleHook.d.ts
+declare class EggContextCompatibleHook implements LifecycleHook<EggContextLifecycleContext, EggContext> {
+  private readonly moduleHandler;
+  private requestProtoList;
+  constructor(moduleHandler: ModuleHandler);
+  preCreate(_: unknown, ctx: EggContext): Promise<void>;
+  postCreate(_: unknown, ctx: EggContext): Promise<void>;
+}
+//#endregion
+export { EggContextCompatibleHook };

package/dist/lib/EggContextCompatibleHook.js

@@ -0,0 +1,32 @@
+import "./ModuleHandler.js";
+import "@eggjs/tegg-metadata";
+import { BackgroundTaskHelper, ObjectInitType, PrototypeUtil } from "@eggjs/tegg";
+import { EggContainerFactory } from "@eggjs/tegg-runtime";
+import { ROOT_PROTO } from "@eggjs/egg-module-common";
+
+//#region src/lib/EggContextCompatibleHook.ts
+var EggContextCompatibleHook = class {
+	moduleHandler;
+	requestProtoList = [];
+	constructor(moduleHandler) {
+		this.moduleHandler = moduleHandler;
+		for (const loadUnitInstance of this.moduleHandler.loadUnitInstances) {
+			const iterator = loadUnitInstance.loadUnit.iterateEggPrototype();
+			for (const proto of iterator) if (proto.initType === ObjectInitType.CONTEXT) this.requestProtoList.push(proto);
+		}
+	}
+	async preCreate(_, ctx) {
+		if (!ctx.get(ROOT_PROTO)) for (const proto of this.requestProtoList) ctx.addProtoToCreate(proto.name, proto);
+		else {
+			const protoObj = PrototypeUtil.getClazzProto(BackgroundTaskHelper);
+			await EggContainerFactory.getOrCreateEggObject(protoObj);
+		}
+	}
+	async postCreate(_, ctx) {
+		const rootProto = ctx.get(ROOT_PROTO);
+		if (rootProto) await EggContainerFactory.getOrCreateEggObject(rootProto);
+	}
+};
+
+//#endregion
+export { EggContextCompatibleHook };

package/dist/lib/EggContextHandler.d.ts

@@ -0,0 +1,13 @@
+import { EggContext } from "@eggjs/tegg-runtime";
+import { Application } from "egg";
+
+//#region src/lib/EggContextHandler.d.ts
+declare class EggContextHandler {
+  private readonly app;
+  constructor(app: Application);
+  getContextCallback(): EggContext | undefined;
+  run<R>(eggContext: EggContext, fn: () => Promise<R>): Promise<R>;
+  register(): void;
+}
+//#endregion
+export { EggContextHandler };

package/dist/lib/EggContextHandler.js

@@ -0,0 +1,29 @@
+import { ContextHandler } from "@eggjs/tegg-runtime";
+import { EGG_CONTEXT } from "@eggjs/egg-module-common";
+import "egg";
+
+//#region src/lib/EggContextHandler.ts
+var EggContextHandler = class {
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	getContextCallback() {
+		return this.app.currentContext?.teggContext;
+	}
+	async run(eggContext, fn) {
+		const ctx = eggContext.get(EGG_CONTEXT);
+		return await this.app.ctxStorage.run(ctx, fn);
+	}
+	register() {
+		ContextHandler.getContextCallback = () => {
+			return this.getContextCallback();
+		};
+		ContextHandler.runInContextCallback = async (context, fn) => {
+			return await this.run(context, fn);
+		};
+	}
+};
+
+//#endregion
+export { EggContextHandler };

package/dist/lib/EggContextImpl.d.ts

@@ -0,0 +1,10 @@
+import { AbstractEggContext } from "@eggjs/tegg-runtime";
+import { Context } from "egg";
+
+//#region src/lib/EggContextImpl.d.ts
+declare class EggContextImpl extends AbstractEggContext {
+  readonly id: string;
+  constructor(ctx: Context);
+}
+//#endregion
+export { EggContextImpl };

package/dist/lib/EggContextImpl.js

@@ -0,0 +1,18 @@
+import { IdenticalUtil } from "@eggjs/tegg";
+import { AbstractEggContext } from "@eggjs/tegg-runtime";
+import { EGG_CONTEXT, TEGG_CONTEXT } from "@eggjs/egg-module-common";
+
+//#region src/lib/EggContextImpl.ts
+var EggContextImpl = class extends AbstractEggContext {
+	id;
+	constructor(ctx) {
+		super();
+		this.set(EGG_CONTEXT, ctx);
+		ctx[TEGG_CONTEXT] = this;
+		const tracer = ctx.tracer;
+		this.id = IdenticalUtil.createContextId(tracer?.traceId);
+	}
+};
+
+//#endregion
+export { EggContextImpl };

package/dist/lib/EggModuleLoader.d.ts

@@ -0,0 +1,15 @@
+import { GlobalGraph } from "@eggjs/tegg-metadata";
+import { Application } from "egg";
+
+//#region src/lib/EggModuleLoader.d.ts
+declare class EggModuleLoader {
+  app: Application;
+  globalGraph: GlobalGraph;
+  constructor(app: Application);
+  private loadApp;
+  private buildAppGraph;
+  private loadModule;
+  load(): Promise<void>;
+}
+//#endregion
+export { EggModuleLoader };

package/dist/lib/EggModuleLoader.js

@@ -0,0 +1,50 @@
+import { EggAppLoader } from "./EggAppLoader.js";
+import { EggLoadUnitType, GlobalGraph, LoadUnitFactory, ModuleDescriptorDumper } from "@eggjs/tegg-metadata";
+import { Application } from "egg";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+
+//#region src/lib/EggModuleLoader.ts
+var EggModuleLoader = class {
+	app;
+	globalGraph;
+	constructor(app) {
+		this.app = app;
+	}
+	async loadApp() {
+		const loader = new EggAppLoader(this.app);
+		const loadUnit = await LoadUnitFactory.createLoadUnit(this.app.baseDir, EggLoadUnitType.APP, loader);
+		this.app.moduleHandler.loadUnits.push(loadUnit);
+	}
+	async buildAppGraph() {
+		for (const plugin of Object.values(this.app.plugins)) {
+			if (!plugin.enable) continue;
+			const modulePlugin = this.app.moduleReferences.find((t) => t.path === plugin.path);
+			if (modulePlugin) modulePlugin.optional = false;
+		}
+		const moduleDescriptors = await LoaderFactory.loadApp(this.app.moduleReferences);
+		for (const moduleDescriptor of moduleDescriptors) ModuleDescriptorDumper.dump(moduleDescriptor, { dumpDir: this.app.baseDir }).catch((e) => {
+			e.message = "dump module descriptor failed: " + e.message;
+			this.app.logger.warn(e);
+		});
+		return await GlobalGraph.create(moduleDescriptors);
+	}
+	async loadModule() {
+		this.globalGraph.build();
+		this.globalGraph.sort();
+		const moduleConfigList = this.globalGraph.moduleConfigList;
+		for (const moduleConfig of moduleConfigList) {
+			const modulePath = moduleConfig.path;
+			const loader = LoaderFactory.createLoader(modulePath, EggLoadUnitType.MODULE);
+			const loadUnit = await LoadUnitFactory.createLoadUnit(modulePath, EggLoadUnitType.MODULE, loader);
+			this.app.moduleHandler.loadUnits.push(loadUnit);
+		}
+	}
+	async load() {
+		GlobalGraph.instance = this.globalGraph = await this.buildAppGraph();
+		await this.loadApp();
+		await this.loadModule();
+	}
+};
+
+//#endregion
+export { EggModuleLoader };

package/dist/lib/EggQualifierProtoHook.d.ts

@@ -0,0 +1,14 @@
+import { LoadUnit, LoadUnitLifecycleContext } from "@eggjs/tegg-metadata";
+import { LifecycleHook } from "@eggjs/tegg";
+import { Application } from "egg";
+
+//#region src/lib/EggQualifierProtoHook.d.ts
+declare class EggQualifierProtoHook implements LifecycleHook<LoadUnitLifecycleContext, LoadUnit> {
+  private readonly app;
+  constructor(app: Application);
+  preCreate(ctx: LoadUnitLifecycleContext): Promise<void>;
+  private isAppObject;
+  private isCtxObject;
+}
+//#endregion
+export { EggQualifierProtoHook };

package/dist/lib/EggQualifierProtoHook.js

@@ -0,0 +1,48 @@
+import { APP_CLAZZ_BLACK_LIST, CONTEXT_CLAZZ_BLACK_LIST, DEFAULT_APP_CLAZZ, DEFAULT_CONTEXT_CLAZZ } from "./EggAppLoader.js";
+import { debuglog } from "node:util";
+import "@eggjs/tegg-metadata";
+import { EggQualifierAttribute, EggType, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
+import { ObjectUtils } from "@eggjs/tegg-common-util";
+import { Application } from "egg";
+
+//#region src/lib/EggQualifierProtoHook.ts
+const debug = debuglog("tegg/plugin/tegg/lib/EggQualifierProtoHook");
+var EggQualifierProtoHook = class {
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	async preCreate(ctx) {
+		const clazzList = await ctx.loader.load();
+		const appProperties = ObjectUtils.getProperties(this.app);
+		const ctxProperties = ObjectUtils.getProperties(this.app.context);
+		if (debug.enabled) debug("preCreate, get clazzList:%o, appProperties:%o, ctxProperties:%o, from unitPath:%o", clazzList.map((t) => t.name), appProperties.length, ctxProperties.length, ctx.unitPath);
+		for (const clazz of clazzList) {
+			const inbjectObjects = PrototypeUtil.getInjectObjects(clazz) || [];
+			if (debug.enabled && inbjectObjects.length > 0) debug("preCreate, get injectObjects:%o, from clazz:%o, from unitPath:%o", inbjectObjects.map((t) => t.refName), clazz.name, ctx.unitPath);
+			for (const injectObject of inbjectObjects) {
+				if (QualifierUtil.getProperQualifiers(clazz, injectObject.refName).find((t) => t.attribute === EggQualifierAttribute)) continue;
+				if (this.isCtxObject(injectObject.objName, ctxProperties)) QualifierUtil.addProperQualifier(clazz, injectObject.refName, EggQualifierAttribute, EggType.CONTEXT);
+				else if (this.isAppObject(injectObject.objName, appProperties)) {
+					QualifierUtil.addProperQualifier(clazz, injectObject.refName, EggQualifierAttribute, EggType.APP);
+					debug("preCreate, add proper qualifier:%o to clazz:%o, from unitPath:%o", injectObject.refName, clazz.name, ctx.unitPath);
+				}
+			}
+		}
+	}
+	isAppObject(name, appProperties) {
+		name = String(name);
+		if (APP_CLAZZ_BLACK_LIST.includes(name)) return false;
+		if (DEFAULT_APP_CLAZZ.includes(name)) return true;
+		return appProperties.includes(name);
+	}
+	isCtxObject(name, ctxProperties) {
+		name = String(name);
+		if (CONTEXT_CLAZZ_BLACK_LIST.includes(name)) return false;
+		if (DEFAULT_CONTEXT_CLAZZ.includes(name)) return true;
+		return ctxProperties.includes(name);
+	}
+};
+
+//#endregion
+export { EggQualifierProtoHook };

package/dist/lib/ModuleConfigLoader.d.ts

@@ -0,0 +1,12 @@
+import { EggProtoImplClass } from "@eggjs/tegg";
+import { Application } from "egg";
+
+//#region src/lib/ModuleConfigLoader.d.ts
+declare class ModuleConfigLoader {
+  readonly app: Application;
+  constructor(app: Application);
+  private loadModuleConfigs;
+  loadModuleConfigList(): EggProtoImplClass[];
+}
+//#endregion
+export { ModuleConfigLoader };