@travetto/di 6.0.1 → 7.0.0-rc.1

package/README.md

@@ -16,7 +16,7 @@ yarn add @travetto/di
 [Dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) is a framework primitive.  When used in conjunction with automatic file scanning, it provides for handling of application dependency wiring. Due to the nature of [Typescript](https://typescriptlang.org) and type erasure of interfaces, dependency injection only supports `class`es as a type signifier. The primary goal of dependency injection is to allow for separation of concerns of object creation and it's usage.
 
 ## Declaration
-The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) and [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L70) decorators provide the registration of dependencies.   Dependency declaration revolves around exposing `class`es and subtypes thereof to provide necessary functionality.  Additionally, the framework will utilize dependencies to satisfy contracts with various implementation.
+The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) and [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L47) decorators provide the registration of dependencies.   Dependency declaration revolves around exposing `class`es and subtypes thereof to provide necessary functionality.  Additionally, the framework will utilize dependencies to satisfy contracts with various implementation.
 
 **Code: Example Injectable**
 ```typescript
@@ -77,7 +77,7 @@ class SpecificService extends BaseService {
 }
 ```
 
-In this scenario, `SpecificService` is a valid candidate for `BaseService` due to the abstract inheritance. Sometimes, you may want to provide a slight variation to  a dependency without extending a class.  To this end, the [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L70) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29).
+In this scenario, `SpecificService` is a valid candidate for `BaseService` due to the abstract inheritance. Sometimes, you may want to provide a slight variation to  a dependency without extending a class.  To this end, the [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L47) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15).
 
 **Code: Example InjectableFactory**
 ```typescript
@@ -125,12 +125,12 @@ class RuntimeService {
 
 In this example, the enabled flag is specified in relationship to the deployment environment.  When coupled with optional properties, and optional chaining, allows for seamless inclusion of optional dependencies at runtime.
 
-**Note**: Other modules are able to provide aliases to [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) that also provide additional functionality.  For example, the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") module @Config or the [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") module @Controller decorator registers the associated class as an injectable element.
+**Note**: Other modules are able to provide aliases to [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) that also provide additional functionality.  For example, the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") module @Config or the [Web API](https://github.com/travetto/travetto/tree/main/module/web#readme "Declarative support for creating Web Applications") module @Controller decorator registers the associated class as an injectable element.
 
 ## Injection
-Once all of your necessary dependencies are defined, now is the time to provide those [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) instances to your code.  There are three primary methods for injection: 
+Once all of your necessary dependencies are defined, now is the time to provide those [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) instances to your code.  There are three primary methods for injection: 
 
-The [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) decorator, which denotes a desire to inject a value directly.  These will be set post construction. 
+The [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) decorator, which denotes a desire to inject a value directly.  These will be set post construction. 
 
 **Code: Example Injectable with dependencies as Inject fields**
 ```typescript
@@ -148,7 +148,7 @@ class CustomService {
 }
 ```
 
-The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) constructor params, which will be provided as the instance is being constructed.
+The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) constructor params, which will be provided as the instance is being constructed.
 
 **Code: Example Injectable with dependencies in constructor**
 ```typescript
@@ -170,7 +170,7 @@ class CustomService {
 }
 ```
 
-Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L70) params, which are comparable to constructor params
+Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L47) params, which are comparable to constructor params
 
 **Code: Example InjectableFactory with parameters as dependencies**
 ```typescript
