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

package/README.md

@@ -1,5 +1,17 @@
 # `@eggjs/tegg-plugin`
 
+[![NPM version][npm-image]][npm-url]
+[![Known Vulnerabilities][snyk-image]][snyk-url]
+[![npm download][download-image]][download-url]
+[![Node.js Version](https://img.shields.io/node/v/@eggjs/tegg-plugin.svg?style=flat)](https://nodejs.org/en/download/)
+
+[npm-image]: https://img.shields.io/npm/v/@eggjs/tegg-plugin.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@eggjs/tegg-plugin
+[snyk-image]: https://snyk.io/test/npm/@eggjs/tegg-plugin/badge.svg?style=flat-square
+[snyk-url]: https://snyk.io/test/npm/@eggjs/tegg-plugin
+[download-image]: https://img.shields.io/npm/dm/@eggjs/tegg-plugin.svg?style=flat-square
+[download-url]: https://npmjs.org/package/@eggjs/tegg-plugin
+
 ## Usage
 
-Please read [../../README.md](../..)
+Please read [../../README.md](../../README.md)

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

@@ -0,0 +1,57 @@
+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
+export { TEggPluginApplication as default };

package/dist/app/extend/application.js

@@ -0,0 +1,72 @@
+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";
+
+//#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

@@ -0,0 +1,26 @@
+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
+export { TEggPluginApplicationUnittest as default };

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

@@ -0,0 +1,43 @@
+import { EggContextImpl } from "../../lib/EggContextImpl.js";
+import "@eggjs/tegg-runtime";
+import { Application } from "egg";
+
+//#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

@@ -0,0 +1,24 @@
+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
+export { TEggPluginContext as default };

package/dist/app/extend/context.js

@@ -0,0 +1,30 @@
+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";
+
+//#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

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

package/dist/app/middleware/tegg_ctx_lifecycle_middleware.js

@@ -0,0 +1,9 @@
+import { ctxLifecycleMiddleware } from "../../lib/ctx_lifecycle_middleware.js";
+
+//#region src/app/middleware/tegg_ctx_lifecycle_middleware.ts
+var tegg_ctx_lifecycle_middleware_default = () => {
+	return ctxLifecycleMiddleware;
+};
+
+//#endregion
+export { tegg_ctx_lifecycle_middleware_default as default };

package/dist/app.d.ts

@@ -0,0 +1,19 @@
+import { Application, ILifecycleBoot } from "egg";
+
+//#region src/app.d.ts
+
+declare class App implements ILifecycleBoot {
+  private readonly app;
+  private compatibleHook?;
+  private eggContextHandler;
+  private eggQualifierProtoHook;
+  private loadUnitMultiInstanceProtoHook;
+  private configSourceEggPrototypeHook;
+  constructor(app: Application);
+  configWillLoad(): void;
+  configDidLoad(): void;
+  didLoad(): Promise<void>;
+  beforeClose(): Promise<void>;
+}
+//#endregion
+export { App as default };

package/dist/app.js

@@ -0,0 +1,57 @@
+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 { LoadUnitMultiInstanceProtoHook } from "@eggjs/tegg-metadata";
+
+//#region src/app.ts
+var App = class {
+	app;
+	compatibleHook;
+	eggContextHandler;
+	eggQualifierProtoHook;
+	loadUnitMultiInstanceProtoHook;
+	configSourceEggPrototypeHook;
+	constructor(app) {
+		this.app = app;
+	}
+	configWillLoad() {
+		this.app.config.coreMiddleware.push("teggCtxLifecycleMiddleware");
+	}
+	configDidLoad() {
+		this.eggContextHandler = new EggContextHandler(this.app);
+		this.app.eggContextHandler = this.eggContextHandler;
+		this.eggContextHandler.register();
+		this.app.moduleHandler = new ModuleHandler(this.app);
+	}
+	async didLoad() {
+		hijackRunInBackground(this.app);
+		this.loadUnitMultiInstanceProtoHook = new LoadUnitMultiInstanceProtoHook();
+		this.app.loadUnitLifecycleUtil.registerLifecycle(this.loadUnitMultiInstanceProtoHook);
+		this.eggQualifierProtoHook = new EggQualifierProtoHook(this.app);
+		this.app.loadUnitLifecycleUtil.registerLifecycle(this.eggQualifierProtoHook);
+		this.configSourceEggPrototypeHook = new ConfigSourceLoadUnitHook();
+		this.app.loadUnitLifecycleUtil.registerLifecycle(this.configSourceEggPrototypeHook);
+		await this.app.moduleHandler.init();
+		this.compatibleHook = new EggContextCompatibleHook(this.app.moduleHandler);
+		this.app.eggContextLifecycleUtil.registerLifecycle(this.compatibleHook);
+	}
+	async beforeClose() {
+		CompatibleUtil.clean();
+		await this.app.moduleHandler.destroy();
+		if (this.compatibleHook) this.app.eggContextLifecycleUtil.deleteLifecycle(this.compatibleHook);
+		if (this.eggQualifierProtoHook) this.app.loadUnitLifecycleUtil.deleteLifecycle(this.eggQualifierProtoHook);
+		if (this.configSourceEggPrototypeHook) this.app.loadUnitLifecycleUtil.deleteLifecycle(this.configSourceEggPrototypeHook);
+		if (this.loadUnitMultiInstanceProtoHook) this.app.loadUnitLifecycleUtil.deleteLifecycle(this.loadUnitMultiInstanceProtoHook);
+		LoadUnitMultiInstanceProtoHook.clear();
+	}
+};
+
+//#endregion
+export { App as default };

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/index.js

@@ -0,0 +1,5 @@
+import "./app/extend/context.js";
+import "./app/extend/application.js";
+import "./types.js";
+
+export {  };

package/dist/lib/AppLoadUnit.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/lib/AppLoadUnit.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/lib/AppLoadUnitInstance.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/lib/AppLoadUnitInstance.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/lib/CompatibleUtil.d.ts

@@ -0,0 +1,18 @@
+import { EggPrototype } from "@eggjs/tegg-metadata";
+import { LoadUnitInstance } from "@eggjs/tegg-runtime";
+import { Application, Context } from "egg";
+
+//#region src/lib/CompatibleUtil.d.ts
+declare class CompatibleUtil {
+  static singletonProtoCache: Map<PropertyKey, EggPrototype>;
+  static requestProtoCache: Map<PropertyKey, EggPrototype>;
+  static getSingletonProto(name: PropertyKey): EggPrototype;
+  static getRequestProto(name: PropertyKey): EggPrototype;
+  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;
+  static clean(): void;
+}
+//#endregion
+export { CompatibleUtil };