@eggjs/tegg-plugin 4.0.0-beta.7 → 4.0.0-beta.8

package/dist/AppLoadUnit-BOWdS4O9.d.ts

@@ -0,0 +1,23 @@
+import { EggLoadUnitTypeLike, EggPrototype, LoadUnit, LoadUnitLifecycleContext, Loader } from "@eggjs/tegg-metadata";
+import { Id, QualifierInfo } from "@eggjs/tegg";
+
+//#region src/lib/AppLoadUnit.d.ts
+declare class AppLoadUnit implements LoadUnit {
+  private readonly loader;
+  id: Id;
+  readonly name: string;
+  readonly type: EggLoadUnitTypeLike;
+  readonly unitPath: string;
+  private protoMap;
+  constructor(name: string, unitPath: string, loader: Loader);
+  init(): Promise<void>;
+  containPrototype(proto: EggPrototype): boolean;
+  getEggPrototype(name: string, qualifiers: QualifierInfo[]): EggPrototype[];
+  registerEggPrototype(proto: EggPrototype): void;
+  deletePrototype(proto: EggPrototype): void;
+  destroy(): Promise<void>;
+  iterateEggPrototype(): IterableIterator<EggPrototype>;
+  static createModule(ctx: LoadUnitLifecycleContext): AppLoadUnit;
+}
+//#endregion
+export { AppLoadUnit };

package/dist/AppLoadUnit-uyHgElRL.js

