@eggjs/core-decorator 4.0.0-beta.7 → 4.0.0-beta.8

package/dist/index.js

@@ -1,19 +1,535 @@
-import { MetadataUtil } from "./util/MetadataUtil.js";
-import { PrototypeUtil } from "./util/PrototypeUtil.js";
-import { QualifierUtil } from "./util/QualifierUtil.js";
-import "./util/index.js";
-import { ConfigSourceQualifier } from "./decorator/ConfigSource.js";
-import { Prototype } from "./decorator/Prototype.js";
-import { ContextProto } from "./decorator/ContextProto.js";
-import { EggQualifier } from "./decorator/EggQualifier.js";
-import { InitTypeQualifier } from "./decorator/InitTypeQualifier.js";
-import { Inject, InjectOptional } from "./decorator/Inject.js";
-import { ModuleQualifier } from "./decorator/ModuleQualifier.js";
-import { MultiInstanceInfo } from "./decorator/MultiInstanceInfo.js";
-import { MultiInstanceProto } from "./decorator/MultiInstanceProto.js";
-import { SingletonProto } from "./decorator/SingletonProto.js";
-import "./decorator/index.js";
+import { AccessLevel, ConfigSourceQualifierAttribute, DEFAULT_PROTO_IMPL_TYPE, EggQualifierAttribute, InitTypeQualifierAttribute, InjectType, LoadUnitNameQualifierAttribute, MultiInstanceType, ObjectInitType, PROPERTY_QUALIFIER_META_DATA, QUALIFIER_META_DATA } from "@eggjs/tegg-types";
+import { MapUtil, NameUtil, ObjectUtils, StackUtil } from "@eggjs/tegg-common-util";
+import { debuglog } from "node:util";
 
 export * from "@eggjs/tegg-types/core-decorator"
 
