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

package/dist/{factory/EggContainerFactory.js → ContextInitiator-DazHfq05.js}

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

package/dist/ContextInitiator-GmZYvMSm.js

@@ -0,0 +1,3 @@
+import { ContextInitiator } from "./ContextInitiator-DazHfq05.js";
+
+export { ContextInitiator };

package/dist/index.d.ts

@@ -1,17 +1,171 @@
-import { AbstractEggContext } from "./model/AbstractEggContext.js";
-import { ContextHandler } from "./model/ContextHandler.js";
-import { EggContextLifecycleUtil } from "./model/EggContext.js";
-import { EggObjectLifecycleUtil } from "./model/EggObject.js";
-import { LoadUnitInstanceLifecycleUtil } from "./model/LoadUnitInstance.js";
-import { ContextInitiator } from "./impl/ContextInitiator.js";
-import { ContextObjectGraph } from "./impl/ContextObjectGraph.js";
-import { EggAlwaysNewObjectContainer } from "./impl/EggAlwaysNewObjectContainer.js";
-import { EggObjectImpl } from "./impl/EggObjectImpl.js";
-import { EggObjectUtil } from "./impl/EggObjectUtil.js";
-import { ModuleLoadUnitInstance } from "./impl/ModuleLoadUnitInstance.js";
-import { EggContainerFactory } from "./factory/EggContainerFactory.js";
-import { EggObjectFactory } from "./factory/EggObjectFactory.js";
-import { LoadUnitInstanceFactory } from "./factory/LoadUnitInstanceFactory.js";
 import { EggRuntimeContext as EggContext } from "@eggjs/tegg-types/runtime";
+import { ContainerGetMethod, CreateObjectMethod, EggContainer, EggContextLifecycleContext, EggLoadUnitTypeLike, EggObject, EggObjectLifeCycleContext, EggObjectName, EggProtoImplClass, EggPrototype, EggPrototypeClass, EggPrototypeName, EggRuntimeContext, Id, InjectObjectProto, LifecycleContext, LoadUnit, LoadUnitInstance, LoadUnitInstanceLifecycleContext, ObjectInitTypeLike, QualifierInfo } from "@eggjs/tegg-types";
+import { LifecycleUtil } from "@eggjs/tegg-lifecycle";
 export * from "@eggjs/tegg-types/runtime";
+
+//#region src/model/AbstractEggContext.d.ts
+declare abstract class AbstractEggContext implements EggRuntimeContext {
+  private contextData;
+  private protoToCreate;
+  private eggObjectMap;
+  private eggObjectPromiseMap;
+  private destroyed;
+  abstract id: string;
+  addProtoToCreate(name: string, proto: EggPrototype): void;
+  deleteProtoToCreate(name: string): void;
+  destroy(ctx: EggContextLifecycleContext): Promise<void>;
+  get(key: string | symbol): any | undefined;
+  getEggObject(name: EggPrototypeName, proto: EggPrototype): EggObject;
+  getOrCreateEggObject(name: EggPrototypeName, proto: EggPrototype): Promise<EggObject>;
+  init(ctx: EggContextLifecycleContext): Promise<void>;
+  iterateProtoToCreate(): IterableIterator<[EggObjectName, EggPrototype]>;
+  set(key: string | symbol, val: any): void;
+}
+//#endregion
+//#region src/model/ContextHandler.d.ts
+type runInContextCallback<R = any> = (context: EggRuntimeContext, fn: () => Promise<R>) => Promise<R>;
+declare class ContextHandler {
+  static getContextCallback: () => EggRuntimeContext | undefined;
+  static runInContextCallback: runInContextCallback;
+  static getContext(): EggRuntimeContext | undefined;
+  static run<R = any>(context: EggRuntimeContext, fn: () => Promise<R>): Promise<R>;
+}
+//#endregion
+//#region src/model/EggContext.d.ts
+declare const EggContextLifecycleUtil: LifecycleUtil<EggContextLifecycleContext, EggRuntimeContext>;
+//#endregion
+//#region src/model/EggObject.d.ts
+declare const EggObjectLifecycleUtil: LifecycleUtil<EggObjectLifeCycleContext, EggObject>;
+//#endregion
+//#region src/model/LoadUnitInstance.d.ts
+declare const LoadUnitInstanceLifecycleUtil: LifecycleUtil<LoadUnitInstanceLifecycleContext, LoadUnitInstance>;
+//#endregion
+//#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
+//#region src/impl/ContextObjectGraph.d.ts
+declare class ContextObjectGraph {
+  private static eggObjectInitRecorder;
+  static getContextProto(proto: EggPrototype): InjectObjectProto[];
+  private static doGetContextProto;
+}
+//#endregion
+//#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
+//#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
+//#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
+//#region src/impl/ModuleLoadUnitInstance.d.ts
+declare class ModuleLoadUnitInstance implements LoadUnitInstance {
+  readonly loadUnit: LoadUnit;
+  readonly id: string;
+  readonly name: string;
+  private protoToCreateMap;
+  private eggObjectMap;
+  private eggObjectPromiseMap;
+  constructor(loadUnit: LoadUnit);
+  iterateProtoToCreate(): IterableIterator<[EggObjectName, EggPrototype]>;
+  addProtoToCreate(name: string, proto: EggPrototype): void;
+  deleteProtoToCreate(name: string): void;
+  init(ctx: LoadUnitInstanceLifecycleContext): Promise<void>;
+  destroy(): Promise<void>;
+  getOrCreateEggObject(name: EggPrototypeName, proto: EggPrototype): Promise<EggObject>;
+  getEggObject(name: EggPrototypeName, proto: EggPrototype): EggObject;
+  static createModuleLoadUnitInstance(ctx: LoadUnitInstanceLifecycleContext): LoadUnitInstance;
+}
+//#endregion
+//#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
+//#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
+//#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 { AbstractEggContext, ContextHandler, ContextInitiator, ContextObjectGraph, EggAlwaysNewObjectContainer, EggContainerFactory, type EggContext, EggContextLifecycleUtil, EggObjectFactory, EggObjectImpl, EggObjectLifecycleUtil, EggObjectUtil, LoadUnitInstanceFactory, LoadUnitInstanceLifecycleUtil, ModuleLoadUnitInstance };