@eggjs/tegg-runtime 4.0.0-beta.4 → 4.0.0-beta.6

package/README.md

@@ -1,5 +1,17 @@
 # `@eggjs/tegg-runtime`
 
+[![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-runtime.svg?style=flat)](https://nodejs.org/en/download/)
+
+[npm-image]: https://img.shields.io/npm/v/@eggjs/tegg-runtime.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@eggjs/tegg-runtime
+[snyk-image]: https://snyk.io/test/npm/@eggjs/tegg-runtime/badge.svg?style=flat-square
+[snyk-url]: https://snyk.io/test/npm/@eggjs/tegg-runtime
+[download-image]: https://img.shields.io/npm/dm/@eggjs/tegg-runtime.svg?style=flat-square
+[download-url]: https://npmjs.org/package/@eggjs/tegg-runtime
+
 # Usage
 
 This is an internal tegg library, you probably shouldn't use it directly.

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/factory/EggContainerFactory.js

@@ -0,0 +1,80 @@
+import { ContextHandler } from "../model/ContextHandler.js";
+import "../model/index.js";
+import { debuglog } from "node:util";
+import { EggPrototypeFactory } from "@eggjs/tegg-metadata";
+import { NameUtil } from "@eggjs/tegg-common-util";
+import { PrototypeUtil } from "@eggjs/core-decorator";
+
+//#region src/factory/EggContainerFactory.ts
+const debug = debuglog("tegg/core/runtime/EggContainerFactory");
+var EggContainerFactory = class EggContainerFactory {
+	static containerGetMethodMap = /* @__PURE__ */ new Map();
+	static ContextInitiatorClass;
+	static registerContainerGetMethod(initType, method) {
+		if (debug.enabled) debug("registerContainerGetMethod %o %o, exists: %s", initType, method.toString(), this.containerGetMethodMap.has(initType));
+		this.containerGetMethodMap.set(initType, method);
+	}
+	static getContainer(proto) {
+		const method = this.containerGetMethodMap.get(proto.initType);
+		if (!method) throw new Error(`InitType ${proto.initType} has not register ContainerGetMethod`);
+		return method(proto);
+	}
+	/**
+	* get or create egg object
+	* If get singleton egg object in context,
+	* will create context egg object for it.
+	*/
+	static async getOrCreateEggObject(proto, name) {
+		const container = this.getContainer(proto);
+		name = name || proto.name;
+		const obj = await container.getOrCreateEggObject(name, proto);
+		const ctx = ContextHandler.getContext();
+		if (ctx) {
+			if (!EggContainerFactory.ContextInitiatorClass) {
+				const { ContextInitiator } = await import("../impl/ContextInitiator.js");
+				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);
+		} else debug("getOrCreateEggObject without context, get eggObject:%o, from proto:%o, name:%s", obj.name, proto.name, name);
+		return obj;
+	}
+	/**
+	* get or create egg object from the Class
+	* If get singleton egg object in context,
+	* will create context egg object for it.
+	*/
+	static async getOrCreateEggObjectFromClazz(clazz, name, qualifiers) {
+		let proto = PrototypeUtil.getClazzProto(clazz);
+		const isMultiInstance = PrototypeUtil.isEggMultiInstancePrototype(clazz);
+		debug("getOrCreateEggObjectFromClazz:%o, isMultiInstance:%s, proto:%o", clazz.name, isMultiInstance, !!proto);
+		if (isMultiInstance) {
+			const defaultName = NameUtil.getClassName(clazz);
+			name = name ?? defaultName;
+			proto = EggPrototypeFactory.instance.getPrototype(name, void 0, qualifiers);
+		} else if (proto) name = name ?? proto.name;
+		if (!proto) {
+			debug("getOrCreateEggObjectFromClazz:%o not found, eggObjectName:%s, qualifiers:%o, proto:%o, isMultiInstance:%s", clazz.name, name, qualifiers, proto, isMultiInstance);
+			throw new Error(`can not get proto for clazz ${clazz.name}`);
+		}
+		return await this.getOrCreateEggObject(proto, name);
+	}
+	/**
+	* get or create egg object from the Name
+	* If get singleton egg object in context,
+	* will create context egg object for it.
+	*/
+	static async getOrCreateEggObjectFromName(name, qualifiers) {
+		const proto = EggPrototypeFactory.instance.getPrototype(name, void 0, qualifiers);
+		if (!proto) throw new Error(`can not get proto for clazz ${String(name)}`);
+		return await this.getOrCreateEggObject(proto, name);
+	}
+	static getEggObject(proto, name) {
+		const container = this.getContainer(proto);
+		name = name || proto.name;
+		return container.getEggObject(name, proto);
+	}
+};
+
+//#endregion
+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,52 @@
+import { EggObjectImpl } from "../impl/EggObjectImpl.js";
+import { LoadUnitInstanceFactory } from "./LoadUnitInstanceFactory.js";
+import "../impl/index.js";
+import { EggObjectLifecycleUtil } from "../model/EggObject.js";
+import "../model/index.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 };

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

package/dist/impl/ContextInitiator.js

@@ -0,0 +1,37 @@
+import { EggContainerFactory } from "../factory/EggContainerFactory.js";
+import { ContextObjectGraph } from "./ContextObjectGraph.js";
+import "../factory/index.js";
+import { LoadUnitFactory } from "@eggjs/tegg-metadata";
+
+//#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 { 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,30 @@
+import { EggContainerFactory } from "../factory/EggContainerFactory.js";
+import { EggObjectFactory } from "../factory/EggObjectFactory.js";
+import "../factory/index.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,126 @@
+import { EggContainerFactory } from "../factory/EggContainerFactory.js";
+import { EggObjectUtil } from "./EggObjectUtil.js";
+import "../factory/index.js";
+import { ContextHandler } from "../model/ContextHandler.js";
+import { EggObjectLifecycleUtil } from "../model/EggObject.js";
+import "../model/index.js";
+import { EggObjectStatus, InjectType, ObjectInitType } from "@eggjs/tegg-types";
+import { LoadUnitFactory } from "@eggjs/tegg-metadata";
+import { IdenticalUtil } from "@eggjs/tegg-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 };