@@ -228,9 +228,9 @@ class Config {
 ```
 
 ## Non-Framework Dependencies
-The module is built around the framework's management of class registration, and being able to decorate the code with [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) decorators. There may also be a desire to leverage external code and pull it into the dependency injection framework.  This could easily be achieved using a wrapper class that is owned by the framework. 
+The module is built around the framework's management of class registration, and being able to decorate the code with [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) decorators. There may also be a desire to leverage external code and pull it into the dependency injection framework.  This could easily be achieved using a wrapper class that is owned by the framework. 
 
-It is also possible to directly reference external types, and they will be converted into unique symbols.  These symbols cannot be used manually, but can be leveraged using [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) decorators.
+It is also possible to directly reference external types, and they will be converted into unique symbols.  These symbols cannot be used manually, but can be leveraged using [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L15) decorators.
 
 **Code: Example External Dependencies**
 ```typescript
@@ -268,18 +268,18 @@ class Service {
 ```
 
 ## Manual Invocation
-Some times you will need to lookup a dependency dynamically, or you want to control the injection process at a more granular level. To achieve that you will need to directly access the [DependencyRegistry](https://github.com/travetto/travetto/tree/main/module/di/src/registry.ts#L25). The registry allows for requesting a dependency by class reference:
+Some times you will need to lookup a dependency dynamically, or you want to control the injection process at a more granular level. To achieve that you will need to directly access the [DependencyRegistryIndex](https://github.com/travetto/travetto/tree/main/module/di/src/registry/registry-index.ts#L19). The registry allows for requesting a dependency by class reference:
 
 **Code: Example of Manual Lookup**
 ```typescript
-import { Injectable, DependencyRegistry } from '@travetto/di';
+import { Injectable, DependencyRegistryIndex } from '@travetto/di';
 
 @Injectable()
 class Complex { }
 
 class ManualLookup {
   async invoke() {
-    const complex = await DependencyRegistry.getInstance(Complex);
+    const complex = await DependencyRegistryIndex.getInstance(Complex);
     return complex;
   }
 }
@@ -289,7 +289,7 @@ Additionally, support for interfaces (over class inheritance) is provided, but r
 
 **Code: Example Interface Injection**
 ```typescript
-import { DependencyRegistry, Inject, Injectable, InjectableFactory } from '@travetto/di';
+import { DependencyRegistryIndex, Inject, Injectable, InjectableFactory } from '@travetto/di';
 import { toConcrete } from '@travetto/runtime';
 
 /**
@@ -315,7 +315,7 @@ class SpecificService {
 class ManualInvocationOfInterface {
   @InjectableFactory()
   static getCustomService(): Promise<ServiceContract> {
-    return DependencyRegistry.getInstance<ServiceContract>(toConcrete<ServiceContract>());
+    return DependencyRegistryIndex.getInstance(toConcrete<ServiceContract>());
   }
 }
 ```

package/__index__.ts

@@ -1,4 +1,5 @@
 export * from './src/decorator.ts';
 export * from './src/error.ts';
-export * from './src/registry.ts';
+export * from './src/registry/registry-index.ts';
+export * from './src/registry/registry-adapter.ts';
 export * from './src/types.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/di",
-  "version": "6.0.1",
+  "version": "7.0.0-rc.1",
   "description": "Dependency registration/management and injection support.",
   "keywords": [
     "ast-transformations",
@@ -27,10 +27,10 @@
     "directory": "module/di"
   },
   "dependencies": {
-    "@travetto/registry": "^6.0.1"
+    "@travetto/registry": "^7.0.0-rc.1"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^6.0.1"
+    "@travetto/transformer": "^7.0.0-rc.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/decorator.ts

@@ -1,80 +1,53 @@
-import { asConstructable, asFull, TypedFunction, type Class } from '@travetto/runtime';
+import { Any, castTo, ClassInstance, getClass, type Class } from '@travetto/runtime';
+import { CONSTRUCTOR_PROPERTY } from '@travetto/schema';
 
-import { InjectableFactoryConfig, InjectableConfig, Dependency } from './types.ts';
-import { DependencyRegistry, ResolutionType } from './registry.ts';
+import { InjectableCandidate, ResolutionType } from './types.ts';
+import { DependencyRegistryIndex } from './registry/registry-index.ts';
 
-function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Partial<InjectConfig> | undefined)[]): T {
-  let out: Partial<T> = {};
-  if (args) {
-    if (Array.isArray(args)) {
-      for (const arg of args) {
-        if (typeof arg === 'symbol') {
-          out.qualifier = arg;
-        } else if (arg) {
-          Object.assign(out, arg);
-        }
-      }
-    } else {
-      out = args;
-    }
-  }
-  return asFull(out);
-}
+const fromArg = <T extends { qualifier?: symbol }>(arg?: T | symbol): T =>
+  typeof arg === 'symbol' ? castTo({ qualifier: arg }) : (arg ?? castTo<T>({}));
 
 /**
  * Indicate that a class is able to be injected
- *
- * @augments `@travetto/di:Injectable`
+ * @augments `@travetto/schema:Schema`
+ * @kind decorator
  */
-export function Injectable(first?: Partial<InjectableConfig> | symbol, ...args: (Partial<InjectableConfig> | undefined)[]) {
-  return <T extends Class>(target: T): T => {
-    const config = {
-      ...collapseConfig<Partial<InjectableConfig>>(first, ...args),
-      class: target
-    };
-    DependencyRegistry.registerClass(target, config);
-    return target;
+export function Injectable(config?: Partial<InjectableCandidate> | symbol) {
+  return <T extends Class>(cls: T): void => {
+    DependencyRegistryIndex.getForRegister(cls).registerClass(fromArg(config));
   };
 }
 
-export type InjectConfig = { qualifier?: symbol, optional?: boolean, resolution?: ResolutionType };
-
-export function InjectArgs(configs?: InjectConfig[][]) {
-  return <T extends Class>(target: T): void => {
-    DependencyRegistry.registerConstructor(target, configs?.map(x => collapseConfig(...x)));
-  };
-}
+export type InjectConfig = { qualifier?: symbol, resolution?: ResolutionType };
 
 /**
- * Indicate that a field is able to be injected
- *
+ * Indicate that a field or parameter is able to be injected
  * @augments `@travetto/di:Inject`
+ * @augments `@travetto/schema:Input`
+ * @kind decorator
  */
-export function Inject(first?: InjectConfig | symbol, ...args: (InjectConfig | undefined)[]) {
-  return (target: unknown, propertyKey?: string, idx?: number | PropertyDescriptor): void => {
-    if (typeof idx !== 'number') { // Only register if on property
-      const config = collapseConfig<Dependency>(first, ...args);
-
-      DependencyRegistry.registerProperty(
-        asConstructable(target).constructor, propertyKey!, config
-      );
+export function Inject(config?: InjectConfig | symbol) {
+  return (instanceOrCls: Class | ClassInstance, property?: string | symbol, idx?: number | PropertyDescriptor): void => {
+    const cfg = fromArg(config);
+    const cls = getClass(instanceOrCls);
+    const propertyKey = property ?? CONSTRUCTOR_PROPERTY;
+    if (typeof idx !== 'number') {
+      DependencyRegistryIndex.registerFieldMetadata(cls, propertyKey, cfg);
+    } else {
+      DependencyRegistryIndex.registerParameterMetadata(cls, propertyKey, idx, cfg);
     }
   };
 }
 
 /**
  * Identifies a static method that is able to produce a dependency
- *
- * @augments `@travetto/di:InjectableFactory`
+ * @augments `@travetto/schema:Method`
+ * @kind decorator
  */
-export function InjectableFactory(first?: Partial<InjectableFactoryConfig> | symbol, ...args: (Partial<InjectableFactoryConfig> | undefined)[]) {
-  return <T extends Class>(target: T, property: string | symbol, descriptor: TypedPropertyDescriptor<TypedFunction>): void => {
-    const config: InjectableFactoryConfig = collapseConfig(first, ...args);
-    DependencyRegistry.registerFactory({
-      ...config,
-      dependencies: config.dependencies?.map(x => Array.isArray(x) ? collapseConfig(...x) : collapseConfig(x)),
-      fn: descriptor.value!,
-      id: `${target.Ⲑid}#${property.toString()}`
+export function InjectableFactory(config?: Partial<InjectableCandidate> | symbol) {
+  return <T extends Class>(cls: T, property: string | symbol, descriptor: TypedPropertyDescriptor<(...args: Any[]) => Any>): void => {
+    DependencyRegistryIndex.getForRegister(cls).registerFactory(property, fromArg(config), {
+      factory: (...params: unknown[]) => descriptor.value!.apply(cls, params),
     });
   };
 }

package/src/error.ts

@@ -1,12 +1,11 @@
-import { AppError } from '@travetto/runtime';
-import { ClassTarget } from './types.ts';
+import { AppError, Class } from '@travetto/runtime';
 
 function getName(symbol: symbol): string {
   return symbol.toString().split(/[()]/g)[1];
 }
 
 export class InjectionError extends AppError {
-  constructor(message: string, target: ClassTarget, qualifiers?: symbol[]) {
+  constructor(message: string, target: Class, qualifiers?: symbol[]) {
     super(`${message}: [${target.Ⲑid}]${qualifiers ? `[${qualifiers.map(getName)}]` : ''}`, {
       category: 'notfound',
       details: {

package/src/registry/registry-adapter.ts

@@ -0,0 +1,79 @@
+import { RegistryAdapter } from '@travetto/registry';
+import { Class, classConstruct, describeFunction, getAllEntries, safeAssign } from '@travetto/runtime';
+import { CONSTRUCTOR_PROPERTY, SchemaRegistryIndex } from '@travetto/schema';
+
+import { InjectableConfig, getDefaultQualifier, InjectableCandidate } from '../types';
+
+function combineInjectableCandidates<T extends InjectableCandidate>(base: T, ...override: Partial<T>[]): typeof base {
+  for (const o of override) {
+    safeAssign(base, o);
+  }
+  return base;
+}
+
+function combineClasses<T extends InjectableConfig>(base: T, ...override: Partial<T>[]): typeof base {
+  for (const o of override) {
+    Object.assign(base, {
+      ...base,
+      ...o,
+      candidates: {
+        ...base.candidates,
+        ...o.candidates,
+      }
+    });
+  }
+  return base;
+}
+
+export class DependencyRegistryAdapter implements RegistryAdapter<InjectableConfig> {
+  #cls: Class;
+  #config: InjectableConfig;
+
+  constructor(cls: Class) {
+    this.#cls = cls;
+  }
+
+  register(...data: Partial<InjectableConfig<unknown>>[]): InjectableConfig<unknown> {
+    this.#config ??= { class: this.#cls, candidates: {} };
+    return combineClasses(this.#config, ...data);
+  }
+
+  registerFactory(method: string | symbol, ...data: Partial<InjectableCandidate<unknown>>[]): InjectableCandidate {
+    const { candidates } = this.register();
+    candidates[method] ??= {
+      class: this.#cls,
+      method,
+      enabled: true,
+      factory: undefined!,
+      candidateType: undefined!,
+    };
+    return combineInjectableCandidates(candidates[method], ...data);
+  }
+
+  registerClass(...data: Partial<InjectableCandidate<unknown>>[]): InjectableCandidate {
+    return this.registerFactory(CONSTRUCTOR_PROPERTY, ...data, {
+      factory: (...args: unknown[]) => classConstruct(this.#cls, args),
+      candidateType: this.#cls,
+    });
+  }
+
+  get(): InjectableConfig<unknown> {
+    return this.#config;
+  }
+
+  finalize(): void {
+    for (const [k] of getAllEntries(this.#config.candidates)) {
+      const v = this.#config.candidates[k];
+      const candidateType = SchemaRegistryIndex.get(v.class).getMethodReturnType(k);
+      v.candidateType = candidateType;
+      v.qualifier ??= getDefaultQualifier(candidateType);
+    }
+  }
+
+  getCandidateConfigs(): InjectableCandidate[] {
+    const entries = getAllEntries(this.#config.candidates).map(([_, item]) => item);
+    return entries
+      .filter(item => (item.enabled ?? true) === true || (typeof item.enabled === 'function' && item.enabled()))
+      .filter(item => item.method !== CONSTRUCTOR_PROPERTY || !describeFunction(item.candidateType)?.abstract);
+  }
+}

package/src/registry/registry-index.ts

@@ -0,0 +1,279 @@
+import { ChangeEvent, RegistryIndex, RegistryIndexStore, Registry, RetargettingProxy } from '@travetto/registry';
+import { AppError, castKey, castTo, Class, describeFunction, getParentClass, hasFunction, Runtime, TypedObject, Util } from '@travetto/runtime';
+import { SchemaFieldConfig, SchemaParameterConfig, SchemaRegistryIndex } from '@travetto/schema';
+
+import { Dependency, InjectableCandidate, InjectableClassMetadata, InjectableConfig, ResolutionType } from '../types';
+import { DependencyRegistryAdapter } from './registry-adapter';
+import { InjectionError } from '../error';
+import { DependencyRegistryResolver } from './registry-resolver';
+
+const MetadataSymbol = Symbol();
+
+const hasPostConstruct = hasFunction<{ postConstruct: () => Promise<unknown> }>('postConstruct');
+const hasPreDestroy = hasFunction<{ preDestroy: () => Promise<unknown> }>('preDestroy');
+
+function readMetadata(item: { metadata?: Record<symbol, unknown> }): Dependency | undefined {
+  return castTo<Dependency | undefined>(item.metadata?.[MetadataSymbol]);
+}
+
+export class DependencyRegistryIndex implements RegistryIndex {
+
+  static #instance = Registry.registerIndex(DependencyRegistryIndex);
+
+  static getForRegister(cls: Class): DependencyRegistryAdapter {
+    return this.#instance.store.getForRegister(cls);
+  }
+
+  static getInstance<T>(candidateType: Class<T>, qualifier?: symbol, resolution?: ResolutionType): Promise<T> {
+    return this.#instance.getInstance(candidateType, qualifier, resolution);
+  }
+
+  static getCandidates<T>(candidateType: Class<T>): InjectableCandidate<T>[] {
+    return this.#instance.getCandidates<T>(candidateType);
+  }
+
+  static getCandidateTypes<T>(candidateType: Class<T>): Class<T>[] {
+    return this.#instance.getCandidates(candidateType).map(c => c.candidateType);
+  }
+
+  static getInstances<T>(candidateType: Class<T>, predicate?: (cfg: InjectableCandidate<T>) => boolean): Promise<T[]> {
+    return this.#instance.getInstances<T>(candidateType, predicate);
+  }
+
+  static injectFields<T extends { constructor: Class<T> }>(o: T, cls = o.constructor): Promise<T> {
+    return this.#instance.injectFields(cls, o, cls);
+  }
+
+  static getOptional(cls: Class): InjectableConfig | undefined {
+    return this.#instance.store.getOptional(cls)?.get();
+  }
+
+  static registerClassMetadata(cls: Class, metadata: InjectableClassMetadata): void {
+    SchemaRegistryIndex.getForRegister(cls).registerMetadata<InjectableClassMetadata>(MetadataSymbol, metadata);
+  }
+
+  static registerParameterMetadata(cls: Class, method: string | symbol, index: number, metadata: Dependency): void {
+    SchemaRegistryIndex.getForRegister(cls).registerParameterMetadata(method, index, MetadataSymbol, metadata);
+  }
+
+  static registerFieldMetadata(cls: Class, field: string | symbol, metadata: Dependency): void {
+    SchemaRegistryIndex.getForRegister(cls).registerFieldMetadata(field, MetadataSymbol, metadata);
+  }
+
+  #proxies = new Map<string, Map<symbol | undefined, RetargettingProxy<unknown>>>();
+  #instances = new Map<Class, Map<symbol, unknown>>();
+  #instancePromises = new Map<Class, Map<symbol, Promise<unknown>>>();
+  #resolver = new DependencyRegistryResolver();
+
+  #proxyInstance<T>(target: Class<unknown>, qualifier: symbol, instance: T): T {
+    let proxy: RetargettingProxy<unknown>;
+    const targetId = target.Ⲑid;
+
+    if (!this.#proxies.has(targetId)) {
+      this.#proxies.set(targetId, new Map());
+    }
+
+    if (!this.#proxies.get(targetId)!.has(qualifier)) {
+      proxy = new RetargettingProxy(instance);
+      this.#proxies.get(targetId)!.set(qualifier, proxy);
+      console.debug('Registering proxy', { id: target.Ⲑid, qualifier: qualifier.toString() });
+    } else {
+      proxy = this.#proxies.get(targetId)!.get(qualifier)!;
+      proxy.setTarget(instance);
+      console.debug('Updating target', {
+        id: target.Ⲑid, qualifier: qualifier.toString(), instanceType: target.name
+      });
+    }
+
+    return proxy.get();
+  }
+
+  #addClass(cls: Class, forceCreate: boolean = false): void {
+    const adapter = this.store.get(cls);
+
+    for (const config of adapter.getCandidateConfigs()) {
+      const parentClass = getParentClass(config.candidateType);
+      const parentConfig = parentClass ? this.store.getOptional(parentClass) : undefined;
+      const hasParentBase = (parentConfig || (parentClass && !!describeFunction(parentClass)?.abstract));
+      const baseParent = hasParentBase ? parentClass : undefined;
+      this.#resolver.registerClass(config, baseParent);
+      if (config.autoInject || forceCreate) {
+        // Don't wait
+        Util.queueMacroTask().then(() => {
+          this.getInstance(config.candidateType, config.qualifier);
+        });
+      }
+    }
+  }
+
+  #removeClass(cls: Class): void {
+    if (this.#instances.has(cls)) {
+      for (const [qualifier, config] of this.#resolver.getContainerEntries(cls)) {
+        try {
+          this.destroyInstance(config.candidateType, qualifier);
+        } catch { }
+      }
+    }
+  }
+
+
+  async #resolveDependencyValue(dependency: Dependency, input: SchemaFieldConfig | SchemaParameterConfig, src: Class): Promise<unknown> {
+    try {
+      const target = dependency.target ?? input.type;
+      return await this.getInstance(target, dependency.qualifier, dependency.resolution);
+    } catch (err) {
+      if (input.required?.active === false && err instanceof InjectionError && err.category === 'notfound') {
+        return undefined;
+      } else {
+        if (err && err instanceof Error) {
+          err.message = `${err.message} via=${src.Ⲑid}[${input.name?.toString() ?? 'constructor'}]`;
+        }
+        throw err;
+      }
+    }
+  }
+
+  store = new RegistryIndexStore(DependencyRegistryAdapter);
+
+  getConfig(cls: Class): InjectableConfig {
+    return this.store.get(cls).get();
+  }
+
+  process(events: ChangeEvent<Class>[]): void {
+    for (const ev of events) {
+      if ('prev' in ev) {
+        this.#removeClass(ev.prev);
+      }
+      if ('curr' in ev) {
+        this.#addClass(ev.curr, 'prev' in ev);
+      }
+    }
+  }
+
+  /**
+   * Get all available candidates for a given type
+   */
+  getCandidates<T>(candidateType: Class<T>): InjectableCandidate<T>[] {
+    return this.#resolver.getCandidateEntries(candidateType).map(([_, x]) => castTo<InjectableCandidate<T>>(x));
+  }
+
+  /**
+   * Get candidate instances by target type, with an optional filter
+   */
+  getInstances<T>(candidateType: Class<T>, predicate?: (cfg: InjectableCandidate<T>) => boolean): Promise<T[]> {
+    const inputs = this.getCandidates<T>(candidateType).filter(x => !predicate || predicate(x));
+    return Promise.all(inputs.map(l => this.getInstance<T>(l.class, l.qualifier)));
+  }
+
+  /**
+   * Retrieve list dependencies
+   */
+  async fetchDependencyParameters<T>(candidate: InjectableCandidate<T>): Promise<unknown[]> {
+    const inputs = SchemaRegistryIndex.has(candidate.class) ?
+      SchemaRegistryIndex.get(candidate.class).getMethod(candidate.method).parameters : [];
+
+    const promises = inputs
+      .map(input => this.#resolveDependencyValue(readMetadata(input) ?? {}, input, candidate.class));
+
+    return await Promise.all(promises);
+  }
+
+  /**
+   * Retrieve mapped dependencies
+   */
+  async injectFields<T>(candidateType: Class, instance: T, srcClass: Class): Promise<T> {
+    const inputs = SchemaRegistryIndex.getOptional(candidateType)?.getFields() ?? {};
+
+    const promises = TypedObject.entries(inputs)
+      .filter(([k, input]) => readMetadata(input) !== undefined && (input.access !== 'readonly' && instance[castKey(k)] === undefined))
+      .map(async ([k, input]) => [k, await this.#resolveDependencyValue(readMetadata(input) ?? {}, input, srcClass)] as const);
+
+    const pairs = await Promise.all(promises);
+
+    for (const [k, v] of pairs) {
+      instance[castKey(k)] = castTo(v);
+    }
+    return instance;
+  }
+
+  /**
+   * Actually construct an instance while resolving the dependencies
+   */
+  async construct<T>(candidateType: Class<T>, qualifier: symbol): Promise<T> {
+    const { candidate } = this.#resolver.resolveCandidate(candidateType, qualifier);
+    const targetType = candidate.candidateType;
+    const params = await this.fetchDependencyParameters(candidate);
+    const inst = await candidate.factory(...params);
+
+    // And auto-wire fields
+    await this.injectFields(targetType, inst, candidate.class);
+
+    // Run post construct, if it wasn't passed in, otherwise it was already created
+    if (hasPostConstruct(inst) && !params.includes(inst)) {
+      await inst.postConstruct();
+    }
+
+    const metadata = SchemaRegistryIndex.has(targetType) ?
+      SchemaRegistryIndex.get(targetType).getMetadata<InjectableClassMetadata>(MetadataSymbol) : undefined;
+
+    // Run post constructors
+    for (const op of Object.values(metadata?.postConstruct ?? {})) {
+      await op(inst);
+    }
+
+    // Proxy if necessary
+    return Runtime.dynamic ? this.#proxyInstance(targetType, qualifier, inst) : inst;
+  }
+
+  /**
+   * Get or create the instance
+   */
+  async getInstance<T>(candidateType: Class<T>, requestedQualifier?: symbol, resolution?: ResolutionType): Promise<T> {
+    if (!candidateType) {
+      throw new AppError('Unable to get instance when target is undefined');
+    }
+
+    const { target, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier, resolution);
+
+    if (!this.#instances.has(target)) {
+      this.#instances.set(target, new Map());
+      this.#instancePromises.set(target, new Map());
+    }
+
+    if (this.#instancePromises.get(target)!.has(qualifier)) {
+      return castTo(this.#instancePromises.get(target)!.get(qualifier));
+    }
+
+    const instancePromise = this.construct(candidateType, qualifier);
+    this.#instancePromises.get(target)!.set(qualifier, instancePromise);
+    try {
+      const instance = await instancePromise;
+      this.#instances.get(target)!.set(qualifier, instance);
+      return instance;
+    } catch (err) {
+      // Clear it out, don't save failed constructions
+      this.#instancePromises.get(target)!.delete(qualifier);
+      throw err;
+    }
+  }
+
+  /**
+   * Destroy an instance
+   */
+  destroyInstance(candidateType: Class, requestedQualifier: symbol): void {
+    const { target, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier);
+
+    const activeInstance = this.#instances.get(target)?.get(qualifier);
+    if (hasPreDestroy(activeInstance)) {
+      activeInstance.preDestroy();
+    }
+
+    this.#resolver.removeClass(candidateType, qualifier);
+    this.#instances.get(target)?.delete(qualifier);
+    this.#instancePromises.get(target)?.delete(qualifier);
+
+    // May not exist
+    this.#proxies.get(target.Ⲑid)?.get(qualifier)?.setTarget(null);
+    console.debug('On uninstall', { id: target, qualifier: qualifier.toString(), classId: target });
+  }
+}