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

package/dist/model/ProtoDescriptor/ClassProtoDescriptor.d.ts

@@ -0,0 +1,16 @@
+import { AbstractProtoDescriptor, AbstractProtoDescriptorOptions } from "./AbstractProtoDescriptor.js";
+import { EggProtoImplClass, ProtoDescriptor } from "@eggjs/tegg-types";
+
+//#region src/model/ProtoDescriptor/ClassProtoDescriptor.d.ts
+interface ClassProtoDescriptorOptions extends Omit<AbstractProtoDescriptorOptions, 'type'> {
+  clazz: EggProtoImplClass;
+}
+declare class ClassProtoDescriptor extends AbstractProtoDescriptor {
+  clazz: EggProtoImplClass;
+  clazzName: string;
+  static isClassProtoDescriptor(descriptor: ProtoDescriptor): descriptor is ClassProtoDescriptor;
+  constructor(options: ClassProtoDescriptorOptions);
+  equal(protoDescriptor: ProtoDescriptor): boolean;
+}
+//#endregion
+export { ClassProtoDescriptor, ClassProtoDescriptorOptions };

package/dist/model/ProtoDescriptor/ClassProtoDescriptor.js

@@ -0,0 +1,27 @@
+import { AbstractProtoDescriptor } from "./AbstractProtoDescriptor.js";
+import { ProtoDescriptorType } from "@eggjs/tegg-types";
+import { QualifierUtil } from "@eggjs/core-decorator";
+
+//#region src/model/ProtoDescriptor/ClassProtoDescriptor.ts
+var ClassProtoDescriptor = class ClassProtoDescriptor extends AbstractProtoDescriptor {
+	clazz;
+	clazzName;
+	static isClassProtoDescriptor(descriptor) {
+		return descriptor.type === ProtoDescriptorType.CLASS;
+	}
+	constructor(options) {
+		super({
+			type: ProtoDescriptorType.CLASS,
+			...options
+		});
+		this.clazz = options.clazz;
+		this.className = this.clazz.name;
+	}
+	equal(protoDescriptor) {
+		if (!ClassProtoDescriptor.isClassProtoDescriptor(protoDescriptor)) return false;
+		return this.clazz === protoDescriptor.clazz && this.name === protoDescriptor.name && this.accessLevel === protoDescriptor.accessLevel && this.initType === protoDescriptor.initType && this.instanceModuleName === protoDescriptor.instanceModuleName && QualifierUtil.equalQualifiers(this.qualifiers, protoDescriptor.qualifiers);
+	}
+};
+
+//#endregion
+export { ClassProtoDescriptor };

package/dist/model/ProtoDescriptor/index.js

@@ -0,0 +1,4 @@
+import { AbstractProtoDescriptor } from "./AbstractProtoDescriptor.js";
+import { ClassProtoDescriptor } from "./ClassProtoDescriptor.js";
+
+export {  };

package/dist/model/ProtoDescriptorHelper.d.ts

@@ -0,0 +1,30 @@
+import { ProtoSelectorContext } from "./graph/ProtoSelector.js";
+import { EggProtoImplClass, MultiInstancePrototypeGetObjectsContext, ObjectInitTypeLike, ProtoDescriptor, QualifierInfo } from "@eggjs/tegg-types";
+
+//#region src/model/ProtoDescriptorHelper.d.ts
+declare class ProtoDescriptorHelper {
+  #private;
+  static addDefaultQualifier(qualifiers: QualifierInfo[], initType: ObjectInitTypeLike, loadUnitName: string): QualifierInfo[];
+  static createByMultiInstanceClazz(clazz: EggProtoImplClass, options: {
+    defineModuleName: string;
+    defineUnitPath: string;
+    instanceModuleName: string;
+    instanceDefineUnitPath: string;
+  }): Promise<ProtoDescriptor[]>;
+  static createByDynamicMultiInstanceClazz(clazz: EggProtoImplClass, options: {
+    defineModuleName: string;
+    defineUnitPath: string;
+    instanceModuleName: string;
+    instanceDefineUnitPath: string;
+  }): Promise<ProtoDescriptor[]>;
+  static createByStaticMultiInstanceClazz(clazz: EggProtoImplClass, options: {
+    defineModuleName: string;
+    defineUnitPath: string;
+    instanceModuleName: string;
+    instanceDefineUnitPath: string;
+  }): ProtoDescriptor[];
+  static createByInstanceClazz(clazz: EggProtoImplClass, ctx: MultiInstancePrototypeGetObjectsContext): ProtoDescriptor;
+  static selectProto(proto: ProtoDescriptor, ctx: ProtoSelectorContext): boolean;
+}
+//#endregion
+export { ProtoDescriptorHelper };

