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

package/README.md

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

package/dist/errors.d.ts

@@ -0,0 +1,18 @@
+import { EggPrototypeName, QualifierInfo } from "@eggjs/tegg-types";
+import { FrameworkBaseError } from "egg-errors";
+
+//#region src/errors.d.ts
+declare class TeggError extends FrameworkBaseError {
+  get module(): string;
+}
+declare class EggPrototypeNotFound extends TeggError {
+  constructor(protoName: EggPrototypeName, loadUnitId: string | undefined);
+}
+declare class MultiPrototypeFound extends TeggError {
+  constructor(name: EggPrototypeName, qualifier: QualifierInfo[], result?: string);
+}
+declare class IncompatibleProtoInject extends TeggError {
+  constructor(msg: string);
+}
+//#endregion
+export { EggPrototypeNotFound, IncompatibleProtoInject, MultiPrototypeFound, TeggError };

package/dist/errors.js

@@ -0,0 +1,29 @@
+import { ErrorCodes } from "@eggjs/tegg-types";
+import { FrameworkBaseError } from "egg-errors";
+
+//#region src/errors.ts
+var TeggError = class extends FrameworkBaseError {
+	get module() {
+		return "TEGG";
+	}
+};
+var EggPrototypeNotFound = class extends TeggError {
+	constructor(protoName, loadUnitId) {
+		const msg = loadUnitId ? `Object ${String(protoName)} not found in ${loadUnitId}` : `Object ${String(protoName)} not found`;
+		super(msg, ErrorCodes.EGG_PROTO_NOT_FOUND);
+	}
+};
+var MultiPrototypeFound = class extends TeggError {
+	constructor(name, qualifier, result) {
+		const msg = `multi proto found for name:${String(name)} and qualifiers ${JSON.stringify(qualifier)}${result ? `, result is ${result}` : ""}`;
+		super(msg, ErrorCodes.MULTI_PROTO_FOUND);
+	}
+};
+var IncompatibleProtoInject = class extends TeggError {
+	constructor(msg) {
+		super(msg, ErrorCodes.INCOMPATIBLE_PROTO_INJECT);
+	}
+};
+
+//#endregion
+export { EggPrototypeNotFound, IncompatibleProtoInject, MultiPrototypeFound, TeggError };

package/dist/factory/EggPrototypeCreatorFactory.d.ts

@@ -0,0 +1,13 @@
+import { ClassProtoDescriptor } from "../model/ProtoDescriptor/ClassProtoDescriptor.js";
+import { EggProtoImplClass, EggPrototype, EggPrototypeCreator, LoadUnit } from "@eggjs/tegg-types";
+
+//#region src/factory/EggPrototypeCreatorFactory.d.ts
+declare class EggPrototypeCreatorFactory {
+  private static creatorMap;
+  static registerPrototypeCreator(type: string, creator: EggPrototypeCreator): void;
+  static getPrototypeCreator(type: string): EggPrototypeCreator | undefined;
+  static createProto(clazz: EggProtoImplClass, loadUnit: LoadUnit): Promise<EggPrototype[]>;
+  static createProtoByDescriptor(protoDescriptor: ClassProtoDescriptor, loadUnit: LoadUnit): Promise<EggPrototype>;
+}
+//#endregion
+export { EggPrototypeCreatorFactory };

package/dist/factory/EggPrototypeCreatorFactory.js