+//#region src/util/MetadataUtil.ts
+var MetadataUtil = class {
+	static deleteMetaData(metadataKey, clazz) {
+		Reflect.deleteMetadata(metadataKey, clazz);
+	}
+	static defineMetaData(metadataKey, metadataValue, clazz) {
+		Reflect.defineMetadata(metadataKey, metadataValue, clazz);
+	}
+	static getOwnMetaData(metadataKey, clazz) {
+		return Reflect.getOwnMetadata(metadataKey, clazz);
+	}
+	static hasMetaData(metadataKey, clazz, propKey) {
+		return Reflect.hasMetadata(metadataKey, clazz, propKey);
+	}
+	static getMetaData(metadataKey, clazz, propKey) {
+		return Reflect.getMetadata(metadataKey, clazz, propKey);
+	}
+	static getBooleanMetaData(metadataKey, clazz) {
+		return !!this.getMetaData(metadataKey, clazz);
+	}
+	static getOwnBooleanMetaData(metadataKey, clazz) {
+		return !!this.getOwnMetaData(metadataKey, clazz);
+	}
+	static getArrayMetaData(metadataKey, clazz) {
+		return this.getMetaData(metadataKey, clazz) || [];
+	}
+	/**
+	* init array metadata
+	* not inherit parent metadata
+	* return value true means use default value
+	* return value false means use map value
+	*/
+	static initArrayMetaData(metadataKey, clazz, defaultValue) {
+		if (!this.getOwnMetaData(metadataKey, clazz)) this.defineMetaData(metadataKey, defaultValue, clazz);
+		return this.getOwnMetaData(metadataKey, clazz);
+	}
+	/**
+	* init own array metadata
+	* if parent metadata exists, inherit
+	* if parent metadata not exits, use default value
+	* return value true means use default value
+	* return value false means use map value
+	*/
+	static initOwnArrayMetaData(metadataKey, clazz, defaultValue) {
+		if (!this.getOwnMetaData(metadataKey, clazz)) {
+			const selfValue = (this.getMetaData(metadataKey, clazz) || defaultValue).slice();
+			this.defineMetaData(metadataKey, selfValue, clazz);
+		}
+		return this.getOwnMetaData(metadataKey, clazz);
+	}
+	/**
+	* init own map metadata
+	* if parent metadata exists, inherit
+	* if parent metadata not exits, use default value
+	* return value true means use default value
+	* return value false means use map value
+	*/
+	static initOwnMapMetaData(metadataKey, clazz, defaultValue) {
+		if (!this.getOwnMetaData(metadataKey, clazz)) {
+			const parentValue = this.getMetaData(metadataKey, clazz);
+			const selfValue = /* @__PURE__ */ new Map();
+			const ownDefaultValue = parentValue || defaultValue;
+			for (const [k, v] of ownDefaultValue) selfValue.set(k, v);
+			this.defineMetaData(metadataKey, selfValue, clazz);
+		}
+		return this.getOwnMetaData(metadataKey, clazz);
+	}
+	static getOrStoreMetaData(metadataKey, clazz, metadataValue) {
+		if (!Reflect.hasMetadata(metadataKey, clazz)) Reflect.defineMetadata(metadataKey, metadataValue, clazz);
+		return Reflect.getMetadata(metadataKey, clazz);
+	}
+};
+
+//#endregion
+//#region src/util/PrototypeUtil.ts
+var PrototypeUtil = class PrototypeUtil {
+	static IS_EGG_OBJECT_PROTOTYPE = Symbol.for("EggPrototype#isEggPrototype");
+	static IS_EGG_OBJECT_MULTI_INSTANCE_PROTOTYPE = Symbol.for("EggPrototype#isEggMultiInstancePrototype");
+	static FILE_PATH = Symbol.for("EggPrototype.filePath");
+	static PROTOTYPE_PROPERTY = Symbol.for("EggPrototype.Property");
+	static MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY = Symbol.for("EggPrototype.MultiInstanceStaticProperty");
+	static MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY = Symbol.for("EggPrototype.MultiInstanceCallbackProperty");
+	static INJECT_OBJECT_NAME_SET = Symbol.for("EggPrototype.injectObjectNames");
+	static INJECT_TYPE = Symbol.for("EggPrototype.injectType");
+	static INJECT_CONSTRUCTOR_NAME_SET = Symbol.for("EggPrototype.injectConstructorNames");
+	static CLAZZ_PROTO = Symbol.for("EggPrototype.clazzProto");
+	static MULTI_INSTANCE_CONSTRUCTOR_INDEX = Symbol.for("EggPrototype#multiInstanceConstructorIndex");
+	static MULTI_INSTANCE_CONSTRUCTOR_ATTRIBUTES = Symbol.for("EggPrototype#multiInstanceConstructorAttributes");
+	/**
+	* Mark class is egg object prototype
+	* @param {Function} clazz -
+	*/
+	static setIsEggPrototype(clazz) {
+		MetadataUtil.defineMetaData(PrototypeUtil.IS_EGG_OBJECT_PROTOTYPE, true, clazz);
+	}
+	/**
+	* If class is egg object prototype, return true
+	* @param {Function} clazz -
+	*/
+	static isEggPrototype(clazz) {
+		return MetadataUtil.getOwnBooleanMetaData(PrototypeUtil.IS_EGG_OBJECT_PROTOTYPE, clazz);
+	}
+	/**
+	* Mark class is egg object multi instance prototype
+	* @param {Function} clazz -
+	*/
+	static setIsEggMultiInstancePrototype(clazz) {
+		MetadataUtil.defineMetaData(PrototypeUtil.IS_EGG_OBJECT_MULTI_INSTANCE_PROTOTYPE, true, clazz);
+	}
+	/**
+	* If class is egg object multi instance prototype, return true
+	* @param {Function} clazz -
+	*/
+	static isEggMultiInstancePrototype(clazz) {
+		return MetadataUtil.getOwnBooleanMetaData(PrototypeUtil.IS_EGG_OBJECT_MULTI_INSTANCE_PROTOTYPE, clazz);
+	}
+	/**
+	* Get the type of the egg multi-instance prototype.
+	* @param {Function} clazz -
+	*/
+	static getEggMultiInstancePrototypeType(clazz) {
+		if (!PrototypeUtil.isEggMultiInstancePrototype(clazz)) return;
+		if (MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY, clazz)) return MultiInstanceType.STATIC;
+		return MultiInstanceType.DYNAMIC;
+	}
+	/**
+	* set class file path
+	* @param {Function} clazz -
+	* @param {string} filePath -
+	*/
+	static setFilePath(clazz, filePath) {
+		MetadataUtil.defineMetaData(PrototypeUtil.FILE_PATH, filePath, clazz);
+	}
+	/**
+	* get class file path
+	* @param {Function} clazz -
+	*/
+	static getFilePath(clazz) {
+		return MetadataUtil.getOwnMetaData(PrototypeUtil.FILE_PATH, clazz);
+	}
+	/**
+	* set class property
+	* @param {EggProtoImplClass} clazz -
+	* @param {EggPrototypeInfo} property -
+	*/
+	static setProperty(clazz, property) {
+		MetadataUtil.defineMetaData(PrototypeUtil.PROTOTYPE_PROPERTY, property, clazz);
+	}
+	/**
+	* get class property
+	* @param {EggProtoImplClass} clazz -
+	* @return {EggPrototypeInfo} -
+	*/
+	static getProperty(clazz) {
+		return MetadataUtil.getOwnMetaData(PrototypeUtil.PROTOTYPE_PROPERTY, clazz);
+	}
+	static async getInitType(clazz, ctx) {
+		return (PrototypeUtil.getProperty(clazz) ?? await PrototypeUtil.getMultiInstanceProperty(clazz, ctx))?.initType;
+	}
+	static async getAccessLevel(clazz, ctx) {
+		return (PrototypeUtil.getProperty(clazz) ?? await PrototypeUtil.getMultiInstanceProperty(clazz, ctx))?.accessLevel;
+	}
+	static async getObjNames(clazz, ctx) {
+		const property = PrototypeUtil.getProperty(clazz);
+		if (property) return [property.name];
+		return (await PrototypeUtil.getMultiInstanceProperty(clazz, ctx))?.objects.map((t) => t.name) || [];
+	}
+	/**
+	* set class property
+	* @param {EggProtoImplClass} clazz -
+	* @param {EggPrototypeInfo} property -
+	*/
+	static setMultiInstanceStaticProperty(clazz, property) {
+		MetadataUtil.defineMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY, property, clazz);
+	}
+	/**
+	* set class property
+	* @param {EggProtoImplClass} clazz -
+	* @param {EggPrototypeInfo} property -
+	*/
+	static setMultiInstanceCallbackProperty(clazz, property) {
+		MetadataUtil.defineMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY, property, clazz);
+	}
+	/**
+	* Get instance property of Static multi-instance prototype.
+	* @param {EggProtoImplClass} clazz -
+	*/
+	static getStaticMultiInstanceProperty(clazz) {
+		const metadata = MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY, clazz);
+		if (metadata) return metadata;
+	}
+	/**
+	* Get instance property of Dynamic multi-instance prototype.
+	* @param {EggProtoImplClass} clazz -
+	* @param {MultiInstancePrototypeGetObjectsContext} ctx -
+	*/
+	static async getDynamicMultiInstanceProperty(clazz, ctx) {
+		const callBackMetadata = MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY, clazz);
+		if (callBackMetadata) {
+			const objects = await callBackMetadata.getObjects(ctx);
+			return {
+				...callBackMetadata,
+				objects
+			};
+		}
+	}
+	/**
+	* get class property
+	* @param {EggProtoImplClass} clazz -
+	* @param {MultiInstancePrototypeGetObjectsContext} ctx -
+	*/
+	static async getMultiInstanceProperty(clazz, ctx) {
+		const metadata = MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_STATIC_PROPERTY, clazz);
+		if (metadata) return metadata;
+		const callBackMetadata = MetadataUtil.getOwnMetaData(PrototypeUtil.MULTI_INSTANCE_PROTOTYPE_CALLBACK_PROPERTY, clazz);
+		if (callBackMetadata) {
+			const objects = await callBackMetadata.getObjects(ctx);
+			const defaultQualifier = [{
+				attribute: InitTypeQualifierAttribute,
+				value: callBackMetadata.initType
+			}, {
+				attribute: LoadUnitNameQualifierAttribute,
+				value: ctx.moduleName
+			}];
+			for (const object of objects) defaultQualifier.forEach((qualifier) => {
+				if (!object.qualifiers.find((t) => t.attribute === qualifier.attribute)) object.qualifiers.push(qualifier);
+			});
+			return {
+				...callBackMetadata,
+				objects
+			};
+		}
+	}
+	static setMultiInstanceConstructorAttributes(clazz, attributes) {
+		MetadataUtil.defineMetaData(PrototypeUtil.MULTI_INSTANCE_CONSTRUCTOR_ATTRIBUTES, attributes, clazz);
+	}
+	static getMultiInstanceConstructorAttributes(clazz) {
+		return MetadataUtil.getMetaData(PrototypeUtil.MULTI_INSTANCE_CONSTRUCTOR_ATTRIBUTES, clazz) || [];
+	}
+	static setMultiInstanceConstructorIndex(clazz, index) {
+		MetadataUtil.defineMetaData(PrototypeUtil.MULTI_INSTANCE_CONSTRUCTOR_INDEX, index, clazz);
+	}
+	static getMultiInstanceConstructorIndex(clazz) {
+		return MetadataUtil.getMetaData(PrototypeUtil.MULTI_INSTANCE_CONSTRUCTOR_INDEX, clazz);
+	}
+	static setInjectType(clazz, type) {
+		const injectType = MetadataUtil.getMetaData(PrototypeUtil.INJECT_TYPE, clazz);
+		if (!injectType) MetadataUtil.defineMetaData(PrototypeUtil.INJECT_TYPE, type, clazz);
+		else if (injectType !== type) throw new Error(`class ${clazz.name} already use inject type ${injectType} can not use ${type}`);
+	}
+	static addInjectObject(clazz, injectObject) {
+		const objs = MetadataUtil.initOwnArrayMetaData(PrototypeUtil.INJECT_OBJECT_NAME_SET, clazz, []);
+		objs.push(injectObject);
+		MetadataUtil.defineMetaData(PrototypeUtil.INJECT_OBJECT_NAME_SET, objs, clazz);
+	}
+	static addInjectConstructor(clazz, injectConstructorInfo) {
+		const objs = MetadataUtil.initArrayMetaData(PrototypeUtil.INJECT_CONSTRUCTOR_NAME_SET, clazz, []);
+		objs.push(injectConstructorInfo);
+		MetadataUtil.defineMetaData(PrototypeUtil.INJECT_CONSTRUCTOR_NAME_SET, objs, clazz);
+	}
+	static getInjectType(clazz) {
+		return MetadataUtil.getMetaData(PrototypeUtil.INJECT_TYPE, clazz);
+	}
+	static getInjectObjects(clazz) {
+		const injectType = MetadataUtil.getMetaData(PrototypeUtil.INJECT_TYPE, clazz);
+		if (!injectType) return [];
+		if (injectType === InjectType.CONSTRUCTOR) return MetadataUtil.getArrayMetaData(PrototypeUtil.INJECT_CONSTRUCTOR_NAME_SET, clazz).sort((a, b) => {
+			return a.refIndex - b.refIndex;
+		});
+		return MetadataUtil.getArrayMetaData(PrototypeUtil.INJECT_OBJECT_NAME_SET, clazz);
+	}
+	static getClazzProto(clazz) {
+		return MetadataUtil.getMetaData(PrototypeUtil.CLAZZ_PROTO, clazz);
+	}
+	static setClazzProto(clazz, proto) {
+		MetadataUtil.defineMetaData(PrototypeUtil.CLAZZ_PROTO, proto, clazz);
+	}
+	static getDesignType(clazz, propKey) {
+		return MetadataUtil.getMetaData("design:type", clazz, propKey);
+	}
+	static getDesignParamtypes(clazz, propKey) {
+		return MetadataUtil.getMetaData("design:paramtypes", clazz, propKey);
+	}
+};
+
+//#endregion
+//#region src/util/QualifierUtil.ts
+var QualifierUtil = class QualifierUtil {
+	static addProtoQualifier(clazz, attribute, value) {
+		MetadataUtil.initOwnMapMetaData(QUALIFIER_META_DATA, clazz, /* @__PURE__ */ new Map()).set(attribute, value);
+	}
+	static getProtoQualifiers(clazz) {
+		const qualifiers = MetadataUtil.getMetaData(QUALIFIER_META_DATA, clazz);
+		if (!qualifiers) return [];
+		const res = [];
+		for (const [attribute, value] of qualifiers) res.push({
+			attribute,
+			value
+		});
+		return res;
+	}
+	static addInjectQualifier(clazz, property, parameterIndex, attribute, value) {
+		if (typeof parameterIndex === "number") {
+			const argName = ObjectUtils.getConstructorArgNameList(clazz)[parameterIndex];
+			QualifierUtil.addProperQualifier(clazz, argName, attribute, value);
+		} else QualifierUtil.addProperQualifier(clazz.constructor, property, attribute, value);
+	}
+	static addProperQualifier(clazz, property, attribute, value) {
+		const properQualifiers = MetadataUtil.initOwnMapMetaData(PROPERTY_QUALIFIER_META_DATA, clazz, /* @__PURE__ */ new Map());
+		MapUtil.getOrStore(properQualifiers, property, /* @__PURE__ */ new Map()).set(attribute, value);
+	}
+	static getProperQualifiers(clazz, property) {
+		const qualifiers = MetadataUtil.getMetaData(PROPERTY_QUALIFIER_META_DATA, clazz)?.get(property);
+		if (!qualifiers) return [];
+		const res = [];
+		for (const [attribute, value] of qualifiers) res.push({
+			attribute,
+			value
+		});
+		return res;
+	}
+	static getQualifierValue(clazz, attribute) {
+		return MetadataUtil.getMetaData(QUALIFIER_META_DATA, clazz)?.get(attribute);
+	}
+	static getProperQualifier(clazz, property, attribute) {
+		return (MetadataUtil.getMetaData(PROPERTY_QUALIFIER_META_DATA, clazz)?.get(property))?.get(attribute);
+	}
+	static matchQualifiers(clazzQualifiers, requestQualifiers) {
+		for (const request of requestQualifiers) if (!clazzQualifiers.find((t) => t.attribute === request.attribute && t.value === request.value)) return false;
+		return true;
+	}
+	static equalQualifiers(clazzQualifiers, requestQualifiers) {
+		if (clazzQualifiers.length !== requestQualifiers.length) return false;
+		return QualifierUtil.matchQualifiers(clazzQualifiers, requestQualifiers);
+	}
+	static mergeQualifiers(...qualifiers) {
+		const result = [];
+		const temp = {};
+		for (const qualifierList of qualifiers) for (const { attribute, value } of qualifierList) temp[attribute] = value;
+		for (const key of Reflect.ownKeys(temp)) result.push({
+			attribute: key,
+			value: temp[key]
+		});
+		return result;
+	}
+};
+
+//#endregion
+//#region src/decorator/ConfigSource.ts
+function ConfigSourceQualifier(moduleName) {
+	return function(target, propertyKey, parameterIndex) {
+		QualifierUtil.addInjectQualifier(target, propertyKey, parameterIndex, ConfigSourceQualifierAttribute, moduleName);
+	};
+}
+
+//#endregion
+//#region src/decorator/Prototype.ts
+const DEFAULT_PARAMS$1 = {
+	initType: ObjectInitType.SINGLETON,
+	accessLevel: AccessLevel.PRIVATE,
+	protoImplType: DEFAULT_PROTO_IMPL_TYPE
+};
+function Prototype(param) {
+	return function(clazz) {
+		PrototypeUtil.setIsEggPrototype(clazz);
+		const property = {
+			...DEFAULT_PARAMS$1,
+			...param,
+			className: clazz.name
+		};
+		if (!property.name) property.name = NameUtil.getClassName(clazz);
+		PrototypeUtil.setProperty(clazz, property);
+		PrototypeUtil.setFilePath(clazz, StackUtil.getCalleeFromStack(false, 4));
+	};
+}
+
+//#endregion
+//#region src/decorator/ContextProto.ts
+function ContextProto(params) {
+	return Prototype({
+		initType: ObjectInitType.CONTEXT,
+		accessLevel: params?.accessLevel || AccessLevel.PRIVATE,
+		...params
+	});
+}
+
+//#endregion
+//#region src/decorator/EggQualifier.ts
+function EggQualifier(eggType) {
+	return function(target, propertyKey, parameterIndex) {
+		QualifierUtil.addInjectQualifier(target, propertyKey, parameterIndex, EggQualifierAttribute, eggType);
+	};
+}
+
+//#endregion
+//#region src/decorator/InitTypeQualifier.ts
+function InitTypeQualifier(initType) {
+	return function(target, propertyKey, parameterIndex) {
+		QualifierUtil.addInjectQualifier(target, propertyKey, parameterIndex, InitTypeQualifierAttribute, initType);
+	};
+}
+
+//#endregion
+//#region src/decorator/Inject.ts
+const debug = debuglog("tegg/core/core-decorator/decorator/Inject");
+function guessInjectInfo(clazz, name, proto) {
+	let objName;
+	let initType;
+	if (typeof proto === "function" && proto !== Object) {
+		const info = PrototypeUtil.getProperty(proto);
+		objName = info?.name;
+		if (info?.initType) {
+			if (!QualifierUtil.getProperQualifier(clazz, name, InitTypeQualifierAttribute)) initType = info.initType;
+		}
+	}
+	return {
+		objName,
+		initType
+	};
+}
+function Inject(param) {
+	const injectParam = typeof param === "string" ? { name: param } : param;
+	function propertyInject(target, propertyKey) {
+		let objName;
+		let initType;
+		if (!injectParam) {
+			const proto = PrototypeUtil.getDesignType(target, propertyKey);
+			const result = guessInjectInfo(target.constructor, propertyKey, proto);
+			objName = result.objName;
+			initType = result.initType;
+		} else objName = injectParam?.name;
+		const injectObject = {
+			refName: propertyKey,
+			objName: objName || propertyKey
+		};
+		if (injectParam?.optional) injectObject.optional = true;
+		PrototypeUtil.setInjectType(target.constructor, InjectType.PROPERTY);
+		PrototypeUtil.addInjectObject(target.constructor, injectObject);
+		debug("propertyInject, clazz: %s, propertyKey: %s, injectObject: %o", target.constructor.name, propertyKey, injectObject);
+		if (initType) QualifierUtil.addProperQualifier(target.constructor, propertyKey, InitTypeQualifierAttribute, initType);
+	}
+	function constructorInject(target, parameterIndex) {
+		const argName = ObjectUtils.getConstructorArgNameList(target)[parameterIndex];
+		let objName;
+		let initType;
+		if (!injectParam) {
+			const protos = PrototypeUtil.getDesignParamtypes(target);
+			({objName, initType} = guessInjectInfo(target, argName, protos?.[parameterIndex]));
+		} else objName = injectParam?.name;
+		const injectObject = {
+			refIndex: parameterIndex,
+			refName: argName,
+			objName: objName || argName
+		};
+		if (injectParam?.optional) injectObject.optional = true;
+		PrototypeUtil.setInjectType(target, InjectType.CONSTRUCTOR);
+		PrototypeUtil.addInjectConstructor(target, injectObject);
+		if (initType) QualifierUtil.addProperQualifier(target, argName, InitTypeQualifierAttribute, initType);
+	}
+	return function(target, propertyKey, parameterIndex) {
+		if (typeof parameterIndex === "undefined") propertyInject(target, propertyKey);
+		else constructorInject(target, parameterIndex);
+	};
+}
+function InjectOptional(param) {
+	return Inject({
+		...typeof param === "string" ? { name: param } : param,
+		optional: true
+	});
+}
+
+//#endregion
+//#region src/decorator/ModuleQualifier.ts
+function ModuleQualifier(moduleName) {
+	return function(target, propertyKey, parameterIndex) {
+		QualifierUtil.addInjectQualifier(target, propertyKey, parameterIndex, LoadUnitNameQualifierAttribute, moduleName);
+	};
+}
+
+//#endregion
+//#region src/decorator/MultiInstanceInfo.ts
+function MultiInstanceInfo(attributes) {
+	return function(target, _propertyKey, parameterIndex) {
+		PrototypeUtil.setMultiInstanceConstructorIndex(target, parameterIndex);
+		PrototypeUtil.setMultiInstanceConstructorAttributes(target, attributes);
+	};
+}
+
+//#endregion
+//#region src/decorator/MultiInstanceProto.ts
+const DEFAULT_PARAMS = {
+	initType: ObjectInitType.SINGLETON,
+	accessLevel: AccessLevel.PRIVATE,
+	protoImplType: DEFAULT_PROTO_IMPL_TYPE
+};
+function MultiInstanceProto(param) {
+	return function(clazz) {
+		PrototypeUtil.setIsEggMultiInstancePrototype(clazz);
+		if (param.objects) {
+			const property = {
+				...DEFAULT_PARAMS,
+				...param,
+				className: clazz.name
+			};
+			PrototypeUtil.setMultiInstanceStaticProperty(clazz, property);
+		} else if (param.getObjects) {
+			const property = {
+				...DEFAULT_PARAMS,
+				...param,
+				className: clazz.name
+			};
+			PrototypeUtil.setMultiInstanceCallbackProperty(clazz, property);
+		}
+		PrototypeUtil.setFilePath(clazz, StackUtil.getCalleeFromStack(false, 4));
+	};
+}
+
+//#endregion
+//#region src/decorator/SingletonProto.ts
+function SingletonProto(params) {
+	return Prototype({
+		initType: ObjectInitType.SINGLETON,
+		accessLevel: params?.accessLevel || AccessLevel.PRIVATE,
+		...params
+	});
+}
+
+//#endregion
 export { ConfigSourceQualifier, ContextProto, EggQualifier, InitTypeQualifier, Inject, InjectOptional, MetadataUtil, ModuleQualifier, MultiInstanceInfo, MultiInstanceProto, Prototype, PrototypeUtil, QualifierUtil, SingletonProto };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eggjs/core-decorator",