package/dist/model/ProtoDescriptorHelper.js

@@ -0,0 +1,113 @@
+import { ClassProtoDescriptor } from "./ProtoDescriptor/ClassProtoDescriptor.js";
+import "./ProtoDescriptor/index.js";
+import "./graph/index.js";
+import { AccessLevel, InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, MultiInstanceType } from "@eggjs/tegg-types";
+import assert from "node:assert";
+import { PrototypeUtil, QualifierUtil } from "@eggjs/core-decorator";
+
+//#region src/model/ProtoDescriptorHelper.ts
+var ProtoDescriptorHelper = class ProtoDescriptorHelper {
+	static addDefaultQualifier(qualifiers, initType, loadUnitName) {
+		const defaultQualifiers = [{
+			attribute: InitTypeQualifierAttribute,
+			value: initType
+		}, {
+			attribute: LoadUnitNameQualifierAttribute,
+			value: loadUnitName
+		}];
+		const res = [...qualifiers];
+		for (const defaultQualifier of defaultQualifiers) if (!qualifiers.find((t) => t.attribute === defaultQualifier.attribute)) res.push(defaultQualifier);
+		return res;
+	}
+	static async createByMultiInstanceClazz(clazz, options) {
+		assert(PrototypeUtil.isEggMultiInstancePrototype(clazz), `clazz ${clazz.name} is not MultiInstancePrototype`);
+		const type = PrototypeUtil.getEggMultiInstancePrototypeType(clazz);
+		if (type === MultiInstanceType.DYNAMIC) return await ProtoDescriptorHelper.createByDynamicMultiInstanceClazz(clazz, options);
+		else if (type === MultiInstanceType.STATIC) {
+			if (options.defineModuleName === options.instanceModuleName) return ProtoDescriptorHelper.createByStaticMultiInstanceClazz(clazz, options);
+		}
+		return [];
+	}
+	static async createByDynamicMultiInstanceClazz(clazz, options) {
+		assert(PrototypeUtil.isEggMultiInstancePrototype(clazz), `clazz ${clazz.name} is not MultiInstancePrototype`);
+		const instanceProperty = await PrototypeUtil.getDynamicMultiInstanceProperty(clazz, {
+			moduleName: options.instanceModuleName,
+			unitPath: options.instanceDefineUnitPath
+		});
+		assert(instanceProperty, `not found PrototypeInfo for clazz ${clazz.name}`);
+		return ProtoDescriptorHelper.#createByMultiInstanceClazz(clazz, instanceProperty, options);
+	}
+	static createByStaticMultiInstanceClazz(clazz, options) {
+		assert(PrototypeUtil.isEggMultiInstancePrototype(clazz), `clazz ${clazz.name} is not MultiInstancePrototype`);
+		const instanceProperty = PrototypeUtil.getStaticMultiInstanceProperty(clazz);
+		assert(instanceProperty, `not found PrototypeInfo for clazz ${clazz.name}`);
+		return ProtoDescriptorHelper.#createByMultiInstanceClazz(clazz, instanceProperty, options);
+	}
+	static #createByMultiInstanceClazz(clazz, instanceProperty, options) {
+		const res = [];
+		for (const obj of instanceProperty.objects) {
+			let qualifiers = QualifierUtil.mergeQualifiers(QualifierUtil.getProtoQualifiers(clazz), obj.qualifiers);
+			qualifiers = ProtoDescriptorHelper.addDefaultQualifier(qualifiers, instanceProperty.initType, options.instanceModuleName);
+			const injectObjects = PrototypeUtil.getInjectObjects(clazz).map((t) => {
+				const qualifiers$1 = QualifierUtil.getProperQualifiers(clazz, t.refName);
+				const instanceQualifier = obj.properQualifiers?.[t.refName] ?? [];
+				return {
+					...t,
+					qualifiers: QualifierUtil.mergeQualifiers(qualifiers$1, instanceQualifier)
+				};
+			});
+			res.push(new ClassProtoDescriptor({
+				name: obj.name,
+				accessLevel: instanceProperty.accessLevel,
+				initType: instanceProperty.initType,
+				protoImplType: instanceProperty.protoImplType,
+				qualifiers,
+				injectObjects,
+				instanceModuleName: options.instanceModuleName,
+				instanceDefineUnitPath: options.instanceDefineUnitPath,
+				defineModuleName: options.defineModuleName,
+				defineUnitPath: options.defineUnitPath,
+				clazz,
+				properQualifiers: obj.properQualifiers || {}
+			}));
+		}
+		return res;
+	}
+	static createByInstanceClazz(clazz, ctx) {
+		assert(PrototypeUtil.isEggPrototype(clazz), `clazz ${clazz.name} is not EggPrototype`);
+		assert(!PrototypeUtil.isEggMultiInstancePrototype(clazz), `clazz ${clazz.name} is not Prototype`);
+		const property = PrototypeUtil.getProperty(clazz);
+		assert(property, `not found PrototypeInfo for clazz ${clazz.name}`);
+		const protoQualifiers = ProtoDescriptorHelper.addDefaultQualifier(QualifierUtil.getProtoQualifiers(clazz), property.initType, ctx.moduleName);
+		const injectObjects = PrototypeUtil.getInjectObjects(clazz).map((t) => {
+			const qualifiers = QualifierUtil.getProperQualifiers(clazz, t.refName);
+			return {
+				...t,
+				qualifiers
+			};
+		});
+		return new ClassProtoDescriptor({
+			name: property.name,
+			protoImplType: property.protoImplType,
+			accessLevel: property.accessLevel,
+			initType: property.initType,
+			qualifiers: protoQualifiers,
+			injectObjects,
+			instanceDefineUnitPath: ctx.unitPath,
+			instanceModuleName: ctx.moduleName,
+			defineUnitPath: ctx.unitPath,
+			defineModuleName: ctx.moduleName,
+			clazz,
+			properQualifiers: {}
+		});
+	}
+	static selectProto(proto, ctx) {
+		if (proto.name !== ctx.name) return false;
+		if (proto.accessLevel !== AccessLevel.PUBLIC && proto.instanceModuleName !== ctx.moduleName) return false;
+		if (!QualifierUtil.matchQualifiers(proto.qualifiers, ctx.qualifiers)) return false;
+		return true;
+	}
+};
+
+//#endregion
+export { ProtoDescriptorHelper };