@@ -0,0 +1,78 @@
+import { debuglog } from "node:util";
+import { EggLoadUnitType, EggPrototypeCreatorFactory, EggPrototypeFactory, LoadUnitFactory } from "@eggjs/tegg-metadata";
+import { IdenticalUtil, InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
+import { MapUtil } from "@eggjs/tegg-common-util";
+
+//#region src/lib/AppLoadUnit.ts
+const debug = debuglog("tegg/plugin/tegg/lib/AppLoadUnit");
+var AppLoadUnit = class AppLoadUnit {
+	loader;
+	id;
+	name;
+	type = EggLoadUnitType.APP;
+	unitPath;
+	protoMap = /* @__PURE__ */ new Map();
+	constructor(name, unitPath, loader) {
+		this.id = IdenticalUtil.createLoadUnitId(name);
+		this.name = name;
+		this.unitPath = unitPath;
+		this.loader = loader;
+	}
+	async init() {
+		const clazzList = await this.loader.load();
+		if (debug.enabled) debug("init, get clazzList:%j, from unitPath:%o:%o:%o", clazzList.map((t) => t.name), this.type, this.name, this.unitPath);
+		for (const clazz of clazzList) {
+			const initTypeQualifierAttributeValue = await PrototypeUtil.getInitType(clazz, {
+				unitPath: this.unitPath,
+				moduleName: this.name
+			});
+			[{
+				attribute: InitTypeQualifierAttribute,
+				value: initTypeQualifierAttributeValue
+			}, {
+				attribute: LoadUnitNameQualifierAttribute,
+				value: this.name
+			}].forEach((qualifier) => {
+				QualifierUtil.addProtoQualifier(clazz, qualifier.attribute, qualifier.value);
+			});
+			const protos = await EggPrototypeCreatorFactory.createProto(clazz, this);
+			for (const proto of protos) EggPrototypeFactory.instance.registerPrototype(proto, this);
+		}
+	}
+	containPrototype(proto) {
+		return !!this.protoMap.get(proto.name)?.find((t) => t === proto);
+	}
+	getEggPrototype(name, qualifiers) {
+		return this.protoMap.get(name)?.filter((proto) => proto.verifyQualifiers(qualifiers)) || [];
+	}
+	registerEggPrototype(proto) {
+		MapUtil.getOrStore(this.protoMap, proto.name, []).push(proto);
+	}
+	deletePrototype(proto) {
+		const protos = this.protoMap.get(proto.name);
+		if (protos) {
+			const index = protos.indexOf(proto);
+			if (index !== -1) protos.splice(index, 1);
+		}
+	}
+	async destroy() {
+		for (const namedProtos of this.protoMap.values()) {
+			const protos = namedProtos.slice();
+			for (const proto of protos) EggPrototypeFactory.instance.deletePrototype(proto, this);
+		}
+		this.protoMap.clear();
+	}
+	iterateEggPrototype() {
+		return Array.from(this.protoMap.values()).reduce((p, c) => {
+			p = p.concat(c);
+			return p;
+		}, []).values();
+	}
+	static createModule(ctx) {
+		return new AppLoadUnit("tegg-app", ctx.unitPath, ctx.loader);
+	}
+};
+LoadUnitFactory.registerLoadUnitCreator(EggLoadUnitType.APP, AppLoadUnit.createModule);
+
+//#endregion
+export { AppLoadUnit };

package/dist/AppLoadUnitInstance-4Z_vSQV3.js

@@ -0,0 +1,69 @@
+import { EggLoadUnitType } from "@eggjs/tegg-metadata";
+import { IdenticalUtil, ObjectInitType } from "@eggjs/tegg";
+import { MapUtil } from "@eggjs/tegg-common-util";
+import { EggObjectFactory, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
+
+//#region src/lib/AppLoadUnitInstance.ts
+var AppLoadUnitInstance = class AppLoadUnitInstance {
+	loadUnit;
+	id;
+	name;
+	protoToCreateMap = /* @__PURE__ */ new Map();
+	eggObjectMap = /* @__PURE__ */ new Map();
+	eggObjectPromiseMap = /* @__PURE__ */ new Map();
+	constructor(loadUnit) {
+		this.loadUnit = loadUnit;
+		this.name = loadUnit.name;
+		const iterator = this.loadUnit.iterateEggPrototype();
+		for (const proto of iterator) if (proto.initType === ObjectInitType.SINGLETON) this.protoToCreateMap.set(proto.name, proto);
+		this.id = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
+	}
+	iterateProtoToCreate() {
+		return this.protoToCreateMap.entries();
+	}
+	addProtoToCreate(name, proto) {
+		this.protoToCreateMap.set(name, proto);
+	}
+	deleteProtoToCreate(name) {
+		this.protoToCreateMap.delete(name);
+	}
+	async init(ctx) {
+		await LoadUnitInstanceLifecycleUtil.objectPreCreate(ctx, this);
+		for (const [name, proto] of this.protoToCreateMap) await this.getOrCreateEggObject(name, proto);
+	}
+	async destroy() {
+		const objs = [];
+		for (const protoObjMap of this.eggObjectMap.values()) for (const protoObj of protoObjMap.values()) objs.push(protoObj);
+		this.eggObjectMap.clear();
+		await Promise.all(objs.map(async (obj) => {
+			await EggObjectFactory.destroyObject(obj);
+		}));
+	}
+	async getOrCreateEggObject(name, proto) {
+		if (!this.loadUnit.containPrototype(proto)) throw new Error("load unit not contain proto");
+		const protoObjMap = MapUtil.getOrStore(this.eggObjectMap, proto.id, /* @__PURE__ */ new Map());
+		if (!protoObjMap.has(name)) {
+			const protoObjPromiseMap = MapUtil.getOrStore(this.eggObjectPromiseMap, proto.id, /* @__PURE__ */ new Map());
+			if (!protoObjPromiseMap.has(name)) {
+				const objPromise = EggObjectFactory.createObject(name, proto);
+				protoObjPromiseMap.set(name, objPromise);
+				const obj = await objPromise;
+				protoObjPromiseMap.delete(name);
+				protoObjMap.set(name, obj);
+			} else await protoObjPromiseMap.get(name);
+		}
+		return protoObjMap.get(name);
+	}
+	getEggObject(name, proto) {
+		const protoObjMap = this.eggObjectMap.get(proto.id);
+		if (!protoObjMap || !protoObjMap.has(name)) throw new Error(`EggObject ${String(proto.name)} not found`);
+		return protoObjMap.get(name);
+	}
+	static createModuleLoadUnitInstance(ctx) {
+		return new AppLoadUnitInstance(ctx.loadUnit);
+	}
+};
+LoadUnitInstanceFactory.registerLoadUnitInstanceClass(EggLoadUnitType.APP, AppLoadUnitInstance.createModuleLoadUnitInstance);
+
+//#endregion
+export { AppLoadUnitInstance };

package/dist/AppLoadUnitInstance-DQ-DxlmR.d.ts

@@ -0,0 +1,24 @@
+import { EggPrototype, LoadUnit } from "@eggjs/tegg-metadata";
+import { EggObjectName, EggPrototypeName } from "@eggjs/tegg";
+import { EggObject, LoadUnitInstance, LoadUnitInstanceLifecycleContext } from "@eggjs/tegg-runtime";
+
+//#region src/lib/AppLoadUnitInstance.d.ts
+declare class AppLoadUnitInstance implements LoadUnitInstance {
+  readonly loadUnit: LoadUnit;
+  readonly id: string;
+  readonly name: string;
+  private protoToCreateMap;
+  private eggObjectMap;
+  private eggObjectPromiseMap;
+  constructor(loadUnit: LoadUnit);
+  iterateProtoToCreate(): IterableIterator<[EggObjectName, EggPrototype]>;
+  addProtoToCreate(name: string, proto: EggPrototype): void;
+  deleteProtoToCreate(name: string): void;
+  init(ctx: LoadUnitInstanceLifecycleContext): Promise<void>;
+  destroy(): Promise<void>;
+  getOrCreateEggObject(name: EggPrototypeName, proto: EggPrototype): Promise<EggObject>;
+  getEggObject(name: EggPrototypeName, proto: EggPrototype): EggObject;
+  static createModuleLoadUnitInstance(ctx: LoadUnitInstanceLifecycleContext): LoadUnitInstance;
+}
+//#endregion
+export { AppLoadUnitInstance };

package/dist/CompatibleUtil-CNhydb0E.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/ConfigSourceLoadUnitHook-BV-R31vA.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/EggAppLoader-DFYg65ry.js

@@ -0,0 +1,106 @@
+import { COMPATIBLE_PROTO_IMPLE_TYPE } from "./EggCompatibleProtoImpl-CPxLvSu4.js";
+import { ModuleConfigLoader } from "./ModuleConfigLoader-CvZLf99E.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/EggCompatibleObject-XfIZyirS.js

@@ -0,0 +1,37 @@
+import { EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl-CPxLvSu4.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/EggCompatibleObject-lzUCfsIY.d.ts

@@ -0,0 +1,21 @@
+import { EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl-DpacWKFB.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/EggCompatibleProtoImpl-CPxLvSu4.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/EggCompatibleProtoImpl-DpacWKFB.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/EggContextCompatibleHook-eFfN2xm6.js

@@ -0,0 +1,31 @@
+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/EggContextHandler-D8gfTbZs.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/EggContextHandler-vGi67He5.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/EggContextImpl-DkCLPTzT.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 };