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

package/dist/index.js

@@ -1,21 +1,528 @@
-import { ContextHandler } from "./model/ContextHandler.js";
-import { EggContainerFactory } from "./factory/EggContainerFactory.js";
-import { EggObjectLifecycleUtil } from "./model/EggObject.js";
-import { EggObjectUtil } from "./impl/EggObjectUtil.js";
-import { EggObjectImpl } from "./impl/EggObjectImpl.js";
-import { LoadUnitInstanceLifecycleUtil } from "./model/LoadUnitInstance.js";
-import { LoadUnitInstanceFactory } from "./factory/LoadUnitInstanceFactory.js";
-import { EggObjectFactory } from "./factory/EggObjectFactory.js";
-import { EggContextLifecycleUtil } from "./model/EggContext.js";
-import { AbstractEggContext } from "./model/AbstractEggContext.js";
-import "./model/index.js";
-import { ContextObjectGraph } from "./impl/ContextObjectGraph.js";
-import { ContextInitiator } from "./impl/ContextInitiator.js";
-import { EggAlwaysNewObjectContainer } from "./impl/EggAlwaysNewObjectContainer.js";
-import { ModuleLoadUnitInstance } from "./impl/ModuleLoadUnitInstance.js";
-import "./impl/index.js";
-import "./factory/index.js";
+import { ContextHandler, ContextInitiator, ContextObjectGraph, EggContainerFactory } from "./ContextInitiator-DazHfq05.js";
+import { debuglog } from "node:util";
+import { EggLoadUnitType, EggObjectStatus, InjectType, ObjectInitType } from "@eggjs/tegg-types";
+import { LoadUnitFactory, TeggError } from "@eggjs/tegg-metadata";
+import { MapUtil } from "@eggjs/tegg-common-util";
+import { IdenticalUtil, LifecycleUtil } from "@eggjs/tegg-lifecycle";
 
 export * from "@eggjs/tegg-types/runtime"
 