package/dist/model/graph/GlobalGraph.d.ts

@@ -0,0 +1,67 @@
+import { ProtoDependencyMeta, ProtoNode } from "./ProtoNode.js";
+import { GlobalModuleNode, ModuleDependencyMeta } from "./GlobalModuleNode.js";
+import { ModuleDescriptor } from "../ModuleDescriptor.js";
+import { Graph, GraphNode, ModuleReference } from "@eggjs/tegg-common-util";
+import { InjectObjectDescriptor, ProtoDescriptor } from "@eggjs/tegg-types";
+
+//#region src/model/graph/GlobalGraph.d.ts
+interface GlobalGraphOptions {
+  strict?: boolean;
+}
+type GlobalGraphBuildHook = (globalGraph: GlobalGraph) => void;
+/**
+ * Sort all prototypes and modules in app.
+ * - 1. LoaderFactory.loadApp: get ModuleDescriptors
+ * - 2. GlobalGraph.create: create global graph instance
+ * - 3. graph.build:
+ *   - check duplicated prototypes exits
+ *   - check inject object exists (only in strict mode,
+ *   can register proto in hooks now, in next major version,
+ *   should use load to create dynamic ProtoDescriptor and delete
+ *   strict false options
+ *   )
+ * - 4. graph.sort: build moduleConfigList and moduleProtoDescriptorMap
+ */
+declare class GlobalGraph {
+  #private;
+  /**
+   * Vertex: ModuleNode, collect prototypes in module
+   * Edge: ModuleDependencyMeta, prototype and it's inject object
+   * @private
+   */
+  moduleGraph: Graph<GlobalModuleNode, ModuleDependencyMeta>;
+  /**
+   * Vertex: ProtoNode, collect all prototypes in app
+   * Edge: ProtoDependencyMeta, inject object
+   * @private
+   */
+  protoGraph: Graph<ProtoNode, ProtoDependencyMeta>;
+  /**
+   * The order of the moduleConfigList is the order in which they are instantiated
+   */
+  moduleConfigList: readonly ModuleReference[];
+  /**
+   * key: module name
+   * value: ProtoDescriptor in module, the order is the order in which they are instantiated
+   */
+  moduleProtoDescriptorMap: Map<string, ProtoDescriptor[]>;
+  strict: boolean;
+  private buildHooks;
+  /**
+   * The global instance used in ModuleLoadUnit
+   */
+  static instance?: GlobalGraph;
+  constructor(options?: GlobalGraphOptions);
+  registerBuildHook(hook: GlobalGraphBuildHook): void;
+  addModuleNode(moduleNode: GlobalModuleNode): void;
+  build(): void;
+  buildInjectEdge(moduleNode: GraphNode<GlobalModuleNode, ModuleDependencyMeta>, protoNode: GraphNode<ProtoNode, ProtoDependencyMeta>, injectObj: InjectObjectDescriptor): void;
+  addInject(moduleNode: GraphNode<GlobalModuleNode, ModuleDependencyMeta>, protoNode: GraphNode<ProtoNode, ProtoDependencyMeta>, injectNode: GraphNode<ProtoNode, ProtoDependencyMeta>, injectName: PropertyKey): void;
+  findInjectProto(proto: ProtoDescriptor, injectObject: InjectObjectDescriptor): ProtoDescriptor | undefined;
+  findDependencyProtoNode(proto: ProtoDescriptor, injectObject: InjectObjectDescriptor): GraphNode<ProtoNode, ProtoDependencyMeta> | undefined;
+  findModuleNode(moduleName: string): GraphNode<GlobalModuleNode, ModuleDependencyMeta>;
+  sort(): void;
+  static create(moduleDescriptors: ModuleDescriptor[], options?: GlobalGraphOptions): Promise<GlobalGraph>;
+}
+//#endregion
+export { GlobalGraph, GlobalGraphBuildHook, GlobalGraphOptions };