@@ -0,0 +1,95 @@
+import { EggPrototypeLifecycleUtil } from "../model/EggPrototype.js";
+import "../model/index.js";
+import assert from "node:assert";
+import { debuglog } from "node:util";
+import { InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, PrototypeUtil } from "@eggjs/core-decorator";
+
+//#region src/factory/EggPrototypeCreatorFactory.ts
+const debug = debuglog("tegg/core/metadata/factory/EggPrototypeCreatorFactory");
+var EggPrototypeCreatorFactory = class {
+	static creatorMap = /* @__PURE__ */ new Map();
+	static registerPrototypeCreator(type, creator) {
+		this.creatorMap.set(type, creator);
+	}
+	static getPrototypeCreator(type) {
+		return this.creatorMap.get(type);
+	}
+	static async createProto(clazz, loadUnit) {
+		let properties = [];
+		const initTypeQualifierAttributeValue = await PrototypeUtil.getInitType(clazz, {
+			unitPath: loadUnit.unitPath,
+			moduleName: loadUnit.name
+		});
+		const defaultQualifier = [{
+			attribute: InitTypeQualifierAttribute,
+			value: initTypeQualifierAttributeValue
+		}, {
+			attribute: LoadUnitNameQualifierAttribute,
+			value: loadUnit.name
+		}];
+		if (PrototypeUtil.isEggMultiInstancePrototype(clazz)) {
+			const multiInstanceProtoInfo = await PrototypeUtil.getMultiInstanceProperty(clazz, {
+				unitPath: loadUnit.unitPath,
+				moduleName: loadUnit.name
+			});
+			assert(multiInstanceProtoInfo, `multiInstanceProtoInfo is undefined, clazz: ${clazz.name}, unitPath: ${loadUnit.unitPath}, moduleName: ${loadUnit.name}`);
+			for (const obj of multiInstanceProtoInfo.objects) {
+				defaultQualifier.forEach((qualifier) => {
+					if (!obj.qualifiers.find((t) => t.attribute === qualifier.attribute)) obj.qualifiers.push(qualifier);
+				});
+				properties.push({
+					name: obj.name,
+					protoImplType: multiInstanceProtoInfo.protoImplType,
+					initType: multiInstanceProtoInfo.initType,
+					accessLevel: multiInstanceProtoInfo.accessLevel,
+					qualifiers: obj.qualifiers,
+					properQualifiers: obj.properQualifiers,
+					className: multiInstanceProtoInfo.className
+				});
+			}
+		} else {
+			const property = PrototypeUtil.getProperty(clazz);
+			if (!property.qualifiers) property.qualifiers = [];
+			defaultQualifier.forEach((qualifier) => {
+				if (!property.qualifiers.find((t) => t.attribute === qualifier.attribute)) property.qualifiers.push(qualifier);
+			});
+			properties = [property];
+		}
+		const protos = [];
+		for (const property of properties) {
+			const creator = this.getPrototypeCreator(property.protoImplType);
+			if (!creator) throw new Error(`not found proto creator for type: ${property.protoImplType}`);
+			const ctx = {
+				clazz,
+				loadUnit,
+				prototypeInfo: property
+			};
+			const proto = creator(ctx);
+			await EggPrototypeLifecycleUtil.objectPreCreate(ctx, proto);
+			if (proto.init) await proto.init(ctx);
+			await EggPrototypeLifecycleUtil.objectPostCreate(ctx, proto);
+			PrototypeUtil.setClazzProto(clazz, proto);
+			protos.push(proto);
+		}
+		if (debug.enabled && loadUnit.name === "egg-app") debug("createProto, get protos:%o, from clazz:%o, from loadUnit:%o:%o:%o", protos.map((t) => t.name), clazz.name, loadUnit.type, loadUnit.name, loadUnit.unitPath);
+		return protos;
+	}
+	static async createProtoByDescriptor(protoDescriptor, loadUnit) {
+		const creator = this.getPrototypeCreator(protoDescriptor.protoImplType);
+		if (!creator) throw new Error(`not found proto creator for type: ${protoDescriptor.protoImplType}`);
+		const ctx = {
+			clazz: protoDescriptor.clazz,
+			loadUnit,
+			prototypeInfo: protoDescriptor
+		};
+		const proto = creator(ctx);
+		await EggPrototypeLifecycleUtil.objectPreCreate(ctx, proto);
+		if (proto.init) await proto.init(ctx);
+		await EggPrototypeLifecycleUtil.objectPostCreate(ctx, proto);
+		PrototypeUtil.setClazzProto(protoDescriptor.clazz, proto);
+		return proto;
+	}
+};
+
+//#endregion
+export { EggPrototypeCreatorFactory };

package/dist/factory/EggPrototypeFactory.d.ts

@@ -0,0 +1,13 @@
+import { EggPrototype, LoadUnit, QualifierInfo } from "@eggjs/tegg-types";
+
+//#region src/factory/EggPrototypeFactory.d.ts
+declare class EggPrototypeFactory {
+  static instance: EggPrototypeFactory;
+  private publicProtoMap;
+  registerPrototype(proto: EggPrototype, loadUnit: LoadUnit): void;
+  deletePrototype(proto: EggPrototype, loadUnit: LoadUnit): void;
+  getPrototype(name: PropertyKey, loadUnit?: LoadUnit, qualifiers?: QualifierInfo[]): EggPrototype;
+  private doGetPrototype;
+}
+//#endregion
+export { EggPrototypeFactory };

