@nmtjs/core 0.7.3 → 0.7.5

package/dist/constants.js

@@ -3,6 +3,7 @@ export const kInjectable = Symbol.for("neemata:InjectableKey");
 export const kLazyInjectable = Symbol.for("neemata:LazyInjectableKey");
 export const kValueInjectable = Symbol.for("neemata:ValueInjectableKey");
 export const kFactoryInjectable = Symbol.for("neemata:FactoryInjectableKey");
+export const kClassInjectable = Symbol.for("neemata:ClassInjectableKey");
 export const kProvider = Symbol.for("neemata:ProviderKey");
 export const kHookCollection = Symbol.for("neemata:HookCollectionKey");
 export const kPlugin = Symbol.for("neemata:PluginKey");

package/dist/constants.js.map

@@ -1 +1 @@
-{"mappings":"AAEA,OAAO,MAAMA,sBAAqC,OAAO,IACvD,gCACD;AAGD,OAAO,MAAMC,cAA6B,OAAO,IAAI,wBAAwB;AAG7E,OAAO,MAAMC,kBAAiC,OAAO,IACnD,4BACD;AAGD,OAAO,MAAMC,mBAAkC,OAAO,IACpD,6BACD;AAGD,OAAO,MAAMC,qBAAoC,OAAO,IACtD,+BACD;AAGD,OAAO,MAAMC,YAA2B,OAAO,IAAI,sBAAsB;AAGzE,OAAO,MAAMC,kBAAiC,OAAO,IACnD,4BACD;AAGD,OAAO,MAAMC,UAAyB,OAAO,IAAI,oBAAoB;AAErE,OAAO,MAAM,WAAW,CAACC,UAAgC,WAAW","names":["kOptionalDependency: unique symbol","kInjectable: unique symbol","kLazyInjectable: unique symbol","kValueInjectable: unique symbol","kFactoryInjectable: unique symbol","kProvider: unique symbol","kHookCollection: unique symbol","kPlugin: unique symbol","value: any"],"sources":["src/constants.ts"],"sourcesContent":["import type { Plugin } from './plugin.ts'\n\nexport const kOptionalDependency: unique symbol = Symbol.for(\n  'neemata:OptionalDependencyKey',\n)\nexport type kOptionalDependency = typeof kOptionalDependency\n\nexport const kInjectable: unique symbol = Symbol.for('neemata:InjectableKey')\nexport type kInjectable = typeof kInjectable\n\nexport const kLazyInjectable: unique symbol = Symbol.for(\n  'neemata:LazyInjectableKey',\n)\nexport type kLazyInjectable = typeof kLazyInjectable\n\nexport const kValueInjectable: unique symbol = Symbol.for(\n  'neemata:ValueInjectableKey',\n)\nexport type kValueInjectable = typeof kValueInjectable\n\nexport const kFactoryInjectable: unique symbol = Symbol.for(\n  'neemata:FactoryInjectableKey',\n)\nexport type kFactoryInjectable = typeof kFactoryInjectable\n\nexport const kProvider: unique symbol = Symbol.for('neemata:ProviderKey')\nexport type kProvider = typeof kProvider\n\nexport const kHookCollection: unique symbol = Symbol.for(\n  'neemata:HookCollectionKey',\n)\nexport type kHookCollection = typeof kHookCollection\n\nexport const kPlugin: unique symbol = Symbol.for('neemata:PluginKey')\nexport type kPlugin = typeof kPlugin\nexport const isPlugin = (value: any): value is Plugin => kPlugin in value\n"],"version":3}
+{"mappings":"AAEA,OAAO,MAAMA,sBAAqC,OAAO,IACvD,gCACD;AAGD,OAAO,MAAMC,cAA6B,OAAO,IAAI,wBAAwB;AAG7E,OAAO,MAAMC,kBAAiC,OAAO,IACnD,4BACD;AAGD,OAAO,MAAMC,mBAAkC,OAAO,IACpD,6BACD;AAGD,OAAO,MAAMC,qBAAoC,OAAO,IACtD,+BACD;AAGD,OAAO,MAAMC,mBAAkC,OAAO,IACpD,6BACD;AAGD,OAAO,MAAMC,YAA2B,OAAO,IAAI,sBAAsB;AAGzE,OAAO,MAAMC,kBAAiC,OAAO,IACnD,4BACD;AAGD,OAAO,MAAMC,UAAyB,OAAO,IAAI,oBAAoB;AAErE,OAAO,MAAM,WAAW,CAACC,UAAgC,WAAW","names":["kOptionalDependency: unique symbol","kInjectable: unique symbol","kLazyInjectable: unique symbol","kValueInjectable: unique symbol","kFactoryInjectable: unique symbol","kClassInjectable: unique symbol","kProvider: unique symbol","kHookCollection: unique symbol","kPlugin: unique symbol","value: any"],"sources":["src/constants.ts"],"sourcesContent":["import type { Plugin } from './plugin.ts'\n\nexport const kOptionalDependency: unique symbol = Symbol.for(\n  'neemata:OptionalDependencyKey',\n)\nexport type kOptionalDependency = typeof kOptionalDependency\n\nexport const kInjectable: unique symbol = Symbol.for('neemata:InjectableKey')\nexport type kInjectable = typeof kInjectable\n\nexport const kLazyInjectable: unique symbol = Symbol.for(\n  'neemata:LazyInjectableKey',\n)\nexport type kLazyInjectable = typeof kLazyInjectable\n\nexport const kValueInjectable: unique symbol = Symbol.for(\n  'neemata:ValueInjectableKey',\n)\nexport type kValueInjectable = typeof kValueInjectable\n\nexport const kFactoryInjectable: unique symbol = Symbol.for(\n  'neemata:FactoryInjectableKey',\n)\nexport type kFactoryInjectable = typeof kFactoryInjectable\n\nexport const kClassInjectable: unique symbol = Symbol.for(\n  'neemata:ClassInjectableKey',\n)\nexport type kClassInjectable = typeof kClassInjectable\n\nexport const kProvider: unique symbol = Symbol.for('neemata:ProviderKey')\nexport type kProvider = typeof kProvider\n\nexport const kHookCollection: unique symbol = Symbol.for(\n  'neemata:HookCollectionKey',\n)\nexport type kHookCollection = typeof kHookCollection\n\nexport const kPlugin: unique symbol = Symbol.for('neemata:PluginKey')\nexport type kPlugin = typeof kPlugin\nexport const isPlugin = (value: any): value is Plugin => kPlugin in value\n"],"version":3}

package/dist/container.js