+//#region src/model/EggObject.ts
+const EggObjectLifecycleUtil = new LifecycleUtil();
+
+//#endregion
+//#region src/impl/EggObjectUtil.ts
+var EggObjectUtil = class {
+	static eggObjectGetProperty(eggObject) {
+		return {
+			get() {
+				return eggObject.obj;
+			},
+			configurable: true,
+			enumerable: true
+		};
+	}
+	static contextEggObjectGetProperty(proto, objName) {
+		const PROTO_OBJ_GETTER = Symbol(`EggPrototype#objGetter#${String(objName)}`);
+		if (!proto[PROTO_OBJ_GETTER]) proto[PROTO_OBJ_GETTER] = {
+			get() {
+				return EggContainerFactory.getEggObject(proto, objName).obj;
+			},
+			configurable: true,
+			enumerable: true
+		};
+		return proto[PROTO_OBJ_GETTER];
+	}
+	static eggObjectProxy(eggObject) {
+		let _obj;
+		function getObj() {
+			if (!_obj) _obj = eggObject.obj;
+			return _obj;
+		}
+		return new Proxy({}, {
+			defineProperty(_target, property, attributes) {
+				const obj = getObj();
+				Object.defineProperty(obj, property, attributes);
+				return true;
+			},
+			deleteProperty(_target, p) {
+				const obj = getObj();
+				delete obj[p];
+				return true;
+			},
+			get(target, p) {
+				if (p === "then") return;
+				if (Object.prototype[p]) return target[p];
+				const obj = getObj();
+				const val = obj[p];
+				if (typeof val === "function") return val.bind(obj);
+				return val;
+			},
+			getOwnPropertyDescriptor(_target, p) {
+				const obj = getObj();
+				return Object.getOwnPropertyDescriptor(obj, p);
+			},
+			getPrototypeOf() {
+				const obj = getObj();
+				return Object.getPrototypeOf(obj);
+			},
+			has(_target, p) {
+				const obj = getObj();
+				return p in obj;
+			},
+			isExtensible() {
+				const obj = getObj();
+				return Object.isExtensible(obj);
+			},
+			ownKeys() {
+				const obj = getObj();
+				return Reflect.ownKeys(obj);
+			},
+			preventExtensions() {
+				const obj = getObj();
+				Object.preventExtensions(obj);
+				return true;
+			},
+			set(_target, p, newValue) {
+				const obj = getObj();
+				obj[p] = newValue;
+				return true;
+			},
+			setPrototypeOf(_target, v) {
+				const obj = getObj();
+				Object.setPrototypeOf(obj, v);
+				return true;
+			}
+		});
+	}
+	static contextEggObjectProxy(proto, objName) {
+		const PROTO_OBJ_PROXY = Symbol(`EggPrototype#objProxy#${String(objName)}`);
+		if (!proto[PROTO_OBJ_PROXY]) proto[PROTO_OBJ_PROXY] = new Proxy({}, {
+			defineProperty(_target, property, attributes) {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				Object.defineProperty(obj, property, attributes);
+				return true;
+			},
+			deleteProperty(_target, p) {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				delete obj[p];
+				return true;
+			},
+			get(target, p) {
+				if (p === "then") return;
+				if (Object.prototype[p]) return target[p];
+				return EggContainerFactory.getEggObject(proto, objName).obj[p];
+			},
+			getOwnPropertyDescriptor(_target, p) {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				return Object.getOwnPropertyDescriptor(obj, p);
+			},
+			getPrototypeOf() {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				return Object.getPrototypeOf(obj);
+			},
+			has(_target, p) {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				return p in obj;
+			},
+			isExtensible() {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				return Object.isExtensible(obj);
+			},
+			ownKeys() {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				return Reflect.ownKeys(obj);
+			},
+			preventExtensions() {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				Object.preventExtensions(obj);
+				return true;
+			},
+			set(_target, p, newValue) {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				obj[p] = newValue;
+				return true;
+			},
+			setPrototypeOf(_target, v) {
+				const obj = EggContainerFactory.getEggObject(proto, objName).obj;
+				Object.setPrototypeOf(obj, v);
+				return true;
+			}
+		});
+		return proto[PROTO_OBJ_PROXY];
+	}
+};
+
+//#endregion
+//#region src/impl/EggObjectImpl.ts
+var EggObjectImpl = class EggObjectImpl {
+	_obj;
+	status = EggObjectStatus.PENDING;
+	proto;
+	name;
+	id;
+	constructor(name, proto) {
+		this.name = name;
+		this.proto = proto;
+		const ctx = ContextHandler.getContext();
+		this.id = IdenticalUtil.createObjectId(this.proto.id, ctx?.id);
+	}
+	async initWithInjectProperty(ctx) {
+		try {
+			this._obj = this.proto.constructEggObject();
+			const objLifecycleHook = this._obj;
+			await EggObjectLifecycleUtil.objectPreCreate(ctx, this);
+			const postConstructMethod = EggObjectLifecycleUtil.getLifecycleHook("postConstruct", this.proto) ?? "postConstruct";
+			if (objLifecycleHook[postConstructMethod]) await objLifecycleHook[postConstructMethod](ctx, this);
+			const preInjectMethod = EggObjectLifecycleUtil.getLifecycleHook("preInject", this.proto) ?? "preInject";
+			if (objLifecycleHook[preInjectMethod]) await objLifecycleHook[preInjectMethod](ctx, this);
+			await Promise.all(this.proto.injectObjects.map(async (injectObject) => {
+				const proto = injectObject.proto;
+				if (!LoadUnitFactory.getLoadUnitById(proto.loadUnitId)) throw new Error(`can not find load unit: ${proto.loadUnitId}`);
+				if (this.proto.initType !== ObjectInitType.CONTEXT && injectObject.proto.initType === ObjectInitType.CONTEXT) this.injectProperty(injectObject.refName, EggObjectUtil.contextEggObjectGetProperty(proto, injectObject.objName));
+				else {
+					const injectObj = await EggContainerFactory.getOrCreateEggObject(proto, injectObject.objName);
+					this.injectProperty(injectObject.refName, EggObjectUtil.eggObjectGetProperty(injectObj));
+				}
+			}));
+			await EggObjectLifecycleUtil.objectPostCreate(ctx, this);
+			const postInjectMethod = EggObjectLifecycleUtil.getLifecycleHook("postInject", this.proto) ?? "postInject";
+			if (objLifecycleHook[postInjectMethod]) await objLifecycleHook[postInjectMethod](ctx, this);
+			const initMethod = EggObjectLifecycleUtil.getLifecycleHook("init", this.proto) ?? "init";
+			if (objLifecycleHook[initMethod]) await objLifecycleHook[initMethod](ctx, this);
+			this.status = EggObjectStatus.READY;
+		} catch (e) {
+			this.status = EggObjectStatus.ERROR;
+			throw e;
+		}
+	}
+	async initWithInjectConstructor(ctx) {
+		try {
+			const constructArgs = await Promise.all(this.proto.injectObjects.map(async (injectObject) => {
+				const proto = injectObject.proto;
+				if (!LoadUnitFactory.getLoadUnitById(proto.loadUnitId)) throw new Error(`can not find load unit: ${proto.loadUnitId}`);
+				if (this.proto.initType !== ObjectInitType.CONTEXT && injectObject.proto.initType === ObjectInitType.CONTEXT) return EggObjectUtil.contextEggObjectProxy(proto, injectObject.objName);
+				const injectObj = await EggContainerFactory.getOrCreateEggObject(proto, injectObject.objName);
+				return EggObjectUtil.eggObjectProxy(injectObj);
+			}));
+			if (typeof this.proto.multiInstanceConstructorIndex !== "undefined") {
+				const qualifiers = this.proto.multiInstanceConstructorAttributes?.map((t) => {
+					return {
+						attribute: t,
+						value: this.proto.getQualifier(t)
+					};
+				})?.filter((t) => typeof t.value !== "undefined") ?? [];
+				const objInfo = {
+					name: this.proto.name,
+					qualifiers
+				};
+				constructArgs.splice(this.proto.multiInstanceConstructorIndex, 0, objInfo);
+			}
+			this._obj = this.proto.constructEggObject(...constructArgs);
+			const objLifecycleHook = this._obj;
+			await EggObjectLifecycleUtil.objectPreCreate(ctx, this);
+			const postConstructMethod = EggObjectLifecycleUtil.getLifecycleHook("postConstruct", this.proto) ?? "postConstruct";
+			if (objLifecycleHook[postConstructMethod]) await objLifecycleHook[postConstructMethod](ctx, this);
+			const preInjectMethod = EggObjectLifecycleUtil.getLifecycleHook("preInject", this.proto) ?? "preInject";
+			if (objLifecycleHook[preInjectMethod]) await objLifecycleHook[preInjectMethod](ctx, this);
+			await EggObjectLifecycleUtil.objectPostCreate(ctx, this);
+			const postInjectMethod = EggObjectLifecycleUtil.getLifecycleHook("postInject", this.proto) ?? "postInject";
+			if (objLifecycleHook[postInjectMethod]) await objLifecycleHook[postInjectMethod](ctx, this);
+			const initMethod = EggObjectLifecycleUtil.getLifecycleHook("init", this.proto) ?? "init";
+			if (objLifecycleHook[initMethod]) await objLifecycleHook[initMethod](ctx, this);
+			this.status = EggObjectStatus.READY;
+		} catch (e) {
+			this.status = EggObjectStatus.ERROR;
+			throw e;
+		}
+	}
+	async init(ctx) {
+		if (this.proto.injectType === InjectType.CONSTRUCTOR) await this.initWithInjectConstructor(ctx);
+		else await this.initWithInjectProperty(ctx);
+	}
+	async destroy(ctx) {
+		if (this.status === EggObjectStatus.READY) {
+			this.status = EggObjectStatus.DESTROYING;
+			await EggObjectLifecycleUtil.objectPreDestroy(ctx, this);
+			const objLifecycleHook = this._obj;
+			const preDestroyMethod = EggObjectLifecycleUtil.getLifecycleHook("preDestroy", this.proto) ?? "preDestroy";
+			if (objLifecycleHook[preDestroyMethod]) await objLifecycleHook[preDestroyMethod](ctx, this);
+			const destroyMethod = EggObjectLifecycleUtil.getLifecycleHook("destroy", this.proto) ?? "destroy";
+			if (objLifecycleHook[destroyMethod]) await objLifecycleHook[destroyMethod](ctx, this);
+			this.status = EggObjectStatus.DESTROYED;
+		}
+	}
+	injectProperty(name, descriptor) {
+		Reflect.defineProperty(this._obj, name, descriptor);
+	}
+	get obj() {
+		return this._obj;
+	}
+	get isReady() {
+		return this.status === EggObjectStatus.READY;
+	}
+	static async createObject(name, proto, lifecycleContext) {
+		const obj = new EggObjectImpl(name, proto);
+		await obj.init(lifecycleContext);
+		return obj;
+	}
+};
+
+//#endregion
+//#region src/model/LoadUnitInstance.ts
+const LoadUnitInstanceLifecycleUtil = new LifecycleUtil();
+
+//#endregion
+//#region src/factory/LoadUnitInstanceFactory.ts
+var LoadUnitInstanceFactory = class {
+	static creatorMap = /* @__PURE__ */ new Map();
+	static instanceMap = /* @__PURE__ */ new Map();
+	static registerLoadUnitInstanceClass(type, creator) {
+		this.creatorMap.set(type, creator);
+	}
+	static async createLoadUnitInstance(loadUnit) {
+		const creator = this.creatorMap.get(loadUnit.type);
+		if (!creator) throw new Error(`load unit instance type ${loadUnit.type} is not implement`);
+		const instanceId = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
+		if (!this.instanceMap.has(instanceId)) {
+			const ctx = { loadUnit };
+			const instance = creator(ctx);
+			this.instanceMap.set(instanceId, {
+				instance,
+				ctx
+			});
+			if (instance.init) await instance.init(ctx);
+		}
+		return this.instanceMap.get(instanceId).instance;
+	}
+	static getLoadUnitInstance(loadUnit) {
+		const instanceId = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
+		return this.instanceMap.get(instanceId)?.instance;
+	}
+	static async destroyLoadUnitInstance(loadUnitInstance) {
+		const { ctx } = this.instanceMap.get(loadUnitInstance.id);
+		await LoadUnitInstanceLifecycleUtil.objectPreDestroy(ctx, loadUnitInstance);
+		if (loadUnitInstance.destroy) await loadUnitInstance.destroy(ctx);
+		this.instanceMap.delete(loadUnitInstance.id);
+		LoadUnitInstanceLifecycleUtil.clearObjectLifecycle(loadUnitInstance);
+	}
+	static getLoadUnitInstanceByProto(proto) {
+		for (const { instance } of this.instanceMap.values()) if (instance.loadUnit.containPrototype(proto)) return instance;
+		throw new Error(`not found load unit for proto ${proto.id}`);
+	}
+};
+EggContainerFactory.registerContainerGetMethod(ObjectInitType.SINGLETON, (proto) => {
+	return LoadUnitInstanceFactory.getLoadUnitInstanceByProto(proto);
+});
+
+//#endregion
+//#region src/factory/EggObjectFactory.ts
+var EggObjectFactory = class {
+	static eggObjectMap = /* @__PURE__ */ new Map();
+	static eggObjectCreateMap = /* @__PURE__ */ new Map();
+	static registerEggObjectCreateMethod(protoClass, method) {
+		this.eggObjectCreateMap.set(protoClass, method);
+	}
+	static getEggObjectCreateMethod(protoClass) {
+		if (this.eggObjectCreateMap.has(protoClass)) return this.eggObjectCreateMap.get(protoClass);
+		return EggObjectImpl.createObject;
+	}
+	static async createObject(name, proto) {
+		const loadUnit = LoadUnitFactory.getLoadUnitById(proto.loadUnitId);
+		if (!loadUnit) throw new Error(`not found load unit ${proto.loadUnitId}`);
+		const loadUnitInstance = LoadUnitInstanceFactory.getLoadUnitInstance(loadUnit);
+		const lifecycleContext = {
+			loadUnit,
+			loadUnitInstance
+		};
+		const method = this.getEggObjectCreateMethod(proto.constructor);
+		const args = [
+			name,
+			proto,
+			lifecycleContext
+		];
+		const obj = await Reflect.apply(method, null, args);
+		this.eggObjectMap.set(obj.id, {
+			obj,
+			ctx: lifecycleContext
+		});
+		return obj;
+	}
+	static async destroyObject(obj) {
+		const { ctx } = this.eggObjectMap.get(obj.id);
+		try {
+			if (obj.destroy) await obj.destroy(ctx);
+		} finally {
+			this.eggObjectMap.delete(obj.id);
+			EggObjectLifecycleUtil.clearObjectLifecycle(obj);
+		}
+	}
+};
+
+//#endregion
+//#region src/model/EggContext.ts
+const EggContextLifecycleUtil = new LifecycleUtil();
+
+//#endregion
+//#region src/model/AbstractEggContext.ts
+const debug = debuglog("tegg/core/runtime/AbstractEggContext");
+var AbstractEggContext = class {
+	contextData = /* @__PURE__ */ new Map();
+	protoToCreate = /* @__PURE__ */ new Map();
+	eggObjectMap = /* @__PURE__ */ new Map();
+	eggObjectPromiseMap = /* @__PURE__ */ new Map();
+	destroyed = false;
+	addProtoToCreate(name, proto) {
+		this.protoToCreate.set(name, proto);
+	}
+	deleteProtoToCreate(name) {
+		this.protoToCreate.delete(name);
+	}
+	async destroy(ctx) {
+		await EggContextLifecycleUtil.objectPreDestroy(ctx, this);
+		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);
+		}));
+		this.contextData.clear();
+		this.destroyed = true;
+		await EggContextLifecycleUtil.clearObjectLifecycle(this);
+	}
+	get(key) {
+		return this.contextData.get(key);
+	}
+	getEggObject(name, proto) {
+		if (this.destroyed) throw TeggError.create(`Can not read property \`${String(name)}\` because egg ctx has been destroyed`, "read_after_ctx_destroyed");
+		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);
+	}
+	async getOrCreateEggObject(name, 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);
+				if (!protoObjPromiseMap.size) this.eggObjectPromiseMap.delete(proto.id);
+				protoObjMap.set(name, obj);
+			} else await protoObjPromiseMap.get(name);
+		}
+		return protoObjMap.get(name);
+	}
+	async init(ctx) {
+		await EggContextLifecycleUtil.objectPreCreate(ctx, this);
+		for (const [name, proto] of this.protoToCreate) await this.getOrCreateEggObject(name, proto);
+		await EggContextLifecycleUtil.objectPostCreate(ctx, this);
+	}
+	iterateProtoToCreate() {
+		return this.protoToCreate.entries();
+	}
+	set(key, val) {
+		this.contextData.set(key, val);
+	}
+};
+EggContainerFactory.registerContainerGetMethod(ObjectInitType.CONTEXT, () => {
+	const ctx = ContextHandler.getContext();
+	if (!ctx) {
+		debug("can not get teggCtx from ContextHandler");
+		throw new Error("ctx is required");
+	}
+	return ctx;
+});
+
+//#endregion
+//#region src/impl/EggAlwaysNewObjectContainer.ts
+var EggAlwaysNewObjectContainer = class EggAlwaysNewObjectContainer {
+	static instance = new EggAlwaysNewObjectContainer();
+	id;
+	constructor() {
+		this.id = "ALWAYS_NEW_OBJECT_CONTAINER";
+	}
+	addProtoToCreate() {}
+	deleteProtoToCreate() {}
+	iterateProtoToCreate() {
+		return (/* @__PURE__ */ new Map()).entries();
+	}
+	getEggObject() {
+		throw new Error("Always Object can not use getEggObject, should use getOrCreateEggObject");
+	}
+	async getOrCreateEggObject(name, proto) {
+		return EggObjectFactory.createObject(name, proto);
+	}
+	async destroy() {}
+	async init() {}
+};
+EggContainerFactory.registerContainerGetMethod(ObjectInitType.ALWAYS_NEW, () => EggAlwaysNewObjectContainer.instance);
+
+//#endregion
+//#region src/impl/ModuleLoadUnitInstance.ts
+var ModuleLoadUnitInstance = class ModuleLoadUnitInstance {
+	loadUnit;
+	id;
+	name;
+	protoToCreateMap = [];
+	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.push([proto.name, proto]);
+		this.id = IdenticalUtil.createLoadUnitInstanceId(loadUnit.id);
+	}
+	iterateProtoToCreate() {
+		return this.protoToCreateMap[Symbol.iterator]();
+	}
+	addProtoToCreate(name, proto) {
+		this.protoToCreateMap.push([name, proto]);
+	}
+	deleteProtoToCreate(name) {
+		const index = this.protoToCreateMap.findIndex(([protoName]) => protoName === name);
+		if (index !== -1) this.protoToCreateMap.splice(index, 1);
+	}
+	async init(ctx) {
+		await LoadUnitInstanceLifecycleUtil.objectPreCreate(ctx, this);
+		for (const [name, proto] of this.protoToCreateMap) await this.getOrCreateEggObject(name, proto);
+		await LoadUnitInstanceLifecycleUtil.objectPostCreate(ctx, this);
+	}
+	async destroy() {
+		const objs = [];
+		for (const protoObjMap of this.eggObjectMap.values()) for (const obj of protoObjMap.values()) objs.push(obj);
+		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 ModuleLoadUnitInstance(ctx.loadUnit);
+	}
+};
+LoadUnitInstanceFactory.registerLoadUnitInstanceClass(EggLoadUnitType.MODULE, ModuleLoadUnitInstance.createModuleLoadUnitInstance);
+
+//#endregion
 export { AbstractEggContext, ContextHandler, ContextInitiator, ContextObjectGraph, EggAlwaysNewObjectContainer, EggContainerFactory, EggContextLifecycleUtil, EggObjectFactory, EggObjectImpl, EggObjectLifecycleUtil, EggObjectUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil, ModuleLoadUnitInstance };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/tegg-runtime",