package/dist/factory/EggPrototypeFactory.js

@@ -0,0 +1,41 @@
+import { EggPrototypeNotFound, MultiPrototypeFound } from "../errors.js";
+import { MapUtil } from "@eggjs/tegg-common-util";
+import { AccessLevel } from "@eggjs/tegg-types";
+import { FrameworkErrorFormater } from "egg-errors";
+
+//#region src/factory/EggPrototypeFactory.ts
+var EggPrototypeFactory = class EggPrototypeFactory {
+	static instance = new EggPrototypeFactory();
+	publicProtoMap = /* @__PURE__ */ new Map();
+	registerPrototype(proto, loadUnit) {
+		if (proto.accessLevel === AccessLevel.PUBLIC) MapUtil.getOrStore(this.publicProtoMap, proto.name, []).push(proto);
+		loadUnit.registerEggPrototype(proto);
+	}
+	deletePrototype(proto, loadUnit) {
+		if (proto.accessLevel === AccessLevel.PUBLIC) {
+			const protos = this.publicProtoMap.get(proto.name);
+			if (protos) {
+				const index = protos.indexOf(proto);
+				if (index !== -1) protos.splice(index, 1);
+			}
+		}
+		loadUnit.deletePrototype(proto);
+	}
+	getPrototype(name, loadUnit, qualifiers) {
+		qualifiers = qualifiers || [];
+		const protos = this.doGetPrototype(name, qualifiers, loadUnit);
+		if (!protos.length) throw FrameworkErrorFormater.formatError(new EggPrototypeNotFound(name, loadUnit?.id));
+		if (protos.length === 1) return protos[0];
+		throw FrameworkErrorFormater.formatError(new MultiPrototypeFound(name, qualifiers));
+	}
+	doGetPrototype(name, qualifiers, loadUnit) {
+		if (loadUnit) {
+			const protos = loadUnit.getEggPrototype(name, qualifiers);
+			if (protos.length) return protos;
+		}
+		return this.publicProtoMap.get(name)?.filter((proto) => proto.verifyQualifiers(qualifiers)) || [];
+	}
+};
+
+//#endregion
+export { EggPrototypeFactory };

package/dist/factory/LoadUnitFactory.d.ts

@@ -0,0 +1,16 @@
+import { EggLoadUnitTypeLike, Id, LoadUnit, LoadUnitCreator, LoadUnitLifecycleContext, Loader } from "@eggjs/tegg-types";
+
+//#region src/factory/LoadUnitFactory.d.ts
+declare class LoadUnitFactory {
+  private static loadUnitCreatorMap;
+  private static loadUnitMap;
+  private static loadUnitIdMap;
+  protected static getLoanUnit(ctx: LoadUnitLifecycleContext, type: EggLoadUnitTypeLike): Promise<LoadUnit>;
+  static createLoadUnit(unitPath: string, type: EggLoadUnitTypeLike, loader: Loader): Promise<LoadUnit>;
+  static createPreloadLoadUnit(unitPath: string, type: EggLoadUnitTypeLike, loader: Loader): Promise<LoadUnit>;
+  static destroyLoadUnit(loadUnit: LoadUnit): Promise<void>;
+  static getLoadUnitById(id: Id): LoadUnit | undefined;
+  static registerLoadUnitCreator(type: EggLoadUnitTypeLike, creator: LoadUnitCreator): void;
+}
+//#endregion
+export { LoadUnitFactory };

package/dist/factory/LoadUnitFactory.js

