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

package/dist/EggModuleLoader-CCfQMmp5.js

@@ -0,0 +1,50 @@
+import { EggAppLoader } from "./EggAppLoader-DFYg65ry.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/EggQualifierProtoHook-D5jNm-1y.js

@@ -0,0 +1,48 @@
+import { APP_CLAZZ_BLACK_LIST, CONTEXT_CLAZZ_BLACK_LIST, DEFAULT_APP_CLAZZ, DEFAULT_CONTEXT_CLAZZ } from "./EggAppLoader-DFYg65ry.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/ModuleConfigLoader-CvZLf99E.js

@@ -0,0 +1,84 @@
+import { COMPATIBLE_PROTO_IMPLE_TYPE } from "./EggCompatibleProtoImpl-CPxLvSu4.js";
+import { AccessLevel, ConfigSourceQualifierAttribute, EggQualifierAttribute, EggType, InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, ModuleConfigs, ObjectInitType, PrototypeUtil, QualifierUtil } from "@eggjs/tegg";
+import { Application } from "egg";
+import { ModuleConfigUtil } from "@eggjs/tegg/helper";
+import { extend } from "extend2";
+
+//#region src/lib/ModuleConfigLoader.ts
+var ModuleConfigLoader = class {
+	app;
+	constructor(app) {
+		this.app = app;
+	}
+	loadModuleConfigs(moduleConfigMap) {
+		const moduleConfigs = new ModuleConfigs(moduleConfigMap);
+		const func = function() {
+			return moduleConfigs;
+		};
+		const name = "moduleConfigs";
+		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;
+	}
+	loadModuleConfigList() {
+		const result = [];
+		const moduleConfigMap = {};
+		for (const reference of this.app.moduleReferences) {
+			const moduleName = ModuleConfigUtil.readModuleNameSync(reference.path);
+			const defaultConfig = ModuleConfigUtil.loadModuleConfigSync(reference.path, void 0, this.app.config.env);
+			const config = extend(true, {}, defaultConfig, this.app.moduleConfigs[moduleName]?.config);
+			moduleConfigMap[moduleName] = {
+				name: moduleName,
+				reference: {
+					name: moduleName,
+					path: reference.path
+				},
+				config
+			};
+			const func = function() {
+				return config;
+			};
+			const name = "moduleConfig";
+			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);
+			QualifierUtil.addProtoQualifier(func, ConfigSourceQualifierAttribute, moduleName);
+			result.push(func);
+		}
+		const moduleConfigs = this.loadModuleConfigs(moduleConfigMap);
+		result.push(moduleConfigs);
+		return result;
+	}
+};
+
+//#endregion
+export { ModuleConfigLoader };

package/dist/ModuleHandler-Dyx7JGj-.d.ts

@@ -0,0 +1,17 @@
+import { LoadUnit } from "@eggjs/tegg-metadata";
+import { LoadUnitInstance } from "@eggjs/tegg-runtime";
+import { Base } from "sdk-base";
+import { Application } from "egg";
+
+//#region src/lib/ModuleHandler.d.ts
+declare class ModuleHandler extends Base {
+  loadUnits: LoadUnit[];
+  loadUnitInstances: LoadUnitInstance[];
+  private readonly loadUnitLoader;
+  private readonly app;
+  constructor(app: Application);
+  init(): Promise<void>;
+  destroy(): Promise<void>;
+}
+//#endregion
+export { ModuleHandler };

package/dist/ModuleHandler-fKcUqWca.js