-  "version": "4.0.0-beta.7",
+  "version": "4.0.0-beta.8",
   "description": "tegg core decorator",
   "keywords": [
     "egg",
@@ -34,8 +34,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@eggjs/tegg-common-util": "4.0.0-beta.7",
-    "@eggjs/tegg-types": "4.0.0-beta.7"
+    "@eggjs/tegg-common-util": "4.0.0-beta.8",
+    "@eggjs/tegg-types": "4.0.0-beta.8"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",

package/dist/decorator/ConfigSource.d.ts

@@ -1,4 +0,0 @@
-//#region src/decorator/ConfigSource.d.ts
-declare function ConfigSourceQualifier(moduleName: string): (target: any, propertyKey?: PropertyKey, parameterIndex?: number) => void;
-//#endregion
-export { ConfigSourceQualifier };

package/dist/decorator/ConfigSource.js

@@ -1,13 +0,0 @@
-import { QualifierUtil } from "../util/QualifierUtil.js";
-import "../util/index.js";
-import { ConfigSourceQualifierAttribute } from "@eggjs/tegg-types";
-
-//#region src/decorator/ConfigSource.ts
-function ConfigSourceQualifier(moduleName) {
-	return function(target, propertyKey, parameterIndex) {
-		QualifierUtil.addInjectQualifier(target, propertyKey, parameterIndex, ConfigSourceQualifierAttribute, moduleName);
-	};
-}
-
-//#endregion
-export { ConfigSourceQualifier };

package/dist/decorator/ContextProto.d.ts

@@ -1,7 +0,0 @@
-import * as _eggjs_tegg_types0 from "@eggjs/tegg-types";
-import { ContextProtoParams } from "@eggjs/tegg-types";
-
-//#region src/decorator/ContextProto.d.ts
-declare function ContextProto(params?: ContextProtoParams): (clazz: _eggjs_tegg_types0.EggProtoImplClass) => void;
-//#endregion
-export { ContextProto };

package/dist/decorator/ContextProto.js

@@ -1,14 +0,0 @@
-import { Prototype } from "./Prototype.js";
-import { AccessLevel, ObjectInitType } from "@eggjs/tegg-types";
-
-//#region src/decorator/ContextProto.ts
-function ContextProto(params) {
-	return Prototype({
-		initType: ObjectInitType.CONTEXT,
-		accessLevel: params?.accessLevel || AccessLevel.PRIVATE,
-		...params
-	});
-}
-
-//#endregion
-export { ContextProto };

package/dist/decorator/EggQualifier.d.ts

@@ -1,6 +0,0 @@
-import { EggType } from "@eggjs/tegg-types";
-
-//#region src/decorator/EggQualifier.d.ts
-declare function EggQualifier(eggType: EggType): (target: any, propertyKey?: PropertyKey, parameterIndex?: number) => void;
-//#endregion
-export { EggQualifier };

package/dist/decorator/EggQualifier.js

@@ -1,13 +0,0 @@
-import { QualifierUtil } from "../util/QualifierUtil.js";
-import "../util/index.js";
-import { EggQualifierAttribute } from "@eggjs/tegg-types";
-
-//#region src/decorator/EggQualifier.ts
-function EggQualifier(eggType) {
-	return function(target, propertyKey, parameterIndex) {
-		QualifierUtil.addInjectQualifier(target, propertyKey, parameterIndex, EggQualifierAttribute, eggType);
-	};
-}
-
-//#endregion
-export { EggQualifier };

package/dist/decorator/InitTypeQualifier.d.ts

@@ -1,6 +0,0 @@
-import { ObjectInitTypeLike } from "@eggjs/tegg-types";
-
-//#region src/decorator/InitTypeQualifier.d.ts
-declare function InitTypeQualifier(initType: ObjectInitTypeLike): (target: any, propertyKey?: PropertyKey, parameterIndex?: number) => void;
-//#endregion
-export { InitTypeQualifier };

package/dist/decorator/InitTypeQualifier.js

@@ -1,13 +0,0 @@
-import { QualifierUtil } from "../util/QualifierUtil.js";
-import "../util/index.js";
-import { InitTypeQualifierAttribute } from "@eggjs/tegg-types";
-
-//#region src/decorator/InitTypeQualifier.ts
-function InitTypeQualifier(initType) {
-	return function(target, propertyKey, parameterIndex) {
-		QualifierUtil.addInjectQualifier(target, propertyKey, parameterIndex, InitTypeQualifierAttribute, initType);
-	};
-}
-
-//#endregion
-export { InitTypeQualifier };

package/dist/decorator/Inject.d.ts

@@ -1,7 +0,0 @@
-import { InjectParams } from "@eggjs/tegg-types";
-
-//#region src/decorator/Inject.d.ts
-declare function Inject(param?: InjectParams | string): (target: any, propertyKey?: PropertyKey, parameterIndex?: number) => void;
-declare function InjectOptional(param?: Omit<InjectParams, 'optional'> | string): (target: any, propertyKey?: PropertyKey, parameterIndex?: number) => void;
-//#endregion
-export { Inject, InjectOptional };