@@ -0,0 +1,58 @@
+import { LoadUnitLifecycleUtil } from "../model/LoadUnit.js";
+import "../model/index.js";
+
+//#region src/factory/LoadUnitFactory.ts
+var LoadUnitFactory = class LoadUnitFactory {
+	static loadUnitCreatorMap = /* @__PURE__ */ new Map();
+	static loadUnitMap = /* @__PURE__ */ new Map();
+	static loadUnitIdMap = /* @__PURE__ */ new Map();
+	static async getLoanUnit(ctx, type) {
+		const creator = LoadUnitFactory.loadUnitCreatorMap.get(type);
+		if (!creator) throw new Error(`not find creator for load unit type ${type}`);
+		return await creator(ctx);
+	}
+	static async createLoadUnit(unitPath, type, loader) {
+		if (LoadUnitFactory.loadUnitMap.has(unitPath)) return LoadUnitFactory.loadUnitMap.get(unitPath).loadUnit;
+		const ctx = {
+			unitPath,
+			loader
+		};
+		const loadUnit = await LoadUnitFactory.getLoanUnit(ctx, type);
+		await LoadUnitLifecycleUtil.objectPreCreate(ctx, loadUnit);
+		if (loadUnit.init) await loadUnit.init(ctx);
+		await LoadUnitLifecycleUtil.objectPostCreate(ctx, loadUnit);
+		LoadUnitFactory.loadUnitMap.set(unitPath, {
+			loadUnit,
+			ctx
+		});
+		LoadUnitFactory.loadUnitIdMap.set(loadUnit.id, loadUnit);
+		return loadUnit;
+	}
+	static async createPreloadLoadUnit(unitPath, type, loader) {
+		const ctx = {
+			unitPath,
+			loader
+		};
+		return await LoadUnitFactory.getLoanUnit(ctx, type);
+	}
+	static async destroyLoadUnit(loadUnit) {
+		const { ctx } = LoadUnitFactory.loadUnitMap.get(loadUnit.unitPath);
+		try {
+			await LoadUnitLifecycleUtil.objectPreDestroy(ctx, loadUnit);
+			if (loadUnit.destroy) await loadUnit.destroy(ctx);
+		} finally {
+			LoadUnitFactory.loadUnitMap.delete(loadUnit.unitPath);
+			LoadUnitFactory.loadUnitIdMap.delete(loadUnit.id);
+			LoadUnitLifecycleUtil.clearObjectLifecycle(loadUnit);
+		}
+	}
+	static getLoadUnitById(id) {
+		return LoadUnitFactory.loadUnitIdMap.get(id);
+	}
+	static registerLoadUnitCreator(type, creator) {
+		LoadUnitFactory.loadUnitCreatorMap.set(type, creator);
+	}
+};
+
+//#endregion
+export { LoadUnitFactory };

package/dist/factory/index.js

@@ -0,0 +1,5 @@
+import { EggPrototypeFactory } from "./EggPrototypeFactory.js";
+import { EggPrototypeCreatorFactory } from "./EggPrototypeCreatorFactory.js";
+import { LoadUnitFactory } from "./LoadUnitFactory.js";
+
+export {  };

package/dist/impl/EggPrototypeBuilder.d.ts

@@ -0,0 +1,26 @@
+import { EggPrototype, EggPrototypeLifecycleContext } from "@eggjs/tegg-types";
+
+//#region src/impl/EggPrototypeBuilder.d.ts
+declare class EggPrototypeBuilder {
+  private clazz;
+  private name;
+  private initType;
+  private accessLevel;
+  private filepath;
+  private injectType;
+  private injectObjects;
+  private loadUnit;
+  private qualifiers;
+  private properQualifiers;
+  private className?;
+  private multiInstanceConstructorIndex?;
+  private multiInstanceConstructorAttributes?;
+  static create(ctx: EggPrototypeLifecycleContext): EggPrototype;
+  private tryFindDefaultPrototype;
+  private tryFindContextPrototype;
+  private tryFindSelfInitTypePrototype;
+  private findInjectObjectPrototype;
+  build(): EggPrototype;
+}
+//#endregion
+export { EggPrototypeBuilder };

package/dist/impl/EggPrototypeBuilder.js