@@ -0,0 +1,46 @@
+import { COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl } from "./EggCompatibleProtoImpl-CPxLvSu4.js";
+import { EggModuleLoader } from "./EggModuleLoader-CCfQMmp5.js";
+import { CompatibleUtil } from "./CompatibleUtil-CNhydb0E.js";
+import { EggLoadUnitType, LoadUnitFactory } from "@eggjs/tegg-metadata";
+import { LoadUnitInstanceFactory } from "@eggjs/tegg-runtime";
+import { Base } from "sdk-base";
+import { Application, Context } from "egg";
+
+//#region src/lib/ModuleHandler.ts
+var ModuleHandler = class extends Base {
+	loadUnits = [];
+	loadUnitInstances = [];
+	loadUnitLoader;
+	app;
+	constructor(app) {
+		super();
+		this.app = app;
+		this.loadUnitLoader = new EggModuleLoader(this.app);
+	}
+	async init() {
+		try {
+			this.app.eggPrototypeCreatorFactory.registerPrototypeCreator(COMPATIBLE_PROTO_IMPLE_TYPE, EggCompatibleProtoImpl.create);
+			await this.loadUnitLoader.load();
+			const instances = [];
+			this.app.module = {};
+			for (const loadUnit of this.loadUnits) {
+				const instance = await LoadUnitInstanceFactory.createLoadUnitInstance(loadUnit);
+				if (instance.loadUnit.type !== EggLoadUnitType.APP) CompatibleUtil.appCompatible(this.app, instance);
+				instances.push(instance);
+			}
+			CompatibleUtil.contextModuleCompatible(this.app.context, instances);
+			this.loadUnitInstances = instances;
+			this.ready(true);
+		} catch (e) {
+			this.ready(e);
+			throw e;
+		}
+	}
+	async destroy() {
+		if (this.loadUnitInstances) for (const instance of this.loadUnitInstances) await LoadUnitInstanceFactory.destroyLoadUnitInstance(instance);
+		if (this.loadUnits) for (const loadUnit of this.loadUnits) await LoadUnitFactory.destroyLoadUnit(loadUnit);
+	}
+};
+
+//#endregion
+export { ModuleHandler };

package/dist/Utils-11aRpnkd.js

@@ -0,0 +1,33 @@
+//#region src/lib/Utils.ts
+function prepareObjectStackTrace(_, stack) {
+	return stack;
+}
+function getCalleeFromStack(withLine, stackIndex) {
+	stackIndex = stackIndex === void 0 ? 2 : stackIndex;
+	const limit = Error.stackTraceLimit;
+	const prep = Error.prepareStackTrace;
+	Error.prepareStackTrace = prepareObjectStackTrace;
+	Error.stackTraceLimit = 5;
+	const obj = {};
+	Error.captureStackTrace(obj);
+	let callSite = obj.stack[stackIndex];
+	let fileName;
+	/* istanbul ignore else */
+	if (callSite) {
+		fileName = callSite.getFileName();
+		/* istanbul ignore if */
+		if (fileName && fileName.endsWith("egg-mock/lib/app.js")) {
+			callSite = obj.stack[stackIndex + 1];
+			fileName = callSite.getFileName();
+		}
+	}
+	Error.prepareStackTrace = prep;
+	Error.stackTraceLimit = limit;
+	/* istanbul ignore if */
+	if (!callSite || !fileName) return "<anonymous>";
+	if (!withLine) return fileName;
+	return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
+}
+
+//#endregion
+export { getCalleeFromStack };

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

