@eggjs/tegg-plugin 4.0.0-beta.8 → 4.0.1-beta.0

package/dist/app/extend/application.d.ts

@@ -1,4 +1,29 @@
-import "../../ModuleHandler-Dyx7JGj-.js";
-import "../../EggContextHandler-vGi67He5.js";
-import { TEggPluginApplication } from "../../application-Ccljinuy.js";
+import { EggProtoImplClass, QualifierInfo } from "@eggjs/core-decorator";
+import { IdenticalUtil } from "@eggjs/lifecycle";
+import { EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from "@eggjs/metadata";
+import { AbstractEggContext, EggContainerFactory, EggContextLifecycleUtil, EggObjectFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
+import { LoaderFactory } from "@eggjs/tegg-loader";
+import { RuntimeConfig } from "@eggjs/tegg-types";
+
+//#region src/app/extend/application.d.ts
+declare class TEggPluginApplication {
+  get eggPrototypeCreatorFactory(): typeof EggPrototypeCreatorFactory;
+  get eggPrototypeFactory(): EggPrototypeFactory;
+  get loadUnitLifecycleUtil(): typeof LoadUnitLifecycleUtil;
+  get loadUnitFactory(): typeof LoadUnitFactory;
+  get eggObjectFactory(): typeof EggObjectFactory;
+  get loadUnitInstanceFactory(): typeof LoadUnitInstanceFactory;
+  get loadUnitInstanceLifecycleUtil(): typeof LoadUnitInstanceLifecycleUtil;
+  get eggContainerFactory(): typeof EggContainerFactory;
+  get loaderFactory(): typeof LoaderFactory;
+  get eggPrototypeLifecycleUtil(): typeof EggPrototypeLifecycleUtil;
+  get eggContextLifecycleUtil(): typeof EggContextLifecycleUtil;
+  get eggObjectLifecycleUtil(): typeof EggObjectLifecycleUtil;
+  get abstractEggContext(): typeof AbstractEggContext;
+  get identicalUtil(): typeof IdenticalUtil;
+  get runtimeConfig(): RuntimeConfig;
+  getEggObject<T>(clazz: EggProtoImplClass<T>, name?: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+  getEggObjectFromName<T extends object>(name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+}
+//#endregion
 export { TEggPluginApplication as default };

package/dist/app/extend/application.js

@@ -1,10 +1,69 @@
-import "../../EggCompatibleProtoImpl-CPxLvSu4.js";
-import "../../ModuleConfigLoader-CvZLf99E.js";
-import "../../EggAppLoader-DFYg65ry.js";
-import "../../EggModuleLoader-CCfQMmp5.js";
-import "../../CompatibleUtil-CNhydb0E.js";
-import "../../ModuleHandler-fKcUqWca.js";
-import "../../EggContextHandler-D8gfTbZs.js";
-import { TEggPluginApplication } from "../../application-DFI1junS.js";
+import { IdenticalUtil } from "@eggjs/lifecycle";
+import { EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from "@eggjs/metadata";
+import { AbstractEggContext, EggContainerFactory, EggContextLifecycleUtil, EggObjectFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
+import { LoaderFactory } from "@eggjs/tegg-loader";
 
+//#region src/app/extend/application.ts
+var TEggPluginApplication = class {
+	get eggPrototypeCreatorFactory() {
+		return EggPrototypeCreatorFactory;
+	}
+	get eggPrototypeFactory() {
+		return EggPrototypeFactory.instance;
+	}
+	get loadUnitLifecycleUtil() {
+		return LoadUnitLifecycleUtil;
+	}
+	get loadUnitFactory() {
+		return LoadUnitFactory;
+	}
+	get eggObjectFactory() {
+		return EggObjectFactory;
+	}
+	get loadUnitInstanceFactory() {
+		return LoadUnitInstanceFactory;
+	}
+	get loadUnitInstanceLifecycleUtil() {
+		return LoadUnitInstanceLifecycleUtil;
+	}
+	get eggContainerFactory() {
+		return EggContainerFactory;
+	}
+	get loaderFactory() {
+		return LoaderFactory;
+	}
+	get eggPrototypeLifecycleUtil() {
+		return EggPrototypeLifecycleUtil;
+	}
+	get eggContextLifecycleUtil() {
+		return EggContextLifecycleUtil;
+	}
+	get eggObjectLifecycleUtil() {
+		return EggObjectLifecycleUtil;
+	}
+	get abstractEggContext() {
+		return AbstractEggContext;
+	}
+	get identicalUtil() {
+		return IdenticalUtil;
+	}
+	get runtimeConfig() {
+		const config = this.config;
+		return {
+			baseDir: config.baseDir,
+			env: config.env,
+			name: config.name
+		};
+	}
+	async getEggObject(clazz, name, qualifiers) {
+		if (qualifiers) qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];
+		return (await EggContainerFactory.getOrCreateEggObjectFromClazz(clazz, name, qualifiers)).obj;
+	}
+	async getEggObjectFromName(name, qualifiers) {
+		if (qualifiers) qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];
+		return (await EggContainerFactory.getOrCreateEggObjectFromName(name, qualifiers)).obj;
+	}
+};
+
+//#endregion
 export { TEggPluginApplication as default };

package/dist/app/extend/application.unittest.d.ts

@@ -1,2 +1,10 @@
-import { TEggPluginApplicationUnittest } from "../../application.unittest-CpoCu6-E.js";
+import { Application, Context } from "egg";
+
+//#region src/app/extend/application.unittest.d.ts
+declare class TEggPluginApplicationUnittest {
+  mockModuleContext(this: Application, data?: any): Promise<Context>;
+  destroyModuleContext(this: Application, ctx: Context): Promise<void>;
+  mockModuleContextScope<R = any>(fn: (ctx: Context) => Promise<R>, data?: any): Promise<R>;
+}
+//#endregion
 export { TEggPluginApplicationUnittest as default };

package/dist/app/extend/application.unittest.js

@@ -1,4 +1,41 @@
-import "../../EggContextImpl-DkCLPTzT.js";
-import { TEggPluginApplicationUnittest } from "../../application.unittest-Cmia71Fx.js";
+import { EggContextImpl } from "../../lib/EggContextImpl.js";
 
+//#region src/app/extend/application.unittest.ts
+const TEGG_LIFECYCLE_CACHE = /* @__PURE__ */ new Map();
+let hasMockModuleContext = false;
+var TEggPluginApplicationUnittest = class {
+	async mockModuleContext(data) {
+		this.deprecate("app.mockModuleContext is deprecated, use mockModuleContextScope.");
+		if (hasMockModuleContext) throw new Error("should not call mockModuleContext twice.");
+		const ctx = this.mockContext(data);
+		const teggCtx = new EggContextImpl(ctx);
+		const lifecycle = {};
+		TEGG_LIFECYCLE_CACHE.set(teggCtx, lifecycle);
+		if (teggCtx.init) await teggCtx.init(lifecycle);
+		hasMockModuleContext = true;
+		return ctx;
+	}
+	async destroyModuleContext(ctx) {
+		hasMockModuleContext = false;
+		const teggCtx = ctx.teggContext;
+		if (!teggCtx) return;
+		const lifecycle = TEGG_LIFECYCLE_CACHE.get(teggCtx);
+		if (teggCtx.destroy && lifecycle) await teggCtx.destroy(lifecycle);
+	}
+	async mockModuleContextScope(fn, data) {
+		if (hasMockModuleContext) throw new Error("mockModuleContextScope can not use with mockModuleContext, should use mockModuleContextScope only.");
+		return this.mockContextScope(async (ctx) => {
+			const teggCtx = new EggContextImpl(ctx);
+			const lifecycle = {};
+			if (teggCtx.init) await teggCtx.init(lifecycle);
+			try {
+				return await fn(ctx);
+			} finally {
+				await teggCtx.destroy(lifecycle);
+			}
+		}, data);
+	}
+};
+
+//#endregion
 export { TEggPluginApplicationUnittest as default };

package/dist/app/extend/context.d.ts

@@ -1,2 +1,13 @@
-import { TEggPluginContext } from "../../context-BoIt2G5h.js";
+import { EggProtoImplClass, QualifierInfo } from "@eggjs/core-decorator";
+import { EggContext } from "@eggjs/tegg-runtime";
+import { Context } from "egg";
+
+//#region src/app/extend/context.d.ts
+declare class TEggPluginContext {
+  beginModuleScope(this: Context, func: () => Promise<void>): Promise<void>;
+  get teggContext(): EggContext;
+  getEggObject<T>(this: Context, clazz: EggProtoImplClass<T>, name?: string): Promise<T>;
+  getEggObjectFromName<T>(this: Context, name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
+}
+//#endregion
 export { TEggPluginContext as default };

package/dist/app/extend/context.js

@@ -1,5 +1,28 @@
-import "../../EggContextImpl-DkCLPTzT.js";
-import "../../ctx_lifecycle_middleware-CIeSrbVY.js";
-import { TEggPluginContext } from "../../context-BWYE1dif.js";
+import { ctxLifecycleMiddleware } from "../../lib/ctx_lifecycle_middleware.js";
+import { PrototypeUtil } from "@eggjs/core-decorator";
+import { TEGG_CONTEXT } from "@eggjs/module-common";
 
+//#region src/app/extend/context.ts
+var TEggPluginContext = class {
+	async beginModuleScope(func) {
+		await ctxLifecycleMiddleware(this, func);
+	}
+	get teggContext() {
+		const ctx = this;
+		if (!ctx[TEGG_CONTEXT]) throw new Error("tegg context have not ready, should call after teggCtxLifecycleMiddleware");
+		return ctx[TEGG_CONTEXT];
+	}
+	async getEggObject(clazz, name) {
+		const protoObj = PrototypeUtil.getClazzProto(clazz);
+		if (!protoObj) throw new Error(`can not get proto for clazz ${clazz.name}`);
+		const proto = protoObj;
+		return (await this.app.eggContainerFactory.getOrCreateEggObject(proto, name ?? proto.name)).obj;
+	}
+	async getEggObjectFromName(name, qualifiers) {
+		if (qualifiers) qualifiers = Array.isArray(qualifiers) ? qualifiers : [qualifiers];
+		return (await this.app.eggContainerFactory.getOrCreateEggObjectFromName(name, qualifiers)).obj;
+	}
+};
+
+//#endregion
 export { TEggPluginContext as default };

package/dist/app/middleware/tegg_ctx_lifecycle_middleware.d.ts

@@ -1,6 +1,6 @@
-import { ctxLifecycleMiddleware } from "../../ctx_lifecycle_middleware-DV7uN5PG.js";
+import { MiddlewareFunc } from "egg";
 
 //#region src/app/middleware/tegg_ctx_lifecycle_middleware.d.ts
-declare const _default: () => typeof ctxLifecycleMiddleware;
+declare const _default: () => MiddlewareFunc;
 //#endregion
 export { _default as default };

package/dist/app/middleware/tegg_ctx_lifecycle_middleware.js

@@ -1,5 +1,4 @@
-import "../../EggContextImpl-DkCLPTzT.js";
-import { ctxLifecycleMiddleware } from "../../ctx_lifecycle_middleware-CIeSrbVY.js";
+import { ctxLifecycleMiddleware } from "../../lib/ctx_lifecycle_middleware.js";
 
 //#region src/app/middleware/tegg_ctx_lifecycle_middleware.ts
 var tegg_ctx_lifecycle_middleware_default = () => {

package/dist/app.d.ts

@@ -1,11 +1,10 @@
-import "./AppLoadUnit-BOWdS4O9.js";
-import "./AppLoadUnitInstance-DQ-DxlmR.js";
-import "./EggCompatibleProtoImpl-DpacWKFB.js";
-import "./EggCompatibleObject-lzUCfsIY.js";
+import "./lib/AppLoadUnit.js";
+import "./lib/AppLoadUnitInstance.js";
+import "./lib/EggCompatibleObject.js";
 import { Application, ILifecycleBoot } from "egg";
 
 //#region src/app.d.ts
-declare class App implements ILifecycleBoot {
+declare class TeggAppBoot implements ILifecycleBoot {
   private readonly app;
   private compatibleHook?;
   private eggContextHandler;
@@ -19,4 +18,4 @@ declare class App implements ILifecycleBoot {
   beforeClose(): Promise<void>;
 }
 //#endregion
-export { App as default };
+export { TeggAppBoot as default };

package/dist/app.js

@@ -1,25 +1,17 @@
-import "./AppLoadUnit-uyHgElRL.js";
-import "./AppLoadUnitInstance-4Z_vSQV3.js";
-import "./EggCompatibleProtoImpl-CPxLvSu4.js";
-import "./EggCompatibleObject-XfIZyirS.js";
-import "./ModuleConfigLoader-CvZLf99E.js";
-import "./EggAppLoader-DFYg65ry.js";
-import "./EggModuleLoader-CCfQMmp5.js";
-import { CompatibleUtil } from "./CompatibleUtil-CNhydb0E.js";
-import { ModuleHandler } from "./ModuleHandler-fKcUqWca.js";
-import { EggContextCompatibleHook } from "./EggContextCompatibleHook-eFfN2xm6.js";
-import { EggContextHandler } from "./EggContextHandler-D8gfTbZs.js";
-import "./EggContextImpl-DkCLPTzT.js";
-import "./ctx_lifecycle_middleware-CIeSrbVY.js";
-import "./context-BWYE1dif.js";
-import "./Utils-11aRpnkd.js";
-import { hijackRunInBackground } from "./run_in_background-CEUPBmDB.js";
-import { EggQualifierProtoHook } from "./EggQualifierProtoHook-D5jNm-1y.js";
-import { ConfigSourceLoadUnitHook } from "./ConfigSourceLoadUnitHook-BV-R31vA.js";
-import { LoadUnitMultiInstanceProtoHook } from "@eggjs/tegg-metadata";
+import "./lib/AppLoadUnit.js";
+import "./lib/AppLoadUnitInstance.js";
+import "./lib/EggCompatibleObject.js";
+import { CompatibleUtil } from "./lib/CompatibleUtil.js";
+import { ConfigSourceLoadUnitHook } from "./lib/ConfigSourceLoadUnitHook.js";
+import { ModuleHandler } from "./lib/ModuleHandler.js";
+import { EggContextCompatibleHook } from "./lib/EggContextCompatibleHook.js";
+import { EggContextHandler } from "./lib/EggContextHandler.js";
+import { EggQualifierProtoHook } from "./lib/EggQualifierProtoHook.js";
+import { hijackRunInBackground } from "./lib/run_in_background.js";
+import { LoadUnitMultiInstanceProtoHook } from "@eggjs/metadata";
 
 //#region src/app.ts
-var App = class {
+var TeggAppBoot = class {
 	app;
 	compatibleHook;
 	eggContextHandler;
@@ -62,4 +54,4 @@ var App = class {
 };
 
 //#endregion
-export { App as default };
+export { TeggAppBoot as default };

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-import "./ModuleHandler-Dyx7JGj-.js";
-import "./EggContextHandler-vGi67He5.js";
-import "./application-Ccljinuy.js";
-import "./application.unittest-CpoCu6-E.js";
-import "./context-BoIt2G5h.js";
-import "./types-CuoKQV4X.js";
+import "./app/extend/application.js";
+import "./app/extend/context.js";
+import "./types.js";

package/dist/index.js

@@ -1,15 +1,5 @@
-import "./EggCompatibleProtoImpl-CPxLvSu4.js";
-import "./ModuleConfigLoader-CvZLf99E.js";
-import "./EggAppLoader-DFYg65ry.js";
-import "./EggModuleLoader-CCfQMmp5.js";
-import "./CompatibleUtil-CNhydb0E.js";
-import "./ModuleHandler-fKcUqWca.js";
-import "./EggContextHandler-D8gfTbZs.js";
-import "./EggContextImpl-DkCLPTzT.js";
-import "./ctx_lifecycle_middleware-CIeSrbVY.js";
-import "./context-BWYE1dif.js";
-import "./application-DFI1junS.js";
-import "./application.unittest-Cmia71Fx.js";
-import "./types-BHg5p4Xk.js";
+import "./types.js";
+import "./app/extend/application.js";
+import "./app/extend/context.js";
 
 export {  };

package/dist/lib/AppLoadUnit.d.ts

@@ -1,2 +1,24 @@
-import { AppLoadUnit } from "../AppLoadUnit-BOWdS4O9.js";
+import { QualifierInfo } from "@eggjs/core-decorator";
+import { EggLoadUnitTypeLike, EggPrototype, LoadUnit, LoadUnitLifecycleContext, Loader } from "@eggjs/metadata";
+import { Id } from "@eggjs/tegg-types";
+
+//#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/lib/AppLoadUnit.js

@@ -1,3 +1,78 @@
-import { AppLoadUnit } from "../AppLoadUnit-uyHgElRL.js";
+import { debuglog } from "node:util";
+import { InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, PrototypeUtil, QualifierUtil } from "@eggjs/core-decorator";
+import { IdenticalUtil } from "@eggjs/lifecycle";
+import { EggLoadUnitType, EggPrototypeCreatorFactory, EggPrototypeFactory, LoadUnitFactory } from "@eggjs/metadata";
+import { MapUtil } from "@eggjs/tegg-common-util";
 
+//#region src/lib/AppLoadUnit.ts
+const debug = debuglog("egg/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) {
+			[{
+				attribute: InitTypeQualifierAttribute,
+				value: await PrototypeUtil.getInitType(clazz, {
+					unitPath: this.unitPath,
+					moduleName: this.name
+				})
+			}, {
+				attribute: LoadUnitNameQualifierAttribute,
+				value: this.name
+			}].forEach((qualifier) => {
+				QualifierUtil.addProtoQualifier(clazz, qualifier.attribute, qualifier.value, true);
+			});
+			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/lib/AppLoadUnitInstance.d.ts

@@ -1,2 +1,24 @@
-import { AppLoadUnitInstance } from "../AppLoadUnitInstance-DQ-DxlmR.js";
+import { EggObjectName, EggPrototypeName } from "@eggjs/core-decorator";
+import { EggPrototype, LoadUnit } from "@eggjs/metadata";
+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/lib/AppLoadUnitInstance.js

@@ -1,3 +1,70 @@
-import { AppLoadUnitInstance } from "../AppLoadUnitInstance-4Z_vSQV3.js";
+import { ObjectInitType } from "@eggjs/core-decorator";
+import { IdenticalUtil } from "@eggjs/lifecycle";
+import { EggLoadUnitType } from "@eggjs/metadata";
+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/lib/CompatibleUtil.d.ts

@@ -1,4 +1,4 @@
-import { EggPrototype } from "@eggjs/tegg-metadata";
+import { EggPrototype } from "@eggjs/metadata";
 import { LoadUnitInstance } from "@eggjs/tegg-runtime";
 import { Application, Context } from "egg";
 
@@ -11,7 +11,12 @@ declare class CompatibleUtil {
   private static singletonModuleProxyFactory;
   static appCompatible(app: Application, loadUnitInstance: LoadUnitInstance): void;
   static contextModuleProxyFactory(holder: Record<string, any>, ctx: Context, loadUnitInstance: LoadUnitInstance): any;
-  static contextModuleCompatible(ctx: Context, loadUnitInstances: LoadUnitInstance[]): void;
+  /**
+  * Compatible the context module, only for koa application
+  * @param contextPrototype - The prototype of the context
+  * @param loadUnitInstances - The load unit instances
+  */
+  static contextModuleCompatible(contextPrototype: any, loadUnitInstances: LoadUnitInstance[]): void;
   static clean(): void;
 }
 //#endregion

package/dist/lib/CompatibleUtil.js

@@ -1,3 +1,99 @@
-import { CompatibleUtil } from "../CompatibleUtil-CNhydb0E.js";
+import { InitTypeQualifierAttribute, ObjectInitType } from "@eggjs/core-decorator";
+import { EggPrototypeFactory } from "@eggjs/metadata";
+import { ProxyUtil } from "@eggjs/tegg-common-util";
+import { EggContainerFactory } from "@eggjs/tegg-runtime";
 
+//#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];
+	}
+	/**
+	* Compatible the context module, only for koa application
+	* @param contextPrototype - The prototype of the context
+	* @param loadUnitInstances - The load unit instances
+	*/
+	static contextModuleCompatible(contextPrototype, loadUnitInstances) {
+		const loadUnitInstanceMap = loadUnitInstances.reduce((p, c) => {
+			p[c.name] = c;
+			return p;
+		}, {});
+		Reflect.defineProperty(contextPrototype, "module", {
+			configurable: true,
+			enumerable: true,
+			get() {
+				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, this, loadUnitInstance);
+					});
+				}
+				return this._moduleProxy;
+			}
+		});
+	}
+	static clean() {
+		this.singletonProtoCache.clear();
+		this.requestProtoCache.clear();
+	}
+};
+
+//#endregion
 export { CompatibleUtil };