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

package/dist/factory/EggContainerFactory.d.ts

@@ -0,0 +1,30 @@
+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/{ContextInitiator-DazHfq05.js → factory/EggContainerFactory.js}

@@ -1,25 +1,9 @@
+import { ContextHandler } from "../model/ContextHandler.js";
 import { debuglog } from "node:util";
-import { ObjectInitType } from "@eggjs/tegg-types";
-import { EggPrototypeFactory, LoadUnitFactory } from "@eggjs/tegg-metadata";
+import { EggPrototypeFactory } from "@eggjs/metadata";
 import { NameUtil } from "@eggjs/tegg-common-util";
 import { PrototypeUtil } from "@eggjs/core-decorator";
-import assert from "node:assert";
 
-//#region src/model/ContextHandler.ts
-var ContextHandler = class {
-	static getContextCallback;
-	static runInContextCallback;
-	static getContext() {
-		assert(this.getContextCallback, "getContextCallback not set");
-		return this.getContextCallback ? this.getContextCallback() : void 0;
-	}
-	static run(context, fn) {
-		assert(this.runInContextCallback, "runInContextCallback not set");
-		return this.runInContextCallback(context, fn);
-	}
-};
-
-//#endregion
 //#region src/factory/EggContainerFactory.ts
 const debug = debuglog("tegg/core/runtime/EggContainerFactory");
 var EggContainerFactory = class EggContainerFactory {
@@ -46,9 +30,9 @@ var EggContainerFactory = class EggContainerFactory {
 		const ctx = ContextHandler.getContext();
 		if (ctx) {
 			if (!EggContainerFactory.ContextInitiatorClass) {
-				const { ContextInitiator: ContextInitiator$1 } = await import("./ContextInitiator-GmZYvMSm.js");
+				const { ContextInitiator } = await import("../impl/ContextInitiator.js");
 				debug("import ContextInitiator to fix dependency cycle");
-				EggContainerFactory.ContextInitiatorClass = ContextInitiator$1;
+				EggContainerFactory.ContextInitiatorClass = ContextInitiator;
 			}
 			await EggContainerFactory.ContextInitiatorClass.createContextInitiator(ctx).init(obj);
 			debug("getOrCreateEggObject with context eggObject:%o, from proto:%o, name:%s", obj.name, proto.name, name);
@@ -93,68 +77,4 @@ var EggContainerFactory = class EggContainerFactory {
 };
 
 //#endregion
-//#region src/impl/ContextObjectGraph.ts
-var InjectProtoHolder = class {
-	idSet = /* @__PURE__ */ new Set();
-	injectProtos = [];
-	addInjectProto(injectObjectProto) {
-		const id = `${String(injectObjectProto.objName)}:${injectObjectProto.proto.id}`;
-		if (this.idSet.has(id)) return;
-		this.idSet.add(id);
-		this.injectProtos.push(injectObjectProto);
-	}
-	dumpProtos() {
-		return this.injectProtos;
-	}
-};
-var ContextObjectGraph = class ContextObjectGraph {
-	static eggObjectInitRecorder = /* @__PURE__ */ new WeakMap();
-	static getContextProto(proto) {
-		if (ContextObjectGraph.eggObjectInitRecorder.has(proto)) return ContextObjectGraph.eggObjectInitRecorder.get(proto);
-		const holder = new InjectProtoHolder();
-		this.doGetContextProto(proto, holder);
-		const injectObjectProtos = holder.dumpProtos();
-		ContextObjectGraph.eggObjectInitRecorder.set(proto, injectObjectProtos);
-		return injectObjectProtos;
-	}
-	static doGetContextProto(proto, holder) {
-		for (const injectObject of proto.injectObjects) {
-			if (injectObject.proto.initType === ObjectInitType.CONTEXT && proto.initType !== ObjectInitType.CONTEXT) holder.addInjectProto(injectObject);
-			ContextObjectGraph.doGetContextProto(injectObject.proto, holder);
-		}
-	}
-};
-
-//#endregion
-//#region src/impl/ContextInitiator.ts
-const CONTEXT_INITIATOR = Symbol("EggContext#ContextInitiator");
-var ContextInitiator = class ContextInitiator {
-	eggContext;
-	eggObjectInitRecorder;
-	constructor(eggContext) {
-		this.eggContext = eggContext;
-		this.eggObjectInitRecorder = /* @__PURE__ */ new WeakMap();
-		this.eggContext.set(CONTEXT_INITIATOR, this);
-	}
-	async init(obj) {
-		if (this.eggObjectInitRecorder.get(obj) === true) return;
-		this.eggObjectInitRecorder.set(obj, true);
-		const injectObjectProtos = ContextObjectGraph.getContextProto(obj.proto);
-		await Promise.all(injectObjectProtos.map(async (injectObject) => {
-			const proto = injectObject.proto;
-			if (!LoadUnitFactory.getLoadUnitById(proto.loadUnitId)) throw new Error(`can not find load unit: ${proto.loadUnitId}`);
-			await EggContainerFactory.getOrCreateEggObject(proto, injectObject.objName);
-		}));
-	}
-	static createContextInitiator(context) {
-		let initiator = context.get(CONTEXT_INITIATOR);
-		if (!initiator) {
-			initiator = new ContextInitiator(context);
-			context.set(CONTEXT_INITIATOR, initiator);
-		}
-		return initiator;
-	}
-};
-
-//#endregion
-export { ContextHandler, ContextInitiator, ContextObjectGraph, EggContainerFactory };
+export { EggContainerFactory };

package/dist/factory/EggObjectFactory.d.ts

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,49 @@
+import { EggObjectLifecycleUtil } from "../model/EggObject.js";
+import { EggObjectImpl } from "../impl/EggObjectImpl.js";
+import { LoadUnitInstanceFactory } from "./LoadUnitInstanceFactory.js";
+import { LoadUnitFactory } from "@eggjs/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 lifecycleContext = {
+			loadUnit,
+			loadUnitInstance: LoadUnitInstanceFactory.getLoadUnitInstance(loadUnit)
+		};
+		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 };

package/dist/factory/LoadUnitInstanceFactory.d.ts

@@ -0,0 +1,15 @@
+import { EggLoadUnitTypeLike, EggPrototype, LoadUnit, LoadUnitInstance, LoadUnitInstanceLifecycleContext } from "@eggjs/tegg-types";
+
+//#region src/factory/LoadUnitInstanceFactory.d.ts
+type LoadUnitInstanceCreator = (ctx: LoadUnitInstanceLifecycleContext) => LoadUnitInstance;
+declare class LoadUnitInstanceFactory {
+  private static creatorMap;
+  private static instanceMap;
+  static registerLoadUnitInstanceClass(type: EggLoadUnitTypeLike, creator: LoadUnitInstanceCreator): void;
+  static createLoadUnitInstance(loadUnit: LoadUnit): Promise<LoadUnitInstance>;
+  static getLoadUnitInstance(loadUnit: LoadUnit): LoadUnitInstance | undefined;
+  static destroyLoadUnitInstance(loadUnitInstance: LoadUnitInstance): Promise<void>;
+  static getLoadUnitInstanceByProto(proto: EggPrototype): LoadUnitInstance;
+}
+//#endregion
+export { LoadUnitInstanceFactory };

package/dist/factory/LoadUnitInstanceFactory.js

@@ -0,0 +1,49 @@
+import { EggContainerFactory } from "./EggContainerFactory.js";
+import { LoadUnitInstanceLifecycleUtil } from "../model/LoadUnitInstance.js";
+import { ObjectInitType } from "@eggjs/tegg-types";
+import { IdenticalUtil } from "@eggjs/lifecycle";
+
+//#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
+export { LoadUnitInstanceFactory };

package/dist/factory/index.d.ts

@@ -0,0 +1,3 @@
+import { EggContainerFactory } from "./EggContainerFactory.js";
+import { EggObjectFactory } from "./EggObjectFactory.js";
+import { LoadUnitInstanceFactory } from "./LoadUnitInstanceFactory.js";

package/dist/factory/index.js

@@ -0,0 +1,5 @@
+import { EggContainerFactory } from "./EggContainerFactory.js";
+import { LoadUnitInstanceFactory } from "./LoadUnitInstanceFactory.js";
+import { EggObjectFactory } from "./EggObjectFactory.js";
+
+export {  };

package/dist/impl/ContextInitiator.d.ts

@@ -0,0 +1,13 @@
+import { EggObject, EggRuntimeContext } from "@eggjs/tegg-types";
+
+//#region src/impl/ContextInitiator.d.ts
+declare class ContextInitiator {
+  private readonly eggContext;
+  private readonly eggObjectInitRecorder;
+  private readonly eggObjectInitPromise;
+  constructor(eggContext: EggRuntimeContext);
+  init(obj: EggObject): Promise<void>;
+  static createContextInitiator(context: EggRuntimeContext): ContextInitiator;
+}
+//#endregion
+export { ContextInitiator };

package/dist/impl/ContextInitiator.js

@@ -0,0 +1,44 @@
+import { EggContainerFactory } from "../factory/EggContainerFactory.js";
+import { ContextObjectGraph } from "./ContextObjectGraph.js";
+import { LoadUnitFactory } from "@eggjs/metadata";
+
+//#region src/impl/ContextInitiator.ts
+const CONTEXT_INITIATOR = Symbol("EggContext#ContextInitiator");
+var ContextInitiator = class ContextInitiator {
+	eggContext;
+	eggObjectInitRecorder;
+	eggObjectInitPromise;
+	constructor(eggContext) {
+		this.eggContext = eggContext;
+		this.eggObjectInitRecorder = /* @__PURE__ */ new WeakMap();
+		this.eggObjectInitPromise = /* @__PURE__ */ new WeakMap();
+		this.eggContext.set(CONTEXT_INITIATOR, this);
+	}
+	async init(obj) {
+		if (this.eggObjectInitRecorder.get(obj) === true) {
+			if (this.eggObjectInitPromise.has(obj)) await this.eggObjectInitPromise.get(obj);
+			return;
+		}
+		this.eggObjectInitRecorder.set(obj, true);
+		const injectObjectProtos = ContextObjectGraph.getContextProto(obj.proto);
+		const initPromise = Promise.all(injectObjectProtos.map(async (injectObject) => {
+			const proto = injectObject.proto;
+			if (!LoadUnitFactory.getLoadUnitById(proto.loadUnitId)) throw new Error(`can not find load unit: ${proto.loadUnitId}`);
+			await EggContainerFactory.getOrCreateEggObject(proto, injectObject.objName);
+		}));
+		this.eggObjectInitPromise.set(obj, initPromise);
+		await initPromise;
+		this.eggObjectInitPromise.delete(obj);
+	}
+	static createContextInitiator(context) {
+		let initiator = context.get(CONTEXT_INITIATOR);
+		if (!initiator) {
+			initiator = new ContextInitiator(context);
+			context.set(CONTEXT_INITIATOR, initiator);
+		}
+		return initiator;
+	}
+};
+
+//#endregion
+export { ContextInitiator };

package/dist/impl/ContextObjectGraph.d.ts

@@ -0,0 +1,10 @@
+import { EggPrototype, InjectObjectProto } from "@eggjs/tegg-types";
+
+//#region src/impl/ContextObjectGraph.d.ts
+declare class ContextObjectGraph {
+  private static eggObjectInitRecorder;
+  static getContextProto(proto: EggPrototype): InjectObjectProto[];
+  private static doGetContextProto;
+}
+//#endregion
+export { ContextObjectGraph };

package/dist/impl/ContextObjectGraph.js

@@ -0,0 +1,36 @@
+import { ObjectInitType } from "@eggjs/tegg-types";
+
+//#region src/impl/ContextObjectGraph.ts
+var InjectProtoHolder = class {
+	idSet = /* @__PURE__ */ new Set();
+	injectProtos = [];
+	addInjectProto(injectObjectProto) {
+		const id = `${String(injectObjectProto.objName)}:${injectObjectProto.proto.id}`;
+		if (this.idSet.has(id)) return;
+		this.idSet.add(id);
+		this.injectProtos.push(injectObjectProto);
+	}
+	dumpProtos() {
+		return this.injectProtos;
+	}
+};
+var ContextObjectGraph = class ContextObjectGraph {
+	static eggObjectInitRecorder = /* @__PURE__ */ new WeakMap();
+	static getContextProto(proto) {
+		if (ContextObjectGraph.eggObjectInitRecorder.has(proto)) return ContextObjectGraph.eggObjectInitRecorder.get(proto);
+		const holder = new InjectProtoHolder();
+		this.doGetContextProto(proto, holder);
+		const injectObjectProtos = holder.dumpProtos();
+		ContextObjectGraph.eggObjectInitRecorder.set(proto, injectObjectProtos);
+		return injectObjectProtos;
+	}
+	static doGetContextProto(proto, holder) {
+		for (const injectObject of proto.injectObjects) {
+			if (injectObject.proto.initType === ObjectInitType.CONTEXT && proto.initType !== ObjectInitType.CONTEXT) holder.addInjectProto(injectObject);
+			ContextObjectGraph.doGetContextProto(injectObject.proto, holder);
+		}
+	}
+};
+
+//#endregion
+export { ContextObjectGraph };

package/dist/impl/EggAlwaysNewObjectContainer.d.ts

@@ -0,0 +1,17 @@
+import { EggContainer, EggObject, EggObjectName, EggPrototype, Id, LifecycleContext } from "@eggjs/tegg-types";
+
+//#region src/impl/EggAlwaysNewObjectContainer.d.ts
+declare class EggAlwaysNewObjectContainer implements EggContainer<LifecycleContext> {
+  static instance: EggAlwaysNewObjectContainer;
+  readonly id: Id;
+  constructor();
+  addProtoToCreate(): void;
+  deleteProtoToCreate(): void;
+  iterateProtoToCreate(): IterableIterator<[EggObjectName, EggPrototype]>;
+  getEggObject(): EggObject;
+  getOrCreateEggObject(name: string, proto: EggPrototype): Promise<EggObject>;
+  destroy(): Promise<void>;
+  init(): Promise<void>;
+}
+//#endregion
+export { EggAlwaysNewObjectContainer };

package/dist/impl/EggAlwaysNewObjectContainer.js

@@ -0,0 +1,29 @@
+import { EggContainerFactory } from "../factory/EggContainerFactory.js";
+import { EggObjectFactory } from "../factory/EggObjectFactory.js";
+import { ObjectInitType } from "@eggjs/tegg-types";
+
+//#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
+export { EggAlwaysNewObjectContainer };

package/dist/impl/EggObjectImpl.d.ts

@@ -0,0 +1,21 @@
+import { EggObject, EggObjectLifeCycleContext, EggObjectName, EggPrototype } from "@eggjs/tegg-types";
+
+//#region src/impl/EggObjectImpl.d.ts
+declare class EggObjectImpl implements EggObject {
+  private _obj;
+  private status;
+  readonly proto: EggPrototype;
+  readonly name: EggObjectName;
+  readonly id: string;
+  constructor(name: EggObjectName, proto: EggPrototype);
+  initWithInjectProperty(ctx: EggObjectLifeCycleContext): Promise<void>;
+  initWithInjectConstructor(ctx: EggObjectLifeCycleContext): Promise<void>;
+  init(ctx: EggObjectLifeCycleContext): Promise<void>;
+  destroy(ctx: EggObjectLifeCycleContext): Promise<void>;
+  injectProperty(name: EggObjectName, descriptor: PropertyDescriptor): void;
+  get obj(): object;
+  get isReady(): boolean;
+  static createObject(name: EggObjectName, proto: EggPrototype, lifecycleContext: EggObjectLifeCycleContext): Promise<EggObjectImpl>;
+}
+//#endregion
+export { EggObjectImpl };

package/dist/impl/EggObjectImpl.js

@@ -0,0 +1,124 @@
+import { ContextHandler } from "../model/ContextHandler.js";
+import { EggContainerFactory } from "../factory/EggContainerFactory.js";
+import { EggObjectLifecycleUtil } from "../model/EggObject.js";
+import { EggObjectUtil } from "./EggObjectUtil.js";
+import { LoadUnitFactory } from "@eggjs/metadata";
+import { EggObjectStatus, InjectType, ObjectInitType } from "@eggjs/tegg-types";
+import { IdenticalUtil } from "@eggjs/lifecycle";
+
+//#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
+export { EggObjectImpl };

package/dist/impl/EggObjectUtil.d.ts

@@ -0,0 +1,11 @@
+import { EggObject, EggPrototype } from "@eggjs/tegg-types";
+
+//#region src/impl/EggObjectUtil.d.ts
+declare class EggObjectUtil {
+  static eggObjectGetProperty(eggObject: EggObject): PropertyDescriptor;
+  static contextEggObjectGetProperty(proto: EggPrototype, objName: PropertyKey): PropertyDescriptor;
+  static eggObjectProxy(eggObject: EggObject): PropertyDescriptor;
+  static contextEggObjectProxy(proto: EggPrototype, objName: PropertyKey): PropertyDescriptor;
+}
+//#endregion
+export { EggObjectUtil };