@@ -0,0 +1,115 @@
+import { EggPrototypeNotFound, MultiPrototypeFound } from "../errors.js";
+import { EggPrototypeFactory } from "../factory/EggPrototypeFactory.js";
+import { EggPrototypeCreatorFactory } from "../factory/EggPrototypeCreatorFactory.js";
+import "../factory/index.js";
+import { EggPrototypeImpl } from "./EggPrototypeImpl.js";
+import { DEFAULT_PROTO_IMPL_TYPE, InitTypeQualifierAttribute, ObjectInitType } from "@eggjs/tegg-types";
+import assert from "node:assert";
+import { InjectType, PrototypeUtil, QualifierUtil } from "@eggjs/core-decorator";
+import { IdenticalUtil } from "@eggjs/tegg-lifecycle";
+
+//#region src/impl/EggPrototypeBuilder.ts
+var EggPrototypeBuilder = class EggPrototypeBuilder {
+	clazz;
+	name;
+	initType;
+	accessLevel;
+	filepath;
+	injectType;
+	injectObjects = [];
+	loadUnit;
+	qualifiers = [];
+	properQualifiers = {};
+	className;
+	multiInstanceConstructorIndex;
+	multiInstanceConstructorAttributes;
+	static create(ctx) {
+		const { clazz, loadUnit } = ctx;
+		const filepath = PrototypeUtil.getFilePath(clazz);
+		assert(filepath, "not find filepath");
+		const builder = new EggPrototypeBuilder();
+		builder.clazz = clazz;
+		builder.name = ctx.prototypeInfo.name;
+		builder.className = ctx.prototypeInfo.className;
+		builder.initType = ctx.prototypeInfo.initType;
+		builder.accessLevel = ctx.prototypeInfo.accessLevel;
+		builder.filepath = filepath;
+		builder.injectType = PrototypeUtil.getInjectType(clazz);
+		builder.injectObjects = PrototypeUtil.getInjectObjects(clazz) || [];
+		builder.loadUnit = loadUnit;
+		builder.qualifiers = QualifierUtil.mergeQualifiers(QualifierUtil.getProtoQualifiers(clazz), ctx.prototypeInfo.qualifiers ?? []);
+		builder.properQualifiers = ctx.prototypeInfo.properQualifiers ?? {};
+		builder.multiInstanceConstructorIndex = PrototypeUtil.getMultiInstanceConstructorIndex(clazz);
+		builder.multiInstanceConstructorAttributes = PrototypeUtil.getMultiInstanceConstructorAttributes(clazz);
+		return builder.build();
+	}
+	tryFindDefaultPrototype(injectObject) {
+		const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+		const multiInstancePropertyQualifiers = this.properQualifiers[injectObject.refName] ?? [];
+		return EggPrototypeFactory.instance.getPrototype(injectObject.objName, this.loadUnit, QualifierUtil.mergeQualifiers(propertyQualifiers, multiInstancePropertyQualifiers));
+	}
+	tryFindContextPrototype(injectObject) {
+		const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+		const multiInstancePropertyQualifiers = this.properQualifiers[injectObject.refName] ?? [];
+		return EggPrototypeFactory.instance.getPrototype(injectObject.objName, this.loadUnit, QualifierUtil.mergeQualifiers(propertyQualifiers, multiInstancePropertyQualifiers, [{
+			attribute: InitTypeQualifierAttribute,
+			value: ObjectInitType.CONTEXT
+		}]));
+	}
+	tryFindSelfInitTypePrototype(injectObject) {
+		const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+		const multiInstancePropertyQualifiers = this.properQualifiers[injectObject.refName] ?? [];
+		return EggPrototypeFactory.instance.getPrototype(injectObject.objName, this.loadUnit, QualifierUtil.mergeQualifiers(propertyQualifiers, multiInstancePropertyQualifiers, [{
+			attribute: InitTypeQualifierAttribute,
+			value: this.initType
+		}]));
+	}
+	findInjectObjectPrototype(injectObject) {
+		const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+		try {
+			return this.tryFindDefaultPrototype(injectObject);
+		} catch (e) {
+			if (!(e instanceof MultiPrototypeFound && !propertyQualifiers.find((t) => t.attribute === InitTypeQualifierAttribute))) throw e;
+		}
+		try {
+			return this.tryFindContextPrototype(injectObject);
+		} catch (e) {
+			if (!(e instanceof EggPrototypeNotFound)) throw e;
+		}
+		return this.tryFindSelfInitTypePrototype(injectObject);
+	}
+	build() {
+		const injectObjectProtos = [];
+		for (const injectObject of this.injectObjects) {
+			const propertyQualifiers = QualifierUtil.getProperQualifiers(this.clazz, injectObject.refName);
+			try {
+				const proto = this.findInjectObjectPrototype(injectObject);
+				let injectObjectProto;
+				if (this.injectType === InjectType.PROPERTY) injectObjectProto = {
+					refName: injectObject.refName,
+					objName: injectObject.objName,
+					qualifiers: propertyQualifiers,
+					proto
+				};
+				else injectObjectProto = {
+					refIndex: injectObject.refIndex,
+					refName: injectObject.refName,
+					objName: injectObject.objName,
+					qualifiers: propertyQualifiers,
+					proto
+				};
+				if (injectObject.optional) injectObject.optional = true;
+				injectObjectProtos.push(injectObjectProto);
+			} catch (e) {
+				if (e instanceof EggPrototypeNotFound && injectObject.optional) continue;
+				throw e;
+			}
+		}
+		const id = IdenticalUtil.createProtoId(this.loadUnit.id, this.name);
+		return new EggPrototypeImpl(id, this.name, this.clazz, this.filepath, this.initType, this.accessLevel, injectObjectProtos, this.loadUnit.id, this.qualifiers, this.className, this.injectType, this.multiInstanceConstructorIndex, this.multiInstanceConstructorAttributes);
+	}
+};
+EggPrototypeCreatorFactory.registerPrototypeCreator(DEFAULT_PROTO_IMPL_TYPE, EggPrototypeBuilder.create);
+
+//#endregion
+export { EggPrototypeBuilder };