package/dist/model/graph/GlobalGraph.js

@@ -0,0 +1,176 @@
+import { EggPrototypeNotFound, MultiPrototypeFound } from "../../errors.js";
+import { ProtoDependencyMeta, ProtoNode } from "./ProtoNode.js";
+import { ModuleDependencyMeta } from "./GlobalModuleNode.js";
+import { GlobalModuleNodeBuilder } from "./GlobalModuleNodeBuilder.js";
+import { Graph, GraphNode } from "@eggjs/tegg-common-util";
+import { InitTypeQualifierAttribute, LoadUnitNameQualifierAttribute, ObjectInitType } from "@eggjs/tegg-types";
+import { FrameworkErrorFormater } from "egg-errors";
+import { debuglog } from "node:util";
+import { QualifierUtil } from "@eggjs/core-decorator";
+
+//#region src/model/graph/GlobalGraph.ts
+const debug = debuglog("tegg/core/metadata/model/graph/GlobalGraph");
+/**
+* Sort all prototypes and modules in app.
+* - 1. LoaderFactory.loadApp: get ModuleDescriptors
+* - 2. GlobalGraph.create: create global graph instance
+* - 3. graph.build:
+*   - check duplicated prototypes exits
+*   - check inject object exists (only in strict mode,
+*   can register proto in hooks now, in next major version,
+*   should use load to create dynamic ProtoDescriptor and delete
+*   strict false options
+*   )
+* - 4. graph.sort: build moduleConfigList and moduleProtoDescriptorMap
+*/
+var GlobalGraph = class GlobalGraph {
+	/**
+	* Vertex: ModuleNode, collect prototypes in module
+	* Edge: ModuleDependencyMeta, prototype and it's inject object
+	* @private
+	*/
+	moduleGraph;
+	/**
+	* Vertex: ProtoNode, collect all prototypes in app
+	* Edge: ProtoDependencyMeta, inject object
+	* @private
+	*/
+	protoGraph;
+	/**
+	* The order of the moduleConfigList is the order in which they are instantiated
+	*/
+	moduleConfigList;
+	/**
+	* key: module name
+	* value: ProtoDescriptor in module, the order is the order in which they are instantiated
+	*/
+	moduleProtoDescriptorMap;
+	strict;
+	buildHooks;
+	/**
+	* The global instance used in ModuleLoadUnit
+	*/
+	static instance;
+	constructor(options) {
+		this.moduleGraph = new Graph();
+		this.protoGraph = new Graph();
+		this.strict = options?.strict ?? false;
+		this.moduleProtoDescriptorMap = /* @__PURE__ */ new Map();
+		this.buildHooks = [];
+	}
+	registerBuildHook(hook) {
+		this.buildHooks.push(hook);
+	}
+	addModuleNode(moduleNode) {
+		if (!this.moduleGraph.addVertex(new GraphNode(moduleNode))) throw new Error(`duplicate module: ${moduleNode}`);
+		for (const protoNode of moduleNode.protos) if (!this.protoGraph.addVertex(protoNode)) throw new Error(`duplicate proto: ${protoNode.val}`);
+	}
+	build() {
+		for (const moduleNode of this.moduleGraph.nodes.values()) for (const protoNode of moduleNode.val.protos) for (const injectObj of protoNode.val.proto.injectObjects) this.buildInjectEdge(moduleNode, protoNode, injectObj);
+		for (const buildHook of this.buildHooks) buildHook(this);
+	}
+	buildInjectEdge(moduleNode, protoNode, injectObj) {
+		const injectProto = this.findDependencyProtoNode(protoNode.val.proto, injectObj);
+		if (!injectProto) {
+			if (!this.strict) return;
+			throw FrameworkErrorFormater.formatError(new EggPrototypeNotFound(injectObj.objName, protoNode.val.proto.instanceModuleName));
+		}
+		this.addInject(moduleNode, protoNode, injectProto, injectObj.objName);
+	}
+	addInject(moduleNode, protoNode, injectNode, injectName) {
+		this.protoGraph.addEdge(protoNode, injectNode, new ProtoDependencyMeta({ injectObj: injectName }));
+		const injectModule = this.findModuleNode(injectNode.val.proto.instanceModuleName);
+		if (!injectModule) {
+			if (!this.strict) return;
+			throw new Error(`not found module ${injectNode.val.proto.instanceModuleName}`);
+		}
+		if (moduleNode.val.id !== injectModule.val.id) this.moduleGraph.addEdge(moduleNode, injectModule, new ModuleDependencyMeta(protoNode.val.proto, injectName));
+	}
+	findInjectProto(proto, injectObject) {
+		return this.protoGraph.findToNode(ProtoNode.createProtoId(proto), new ProtoDependencyMeta({ injectObj: injectObject.objName }))?.val.proto;
+	}
+	#findDependencyProtoWithDefaultQualifiers(proto, injectObject, qualifiers) {
+		const result = [];
+		for (const node of this.protoGraph.nodes.values()) if (node.val.selectProto({
+			name: injectObject.objName,
+			qualifiers: QualifierUtil.mergeQualifiers(injectObject.qualifiers, qualifiers),
+			moduleName: proto.instanceModuleName
+		})) result.push(node);
+		return result;
+	}
+	findDependencyProtoNode(proto, injectObject) {
+		const protos = this.#findDependencyProtoWithDefaultQualifiers(proto, injectObject, []);
+		if (protos.length === 0) return;
+		if (protos.length === 1) return protos[0];
+		const protoWithContext = this.#findDependencyProtoWithDefaultQualifiers(proto, injectObject, [{
+			attribute: InitTypeQualifierAttribute,
+			value: ObjectInitType.CONTEXT
+		}]);
+		if (protoWithContext.length === 1) return protoWithContext[0];
+		const protoWithSelfInitType = this.#findDependencyProtoWithDefaultQualifiers(proto, injectObject, [{
+			attribute: InitTypeQualifierAttribute,
+			value: proto.initType
+		}]);
+		if (protoWithSelfInitType.length === 1) return protoWithSelfInitType[0];
+		if (!injectObject.qualifiers.find((t) => t.attribute === LoadUnitNameQualifierAttribute)) return this.findDependencyProtoNode(proto, {
+			...injectObject,
+			qualifiers: QualifierUtil.mergeQualifiers(injectObject.qualifiers, [{
+				attribute: LoadUnitNameQualifierAttribute,
+				value: proto.instanceModuleName
+			}])
+		});
+		throw FrameworkErrorFormater.formatError(new MultiPrototypeFound(injectObject.objName, injectObject.qualifiers));
+	}
+	findModuleNode(moduleName) {
+		for (const node of this.moduleGraph.nodes.values()) if (node.val.name === moduleName) return node;
+	}
+	#sortModule() {
+		const loopPath = this.moduleGraph.loopPath();
+		if (loopPath) throw new Error("module has recursive deps: " + loopPath);
+		debug("sortModule, loopPath: %o", loopPath);
+		this.moduleConfigList = this.moduleGraph.sort().filter((t) => {
+			return t.val.optional !== true || t.fromNodeMap.size > 0;
+		}).map((t) => {
+			return {
+				name: t.val.name,
+				path: t.val.unitPath,
+				optional: t.val.optional
+			};
+		});
+	}
+	#sortClazz() {
+		const loopPath = this.protoGraph.loopPath();
+		if (loopPath) throw new Error("proto has recursive deps: " + loopPath);
+		debug("sortClazz, loopPath: %o", loopPath);
+		for (const proto of this.protoGraph.sort()) {
+			const instanceModuleName = proto.val.proto.instanceModuleName;
+			let moduleProtoList = this.moduleProtoDescriptorMap.get(instanceModuleName);
+			if (!moduleProtoList) {
+				moduleProtoList = [];
+				this.moduleProtoDescriptorMap.set(instanceModuleName, moduleProtoList);
+			}
+			moduleProtoList.push(proto.val.proto);
+		}
+	}
+	sort() {
+		this.#sortModule();
+		this.#sortClazz();
+	}
+	static async create(moduleDescriptors, options) {
+		const graph = new GlobalGraph(options);
+		for (const moduleDescriptor of moduleDescriptors) {
+			const moduleNodeBuilder = new GlobalModuleNodeBuilder({
+				name: moduleDescriptor.name,
+				unitPath: moduleDescriptor.unitPath,
+				optional: moduleDescriptor.optional ?? false
+			});
+			for (const clazz of moduleDescriptor.clazzList) moduleNodeBuilder.addClazz(clazz);
+			for (const clazz of moduleDescriptor.multiInstanceClazzList) await moduleNodeBuilder.addMultiInstanceClazz(clazz, moduleDescriptor.name, moduleDescriptor.unitPath);
+			graph.addModuleNode(moduleNodeBuilder.build());
+		}
+		return graph;
+	}
+};
+
+//#endregion
+export { GlobalGraph };