@@ -1,57 +1,4 @@
-import { ModuleHandler } from "../../lib/ModuleHandler.js";
-import { EggContextHandler } from "../../lib/EggContextHandler.js";
-import * as _eggjs_tegg_metadata0 from "@eggjs/tegg-metadata";
-import { EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from "@eggjs/tegg-metadata";
-import * as _eggjs_tegg0 from "@eggjs/tegg";
-import { EggProtoImplClass, IdenticalUtil, QualifierInfo, RuntimeConfig } from "@eggjs/tegg";
-import * as _eggjs_tegg_runtime0 from "@eggjs/tegg-runtime";
-import { AbstractEggContext, EggContainerFactory, EggContext, EggContextLifecycleUtil, EggObjectFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
-import { Application } from "egg";
-import { LoaderFactory } from "@eggjs/tegg-loader";
-
-//#region src/app/extend/application.d.ts
-declare class TEggPluginApplication extends Application {
-  get eggPrototypeCreatorFactory(): typeof EggPrototypeCreatorFactory;
-  get eggPrototypeFactory(): EggPrototypeFactory;
-  get loadUnitLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_metadata0.LoadUnitLifecycleContext, _eggjs_tegg_metadata0.LoadUnit>;
-  get loadUnitFactory(): typeof LoadUnitFactory;
-  get eggObjectFactory(): typeof EggObjectFactory;
-  get loadUnitInstanceFactory(): typeof LoadUnitInstanceFactory;
-  get loadUnitInstanceLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_runtime0.LoadUnitInstanceLifecycleContext, _eggjs_tegg_runtime0.LoadUnitInstance>;
-  get eggContainerFactory(): typeof EggContainerFactory;
-  get loaderFactory(): typeof LoaderFactory;
-  get eggPrototypeLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_metadata0.EggPrototypeLifecycleContext, _eggjs_tegg_metadata0.EggPrototype>;
-  get eggContextLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_runtime0.EggContextLifecycleContext, EggContext>;
-  get eggObjectLifecycleUtil(): _eggjs_tegg0.LifecycleUtil<_eggjs_tegg_runtime0.EggObjectLifeCycleContext, _eggjs_tegg_runtime0.EggObject>;
-  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>;
-}
-declare module 'egg' {
-  interface Application {
-    eggPrototypeCreatorFactory: typeof EggPrototypeCreatorFactory;
-    eggPrototypeFactory: EggPrototypeFactory;
-    eggContainerFactory: typeof EggContainerFactory;
-    loadUnitFactory: typeof LoadUnitFactory;
-    eggObjectFactory: typeof EggObjectFactory;
-    loadUnitInstanceFactory: typeof LoadUnitInstanceFactory;
-    abstractEggContext: typeof AbstractEggContext;
-    identicalUtil: typeof IdenticalUtil;
-    loaderFactory: typeof LoaderFactory;
-    loadUnitLifecycleUtil: typeof LoadUnitLifecycleUtil;
-    loadUnitInstanceLifecycleUtil: typeof LoadUnitInstanceLifecycleUtil;
-    eggPrototypeLifecycleUtil: typeof EggPrototypeLifecycleUtil;
-    eggContextLifecycleUtil: typeof EggContextLifecycleUtil;
-    eggObjectLifecycleUtil: typeof EggObjectLifecycleUtil;
-    teggContext: EggContext;
-    moduleHandler: ModuleHandler;
-    eggContextHandler: EggContextHandler;
-    getEggObject<T>(clazz: new (...args: any[]) => T, name?: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
-    getEggObjectFromName<T extends object>(name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
-    module: EggModule;
-  }
-}
-//#endregion
+import "../../ModuleHandler-Dyx7JGj-.js";
+import "../../EggContextHandler-vGi67He5.js";
+import { TEggPluginApplication } from "../../application-Ccljinuy.js";
 export { TEggPluginApplication as default };

package/dist/app/extend/application.js

@@ -1,72 +1,10 @@
-import "../../lib/ModuleHandler.js";
-import "../../lib/EggContextHandler.js";
-import { EggPrototypeCreatorFactory, EggPrototypeFactory, EggPrototypeLifecycleUtil, LoadUnitFactory, LoadUnitLifecycleUtil } from "@eggjs/tegg-metadata";
-import { IdenticalUtil } from "@eggjs/tegg";
-import { AbstractEggContext, EggContainerFactory, EggContextLifecycleUtil, EggObjectFactory, EggObjectLifecycleUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil } from "@eggjs/tegg-runtime";
-import { Application } from "egg";
-import { LoaderFactory } from "@eggjs/tegg-loader";
+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";
 
-//#region src/app/extend/application.ts
-var TEggPluginApplication = class extends Application {
-	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,26 +1,2 @@
-import { Application, Context } from "egg";
-
-//#region src/app/extend/application.unittest.d.ts
-declare class TEggPluginApplicationUnittest extends Application {
-  mockModuleContext(data?: any): Promise<Context>;
-  destroyModuleContext(ctx: Context): Promise<void>;
-  mockModuleContextScope<R = any>(fn: (ctx: Context) => Promise<R>, data?: any): Promise<R>;
-}
-declare module 'egg' {
-  interface Application {
-    /**
-     * Mock the module context, only for unittest
-     */
-    mockModuleContext(data?: any): Promise<Context>;
-    /**
-     * Mock the module context scope, only for unittest
-     */
-    mockModuleContextScope<R = any>(fn: (ctx: Context) => Promise<R>, data?: any): Promise<R>;
-    /**
-     * Destroy the module context, only for unittest
-     */
-    destroyModuleContext(context: Context): Promise<void>;
-  }
-}
-//#endregion
+import { TEggPluginApplicationUnittest } from "../../application.unittest-CpoCu6-E.js";
 export { TEggPluginApplicationUnittest as default };

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

@@ -1,43 +1,4 @@
-import { EggContextImpl } from "../../lib/EggContextImpl.js";
-import "@eggjs/tegg-runtime";
-import { Application } from "egg";
+import "../../EggContextImpl-DkCLPTzT.js";
+import { TEggPluginApplicationUnittest } from "../../application.unittest-Cmia71Fx.js";
 
-//#region src/app/extend/application.unittest.ts
-const TEGG_LIFECYCLE_CACHE = /* @__PURE__ */ new Map();
-let hasMockModuleContext = false;
-var TEggPluginApplicationUnittest = class extends Application {
-	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,24 +1,2 @@
-import { EggProtoImplClass, QualifierInfo } from "@eggjs/tegg";
-import { EggContext } from "@eggjs/tegg-runtime";
-import { TEGG_CONTEXT } from "@eggjs/egg-module-common";
-import { Context } from "egg";
-
-//#region src/app/extend/context.d.ts
-declare class TEggPluginContext extends Context {
-  [TEGG_CONTEXT]: EggContext | undefined;
-  beginModuleScope(func: () => Promise<void>): Promise<void>;
-  get teggContext(): EggContext;
-  getEggObject<T>(clazz: EggProtoImplClass<T>, name?: string): Promise<T>;
-  getEggObjectFromName<T>(name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
-}
-declare module 'egg' {
-  interface Context {
-    beginModuleScope(func: () => Promise<void>): Promise<void>;
-    getEggObject<T>(clazz: new (...args: any[]) => T, name?: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
-    getEggObjectFromName<T>(name: string, qualifiers?: QualifierInfo | QualifierInfo[]): Promise<T>;
-    teggContext: EggContext;
-    module: EggModule;
-  }
-}
-//#endregion
+import { TEggPluginContext } from "../../context-BoIt2G5h.js";
 export { TEggPluginContext as default };

package/dist/app/extend/context.js

@@ -1,30 +1,5 @@
-import { ctxLifecycleMiddleware } from "../../lib/ctx_lifecycle_middleware.js";
-import "@eggjs/tegg-metadata";
-import { PrototypeUtil } from "@eggjs/tegg";
-import { TEGG_CONTEXT } from "@eggjs/egg-module-common";
-import { Context } from "egg";
+import "../../EggContextImpl-DkCLPTzT.js";
+import "../../ctx_lifecycle_middleware-CIeSrbVY.js";
+import { TEggPluginContext } from "../../context-BWYE1dif.js";
 
-//#region src/app/extend/context.ts
-var TEggPluginContext = class extends Context {
-	[TEGG_CONTEXT];
-	async beginModuleScope(func) {
-		await ctxLifecycleMiddleware(this, func);
-	}
-	get teggContext() {
-		if (!this[TEGG_CONTEXT]) throw new Error("tegg context have not ready, should call after teggCtxLifecycleMiddleware");
-		return this[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,4 +1,4 @@
-import { ctxLifecycleMiddleware } from "../../lib/ctx_lifecycle_middleware.js";
+import { ctxLifecycleMiddleware } from "../../ctx_lifecycle_middleware-DV7uN5PG.js";
 
 //#region src/app/middleware/tegg_ctx_lifecycle_middleware.d.ts
 declare const _default: () => typeof ctxLifecycleMiddleware;

package/dist/app/middleware/tegg_ctx_lifecycle_middleware.js

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

package/dist/app.d.ts

@@ -1,7 +1,10 @@
+import "./AppLoadUnit-BOWdS4O9.js";
+import "./AppLoadUnitInstance-DQ-DxlmR.js";
+import "./EggCompatibleProtoImpl-DpacWKFB.js";
+import "./EggCompatibleObject-lzUCfsIY.js";
 import { Application, ILifecycleBoot } from "egg";
 
 //#region src/app.d.ts
-
 declare class App implements ILifecycleBoot {
   private readonly app;
   private compatibleHook?;

package/dist/app.js

@@ -1,13 +1,21 @@
-import "./lib/AppLoadUnit.js";
-import "./lib/AppLoadUnitInstance.js";
-import "./lib/EggCompatibleObject.js";
-import { CompatibleUtil } from "./lib/CompatibleUtil.js";
-import { ModuleHandler } from "./lib/ModuleHandler.js";
-import { EggContextCompatibleHook } from "./lib/EggContextCompatibleHook.js";
-import { EggContextHandler } from "./lib/EggContextHandler.js";
-import { hijackRunInBackground } from "./lib/run_in_background.js";
-import { EggQualifierProtoHook } from "./lib/EggQualifierProtoHook.js";
-import { ConfigSourceLoadUnitHook } from "./lib/ConfigSourceLoadUnitHook.js";
+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";
 
 //#region src/app.ts