package/dist/impl/EggPrototypeImpl.d.ts

@@ -0,0 +1,28 @@
+import { AccessLevel, EggProtoImplClass, EggPrototype, EggPrototypeName, Id, InjectConstructorProto, InjectObjectProto, MetaDataKey, ObjectInitTypeLike, QualifierInfo, QualifierValue } from "@eggjs/tegg-types";
+import { InjectType, QualifierAttribute } from "@eggjs/core-decorator";
+
+//#region src/impl/EggPrototypeImpl.d.ts
+declare class EggPrototypeImpl implements EggPrototype {
+  private readonly clazz;
+  private readonly qualifiers;
+  readonly filepath: string;
+  readonly id: string;
+  readonly name: EggPrototypeName;
+  readonly initType: ObjectInitTypeLike;
+  readonly accessLevel: AccessLevel;
+  readonly injectObjects: Array<InjectObjectProto | InjectConstructorProto>;
+  readonly injectType: InjectType;
+  readonly loadUnitId: Id;
+  readonly className?: string;
+  readonly multiInstanceConstructorIndex?: number;
+  readonly multiInstanceConstructorAttributes?: QualifierAttribute[];
+  [key: symbol]: PropertyDescriptor;
+  constructor(id: string, name: EggPrototypeName, clazz: EggProtoImplClass, filepath: string, initType: ObjectInitTypeLike, accessLevel: AccessLevel, injectObjectMap: Array<InjectObjectProto | InjectConstructorProto>, loadUnitId: Id, qualifiers: QualifierInfo[], className?: string, injectType?: InjectType, multiInstanceConstructorIndex?: number, multiInstanceConstructorAttributes?: QualifierAttribute[]);
+  verifyQualifiers(qualifiers: QualifierInfo[]): boolean;
+  verifyQualifier(qualifier: QualifierInfo): boolean;
+  getQualifier(attribute: string): QualifierValue | undefined;
+  constructEggObject(...args: any): object;
+  getMetaData<T>(metadataKey: MetaDataKey): T | undefined;
+}
+//#endregion
+export { EggPrototypeImpl };

package/dist/impl/EggPrototypeImpl.js