@@ -1,12 +1,5 @@
-import { tryCaptureStackTrace } from "@nmtjs/common";
-import { kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from "./constants.js";
 import { Scope } from "./enums.js";
-const ScopeStrictness = {
-	[Scope.Global]: 0,
-	[Scope.Connection]: 1,
-	[Scope.Call]: 2,
-	[Scope.Transient]: 3
-};
+import { CoreInjectables, compareScope, createValueInjectable, getDepedencencyInjectable, isClassInjectable, isFactoryInjectable, isInjectable, isLazyInjectable, isOptionalInjectable, isValueInjectable } from "./injectables.js";
 export class Container {
 	instances = new Map();
 	resolvers = new Map();
@@ -19,6 +12,7 @@ export class Container {
 		if (scope === Scope.Transient) {
 			throw new Error("Invalid scope");
 		}
+		this.provide(CoreInjectables.inject, createInjectFunction(this));
 	}
 	async load() {
 		const traverse = (dependencies) => {
@@ -116,7 +110,7 @@ export class Container {
 		if (dependant && compareScope(dependant.scope, "<", injectable.scope)) {
 			throw new Error("Invalid scope: dependant is looser than injectable");
 		}
-		if (checkIsValueInjectable(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);
@@ -134,40 +128,59 @@ export class Container {
 			} else if (this.resolvers.has(injectable)) {
 				return this.resolvers.get(injectable);
 			} else {
-				const isLazy = checkIsLazyInjectable(injectable);
+				const isLazy = isLazyInjectable(injectable);
 				if (isLazy) {
-					const isOptional = checkIsOptional(injectable);
+					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 if (!checkIsFactoryInjectable(injectable)) {
-					throw new Error("Invalid injectable");
-				}
-				const resolution = this.createInjectableContext(dependencies, injectable).then((context) => Promise.resolve(injectable.factory(context)).then((instance) => ({
-					instance,
-					context
-				}))).then(({ instance, context }) => {
-					const picked = injectable.pick(instance);
-					if (compareScope(this.scope, ">=", scope)) this.instances.set(injectable, {
+				} else if (isFactoryInjectable(injectable)) {
+					const resolution = this.createInjectableContext(dependencies, injectable).then((context) => Promise.resolve(injectable.factory(context)).then((instance) => ({
 						instance,
-						picked,
 						context
+					}))).then(({ instance, context }) => {
+						const picked = injectable.pick(instance);
+						if (compareScope(this.scope, ">=", scope)) this.instances.set(injectable, {
+							instance,
+							picked,
+							context
+						});
+						if (scope !== Scope.Transient) this.resolvers.delete(injectable);
+						return picked;
+					});
+					if (scope !== Scope.Transient) this.resolvers.set(injectable, resolution);
+					return resolution;
+				} else if (isClassInjectable(injectable)) {
+					const resolution = this.createInjectableContext(dependencies, injectable).then((context) => {
+						const instance = new injectable(context);
+						return instance.$onCreate().then(() => instance);
+					}).then((instance) => {
+						if (compareScope(this.scope, ">=", scope)) this.instances.set(injectable, {
+							instance,
+							picked: undefined,
+							context: undefined
+						});
+						if (scope !== Scope.Transient) this.resolvers.delete(injectable);
+						return instance;
 					});
-					if (scope !== Scope.Transient) this.resolvers.delete(injectable);
-					return picked;
-				});
-				if (scope !== Scope.Transient) this.resolvers.set(injectable, resolution);
-				return resolution;
+					if (scope !== Scope.Transient) this.resolvers.set(injectable, resolution);
+					return resolution;
+				} else {
+					throw new Error("Invalid injectable type");
+				}
 			}
 		}
 	}
 	async disposeInjectable(injectable) {
 		try {
-			if (kFactoryInjectable in injectable) {
+			if (isFactoryInjectable(injectable)) {
 				const { dispose } = injectable;
 				if (dispose) {
 					const { instance, context } = this.instances.get(injectable);
 					await dispose(instance, context);
 				}
+			} else if (isClassInjectable(injectable)) {
+				const { instance } = this.instances.get(injectable);
+				await instance.$onDispose();
 			}
 		} catch (cause) {
 			const error = new Error("Injectable disposal error. Potential memory leak", { cause });
@@ -177,85 +190,22 @@ export class Container {
 		}
 	}
 }
-function compareScope(left, operator, right) {
-	const leftScope = ScopeStrictness[left];
-	const rightScope = ScopeStrictness[right];
-	switch (operator) {
-		case "=": return leftScope === rightScope;
-		case "!=": return leftScope !== rightScope;
-		case ">": return leftScope > rightScope;
-		case "<": return leftScope < rightScope;
-		case ">=": return leftScope >= rightScope;
-		case "<=": return leftScope <= rightScope;
-		default: throw new Error("Invalid operator");
-	}
-}
-export const checkIsLazyInjectable = (injectable) => kLazyInjectable in injectable;
-export const checkIsFactoryInjectable = (injectable) => kFactoryInjectable in injectable;
-export const checkIsValueInjectable = (injectable) => kValueInjectable in injectable;
-export const checkIsInjectable = (injectable) => kInjectable in injectable;
-export const checkIsOptional = (injectable) => kOptionalDependency in injectable;
-export function getInjectableScope(injectable) {
-	let scope = injectable.scope;
-	const deps = Object.values(injectable.dependencies);
-	for (const dependency of deps) {
-		const injectable = getDepedencencyInjectable(dependency);
-		const dependencyScope = getInjectableScope(injectable);
-		if (compareScope(dependencyScope, ">", scope)) {
-			scope = dependencyScope;
+export function createInjectFunction(container) {
+	return (injectable, context) => {
+		const dependencies = {};
+		for (const key in context) {
+			const dep = context[key];
+			if (isInjectable(dep) || isOptionalInjectable(dep)) {
+				dependencies[key] = dep;
+			} else {
+				dependencies[key] = createValueInjectable(dep);
+			}
 		}
-	}
-	return scope;
-}
-export function getDepedencencyInjectable(dependency) {
-	if (kOptionalDependency in dependency) {
-		return dependency.injectable;
-	}
-	return dependency;
-}
-export function createOptionalInjectable(injectable) {
-	return {
-		[kOptionalDependency]: true,
-		injectable
-	};
-}
-export function createLazyInjectable(scope = Scope.Global, label) {
-	return Object.freeze({
-		scope,
-		dependencies: {},
-		label,
-		stack: tryCaptureStackTrace(),
-		[kInjectable]: true,
-		[kLazyInjectable]: true
-	});
-}
-export function createValueInjectable(value, label) {
-	return Object.freeze({
-		value,
-		scope: Scope.Global,
-		dependencies: {},
-		label,
-		stack: tryCaptureStackTrace(),
-		[kInjectable]: true,
-		[kValueInjectable]: true
-	});
-}
-export function createFactoryInjectable(paramsOrFactory, label) {
-	const isFactory = typeof paramsOrFactory === "function";
-	const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory;
-	const injectable = {
-		dependencies: params.dependencies ?? {},
-		scope: params.scope ?? Scope.Global,
-		factory: params.factory,
-		dispose: params.dispose,
-		pick: params.pick ?? ((instance) => instance),
-		label,
-		stack: tryCaptureStackTrace(),
-		[kInjectable]: true,
-		[kFactoryInjectable]: true
+		const newInjectable = {
+			...injectable,
+			dependencies,
+			scope: Scope.Transient
+		};
+		return container.resolve(newInjectable);
 	};
-	const actualScope = getInjectableScope(injectable);
-	if (!isFactory && params.scope && ScopeStrictness[actualScope] > ScopeStrictness[params.scope]) throw new Error(`Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`);
-	injectable.scope = actualScope;
-	return Object.freeze(injectable);
 }

package/dist/container.js.map

@@ -1 +1 @@
-{"mappings":"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","names":["application: {\n      registry: Registry\n      logger: Logger\n    }","scope: Exclude<Scope, Scope.Transient>","parent?: Container","dependencies: Dependencies","injectable: AnyInjectable","injectable: T","dependencies: T","dependant?: AnyInjectable","injections: Record<string, any>","resolvers: Promise<any>[]","instance: ResolveInjectableType<T>","left: Scope","operator: '>' | '<' | '>=' | '<=' | '=' | '!='","right: Scope","injectable: any","dependency: Depedency","label?: string","value: T","paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>","instance: P"],"sources":["src/container.ts"],"sourcesContent":["import { type Async, tryCaptureStackTrace } from '@nmtjs/common'\nimport {\n  kFactoryInjectable,\n  kInjectable,\n  kLazyInjectable,\n  kOptionalDependency,\n  kValueInjectable,\n} from './constants.ts'\nimport { Scope } from './enums.ts'\nimport type { Logger } from './logger.ts'\nimport type { Registry } from './registry.ts'\n\nconst ScopeStrictness = {\n  [Scope.Global]: 0,\n  [Scope.Connection]: 1,\n  [Scope.Call]: 2,\n  [Scope.Transient]: 3,\n}\n\nexport type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {\n  [kOptionalDependency]: any\n  injectable: T\n}\n\nexport type Depedency = DependencyOptional | AnyInjectable\n\nexport type Dependencies = Record<string, Depedency>\n\nexport type ResolveInjectableType<T extends AnyInjectable> =\n  T extends Injectable<infer Type, any, any> ? Type : never\n\nexport interface Dependant<Deps extends Dependencies = Dependencies> {\n  dependencies: Deps\n  label?: string\n  stack?: string\n}\n\nexport type DependencyInjectable<T extends Depedency> = T extends AnyInjectable\n  ? T\n  : T extends DependencyOptional\n    ? T['injectable']\n    : never\n\nexport type DependencyContext<Deps extends Dependencies> = {\n  readonly [K in keyof Deps as Deps[K] extends AnyInjectable\n    ? K\n    : never]: Deps[K] extends AnyInjectable\n    ? ResolveInjectableType<Deps[K]>\n    : never\n} & {\n  readonly [K in keyof Deps as Deps[K] extends DependencyOptional\n    ? K\n    : never]?: Deps[K] extends DependencyOptional\n    ? ResolveInjectableType<Deps[K]['injectable']>\n    : never\n}\n\nexport type InjectableFactoryType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>\n\nexport type InjectablePickType<Input, Output> = (injectable: Input) => Output\n\nexport type InjectableDisposeType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (\n  instance: InjectableType,\n  context: DependencyContext<InjectableDeps>,\n) => any\n\nexport interface LazyInjectable<T, S extends Scope = Scope.Global>\n  extends Dependant<{}> {\n  scope: S\n  [kInjectable]: any\n  [kLazyInjectable]: T\n}\n\nexport interface ValueInjectable<T> extends Dependant<{}> {\n  scope: Scope.Global\n  value: T\n  [kInjectable]: any\n  [kValueInjectable]: any\n}\n\nexport interface FactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n> extends Dependant<D> {\n  scope: S\n  factory: InjectableFactoryType<P, D>\n  pick: InjectablePickType<P, T>\n  dispose?: InjectableDisposeType<P, D>\n  [kInjectable]: any\n  [kFactoryInjectable]: any\n}\n\nexport type Injectable<\n  InjectableValue = any,\n  InjectableDeps extends Dependencies = {},\n  InjectableScope extends Scope = Scope,\n> =\n  | LazyInjectable<InjectableValue, InjectableScope>\n  | ValueInjectable<InjectableValue>\n  | FactoryInjectable<InjectableValue, InjectableDeps, InjectableScope, any>\n\nexport type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<\n  T,\n  any,\n  S\n>\n\nexport class Container {\n  readonly instances = new Map<\n    AnyInjectable,\n    { instance: any; picked: any; context: any }\n  >()\n  private readonly resolvers = new Map<AnyInjectable, Promise<any>>()\n  private readonly injectables = new Set<AnyInjectable>()\n  private readonly dependants = new Map<AnyInjectable, Set<AnyInjectable>>()\n\n  constructor(\n    private readonly application: {\n      registry: Registry\n      logger: Logger\n    },\n    public readonly scope: Exclude<Scope, Scope.Transient> = Scope.Global,\n    private readonly parent?: Container,\n  ) {\n    if ((scope as any) === Scope.Transient) {\n      throw new Error('Invalid scope')\n    }\n  }\n\n  async load() {\n    const traverse = (dependencies: Dependencies) => {\n      for (const key in dependencies) {\n        const dependency = dependencies[key]\n        const injectable = getDepedencencyInjectable(dependency)\n        this.injectables.add(injectable)\n        traverse(injectable.dependencies)\n      }\n    }\n\n    for (const dependant of this.application.registry.getDependants()) {\n      traverse(dependant.dependencies)\n    }\n\n    const injectables = Array.from(this.findCurrentScopeInjectables())\n    await Promise.all(injectables.map((injectable) => this.resolve(injectable)))\n  }\n\n  fork(scope: Exclude<Scope, Scope.Transient>) {\n    return new Container(this.application, scope, this)\n  }\n\n  async dispose() {\n    this.application.logger.trace('Disposing [%s] scope context...', this.scope)\n\n    // Loop through all instances and dispose them,\n    // until there are no more instances left\n    while (this.instances.size) {\n      for (const injectable of this.instances.keys()) {\n        const dependants = this.dependants.get(injectable)\n        // Firstly, dispose instances that other injectables don't depend on\n        if (!dependants?.size) {\n          await this.disposeInjectable(injectable)\n          for (const dependants of this.dependants.values()) {\n            // Clear current istances as a dependant for other injectables\n            if (dependants.has(injectable)) {\n              dependants.delete(injectable)\n            }\n          }\n        }\n      }\n    }\n\n    this.instances.clear()\n    this.injectables.clear()\n    this.resolvers.clear()\n    this.dependants.clear()\n  }\n\n  containsWithinSelf(injectable: AnyInjectable) {\n    return this.instances.has(injectable) || this.resolvers.has(injectable)\n  }\n\n  contains(injectable: AnyInjectable): boolean {\n    return (\n      this.containsWithinSelf(injectable) ||\n      (this.parent?.contains(injectable) ?? false)\n    )\n  }\n\n  get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T> {\n    if (this.instances.has(injectable)) {\n      return this.instances.get(injectable)!.instance\n    }\n\n    if (this.parent?.contains(injectable)) {\n      return this.parent.get(injectable)\n    }\n\n    throw new Error('No instance found')\n  }\n\n  resolve<T extends AnyInjectable>(injectable: T) {\n    return this.resolveInjectable(injectable)\n  }\n\n  async createContext<T extends Dependencies>(dependencies: T) {\n    return this.createInjectableContext(dependencies)\n  }\n\n  private async createInjectableContext<T extends Dependencies>(\n    dependencies: T,\n    dependant?: AnyInjectable,\n  ) {\n    const injections: Record<string, any> = {}\n    const deps = Object.entries(dependencies)\n    const resolvers: Promise<any>[] = Array(deps.length)\n    for (let i = 0; i < deps.length; i++) {\n      const [key, dependency] = deps[i]\n      const injectable = getDepedencencyInjectable(dependency)\n      const resolver = this.resolveInjectable(injectable, dependant)\n      resolvers[i] = resolver.then((value) => (injections[key] = value))\n    }\n    await Promise.all(resolvers)\n    return Object.freeze(injections) as DependencyContext<T>\n  }\n\n  async provide<T extends AnyInjectable>(\n    injectable: T,\n    instance: ResolveInjectableType<T>,\n  ) {\n    if (compareScope(injectable.scope, '>', this.scope)) {\n      throw new Error('Invalid scope') // TODO: more informative error\n    }\n    this.instances.set(injectable, {\n      instance,\n      picked: instance,\n      context: undefined,\n    })\n  }\n\n  satisfies(injectable: AnyInjectable) {\n    return compareScope(injectable.scope, '<=', this.scope)\n  }\n\n  private *findCurrentScopeInjectables() {\n    for (const injectable of this.injectables) {\n      if (injectable.scope === this.scope) {\n        yield injectable\n      }\n    }\n  }\n\n  private resolveInjectable<T extends AnyInjectable>(\n    injectable: T,\n    dependant?: AnyInjectable,\n  ): Promise<ResolveInjectableType<T>> {\n    if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {\n      // TODO: more informative error\n      throw new Error('Invalid scope: dependant is looser than injectable')\n    }\n\n    if (checkIsValueInjectable(injectable)) {\n      return Promise.resolve(injectable.value)\n    } else if (\n      this.parent?.contains(injectable) ||\n      (this.parent?.satisfies(injectable) &&\n        compareScope(this.parent.scope, '<', this.scope))\n    ) {\n      return this.parent.resolveInjectable(injectable, dependant)\n    } else {\n      const { scope, dependencies, stack, label } = injectable\n\n      if (dependant && compareScope(scope, '=', dependant.scope)) {\n        let dependants = this.dependants.get(injectable)\n        if (!dependants) {\n          this.dependants.set(injectable, (dependants = new Set()))\n        }\n        dependants.add(dependant)\n      }\n\n      if (this.instances.has(injectable)) {\n        return Promise.resolve(this.instances.get(injectable)!.picked)\n      } else if (this.resolvers.has(injectable)) {\n        return this.resolvers.get(injectable)!\n      } else {\n        const isLazy = checkIsLazyInjectable(injectable)\n\n        if (isLazy) {\n          const isOptional = checkIsOptional(injectable)\n          if (isOptional) return Promise.resolve(undefined as any)\n          return Promise.reject(\n            new Error(\n              `No instance provided for ${label || 'an'} injectable:\\n${stack}`,\n            ),\n          )\n        } else if (!checkIsFactoryInjectable(injectable)) {\n          throw new Error('Invalid injectable')\n        }\n\n        const resolution = this.createInjectableContext(\n          dependencies,\n          injectable,\n        )\n          .then((context) =>\n            Promise.resolve(injectable.factory(context)).then((instance) => ({\n              instance,\n              context,\n            })),\n          )\n          .then(({ instance, context }) => {\n            const picked = injectable.pick(instance)\n            if (compareScope(this.scope, '>=', scope))\n              this.instances.set(injectable, { instance, picked, context })\n            if (scope !== Scope.Transient) this.resolvers.delete(injectable)\n            return picked\n          })\n        if (scope !== Scope.Transient)\n          this.resolvers.set(injectable, resolution)\n        return resolution\n      }\n    }\n  }\n\n  private async disposeInjectable(injectable: AnyInjectable) {\n    try {\n      if (kFactoryInjectable in injectable) {\n        const { dispose } = injectable\n        if (dispose) {\n          const { instance, context } = this.instances.get(injectable)!\n          await dispose(instance, context)\n        }\n      }\n    } catch (cause) {\n      const error = new Error(\n        'Injectable disposal error. Potential memory leak',\n        { cause },\n      )\n      this.application.logger.error(error)\n    } finally {\n      this.instances.delete(injectable)\n    }\n  }\n}\n\nfunction compareScope(\n  left: Scope,\n  operator: '>' | '<' | '>=' | '<=' | '=' | '!=',\n  right: Scope,\n) {\n  const leftScope = ScopeStrictness[left]\n  const rightScope = ScopeStrictness[right]\n  switch (operator) {\n    case '=':\n      return leftScope === rightScope\n    case '!=':\n      return leftScope !== rightScope\n    case '>':\n      return leftScope > rightScope\n    case '<':\n      return leftScope < rightScope\n    case '>=':\n      return leftScope >= rightScope\n    case '<=':\n      return leftScope <= rightScope\n    default:\n      throw new Error('Invalid operator')\n  }\n}\n\nexport const checkIsLazyInjectable = (\n  injectable: any,\n): injectable is LazyInjectable<any> => kLazyInjectable in injectable\nexport const checkIsFactoryInjectable = (\n  injectable: any,\n): injectable is FactoryInjectable<any> => kFactoryInjectable in injectable\nexport const checkIsValueInjectable = (\n  injectable: any,\n): injectable is ValueInjectable<any> => kValueInjectable in injectable\nexport const checkIsInjectable = (\n  injectable: any,\n): injectable is AnyInjectable<any> => kInjectable in injectable\nexport const checkIsOptional = (\n  injectable: any,\n): injectable is DependencyOptional<any> => kOptionalDependency in injectable\n\nexport function getInjectableScope(injectable: AnyInjectable) {\n  let scope = injectable.scope\n  const deps = Object.values(injectable.dependencies as Dependencies)\n  for (const dependency of deps) {\n    const injectable = getDepedencencyInjectable(dependency)\n    const dependencyScope = getInjectableScope(injectable)\n    if (compareScope(dependencyScope, '>', scope)) {\n      scope = dependencyScope\n    }\n  }\n  return scope\n}\n\nexport function getDepedencencyInjectable(\n  dependency: Depedency,\n): AnyInjectable {\n  if (kOptionalDependency in dependency) {\n    return dependency.injectable\n  }\n  return dependency\n}\n\nexport function createOptionalInjectable<T extends AnyInjectable>(\n  injectable: T,\n) {\n  return {\n    [kOptionalDependency]: true,\n    injectable,\n  } as DependencyOptional<T>\n}\n\nexport function createLazyInjectable<T, S extends Scope = Scope.Global>(\n  scope = Scope.Global as S,\n  label?: string,\n): LazyInjectable<T, S> {\n  return Object.freeze({\n    scope,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(),\n    [kInjectable]: true,\n    [kLazyInjectable]: true as unknown as T,\n  })\n}\n\nexport function createValueInjectable<T>(\n  value: T,\n  label?: string,\n): ValueInjectable<T> {\n  return Object.freeze({\n    value,\n    scope: Scope.Global,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(),\n    [kInjectable]: true,\n    [kValueInjectable]: true,\n  })\n}\n\nexport function createFactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n>(\n  paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>,\n  label?: string,\n): FactoryInjectable<null extends T ? P : T, D, S, P> {\n  const isFactory = typeof paramsOrFactory === 'function'\n  const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory\n  const injectable = {\n    dependencies: (params.dependencies ?? {}) as D,\n    scope: (params.scope ?? Scope.Global) as S,\n    factory: params.factory,\n    dispose: params.dispose,\n    pick: params.pick ?? ((instance: P) => instance as unknown as T),\n    label,\n    stack: tryCaptureStackTrace(),\n    [kInjectable]: true,\n    [kFactoryInjectable]: true,\n  }\n  const actualScope = getInjectableScope(injectable)\n  if (\n    !isFactory &&\n    params.scope &&\n    ScopeStrictness[actualScope] > ScopeStrictness[params.scope]\n  )\n    throw new Error(\n      `Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`,\n    )\n  injectable.scope = actualScope as unknown as S\n  return Object.freeze(injectable) as any\n}\n"],"version":3}
+{"mappings":"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","names":["application: {\n      registry: Registry\n      logger: Logger\n    }","scope: Exclude<Scope, Scope.Transient>","parent?: Container","dependencies: Dependencies","injectable: AnyInjectable","injectable: T","dependencies: T","dependant?: AnyInjectable","injections: Record<string, any>","resolvers: Promise<any>[]","instance: ResolveInjectableType<T>","container: Container","context: InlineInjectionDependencies<T>"],"sources":["src/container.ts"],"sourcesContent":["import { Scope } from './enums.ts'\nimport {\n  type AnyInjectable,\n  CoreInjectables,\n  compareScope,\n  createValueInjectable,\n  type Dependencies,\n  type DependencyContext,\n  getDepedencencyInjectable,\n  isClassInjectable,\n  isFactoryInjectable,\n  isInjectable,\n  isLazyInjectable,\n  isOptionalInjectable,\n  isValueInjectable,\n  type ResolveInjectableType,\n} from './injectables.ts'\nimport type { Logger } from './logger.ts'\nimport type { Registry } from './registry.ts'\n\nexport class Container {\n  readonly instances = new Map<\n    AnyInjectable,\n    { instance: any; picked?: any; context?: any }\n  >()\n  private readonly resolvers = new Map<AnyInjectable, Promise<any>>()\n  private readonly injectables = new Set<AnyInjectable>()\n  private readonly dependants = new Map<AnyInjectable, Set<AnyInjectable>>()\n\n  constructor(\n    private readonly application: {\n      registry: Registry\n      logger: Logger\n    },\n    public readonly scope: Exclude<Scope, Scope.Transient> = Scope.Global,\n    private readonly parent?: Container,\n  ) {\n    if ((scope as any) === Scope.Transient) {\n      throw new Error('Invalid scope')\n    }\n    this.provide(CoreInjectables.inject, createInjectFunction(this))\n  }\n\n  async load() {\n    const traverse = (dependencies: Dependencies) => {\n      for (const key in dependencies) {\n        const dependency = dependencies[key]\n        const injectable = getDepedencencyInjectable(dependency)\n        this.injectables.add(injectable)\n        traverse(injectable.dependencies)\n      }\n    }\n\n    for (const dependant of this.application.registry.getDependants()) {\n      traverse(dependant.dependencies)\n    }\n\n    const injectables = Array.from(this.findCurrentScopeInjectables())\n    await Promise.all(injectables.map((injectable) => this.resolve(injectable)))\n  }\n\n  fork(scope: Exclude<Scope, Scope.Transient>) {\n    return new Container(this.application, scope, this)\n  }\n\n  async dispose() {\n    this.application.logger.trace('Disposing [%s] scope context...', this.scope)\n\n    // Loop through all instances and dispose them,\n    // until there are no more instances left\n    while (this.instances.size) {\n      for (const injectable of this.instances.keys()) {\n        const dependants = this.dependants.get(injectable)\n        // Firstly, dispose instances that other injectables don't depend on\n        if (!dependants?.size) {\n          await this.disposeInjectable(injectable)\n          for (const dependants of this.dependants.values()) {\n            // Clear current istances as a dependant for other injectables\n            if (dependants.has(injectable)) {\n              dependants.delete(injectable)\n            }\n          }\n        }\n      }\n    }\n\n    this.instances.clear()\n    this.injectables.clear()\n    this.resolvers.clear()\n    this.dependants.clear()\n  }\n\n  containsWithinSelf(injectable: AnyInjectable) {\n    return this.instances.has(injectable) || this.resolvers.has(injectable)\n  }\n\n  contains(injectable: AnyInjectable): boolean {\n    return (\n      this.containsWithinSelf(injectable) ||\n      (this.parent?.contains(injectable) ?? false)\n    )\n  }\n\n  get<T extends AnyInjectable>(injectable: T): ResolveInjectableType<T> {\n    if (this.instances.has(injectable)) {\n      return this.instances.get(injectable)!.instance\n    }\n\n    if (this.parent?.contains(injectable)) {\n      return this.parent.get(injectable)\n    }\n\n    throw new Error('No instance found')\n  }\n\n  resolve<T extends AnyInjectable>(injectable: T) {\n    return this.resolveInjectable(injectable)\n  }\n\n  async createContext<T extends Dependencies>(dependencies: T) {\n    return this.createInjectableContext(dependencies)\n  }\n\n  private async createInjectableContext<T extends Dependencies>(\n    dependencies: T,\n    dependant?: AnyInjectable,\n  ) {\n    const injections: Record<string, any> = {}\n    const deps = Object.entries(dependencies)\n    const resolvers: Promise<any>[] = Array(deps.length)\n    for (let i = 0; i < deps.length; i++) {\n      const [key, dependency] = deps[i]\n      const injectable = getDepedencencyInjectable(dependency)\n      const resolver = this.resolveInjectable(injectable, dependant)\n      resolvers[i] = resolver.then((value) => (injections[key] = value))\n    }\n    await Promise.all(resolvers)\n    return Object.freeze(injections) as DependencyContext<T>\n  }\n\n  async provide<T extends AnyInjectable>(\n    injectable: T,\n    instance: ResolveInjectableType<T>,\n  ) {\n    if (compareScope(injectable.scope, '>', this.scope)) {\n      throw new Error('Invalid scope') // TODO: more informative error\n    }\n    this.instances.set(injectable, {\n      instance,\n      picked: instance,\n      context: undefined,\n    })\n  }\n\n  satisfies(injectable: AnyInjectable) {\n    return compareScope(injectable.scope, '<=', this.scope)\n  }\n\n  private *findCurrentScopeInjectables() {\n    for (const injectable of this.injectables) {\n      if (injectable.scope === this.scope) {\n        yield injectable\n      }\n    }\n  }\n\n  private resolveInjectable<T extends AnyInjectable>(\n    injectable: T,\n    dependant?: AnyInjectable,\n  ): Promise<ResolveInjectableType<T>> {\n    if (dependant && compareScope(dependant.scope, '<', injectable.scope)) {\n      // TODO: more informative error\n      throw new Error('Invalid scope: dependant is looser than injectable')\n    }\n\n    if (isValueInjectable(injectable)) {\n      return Promise.resolve(injectable.value)\n    } else if (\n      this.parent?.contains(injectable) ||\n      (this.parent?.satisfies(injectable) &&\n        compareScope(this.parent.scope, '<', this.scope))\n    ) {\n      return this.parent.resolveInjectable(injectable, dependant)\n    } else {\n      const { scope, dependencies, stack, label } = injectable\n\n      if (dependant && compareScope(scope, '=', dependant.scope)) {\n        let dependants = this.dependants.get(injectable)\n        if (!dependants) {\n          this.dependants.set(injectable, (dependants = new Set()))\n        }\n        dependants.add(dependant)\n      }\n\n      if (this.instances.has(injectable)) {\n        return Promise.resolve(this.instances.get(injectable)!.picked)\n      } else if (this.resolvers.has(injectable)) {\n        return this.resolvers.get(injectable)!\n      } else {\n        const isLazy = isLazyInjectable(injectable)\n\n        if (isLazy) {\n          const isOptional = isOptionalInjectable(injectable)\n          if (isOptional) return Promise.resolve(undefined as any)\n          return Promise.reject(\n            new Error(\n              `No instance provided for ${label || 'an'} injectable:\\n${stack}`,\n            ),\n          )\n        } else if (isFactoryInjectable(injectable)) {\n          const resolution = this.createInjectableContext(\n            dependencies,\n            injectable,\n          )\n            .then((context) =>\n              Promise.resolve(injectable.factory(context)).then((instance) => ({\n                instance,\n                context,\n              })),\n            )\n            .then(({ instance, context }) => {\n              const picked = injectable.pick(instance)\n              if (compareScope(this.scope, '>=', scope))\n                this.instances.set(injectable, { instance, picked, context })\n              if (scope !== Scope.Transient) this.resolvers.delete(injectable)\n              return picked\n            })\n          if (scope !== Scope.Transient)\n            this.resolvers.set(injectable, resolution)\n          return resolution\n        } else if (isClassInjectable(injectable)) {\n          const resolution = this.createInjectableContext(\n            dependencies,\n            injectable,\n          )\n            .then((context) => {\n              const instance = new injectable(context)\n              return instance.$onCreate().then(() => instance)\n            })\n            .then((instance) => {\n              // const picked = injectable.pick(instance)\n              if (compareScope(this.scope, '>=', scope))\n                this.instances.set(injectable, {\n                  instance,\n                  picked: undefined,\n                  context: undefined,\n                })\n              if (scope !== Scope.Transient) this.resolvers.delete(injectable)\n              return instance\n            })\n          if (scope !== Scope.Transient)\n            this.resolvers.set(injectable, resolution)\n          return resolution\n        } else {\n          throw new Error('Invalid injectable type')\n        }\n      }\n    }\n  }\n\n  private async disposeInjectable(injectable: AnyInjectable) {\n    try {\n      if (isFactoryInjectable(injectable)) {\n        const { dispose } = injectable\n        if (dispose) {\n          const { instance, context } = this.instances.get(injectable)!\n          await dispose(instance, context)\n        }\n      } else if (isClassInjectable(injectable)) {\n        const { instance } = this.instances.get(injectable)!\n        await instance.$onDispose()\n      }\n    } catch (cause) {\n      const error = new Error(\n        'Injectable disposal error. Potential memory leak',\n        { cause },\n      )\n      this.application.logger.error(error)\n    } finally {\n      this.instances.delete(injectable)\n    }\n  }\n}\n\nexport function createInjectFunction(container: Container) {\n  return <T extends AnyInjectable>(\n    injectable: T,\n    context: InlineInjectionDependencies<T>,\n  ) => {\n    const dependencies: Dependencies = {}\n\n    for (const key in context) {\n      const dep = context[key]\n      if (isInjectable(dep) || isOptionalInjectable(dep)) {\n        dependencies[key] = dep\n      } else {\n        dependencies[key] = createValueInjectable(dep)\n      }\n    }\n\n    const newInjectable = {\n      ...injectable,\n      dependencies,\n      scope: Scope.Transient,\n    }\n\n    return container.resolve(newInjectable)\n  }\n}\n\ntype InlineInjectionDependencies<T extends AnyInjectable> = {\n  [K in keyof T['dependencies']]:\n    | ResolveInjectableType<T['dependencies'][K]>\n    | AnyInjectable<ResolveInjectableType<T['dependencies'][K]>>\n}\n\nexport type InjectFn = ReturnType<typeof createInjectFunction>\n"],"version":3}

package/dist/injectables.js

@@ -1,4 +1,172 @@
-import { createLazyInjectable } from "./container.js";
+import { tryCaptureStackTrace } from "@nmtjs/common";
+import { kClassInjectable, kFactoryInjectable, kInjectable, kLazyInjectable, kOptionalDependency, kValueInjectable } from "./constants.js";
 import { Scope } from "./enums.js";
-const logger = createLazyInjectable(Scope.Global, "Logger");
-export const CoreInjectables = { logger };
+const ScopeStrictness = {
+	[Scope.Global]: 0,
+	[Scope.Connection]: 1,
+	[Scope.Call]: 2,
+	[Scope.Transient]: 3
+};
+export const isLazyInjectable = (injectable) => kLazyInjectable in injectable;
+export const isFactoryInjectable = (injectable) => kFactoryInjectable in injectable;
+export const isClassInjectable = (injectable) => kClassInjectable in injectable;
+export const isValueInjectable = (injectable) => kValueInjectable in injectable;
+export const isInjectable = (injectable) => kInjectable in injectable;
+export const isOptionalInjectable = (injectable) => kOptionalDependency in injectable;
+export function getInjectableScope(injectable) {
+	let scope = injectable.scope;
+	const deps = Object.values(injectable.dependencies);
+	for (const dependency of deps) {
+		const injectable = getDepedencencyInjectable(dependency);
+		const dependencyScope = getInjectableScope(injectable);
+		if (compareScope(dependencyScope, ">", scope)) {
+			scope = dependencyScope;
+		}
+	}
+	return scope;
+}
+export function getDepedencencyInjectable(dependency) {
+	if (kOptionalDependency in dependency) {
+		return dependency.injectable;
+	}
+	return dependency;
+}
+export function createOptionalInjectable(injectable) {
+	return {
+		[kOptionalDependency]: true,
+		injectable
+	};
+}
+export function createLazyInjectable(scope = Scope.Global, label, stackTraceDepth = 0) {
+	return Object.freeze({
+		scope,
+		dependencies: {},
+		label,
+		stack: tryCaptureStackTrace(stackTraceDepth),
+		[kInjectable]: true,
+		[kLazyInjectable]: true
+	});
+}
+export function createValueInjectable(value, label, stackTraceDepth = 0) {
+	return Object.freeze({
+		value,
+		scope: Scope.Global,
+		dependencies: {},
+		label,
+		stack: tryCaptureStackTrace(stackTraceDepth),
+		[kInjectable]: true,
+		[kValueInjectable]: true
+	});
+}
+export function createFactoryInjectable(paramsOrFactory, label, stackTraceDepth = 0) {
+	const isFactory = typeof paramsOrFactory === "function";
+	const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory;
+	const injectable = {
+		dependencies: params.dependencies ?? {},
+		scope: params.scope ?? Scope.Global,
+		factory: params.factory,
+		dispose: params.dispose,
+		pick: params.pick ?? ((instance) => instance),
+		label,
+		stack: tryCaptureStackTrace(stackTraceDepth),
+		[kInjectable]: true,
+		[kFactoryInjectable]: true
+	};
+	const actualScope = getInjectableScope(injectable);
+	if (!isFactory && params.scope && ScopeStrictness[actualScope] > ScopeStrictness[params.scope]) throw new Error(`Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`);
+	injectable.scope = actualScope;
+	return Object.freeze(injectable);
+}
+export const createClassInjectable = (dependencies = {}, scope = Scope.Global, stackTraceDepth = 0) => {
+	const klass = class {
+		static dependencies = dependencies;
+		static scope = scope;
+		static stack = tryCaptureStackTrace(stackTraceDepth + 2);
+		static [kInjectable] = true;
+		static [kClassInjectable] = true;
+		static get label() {
+			return this.name;
+		}
+		constructor($context) {
+			this.$context = $context;
+		}
+		async $onCreate() {}
+		async $onDispose() {}
+	};
+	return klass;
+};
+export function createExtendableClassInjectable(baseClass, dependencies = {}, scope = Scope.Global, stackTraceDepth = 0) {
+	if (isClassInjectable(baseClass)) {
+		dependencies = Object.assign({}, baseClass.dependencies, dependencies);
+		if (compareScope(scope, "<", baseClass.scope)) {
+			throw new Error("Invalid scope for injectable: base class has stricter scope");
+		}
+	}
+	return class extends baseClass {
+		static dependencies = dependencies;
+		static scope = scope;
+		static stack = tryCaptureStackTrace(stackTraceDepth);
+		static [kInjectable] = true;
+		static [kClassInjectable] = true;
+		static get label() {
+			return this.name;
+		}
+		$context;
+		constructor(...args) {
+			const [$context, ...baseClassArgs] = args;
+			if (isClassInjectable(baseClass)) {
+				super($context);
+			} else {
+				super(...baseClassArgs);
+				this.$context = $context;
+			}
+		}
+		async $onCreate() {
+			await super.$onCreate?.();
+		}
+		async $onDispose() {
+			await super.$onDispose?.();
+		}
+	};
+}
+export function substitute(injectable, substitution, stackTraceDepth = 0) {
+	const dependencies = { ...injectable.dependencies };
+	const depth = stackTraceDepth + 1;
+	for (const key in substitution) {
+		const value = substitution[key];
+		if (key in dependencies) {
+			const original = dependencies[key];
+			if (isInjectable(value)) {
+				dependencies[key] = value;
+			} else if (isClassInjectable(original) || isFactoryInjectable(original)) {
+				dependencies[key] = substitute(original, value, depth);
+			}
+		}
+	}
+	if (isClassInjectable(injectable)) {
+		return createExtendableClassInjectable(injectable, dependencies, injectable.scope, depth);
+	} else if (isFactoryInjectable(injectable)) {
+		return createFactoryInjectable({
+			...injectable,
+			dependencies
+		}, injectable.label, depth);
+	}
+	throw new Error("Invalid injectable type");
+}
+export function compareScope(left, operator, right) {
+	const leftScope = ScopeStrictness[left];
+	const rightScope = ScopeStrictness[right];
+	switch (operator) {
+		case "=": return leftScope === rightScope;
+		case "!=": return leftScope !== rightScope;
+		case ">": return leftScope > rightScope;
+		case "<": return leftScope < rightScope;
+		case ">=": return leftScope >= rightScope;
+		case "<=": return leftScope <= rightScope;
+		default: throw new Error("Invalid operator");
+	}
+}
+export const CoreInjectables = {
+	logger: createLazyInjectable(Scope.Global, "Logger"),
+	inject: createLazyInjectable(Scope.Global, "Inject function")
+};

package/dist/injectables.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAAS,4BAA4B,gBAAgB;AACrD,SAAS,aAAa,YAAY;AAGlC,MAAM,SAAS,qBAA6B,MAAM,QAAQ,SAAS;AAEnE,OAAO,MAAM,kBAAkB,EAAE,OAAQ","names":[],"sources":["src/injectables.ts"],"sourcesContent":["import { createLazyInjectable } from './container.ts'\nimport { Scope } from './enums.ts'\nimport type { Logger } from './logger.ts'\n\nconst logger = createLazyInjectable<Logger>(Scope.Global, 'Logger')\n\nexport const CoreInjectables = { logger }\n"],"version":3}
+{"mappings":"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","names":["injectable: any","injectable: AnyInjectable","dependency: Depedency","injectable: T","label?: string","value: T","paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>","instance: P","dependencies: D","scope: S","$context: DependencyContext<D>","baseClass: B","substitution: DependenciesSubstitution<T['dependencies']>","left: Scope","operator: '>' | '<' | '>=' | '<=' | '=' | '!='","right: Scope"],"sources":["src/injectables.ts"],"sourcesContent":["import {\n  type Async,\n  type ClassConstructor,\n  type ClassConstructorArgs,\n  type ClassInstance,\n  tryCaptureStackTrace,\n} from '@nmtjs/common'\nimport {\n  kClassInjectable,\n  kFactoryInjectable,\n  kInjectable,\n  kLazyInjectable,\n  kOptionalDependency,\n  kValueInjectable,\n} from './constants.ts'\nimport type { InjectFn } from './container.ts'\nimport { Scope } from './enums.ts'\nimport type { Logger } from './logger.ts'\n\nconst ScopeStrictness = {\n  [Scope.Global]: 0,\n  [Scope.Connection]: 1,\n  [Scope.Call]: 2,\n  [Scope.Transient]: 3,\n}\n\nexport type DependencyOptional<T extends AnyInjectable = AnyInjectable> = {\n  [kOptionalDependency]: any\n  injectable: T\n}\n\nexport type Depedency = DependencyOptional | AnyInjectable\n\nexport type Dependencies = Record<string, Depedency>\n\nexport type ResolveInjectableType<T extends AnyInjectable> =\n  T extends Injectable<infer Type, any, any> ? Type : never\n\nexport interface Dependant<Deps extends Dependencies = Dependencies> {\n  dependencies: Deps\n  label?: string\n  stack?: string\n}\n\nexport type DependencyInjectable<T extends Depedency> = T extends AnyInjectable\n  ? T\n  : T extends DependencyOptional\n    ? T['injectable']\n    : never\n\nexport type DependencyContext<Deps extends Dependencies> = {\n  readonly [K in keyof Deps as Deps[K] extends AnyInjectable\n    ? K\n    : never]: Deps[K] extends AnyInjectable\n    ? ResolveInjectableType<Deps[K]>\n    : never\n} & {\n  readonly [K in keyof Deps as Deps[K] extends DependencyOptional\n    ? K\n    : never]?: Deps[K] extends DependencyOptional\n    ? ResolveInjectableType<Deps[K]['injectable']>\n    : never\n}\n\nexport type InjectableFactoryType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (context: DependencyContext<InjectableDeps>) => Async<InjectableType>\n\nexport type InjectablePickType<Input, Output> = (injectable: Input) => Output\n\nexport type InjectableDisposeType<\n  InjectableType,\n  InjectableDeps extends Dependencies,\n> = (\n  instance: InjectableType,\n  context: DependencyContext<InjectableDeps>,\n) => any\n\nexport interface LazyInjectable<T, S extends Scope = Scope.Global>\n  extends Dependant<{}> {\n  scope: S\n  [kInjectable]: any\n  [kLazyInjectable]: T\n}\n\nexport interface ValueInjectable<T> extends Dependant<{}> {\n  scope: Scope.Global\n  value: T\n  [kInjectable]: any\n  [kValueInjectable]: any\n}\n\nexport interface FactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n> extends Dependant<D> {\n  scope: S\n  factory: InjectableFactoryType<P, D>\n  pick: InjectablePickType<P, T>\n  dispose?: InjectableDisposeType<P, D>\n  [kInjectable]: any\n  [kFactoryInjectable]: any\n}\n\nexport interface BaseClassInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n> extends Dependant<D> {\n  new (...args: any[]): T\n  scope: S\n  [kInjectable]: any\n  [kClassInjectable]: any\n}\n\nexport interface ClassInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  A extends any[] = [],\n> extends Dependant<D> {\n  new (\n    $context: DependencyContext<D>,\n    ...args: A\n  ): T & {\n    $context: DependencyContext<D>\n  }\n  scope: S\n  [kInjectable]: any\n  [kClassInjectable]: any\n}\n\nexport type Injectable<\n  V = any,\n  D extends Dependencies = {},\n  S extends Scope = Scope,\n> =\n  | LazyInjectable<V, S>\n  | ValueInjectable<V>\n  | FactoryInjectable<V, D, S, any>\n  | BaseClassInjectable<V, D, S>\n\nexport type AnyInjectable<T = any, S extends Scope = Scope> = Injectable<\n  T,\n  any,\n  S\n>\n\nexport const isLazyInjectable = (\n  injectable: any,\n): injectable is LazyInjectable<any> => kLazyInjectable in injectable\nexport const isFactoryInjectable = (\n  injectable: any,\n): injectable is FactoryInjectable<any> => kFactoryInjectable in injectable\nexport const isClassInjectable = (\n  injectable: any,\n): injectable is ClassInjectable<any> => kClassInjectable in injectable\nexport const isValueInjectable = (\n  injectable: any,\n): injectable is ValueInjectable<any> => kValueInjectable in injectable\nexport const isInjectable = (\n  injectable: any,\n): injectable is AnyInjectable<any> => kInjectable in injectable\nexport const isOptionalInjectable = (\n  injectable: any,\n): injectable is DependencyOptional<any> => kOptionalDependency in injectable\n\nexport function getInjectableScope(injectable: AnyInjectable) {\n  let scope = injectable.scope\n  const deps = Object.values(injectable.dependencies as Dependencies)\n  for (const dependency of deps) {\n    const injectable = getDepedencencyInjectable(dependency)\n    const dependencyScope = getInjectableScope(injectable)\n    if (compareScope(dependencyScope, '>', scope)) {\n      scope = dependencyScope\n    }\n  }\n  return scope\n}\n\nexport function getDepedencencyInjectable(\n  dependency: Depedency,\n): AnyInjectable {\n  if (kOptionalDependency in dependency) {\n    return dependency.injectable\n  }\n  return dependency\n}\n\nexport function createOptionalInjectable<T extends AnyInjectable>(\n  injectable: T,\n) {\n  return {\n    [kOptionalDependency]: true,\n    injectable,\n  } as DependencyOptional<T>\n}\n\nexport function createLazyInjectable<T, S extends Scope = Scope.Global>(\n  scope = Scope.Global as S,\n  label?: string,\n  stackTraceDepth = 0,\n): LazyInjectable<T, S> {\n  return Object.freeze({\n    scope,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kLazyInjectable]: true as unknown as T,\n  })\n}\n\nexport function createValueInjectable<T>(\n  value: T,\n  label?: string,\n  stackTraceDepth = 0,\n): ValueInjectable<T> {\n  return Object.freeze({\n    value,\n    scope: Scope.Global,\n    dependencies: {},\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kValueInjectable]: true,\n  })\n}\n\nexport function createFactoryInjectable<\n  T,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n  P = T,\n>(\n  paramsOrFactory:\n    | {\n        dependencies?: D\n        scope?: S\n        pick?: InjectablePickType<P, T>\n        factory: InjectableFactoryType<P, D>\n        dispose?: InjectableDisposeType<P, D>\n      }\n    | InjectableFactoryType<P, D>,\n  label?: string,\n  stackTraceDepth = 0,\n): FactoryInjectable<null extends T ? P : T, D, S, P> {\n  const isFactory = typeof paramsOrFactory === 'function'\n  const params = isFactory ? { factory: paramsOrFactory } : paramsOrFactory\n  const injectable = {\n    dependencies: (params.dependencies ?? {}) as D,\n    scope: (params.scope ?? Scope.Global) as S,\n    factory: params.factory,\n    dispose: params.dispose,\n    pick: params.pick ?? ((instance: P) => instance as unknown as T),\n    label,\n    stack: tryCaptureStackTrace(stackTraceDepth),\n    [kInjectable]: true,\n    [kFactoryInjectable]: true,\n  }\n  const actualScope = getInjectableScope(injectable)\n  if (\n    !isFactory &&\n    params.scope &&\n    ScopeStrictness[actualScope] > ScopeStrictness[params.scope]\n  )\n    throw new Error(\n      `Invalid scope ${params.scope} for factory injectable: dependencies have stricter scope - ${actualScope}`,\n    )\n  injectable.scope = actualScope as unknown as S\n  return Object.freeze(injectable) as any\n}\n\nexport const createClassInjectable = <\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n>(\n  dependencies: D = {} as D,\n  scope: S = Scope.Global as S,\n  stackTraceDepth = 0,\n): ClassInjectable<ClassInstance<typeof klass>, D, S> => {\n  const klass = class {\n    static dependencies = dependencies\n    static scope = scope\n    static stack = tryCaptureStackTrace(stackTraceDepth + 2)\n    static [kInjectable] = true\n    static [kClassInjectable] = true\n\n    static get label() {\n      // biome-ignore lint/complexity/noThisInStatic:\n      return this.name\n    }\n\n    constructor(public $context: DependencyContext<D>) {}\n\n    protected async $onCreate() {}\n    protected async $onDispose() {}\n  }\n  return klass\n}\n\nexport function createExtendableClassInjectable<\n  B extends ClassConstructor<any>,\n  D extends Dependencies = {},\n  S extends Scope = Scope.Global,\n>(\n  baseClass: B,\n  dependencies: D = {} as D,\n  scope: S = Scope.Global as S,\n  stackTraceDepth = 0,\n): B extends ClassInjectable<any>\n  ? ClassInjectable<ClassInstance<B>, D, S>\n  : ClassInjectable<ClassInstance<B>, D, S, ClassConstructorArgs<B, []>> {\n  if (isClassInjectable(baseClass)) {\n    dependencies = Object.assign({}, baseClass.dependencies, dependencies)\n    if (compareScope(scope, '<', baseClass.scope)) {\n      throw new Error(\n        'Invalid scope for injectable: base class has stricter scope',\n      )\n    }\n  }\n  // @ts-expect-error\n  return class extends baseClass {\n    static dependencies = dependencies\n    static scope = scope\n    static stack = tryCaptureStackTrace(stackTraceDepth)\n    static [kInjectable] = true\n    static [kClassInjectable] = true\n\n    static get label() {\n      // biome-ignore lint/complexity/noThisInStatic:\n      return this.name\n    }\n\n    $context!: DependencyContext<D>\n\n    constructor(...args: any[]) {\n      const [$context, ...baseClassArgs] = args\n      if (isClassInjectable(baseClass)) {\n        super($context)\n      } else {\n        super(...baseClassArgs)\n        this.$context = $context\n      }\n    }\n\n    protected async $onCreate() {\n      await super.$onCreate?.()\n    }\n\n    protected async $onDispose() {\n      await super.$onDispose?.()\n    }\n  }\n}\n\nexport type DependenciesSubstitution<T extends Dependencies> = {\n  [K in keyof T]?: T[K] extends AnyInjectable<infer Type>\n    ? AnyInjectable<Type> | DependenciesSubstitution<T[K]['dependencies']>\n    : never\n}\n\nexport function substitute<\n  T extends\n    | FactoryInjectable<any, any, Scope>\n    | BaseClassInjectable<any, any, Scope>,\n>(\n  injectable: T,\n  substitution: DependenciesSubstitution<T['dependencies']>,\n  stackTraceDepth = 0,\n): T {\n  const dependencies = { ...injectable.dependencies }\n  const depth = stackTraceDepth + 1\n  for (const key in substitution) {\n    const value = substitution[key]!\n    if (key in dependencies) {\n      const original = dependencies[key]\n      if (isInjectable(value)) {\n        dependencies[key] = value\n      } else if (isClassInjectable(original) || isFactoryInjectable(original)) {\n        dependencies[key] = substitute(original, value, depth)\n      }\n    }\n  }\n\n  if (isClassInjectable(injectable)) {\n    // @ts-expect-error\n    return createExtendableClassInjectable(\n      injectable,\n      dependencies,\n      injectable.scope,\n      depth,\n    )\n  } else if (isFactoryInjectable(injectable)) {\n    // @ts-expect-error\n    return createFactoryInjectable(\n      {\n        ...injectable,\n        dependencies,\n      },\n      injectable.label,\n      depth,\n    )\n  }\n\n  throw new Error('Invalid injectable type')\n}\n\nexport function compareScope(\n  left: Scope,\n  operator: '>' | '<' | '>=' | '<=' | '=' | '!=',\n  right: Scope,\n) {\n  const leftScope = ScopeStrictness[left]\n  const rightScope = ScopeStrictness[right]\n  switch (operator) {\n    case '=':\n      return leftScope === rightScope\n    case '!=':\n      return leftScope !== rightScope\n    case '>':\n      return leftScope > rightScope\n    case '<':\n      return leftScope < rightScope\n    case '>=':\n      return leftScope >= rightScope\n    case '<=':\n      return leftScope <= rightScope\n    default:\n      throw new Error('Invalid operator')\n  }\n}\n\nexport const CoreInjectables = {\n  logger: createLazyInjectable<Logger>(Scope.Global, 'Logger'),\n  inject: createLazyInjectable<InjectFn>(Scope.Global, 'Inject function'),\n}\n"],"version":3}

package/dist/registry.js

@@ -1,6 +1,6 @@
-import { getInjectableScope } from "./container.js";
 import { Scope } from "./enums.js";
 import { Hooks } from "./hooks.js";
+import { getInjectableScope } from "./injectables.js";
 export class Registry {
 	hooks = new Hooks();
 	constructor(application) {

package/dist/registry.js.map

@@ -1 +1 @@
-{"mappings":"AAAA,SAGE,0BACK,gBAAgB;AACvB,SAAoB,aAAa,YAAY;AAC7C,SAAS,aAA4B,YAAY;AAGjD,OAAO,MAAM,SAAS;CACpB,AAAS,QAAQ,IAAI;CAErB,YACqBA,aAGnB;OAHmB;CAGjB;CAEJ,cAA+BC,OAAU;AACvC,QAAM,MAAM,OAAO,KAAK,MAAM;CAC/B;CAED,aAA6BC,MAASC,UAAuB;AAC3D,OAAK,MAAM,IAAI,MAAM,SAAS;CAC/B;CAED,CAAC,gBAAsC,CAAE;CAEzC,QAAQ;AACN,OAAK,MAAM,OAAO;CACnB;AACF;AAED,OAAO,MAAM,oBAAoB,CAAC,MAAM,QAAQ,MAAM,YACnD,EAAE,KAAK,aAAa,MAAM;AAE7B,OAAO,SAAS,oBACdC,aACA,QAAQ,MAAM,QACd;AACA,QAAO,YAAY,KACjB,CAAC,eAAe,mBAAmB,WAAW,KAAK,MACpD;AACF","names":["application: {\n      logger: Logger\n    }","hooks: T","name: T","callback: HookType[T]","injectables: AnyInjectable[]"],"sources":["src/registry.ts"],"sourcesContent":["import {\n  type AnyInjectable,\n  type Dependant,\n  getInjectableScope,\n} from './container.ts'\nimport { type Hook, Scope } from './enums.ts'\nimport { Hooks, type HookType } from './hooks.ts'\nimport type { Logger } from './logger.ts'\n\nexport class Registry {\n  readonly hooks = new Hooks()\n\n  constructor(\n    protected readonly application: {\n      logger: Logger\n    },\n  ) {}\n\n  registerHooks<T extends Hooks>(hooks: T) {\n    Hooks.merge(hooks, this.hooks)\n  }\n\n  registerHook<T extends Hook>(name: T, callback: HookType[T]) {\n    this.hooks.add(name, callback)\n  }\n\n  *getDependants(): Generator<Dependant> {}\n\n  clear() {\n    this.hooks.clear()\n  }\n}\n\nexport const scopeErrorMessage = (name, scope = Scope.Global) =>\n  `${name} must be a ${scope} scope (including all nested dependencies)`\n\nexport function hasInvalidScopeDeps(\n  injectables: AnyInjectable[],\n  scope = Scope.Global,\n) {\n  return injectables.some(\n    (injectable) => getInjectableScope(injectable) !== scope,\n  )\n}\n"],"version":3}
+{"mappings":"AAAA,SAAoB,aAAa,YAAY;AAC7C,SAAS,aAA4B,YAAY;AACjD,SAGE,0BACK,kBAAkB;AAGzB,OAAO,MAAM,SAAS;CACpB,AAAS,QAAQ,IAAI;CAErB,YACqBA,aAGnB;OAHmB;CAGjB;CAEJ,cAA+BC,OAAU;AACvC,QAAM,MAAM,OAAO,KAAK,MAAM;CAC/B;CAED,aAA6BC,MAASC,UAAuB;AAC3D,OAAK,MAAM,IAAI,MAAM,SAAS;CAC/B;CAED,CAAC,gBAAsC,CAAE;CAEzC,QAAQ;AACN,OAAK,MAAM,OAAO;CACnB;AACF;AAED,OAAO,MAAM,oBAAoB,CAAC,MAAM,QAAQ,MAAM,YACnD,EAAE,KAAK,aAAa,MAAM;AAE7B,OAAO,SAAS,oBACdC,aACA,QAAQ,MAAM,QACd;AACA,QAAO,YAAY,KACjB,CAAC,eAAe,mBAAmB,WAAW,KAAK,MACpD;AACF","names":["application: {\n      logger: Logger\n    }","hooks: T","name: T","callback: HookType[T]","injectables: AnyInjectable[]"],"sources":["src/registry.ts"],"sourcesContent":["import { type Hook, Scope } from './enums.ts'\nimport { Hooks, type HookType } from './hooks.ts'\nimport {\n  type AnyInjectable,\n  type Dependant,\n  getInjectableScope,\n} from './injectables.ts'\nimport type { Logger } from './logger.ts'\n\nexport class Registry {\n  readonly hooks = new Hooks()\n\n  constructor(\n    protected readonly application: {\n      logger: Logger\n    },\n  ) {}\n\n  registerHooks<T extends Hooks>(hooks: T) {\n    Hooks.merge(hooks, this.hooks)\n  }\n\n  registerHook<T extends Hook>(name: T, callback: HookType[T]) {\n    this.hooks.add(name, callback)\n  }\n\n  *getDependants(): Generator<Dependant> {}\n\n  clear() {\n    this.hooks.clear()\n  }\n}\n\nexport const scopeErrorMessage = (name, scope = Scope.Global) =>\n  `${name} must be a ${scope} scope (including all nested dependencies)`\n\nexport function hasInvalidScopeDeps(\n  injectables: AnyInjectable[],\n  scope = Scope.Global,\n) {\n  return injectables.some(\n    (injectable) => getInjectableScope(injectable) !== scope,\n  )\n}\n"],"version":3}

package/package.json

@@ -10,8 +10,8 @@
   "dependencies": {
     "pino": "^9.6.0",
     "pino-pretty": "^11.3.0",
-    "@nmtjs/type": "0.7.3",
-    "@nmtjs/common": "0.7.3"
+    "@nmtjs/common": "0.7.5",
+    "@nmtjs/type": "0.7.5"
   },
   "devDependencies": {
     "@types/node": "^20.17.30"
@@ -22,7 +22,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.7.3",
+  "version": "0.7.5",
   "scripts": {
     "build": "neemata-build --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/constants.ts

@@ -23,6 +23,11 @@ export const kFactoryInjectable: unique symbol = Symbol.for(
 )
 export type kFactoryInjectable = typeof kFactoryInjectable
 
+export const kClassInjectable: unique symbol = Symbol.for(
+  'neemata:ClassInjectableKey',
+)
+export type kClassInjectable = typeof kClassInjectable
+
 export const kProvider: unique symbol = Symbol.for('neemata:ProviderKey')
 export type kProvider = typeof kProvider