-  "version": "4.0.0-beta.7",
+  "version": "4.0.0-beta.8",
   "description": "tegg runtime",
   "type": "module",
   "exports": {
@@ -31,11 +31,11 @@
     "node": ">=22.18.0"
   },
   "dependencies": {
-    "@eggjs/core-decorator": "4.0.0-beta.7",
-    "@eggjs/tegg-common-util": "4.0.0-beta.7",
-    "@eggjs/tegg-lifecycle": "4.0.0-beta.7",
-    "@eggjs/tegg-types": "4.0.0-beta.7",
-    "@eggjs/tegg-metadata": "4.0.0-beta.7"
+    "@eggjs/core-decorator": "4.0.0-beta.8",
+    "@eggjs/tegg-common-util": "4.0.0-beta.8",
+    "@eggjs/tegg-lifecycle": "4.0.0-beta.8",
+    "@eggjs/tegg-metadata": "4.0.0-beta.8",
+    "@eggjs/tegg-types": "4.0.0-beta.8"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",
@@ -43,7 +43,7 @@
     "tsdown": "^0.15.6",
     "unplugin-unused": "^0.5.3",
     "@eggjs/module-test-util": "4.0.0-beta.4",
-    "@eggjs/tegg-loader": "4.0.0-beta.7"
+    "@eggjs/tegg-loader": "4.0.0-beta.8"
   },
   "publishConfig": {
     "access": "public"

package/dist/factory/EggContainerFactory.d.ts

@@ -1,30 +0,0 @@
-import { ContainerGetMethod, EggContainer, EggObject, EggObjectName, EggProtoImplClass, EggPrototype, LifecycleContext, ObjectInitTypeLike, QualifierInfo } from "@eggjs/tegg-types";
-
-//#region src/factory/EggContainerFactory.d.ts
-declare class EggContainerFactory {
-  private static containerGetMethodMap;
-  private static ContextInitiatorClass;
-  static registerContainerGetMethod(initType: ObjectInitTypeLike, method: ContainerGetMethod): void;
-  static getContainer(proto: EggPrototype): EggContainer<LifecycleContext>;
-  /**
-   * get or create egg object
-   * If get singleton egg object in context,
-   * will create context egg object for it.
-   */
-  static getOrCreateEggObject(proto: EggPrototype, name?: EggObjectName): Promise<EggObject>;
-  /**
-   * get or create egg object from the Class
-   * If get singleton egg object in context,
-   * will create context egg object for it.
-   */
-  static getOrCreateEggObjectFromClazz(clazz: EggProtoImplClass, name?: EggObjectName, qualifiers?: QualifierInfo[]): Promise<EggObject>;
-  /**
-   * get or create egg object from the Name
-   * If get singleton egg object in context,
-   * will create context egg object for it.
-   */
-  static getOrCreateEggObjectFromName(name: EggObjectName, qualifiers?: QualifierInfo[]): Promise<EggObject>;
-  static getEggObject(proto: EggPrototype, name?: EggObjectName): EggObject;
-}
-//#endregion
-export { EggContainerFactory };

package/dist/factory/EggObjectFactory.d.ts

@@ -1,17 +0,0 @@
-import { CreateObjectMethod, EggObject, EggObjectLifeCycleContext, EggObjectName, EggPrototype, EggPrototypeClass } from "@eggjs/tegg-types";
-
-//#region src/factory/EggObjectFactory.d.ts
-interface EggObjectPair {
-  obj: EggObject;
-  ctx: EggObjectLifeCycleContext;
-}
-declare class EggObjectFactory {
-  static eggObjectMap: Map<string, EggObjectPair>;
-  static eggObjectCreateMap: Map<EggPrototypeClass, CreateObjectMethod>;
-  static registerEggObjectCreateMethod(protoClass: EggPrototypeClass, method: CreateObjectMethod): void;
-  static getEggObjectCreateMethod(protoClass: EggPrototypeClass): CreateObjectMethod;
-  static createObject(name: EggObjectName, proto: EggPrototype): Promise<EggObject>;
-  static destroyObject(obj: EggObject): Promise<void>;
-}
-//#endregion
-export { EggObjectFactory };

package/dist/factory/EggObjectFactory.js

@@ -1,50 +0,0 @@
-import { EggObjectLifecycleUtil } from "../model/EggObject.js";
-import { EggObjectImpl } from "../impl/EggObjectImpl.js";
-import { LoadUnitInstanceFactory } from "./LoadUnitInstanceFactory.js";
-import { LoadUnitFactory } from "@eggjs/tegg-metadata";
-
-//#region src/factory/EggObjectFactory.ts
-var EggObjectFactory = class {
-	static eggObjectMap = /* @__PURE__ */ new Map();
-	static eggObjectCreateMap = /* @__PURE__ */ new Map();
-	static registerEggObjectCreateMethod(protoClass, method) {
-		this.eggObjectCreateMap.set(protoClass, method);
-	}
-	static getEggObjectCreateMethod(protoClass) {
-		if (this.eggObjectCreateMap.has(protoClass)) return this.eggObjectCreateMap.get(protoClass);
-		return EggObjectImpl.createObject;
-	}
-	static async createObject(name, proto) {
-		const loadUnit = LoadUnitFactory.getLoadUnitById(proto.loadUnitId);
-		if (!loadUnit) throw new Error(`not found load unit ${proto.loadUnitId}`);
-		const loadUnitInstance = LoadUnitInstanceFactory.getLoadUnitInstance(loadUnit);
-		const lifecycleContext = {
-			loadUnit,
-			loadUnitInstance
-		};
-		const method = this.getEggObjectCreateMethod(proto.constructor);
-		const args = [
-			name,
-			proto,
-			lifecycleContext
-		];
-		const obj = await Reflect.apply(method, null, args);
-		this.eggObjectMap.set(obj.id, {
-			obj,
-			ctx: lifecycleContext
-		});
-		return obj;
-	}
-	static async destroyObject(obj) {
-		const { ctx } = this.eggObjectMap.get(obj.id);
-		try {
-			if (obj.destroy) await obj.destroy(ctx);
-		} finally {
-			this.eggObjectMap.delete(obj.id);
-			EggObjectLifecycleUtil.clearObjectLifecycle(obj);
-		}
-	}
-};
-
-//#endregion
-export { EggObjectFactory };