@@ -0,0 +1,52 @@
+import { InjectType, MetadataUtil } from "@eggjs/core-decorator";
+
+//#region src/impl/EggPrototypeImpl.ts
+var EggPrototypeImpl = class {
+	clazz;
+	qualifiers;
+	filepath;
+	id;
+	name;
+	initType;
+	accessLevel;
+	injectObjects;
+	injectType;
+	loadUnitId;
+	className;
+	multiInstanceConstructorIndex;
+	multiInstanceConstructorAttributes;
+	constructor(id, name, clazz, filepath, initType, accessLevel, injectObjectMap, loadUnitId, qualifiers, className, injectType, multiInstanceConstructorIndex, multiInstanceConstructorAttributes) {
+		this.id = id;
+		this.clazz = clazz;
+		this.name = name;
+		this.filepath = filepath;
+		this.initType = initType;
+		this.accessLevel = accessLevel;
+		this.injectObjects = injectObjectMap;
+		this.loadUnitId = loadUnitId;
+		this.qualifiers = qualifiers;
+		this.className = className;
+		this.injectType = injectType || InjectType.PROPERTY;
+		this.multiInstanceConstructorIndex = multiInstanceConstructorIndex;
+		this.multiInstanceConstructorAttributes = multiInstanceConstructorAttributes;
+	}
+	verifyQualifiers(qualifiers) {
+		for (const qualifier of qualifiers) if (!this.verifyQualifier(qualifier)) return false;
+		return true;
+	}
+	verifyQualifier(qualifier) {
+		return this.qualifiers.find((t) => t.attribute === qualifier.attribute)?.value === qualifier.value;
+	}
+	getQualifier(attribute) {
+		return this.qualifiers.find((t) => t.attribute === attribute)?.value;
+	}
+	constructEggObject(...args) {
+		return Reflect.construct(this.clazz, args);
+	}
+	getMetaData(metadataKey) {
+		return MetadataUtil.getMetaData(metadataKey, this.clazz);
+	}
+};
+
+//#endregion
+export { EggPrototypeImpl };

package/dist/impl/LoadUnitMultiInstanceProtoHook.d.ts

@@ -0,0 +1,11 @@
+import { EggProtoImplClass, LifecycleHook, LoadUnit, LoadUnitLifecycleContext } from "@eggjs/tegg-types";
+
+//#region src/impl/LoadUnitMultiInstanceProtoHook.d.ts
+declare class LoadUnitMultiInstanceProtoHook implements LifecycleHook<LoadUnitLifecycleContext, LoadUnit> {
+  static multiInstanceClazzSet: Set<EggProtoImplClass>;
+  static setAllClassList(clazzList: readonly EggProtoImplClass[]): void;
+  static clear(): void;
+  preCreate(): Promise<void>;
+}
+//#endregion
+export { LoadUnitMultiInstanceProtoHook };

package/dist/impl/LoadUnitMultiInstanceProtoHook.js

@@ -0,0 +1,16 @@
+import { PrototypeUtil } from "@eggjs/core-decorator";
+
+//#region src/impl/LoadUnitMultiInstanceProtoHook.ts
+var LoadUnitMultiInstanceProtoHook = class {
+	static multiInstanceClazzSet = /* @__PURE__ */ new Set();
+	static setAllClassList(clazzList) {
+		for (const clazz of clazzList) if (PrototypeUtil.isEggMultiInstancePrototype(clazz)) this.multiInstanceClazzSet.add(clazz);
+	}
+	static clear() {
+		this.multiInstanceClazzSet.clear();
+	}
+	async preCreate() {}
+};
+
+//#endregion
+export { LoadUnitMultiInstanceProtoHook };

package/dist/impl/ModuleLoadUnit.d.ts

@@ -0,0 +1,38 @@
+import { GlobalGraph } from "../model/graph/GlobalGraph.js";
+import { EggLoadUnitType, EggProtoImplClass, EggPrototype, LoadUnit, LoadUnitLifecycleContext, QualifierInfo } from "@eggjs/tegg-types";
+
+//#region src/impl/ModuleLoadUnit.d.ts
+declare class ModuleGraph {
+  private graph;
+  clazzList: EggProtoImplClass[];
+  readonly unitPath: string;
+  readonly name: string;
+  constructor(clazzList: EggProtoImplClass[], unitPath: string, name: string);
+  private findInjectNode;
+  build(): Promise<void>;
+  sort(): void;
+}
+declare class ModuleLoadUnit implements LoadUnit {
+  private protoMap;
+  private protos;
+  private clazzList;
+  readonly id: string;
+  readonly name: string;
+  readonly unitPath: string;
+  readonly type = EggLoadUnitType.MODULE;
+  get globalGraph(): GlobalGraph;
+  constructor(name: string, unitPath: string);
+  private doLoadClazz;
+  private loadClazz;
+  preLoad(): Promise<void>;
+  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): ModuleLoadUnit;
+}
+//#endregion
+export { ModuleGraph, ModuleLoadUnit };