@nmtjs/core 0.12.5 → 0.12.6

package/dist/container.js

@@ -1,280 +1,313 @@
-import assert from "node:assert";
-import { tryCaptureStackTrace } from "@nmtjs/common";
+import assert from 'node:assert';
+import { tryCaptureStackTrace } from '@nmtjs/common';
 import { Scope } from "./enums.js";
-import { CoreInjectables, compareScope, createExtendableClassInjectable, createValueInjectable, getDepedencencyInjectable, isClassInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable } from "./injectables.js";
+import { CoreInjectables, compareScope, createExtendableClassInjectable, createValueInjectable, getDepedencencyInjectable, isClassInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable, } from "./injectables.js";
 export class Container {
-	instances = new Map();
-	resolvers = new Map();
-	injectables = new Set();
-	dependants = new Map();
-	disposing = false;
-	constructor(application, scope = Scope.Global, parent) {
-		this.application = application;
-		this.scope = scope;
-		this.parent = parent;
-		if (scope === Scope.Transient) {
-			throw new Error("Invalid scope");
-		}
-		this.provide(CoreInjectables.inject, this.createInjectFunction());
-		this.provide(CoreInjectables.dispose, this.createDisposeFunction());
-		this.provide(CoreInjectables.registry, application.registry);
-	}
-	async load() {
-		const traverse = (dependencies) => {
-			for (const key in dependencies) {
-				const dependency = dependencies[key];
-				const injectable = getDepedencencyInjectable(dependency);
-				this.injectables.add(injectable);
-				traverse(injectable.dependencies);
-			}
-		};
-		for (const dependant of this.application.registry.getDependants()) {
-			traverse(dependant.dependencies);
-		}
-		const injectables = Array.from(this.findCurrentScopeInjectables());
-		await Promise.all(injectables.map((injectable) => this.resolve(injectable)));
-	}
-	fork(scope) {
-		return new Container(this.application, scope, this);
-	}
-	async dispose() {
-		this.application.logger.trace("Disposing [%s] scope context...", this.scope);
-		this.disposing = true;
-		const disposalOrder = this.getDisposalOrder();
-		for (const injectable of disposalOrder) {
-			if (this.instances.has(injectable)) {
-				await this.disposeInjectableInstances(injectable);
-			}
-		}
-		this.instances.clear();
-		this.injectables.clear();
-		this.resolvers.clear();
-		this.dependants.clear();
-		this.disposing = false;
-	}
-	containsWithinSelf(injectable) {
-		return this.instances.has(injectable) || this.resolvers.has(injectable);
-	}
-	contains(injectable) {
-		return this.containsWithinSelf(injectable) || (this.parent?.contains(injectable) ?? false);
-	}
-	get(injectable) {
-		if (injectable.scope === Scope.Transient) {
-			throw new Error("Cannot get transient injectable directly");
-		}
-		if (this.instances.has(injectable)) {
-			return this.instances.get(injectable).at(0).public;
-		}
-		if (this.parent?.contains(injectable)) {
-			return this.parent.get(injectable);
-		}
-		throw new Error("No instance found");
-	}
-	resolve(injectable) {
-		return this.resolveInjectable(injectable);
-	}
-	async createContext(dependencies) {
-		return this.createInjectableContext(dependencies);
-	}
-	async createInjectableContext(dependencies, dependant) {
-		const injections = {};
-		const deps = Object.entries(dependencies);
-		const resolvers = Array(deps.length);
-		for (let i = 0; i < deps.length; i++) {
-			const [key, dependency] = deps[i];
-			const injectable = getDepedencencyInjectable(dependency);
-			const resolver = this.resolveInjectable(injectable, dependant);
-			resolvers[i] = resolver.then((value) => injections[key] = value);
-		}
-		await Promise.all(resolvers);
-		return Object.freeze(injections);
-	}
-	async provide(injectable, instance) {
-		if (compareScope(injectable.scope, ">", this.scope)) {
-			throw new Error("Invalid scope");
-		}
-		this.instances.set(injectable, [{
-			private: instance,
-			public: instance,
-			context: undefined
-		}]);
-	}
-	satisfies(injectable) {
-		return compareScope(injectable.scope, "<=", this.scope);
-	}
-	*findCurrentScopeInjectables() {
-		for (const injectable of this.injectables) {
-			if (injectable.scope === this.scope) {
-				yield injectable;
-			}
-		}
-	}
-	resolveInjectable(injectable, dependant) {
-		if (this.disposing) {
-			return Promise.reject(new Error("Cannot resolve during disposal"));
-		}
-		if (dependant && compareScope(dependant.scope, "<", injectable.scope)) {
-			return Promise.reject(new Error("Invalid scope: dependant is looser than injectable"));
-		}
-		if (isValueInjectable(injectable)) {
-			return Promise.resolve(injectable.value);
-		} else if (this.parent?.contains(injectable) || this.parent?.satisfies(injectable) && compareScope(this.parent.scope, "<", this.scope)) {
-			return this.parent.resolveInjectable(injectable, dependant);
-		} else {
-			const { stack, label } = injectable;
-			if (dependant) {
-				let dependants = this.dependants.get(injectable);
-				if (!dependants) {
-					this.dependants.set(injectable, dependants = new Set());
-				}
-				dependants.add(dependant);
-			}
-			const isTransient = injectable.scope === Scope.Transient;
-			if (!isTransient && this.instances.has(injectable)) {
-				return Promise.resolve(this.instances.get(injectable).at(0).public);
-			} else if (!isTransient && this.resolvers.has(injectable)) {
-				return this.resolvers.get(injectable);
-			} else {
-				const isLazy = isLazyInjectable(injectable);
-				if (isLazy) {
-					const isOptional = isOptionalInjectable(injectable);
-					if (isOptional) return Promise.resolve(undefined);
-					return Promise.reject(new Error(`No instance provided for ${label || "an"} injectable:\n${stack}`));
-				} else {
-					const resolution = this.createResolution(injectable).finally(() => {
-						this.resolvers.delete(injectable);
-					});
-					if (injectable.scope !== Scope.Transient) {
-						this.resolvers.set(injectable, resolution);
-					}
-					return resolution;
-				}
-			}
-		}
-	}
-	async createResolution(injectable) {
-		const { dependencies } = injectable;
-		const context = await this.createInjectableContext(dependencies, injectable);
-		const wrapper = {
-			private: null,
-			public: null,
-			context
-		};
-		if (isFactoryInjectable(injectable)) {
-			wrapper.private = await Promise.resolve(injectable.factory(wrapper.context));
-			wrapper.public = injectable.pick(wrapper.private);
-		} else if (isClassInjectable(injectable)) {
-			wrapper.private = new injectable(context);
-			wrapper.public = wrapper.private;
-			await wrapper.private.$onCreate();
-		} else {
-			throw new Error("Invalid injectable type");
-		}
-		let instances = this.instances.get(injectable);
-		if (!instances) {
-			instances = [];
-			this.instances.set(injectable, instances);
-		}
-		instances.push(wrapper);
-		return wrapper.public;
-	}
-	createInjectFunction() {
-		const inject = (injectable, context) => {
-			const dependencies = { ...injectable.dependencies };
-			for (const key in context) {
-				const dep = context[key];
-				if (isInjectable(dep) || isOptionalInjectable(dep)) {
-					dependencies[key] = dep;
-				} else {
-					dependencies[key] = createValueInjectable(dep);
-				}
-			}
-			const newInjectable = isClassInjectable(injectable) ? createExtendableClassInjectable(injectable, dependencies, Scope.Transient, 1) : {
-				...injectable,
-				dependencies,
-				scope: Scope.Transient,
-				stack: tryCaptureStackTrace(1)
-			};
-			return this.resolve(newInjectable);
-		};
-		const explicit = async (injectable, context) => {
-			if ("asyncDispose" in Symbol === false) {
-				throw new Error("Symbol.asyncDispose is not supported in this environment");
-			}
-			const instance = await inject(injectable, context);
-			const dispose = this.createDisposeFunction();
-			return Object.assign(instance, { [Symbol.asyncDispose]: async () => {
-				await dispose(injectable, instance);
-			} });
-		};
-		return Object.assign(inject, { explicit });
-	}
-	createDisposeFunction() {
-		return async (injectable, instance) => {
-			if (injectable.scope === Scope.Transient) {
-				assert(instance, "Instance is required for transient injectable disposal");
-				const wrappers = this.instances.get(injectable);
-				if (wrappers) {
-					for (const wrapper of wrappers) {
-						if (wrapper.public === instance) {
-							await this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context);
-							const index = wrappers.indexOf(wrapper);
-							wrappers.splice(index, 1);
-						}
-					}
-					if (wrappers.length === 0) {
-						this.instances.delete(injectable);
-					}
-				}
-			} else {
-				await this.disposeInjectableInstances(injectable);
-			}
-		};
-	}
-	getDisposalOrder() {
-		const visited = new Set();
-		const result = [];
-		const visit = (injectable) => {
-			if (visited.has(injectable)) return;
-			visited.add(injectable);
-			const dependants = this.dependants.get(injectable);
-			if (dependants) {
-				for (const dependant of dependants) {
-					if (this.instances.has(dependant)) {
-						visit(dependant);
-					}
-				}
-			}
-			if (this.instances.has(injectable)) {
-				result.push(injectable);
-			}
-		};
-		for (const injectable of this.instances.keys()) {
-			visit(injectable);
-		}
-		return result;
-	}
-	async disposeInjectableInstances(injectable) {
-		try {
-			if (this.instances.has(injectable)) {
-				const wrappers = this.instances.get(injectable);
-				await Promise.all(wrappers.map((wrapper) => this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context)));
-			}
-		} catch (cause) {
-			const error = new Error("Injectable disposal error. Potential memory leak", { cause });
-			this.application.logger.error(error);
-		} finally {
-			this.instances.delete(injectable);
-		}
-	}
-	async disposeInjectableInstance(injectable, instance, context) {
-		if (isFactoryInjectable(injectable)) {
-			const { dispose } = injectable;
-			if (dispose) await dispose(instance, context);
-		} else if (isClassInjectable(injectable)) {
-			await instance.$onDispose();
-		}
-	}
+    application;
+    scope;
+    parent;
+    instances = new Map();
+    resolvers = new Map();
+    injectables = new Set();
+    dependants = new Map();
+    // private readonly transients = new Map<any, any>()
+    disposing = false;
+    constructor(application, scope = Scope.Global, parent) {
+        this.application = application;
+        this.scope = scope;
+        this.parent = parent;
+        if (scope === Scope.Transient) {
+            throw new Error('Invalid scope');
+        }
+        this.provide(CoreInjectables.inject, this.createInjectFunction());
+        this.provide(CoreInjectables.dispose, this.createDisposeFunction());
+        this.provide(CoreInjectables.registry, application.registry);
+    }
+    async load() {
+        const traverse = (dependencies) => {
+            for (const key in dependencies) {
+                const dependency = dependencies[key];
+                const injectable = getDepedencencyInjectable(dependency);
+                this.injectables.add(injectable);
+                traverse(injectable.dependencies);
+            }
+        };
+        for (const dependant of this.application.registry.getDependants()) {
+            traverse(dependant.dependencies);
+        }
+        const injectables = Array.from(this.findCurrentScopeInjectables());
+        await Promise.all(injectables.map((injectable) => this.resolve(injectable)));
+    }
+    fork(scope) {
+        return new Container(this.application, scope, this);
+    }
+    async dispose() {
+        this.application.logger.trace('Disposing [%s] scope context...', this.scope);
+        // Prevent new resolutions during disposal
+        this.disposing = true;
+        // Get proper disposal order using topological sort
+        const disposalOrder = this.getDisposalOrder();
+        // Dispose in the correct order
+        for (const injectable of disposalOrder) {
+            if (this.instances.has(injectable)) {
+                await this.disposeInjectableInstances(injectable);
+            }
+        }
+        this.instances.clear();
+        this.injectables.clear();
+        this.resolvers.clear();
+        this.dependants.clear();
+        this.disposing = false;
+    }
+    containsWithinSelf(injectable) {
+        return this.instances.has(injectable) || this.resolvers.has(injectable);
+    }
+    contains(injectable) {
+        return (this.containsWithinSelf(injectable) ||
+            (this.parent?.contains(injectable) ?? false));
+    }
+    get(injectable) {
+        if (injectable.scope === Scope.Transient) {
+            throw new Error('Cannot get transient injectable directly');
+        }
+        if (this.instances.has(injectable)) {
+            return this.instances.get(injectable).at(0).public;
+        }
+        if (this.parent?.contains(injectable)) {
+            return this.parent.get(injectable);
+        }
+        throw new Error('No instance found');
+    }
+    resolve(injectable) {
+        return this.resolveInjectable(injectable);
+    }
+    async createContext(dependencies) {
+        return this.createInjectableContext(dependencies);
+    }
+    async createInjectableContext(dependencies, dependant) {
+        const injections = {};
+        const deps = Object.entries(dependencies);
+        const resolvers = Array(deps.length);
+        for (let i = 0; i < deps.length; i++) {
+            const [key, dependency] = deps[i];
+            const injectable = getDepedencencyInjectable(dependency);
+            const resolver = this.resolveInjectable(injectable, dependant);
+            resolvers[i] = resolver.then((value) => (injections[key] = value));
+        }
+        await Promise.all(resolvers);
+        return Object.freeze(injections);
+    }
+    async provide(injectable, instance) {
+        if (compareScope(injectable.scope, '>', this.scope)) {
+            throw new Error('Invalid scope'); // TODO: more informative error
+        }
+        this.instances.set(injectable, [
+            {
+                private: instance,
+                public: instance,
+                context: undefined,
+            },
+        ]);
+    }
+    satisfies(injectable) {
+        return compareScope(injectable.scope, '<=', this.scope);
+    }
+    *findCurrentScopeInjectables() {
+        for (const injectable of this.injectables) {
+            if (injectable.scope === this.scope) {
+                yield injectable;
+            }
+        }
+    }
+    resolveInjectable(injectable, dependant) {
+        if (this.disposing) {
+            return Promise.reject(new Error('Cannot resolve during disposal'));
+        }
+        if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {
+            // TODO: more informative error
+            return Promise.reject(new Error('Invalid scope: dependant is looser than injectable'));
+        }
+        if (isValueInjectable(injectable)) {
+            return Promise.resolve(injectable.value);
+        }
+        else if (this.parent?.contains(injectable) ||
+            (this.parent?.satisfies(injectable) &&
+                compareScope(this.parent.scope, '<', this.scope))) {
+            return this.parent.resolveInjectable(injectable, dependant);
+        }
+        else {
+            const { stack, label } = injectable;
+            if (dependant) {
+                let dependants = this.dependants.get(injectable);
+                if (!dependants) {
+                    this.dependants.set(injectable, (dependants = new Set()));
+                }
+                dependants.add(dependant);
+            }
+            const isTransient = injectable.scope === Scope.Transient;
+            if (!isTransient && this.instances.has(injectable)) {
+                return Promise.resolve(this.instances.get(injectable).at(0).public);
+            }
+            else if (!isTransient && this.resolvers.has(injectable)) {
+                return this.resolvers.get(injectable);
+            }
+            else {
+                const isLazy = isLazyInjectable(injectable);
+                if (isLazy) {
+                    const isOptional = isOptionalInjectable(injectable);
+                    if (isOptional)
+                        return Promise.resolve(undefined);
+                    return Promise.reject(new Error(`No instance provided for ${label || 'an'} injectable:\n${stack}`));
+                }
+                else {
+                    const resolution = this.createResolution(injectable).finally(() => {
+                        this.resolvers.delete(injectable);
+                    });
+                    if (injectable.scope !== Scope.Transient) {
+                        this.resolvers.set(injectable, resolution);
+                    }
+                    return resolution;
+                }
+            }
+        }
+    }
+    async createResolution(injectable) {
+        const { dependencies } = injectable;
+        const context = await this.createInjectableContext(dependencies, injectable);
+        const wrapper = {
+            private: null,
+            public: null,
+            context,
+        };
+        if (isFactoryInjectable(injectable)) {
+            wrapper.private = await Promise.resolve(injectable.factory(wrapper.context));
+            wrapper.public = injectable.pick(wrapper.private);
+        }
+        else if (isClassInjectable(injectable)) {
+            wrapper.private = new injectable(context);
+            wrapper.public = wrapper.private;
+            await wrapper.private.$onCreate();
+        }
+        else {
+            throw new Error('Invalid injectable type');
+        }
+        let instances = this.instances.get(injectable);
+        if (!instances) {
+            instances = [];
+            this.instances.set(injectable, instances);
+        }
+        instances.push(wrapper);
+        return wrapper.public;
+    }
+    createInjectFunction() {
+        const inject = (injectable, context) => {
+            const dependencies = {
+                ...injectable.dependencies,
+            };
+            for (const key in context) {
+                const dep = context[key];
+                if (isInjectable(dep) || isOptionalInjectable(dep)) {
+                    dependencies[key] = dep;
+                }
+                else {
+                    dependencies[key] = createValueInjectable(dep);
+                }
+            }
+            const newInjectable = isClassInjectable(injectable)
+                ? createExtendableClassInjectable(injectable, dependencies, Scope.Transient, 1)
+                : {
+                    ...injectable,
+                    dependencies,
+                    scope: Scope.Transient,
+                    stack: tryCaptureStackTrace(1),
+                };
+            return this.resolve(newInjectable);
+        };
+        const explicit = async (injectable, context) => {
+            if ('asyncDispose' in Symbol === false) {
+                throw new Error('Symbol.asyncDispose is not supported in this environment');
+            }
+            const instance = await inject(injectable, context);
+            const dispose = this.createDisposeFunction();
+            return Object.assign(instance, {
+                [Symbol.asyncDispose]: async () => {
+                    await dispose(injectable, instance);
+                },
+            });
+        };
+        return Object.assign(inject, { explicit });
+    }
+    createDisposeFunction() {
+        return async (injectable, instance) => {
+            if (injectable.scope === Scope.Transient) {
+                assert(instance, 'Instance is required for transient injectable disposal');
+                const wrappers = this.instances.get(injectable);
+                if (wrappers) {
+                    for (const wrapper of wrappers) {
+                        if (wrapper.public === instance) {
+                            await this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context);
+                            const index = wrappers.indexOf(wrapper);
+                            wrappers.splice(index, 1);
+                        }
+                    }
+                    if (wrappers.length === 0) {
+                        this.instances.delete(injectable);
+                    }
+                }
+            }
+            else {
+                await this.disposeInjectableInstances(injectable);
+            }
+        };
+    }
+    getDisposalOrder() {
+        const visited = new Set();
+        const result = [];
+        const visit = (injectable) => {
+            if (visited.has(injectable))
+                return;
+            visited.add(injectable);
+            const dependants = this.dependants.get(injectable);
+            if (dependants) {
+                for (const dependant of dependants) {
+                    if (this.instances.has(dependant)) {
+                        visit(dependant);
+                    }
+                }
+            }
+            // Only add to result if this container owns the instance
+            if (this.instances.has(injectable)) {
+                result.push(injectable);
+            }
+        };
+        for (const injectable of this.instances.keys()) {
+            visit(injectable);
+        }
+        return result;
+    }
+    async disposeInjectableInstances(injectable) {
+        try {
+            if (this.instances.has(injectable)) {
+                const wrappers = this.instances.get(injectable);
+                await Promise.all(wrappers.map((wrapper) => this.disposeInjectableInstance(injectable, wrapper.private, wrapper.context)));
+            }
+        }
+        catch (cause) {
+            const error = new Error('Injectable disposal error. Potential memory leak', { cause });
+            this.application.logger.error(error);
+        }
+        finally {
+            this.instances.delete(injectable);
+        }
+    }
+    async disposeInjectableInstance(injectable, instance, context) {
+        if (isFactoryInjectable(injectable)) {
+            const { dispose } = injectable;
+            if (dispose)
+                await dispose(instance, context);
+        }
+        else if (isClassInjectable(injectable)) {
+            await instance.$onDispose();
+        }
+    }
 }
-
-//# sourceMappingURL=container.js.map

package/dist/enums.d.ts

@@ -0,0 +1,18 @@
+export declare enum Scope {
+    Global = "Global",
+    Connection = "Connection",
+    Call = "Call",
+    Transient = "Transient"
+}
+export declare enum Hook {
+    BeforeInitialize = "BeforeInitialize",
+    AfterInitialize = "AfterInitialize",
+    BeforeStart = "BeforeStart",
+    AfterStart = "AfterStart",
+    BeforeStop = "BeforeStop",
+    AfterStop = "AfterStop",
+    BeforeTerminate = "BeforeTerminate",
+    AfterTerminate = "AfterTerminate",
+    OnConnect = "OnConnect",
+    OnDisconnect = "OnDisconnect"
+}