package/dist/model/graph/GlobalModuleNode.d.ts

@@ -0,0 +1,29 @@
+import { ProtoDependencyMeta, ProtoNode } from "./ProtoNode.js";
+import { EdgeMeta, GraphNode, GraphNodeObj } from "@eggjs/tegg-common-util";
+import { ProtoDescriptor } from "@eggjs/tegg-types";
+
+//#region src/model/graph/GlobalModuleNode.d.ts
+interface GlobalModuleNodeOptions {
+  name: string;
+  unitPath: string;
+  optional: boolean;
+}
+declare class ModuleDependencyMeta implements EdgeMeta {
+  readonly obj: ProtoDescriptor;
+  readonly injectObj: PropertyKey;
+  constructor(obj: ProtoDescriptor, injectObj: PropertyKey);
+  equal(meta: ModuleDependencyMeta): boolean;
+  toString(): string;
+}
+declare class GlobalModuleNode implements GraphNodeObj {
+  readonly id: string;
+  readonly name: string;
+  readonly unitPath: string;
+  readonly optional: boolean;
+  readonly protos: GraphNode<ProtoNode, ProtoDependencyMeta>[];
+  constructor(options: GlobalModuleNodeOptions);
+  addProto(proto: ProtoDescriptor): void;
+  toString(): string;
+}
+//#endregion
+export { GlobalModuleNode, GlobalModuleNodeOptions, ModuleDependencyMeta };

package/dist/model/graph/GlobalModuleNode.js

@@ -0,0 +1,42 @@
+import { ProtoNode } from "./ProtoNode.js";
+import { GraphNode } from "@eggjs/tegg-common-util";
+import "@eggjs/tegg-types";
+
+//#region src/model/graph/GlobalModuleNode.ts
+var ModuleDependencyMeta = class {
+	obj;
+	injectObj;
+	constructor(obj, injectObj) {
+		this.obj = obj;
+		this.injectObj = injectObj;
+	}
+	equal(meta) {
+		return this.obj.equal(meta.obj) && this.injectObj === meta.injectObj;
+	}
+	toString() {
+		return `Object ${String(this.obj.name)} inject ${String(this.injectObj)}`;
+	}
+};
+var GlobalModuleNode = class {
+	id;
+	name;
+	unitPath;
+	optional;
+	protos;
+	constructor(options) {
+		this.id = options.unitPath;
+		this.name = options.name;
+		this.unitPath = options.unitPath;
+		this.optional = options.optional;
+		this.protos = [];
+	}
+	addProto(proto) {
+		this.protos.push(new GraphNode(new ProtoNode(proto)));
+	}
+	toString() {
+		return `${this.name}@${this.unitPath}`;
+	}
+};
+
+//#endregion
+export { GlobalModuleNode, ModuleDependencyMeta };

package/dist/model/graph/GlobalModuleNodeBuilder.d.ts

@@ -0,0 +1,17 @@
+import { GlobalModuleNode, GlobalModuleNodeOptions } from "./GlobalModuleNode.js";
+import { EggProtoImplClass } from "@eggjs/tegg-types";
+
+//#region src/model/graph/GlobalModuleNodeBuilder.d.ts
+declare class GlobalModuleNodeBuilder {
+  private readonly name;
+  private readonly unitPath;
+  private readonly optional;
+  private readonly protos;
+  constructor(options: GlobalModuleNodeOptions);
+  addClazz(clazz: EggProtoImplClass): this;
+  addMultiInstanceClazz(clazz: EggProtoImplClass, defineModuleName: string, defineUnitPath: string): Promise<this>;
+  build(): GlobalModuleNode;
+  static create(unitPath: string, optional?: boolean): GlobalModuleNodeBuilder;
+}
+//#endregion
+export { GlobalModuleNodeBuilder };

package/dist/model/graph/GlobalModuleNodeBuilder.js

@@ -0,0 +1,56 @@
+import { ProtoDescriptorHelper } from "../ProtoDescriptorHelper.js";
+import { GlobalModuleNode } from "./GlobalModuleNode.js";
+import { ModuleConfigUtil } from "@eggjs/tegg-common-util";
+import "@eggjs/tegg-types";
+
+//#region src/model/graph/GlobalModuleNodeBuilder.ts
+var GlobalModuleNodeBuilder = class GlobalModuleNodeBuilder {
+	name;
+	unitPath;
+	optional;
+	protos;
+	constructor(options) {
+		this.name = options.name;
+		this.unitPath = options.unitPath;
+		this.optional = options.optional;
+		this.protos = [];
+	}
+	addClazz(clazz) {
+		const proto = ProtoDescriptorHelper.createByInstanceClazz(clazz, {
+			moduleName: this.name,
+			unitPath: this.unitPath
+		});
+		this.protos.push(proto);
+		return this;
+	}
+	async addMultiInstanceClazz(clazz, defineModuleName, defineUnitPath) {
+		const protos = await ProtoDescriptorHelper.createByMultiInstanceClazz(clazz, {
+			defineModuleName,
+			defineUnitPath,
+			instanceModuleName: this.name,
+			instanceDefineUnitPath: this.unitPath
+		});
+		this.protos.push(...protos);
+		return this;
+	}
+	build() {
+		const node = new GlobalModuleNode({
+			name: this.name,
+			unitPath: this.unitPath,
+			optional: this.optional
+		});
+		for (const proto of this.protos) node.addProto(proto);
+		return node;
+	}
+	static create(unitPath, optional = false) {
+		const name = ModuleConfigUtil.readModuleNameSync(unitPath);
+		return new GlobalModuleNodeBuilder({
+			name,
+			unitPath,
+			optional
+		});
+	}
+};
+
+//#endregion
+export { GlobalModuleNodeBuilder };

package/dist/model/graph/ProtoNode.d.ts

@@ -0,0 +1,25 @@
+import { ProtoSelectorContext } from "./ProtoSelector.js";
+import { EdgeMeta } from "@eggjs/tegg-common-util";
+import { GraphNodeObj as GraphNodeObj$1, ProtoDescriptor } from "@eggjs/tegg-types";
+
+//#region src/model/graph/ProtoNode.d.ts
+declare class ProtoDependencyMeta implements EdgeMeta {
+  injectObj: PropertyKey;
+  constructor({
+    injectObj
+  }: {
+    injectObj: PropertyKey;
+  });
+  equal(meta: ProtoDependencyMeta): boolean;
+  toString(): string;
+}
+declare class ProtoNode implements GraphNodeObj$1 {
+  readonly id: string;
+  readonly proto: ProtoDescriptor;
+  constructor(proto: ProtoDescriptor);
+  toString(): string;
+  selectProto(ctx: ProtoSelectorContext): boolean;
+  static createProtoId(proto: ProtoDescriptor): string;
+}
+//#endregion
+export { ProtoDependencyMeta, ProtoNode };

package/dist/model/graph/ProtoNode.js

@@ -0,0 +1,43 @@
+import { ProtoDescriptorHelper } from "../ProtoDescriptorHelper.js";
+import "./ProtoSelector.js";
+import "@eggjs/tegg-common-util";
+import "@eggjs/tegg-types";
+
+//#region src/model/graph/ProtoNode.ts
+var ProtoDependencyMeta = class {
+	injectObj;
+	constructor({ injectObj }) {
+		this.injectObj = injectObj;
+	}
+	equal(meta) {
+		return this.injectObj === meta.injectObj;
+	}
+	toString() {
+		return `inject ${String(this.injectObj)}`;
+	}
+};
+var ProtoNode = class ProtoNode {
+	id;
+	proto;
+	constructor(proto) {
+		this.id = ProtoNode.createProtoId(proto);
+		this.proto = proto;
+	}
+	toString() {
+		return `${String(this.proto.name)}@${this.proto.instanceDefineUnitPath}`;
+	}
+	selectProto(ctx) {
+		return ProtoDescriptorHelper.selectProto(this.proto, ctx);
+	}
+	static createProtoId(proto) {
+		return [
+			proto.name,
+			proto.instanceModuleName,
+			proto.initType,
+			...proto.qualifiers.map((t) => String(t.attribute) + String(t.value))
+		].join("@");
+	}
+};
+
+//#endregion
+export { ProtoDependencyMeta, ProtoNode };

package/dist/model/graph/ProtoSelector.d.ts

@@ -0,0 +1,10 @@
+import { QualifierInfo } from "@eggjs/tegg-types";
+
+//#region src/model/graph/ProtoSelector.d.ts
+interface ProtoSelectorContext {
+  name: PropertyKey;
+  qualifiers: QualifierInfo[];
+  moduleName: string;
+}
+//#endregion
+export { ProtoSelectorContext };

package/dist/model/graph/ProtoSelector.js

@@ -0,0 +1,3 @@
+import "@eggjs/tegg-types";
+
+export {  };