@travetto/di 7.0.0-rc.0 → 7.0.0-rc.2

package/README.md

@@ -135,7 +135,7 @@ The [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decor
 **Code: Example Injectable with dependencies as Inject fields**
 ```typescript
 import { Injectable, Inject } from '@travetto/di';
-import { DependentService } from './dep.ts';
+import { DependentService } from './dependency.ts';
 
 @Injectable()
 class CustomService {
@@ -153,15 +153,15 @@ The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/d
 **Code: Example Injectable with dependencies in constructor**
 ```typescript
 import { Injectable } from '@travetto/di';
-import { DependentService } from './dep.ts';
+import { DependentService } from './dependency.ts';
 
 @Injectable()
 class CustomService {
 
   dependentService: DependentService;
 
-  constructor(svc: DependentService) {
-    this.dependentService = svc;
+  constructor(service: DependentService) {
+    this.dependentService = service;
   }
 
   async coolOperation() {
@@ -176,7 +176,7 @@ Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/d
 ```typescript
 import { InjectableFactory } from '@travetto/di';
 
-import { DependentService, CustomService } from './dep.ts';
+import { DependentService, CustomService } from './dependency.ts';
 
 class Config {
   @InjectableFactory()
@@ -268,7 +268,7 @@ 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 [DependencyRegistryIndex](https://github.com/travetto/travetto/tree/main/module/di/src/registry/registry-index.ts#L21). 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

package/package.json

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

package/src/decorator.ts

@@ -4,17 +4,17 @@ import { CONSTRUCTOR_PROPERTY } from '@travetto/schema';
 import { InjectableCandidate, ResolutionType } from './types.ts';
 import { DependencyRegistryIndex } from './registry/registry-index.ts';
 
-const fromArg = <T extends { qualifier?: symbol }>(arg?: T | symbol): T =>
-  typeof arg === 'symbol' ? castTo({ qualifier: arg }) : (arg ?? castTo<T>({}));
+const fromInput = <T extends { qualifier?: symbol }>(input?: T | symbol): T =>
+  typeof input === 'symbol' ? castTo({ qualifier: input }) : (input ?? castTo<T>({}));
 
 /**
  * Indicate that a class is able to be injected
  * @augments `@travetto/schema:Schema`
  * @kind decorator
  */
-export function Injectable(config?: Partial<InjectableCandidate> | symbol) {
+export function Injectable(input?: Partial<InjectableCandidate> | symbol) {
   return <T extends Class>(cls: T): void => {
-    DependencyRegistryIndex.getForRegister(cls).registerClass(fromArg(config));
+    DependencyRegistryIndex.getForRegister(cls).registerClass(fromInput(input));
   };
 }
 
@@ -26,15 +26,15 @@ export type InjectConfig = { qualifier?: symbol, resolution?: ResolutionType };
  * @augments `@travetto/schema:Input`
  * @kind decorator
  */
-export function Inject(config?: InjectConfig | symbol) {
-  return (instanceOrCls: Class | ClassInstance, property?: string | symbol, idx?: number | PropertyDescriptor): void => {
-    const cfg = fromArg(config);
+export function Inject(input?: InjectConfig | symbol) {
+  return (instanceOrCls: Class | ClassInstance, property?: string, idx?: number | PropertyDescriptor): void => {
+    const config = fromInput(input);
     const cls = getClass(instanceOrCls);
     const propertyKey = property ?? CONSTRUCTOR_PROPERTY;
     if (typeof idx !== 'number') {
-      DependencyRegistryIndex.registerFieldMetadata(cls, propertyKey, cfg);
+      DependencyRegistryIndex.registerFieldMetadata(cls, propertyKey, config);
     } else {
-      DependencyRegistryIndex.registerParameterMetadata(cls, propertyKey, idx, cfg);
+      DependencyRegistryIndex.registerParameterMetadata(cls, propertyKey, idx, config);
     }
   };
 }
@@ -44,9 +44,9 @@ export function Inject(config?: InjectConfig | symbol) {
  * @augments `@travetto/schema:Method`
  * @kind decorator
  */
-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), {
+export function InjectableFactory(input?: Partial<InjectableCandidate> | symbol) {
+  return <T extends Class>(cls: T, property: string, descriptor: TypedPropertyDescriptor<(...args: Any[]) => Any>): void => {
+    DependencyRegistryIndex.getForRegister(cls).registerFactory(property, fromInput(input), {
       factory: (...params: unknown[]) => descriptor.value!.apply(cls, params),
     });
   };

package/src/registry/registry-adapter.ts

@@ -1,24 +1,24 @@
 import { RegistryAdapter } from '@travetto/registry';
-import { Class, classConstruct, describeFunction, getAllEntries, safeAssign } from '@travetto/runtime';
+import { Class, classConstruct, describeFunction, 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);
+function combineInjectableCandidates<T extends InjectableCandidate>(base: T, ...overrides: Partial<T>[]): typeof base {
+  for (const override of overrides) {
+    safeAssign(base, override);
   }
   return base;
 }
 
-function combineClasses<T extends InjectableConfig>(base: T, ...override: Partial<T>[]): typeof base {
-  for (const o of override) {
+function combineClasses<T extends InjectableConfig>(base: T, ...overrides: Partial<T>[]): typeof base {
+  for (const override of overrides) {
     Object.assign(base, {
       ...base,
-      ...o,
+      ...override,
       candidates: {
         ...base.candidates,
-        ...o.candidates,
+        ...override.candidates,
       }
     });
   }
@@ -38,7 +38,7 @@ export class DependencyRegistryAdapter implements RegistryAdapter<InjectableConf
     return combineClasses(this.#config, ...data);
   }
 
-  registerFactory(method: string | symbol, ...data: Partial<InjectableCandidate<unknown>>[]): InjectableCandidate {
+  registerFactory(method: string, ...data: Partial<InjectableCandidate<unknown>>[]): InjectableCandidate {
     const { candidates } = this.register();
     candidates[method] ??= {
       class: this.#cls,
@@ -62,17 +62,16 @@ export class DependencyRegistryAdapter implements RegistryAdapter<InjectableConf
   }
 
   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);
+    for (const method of Object.keys(this.#config.candidates)) {
+      const candidate = this.#config.candidates[method];
+      const candidateType = SchemaRegistryIndex.get(candidate.class).getMethodReturnType(method);
+      candidate.candidateType = candidateType;
+      candidate.qualifier ??= getDefaultQualifier(candidateType);
     }
   }
 
   getCandidateConfigs(): InjectableCandidate[] {
-    const entries = getAllEntries(this.#config.candidates).map(([_, item]) => item);
-    return entries
+    return Object.values(this.#config.candidates)
       .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

@@ -9,11 +9,9 @@ import { DependencyRegistryResolver } from './registry-resolver';
 
 const MetadataSymbol = Symbol();
 
-type ClassId = string;
 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]);
 }
@@ -35,15 +33,15 @@ export class DependencyRegistryIndex implements RegistryIndex {
   }
 
   static getCandidateTypes<T>(candidateType: Class<T>): Class<T>[] {
-    return this.#instance.getCandidates(candidateType).map(c => c.candidateType);
+    return this.#instance.getCandidates(candidateType).map(candidate => candidate.candidateType);
   }
 
-  static getInstances<T>(candidateType: Class<T>, predicate?: (cfg: InjectableCandidate<T>) => boolean): Promise<T[]> {
+  static getInstances<T>(candidateType: Class<T>, predicate?: (config: 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 injectFields<T extends { constructor: Class<T> }>(item: T, cls = item.constructor): Promise<T> {
+    return this.#instance.injectFields(cls, item, cls);
   }
 
   static getOptional(cls: Class): InjectableConfig | undefined {
@@ -54,33 +52,33 @@ export class DependencyRegistryIndex implements RegistryIndex {
     SchemaRegistryIndex.getForRegister(cls).registerMetadata<InjectableClassMetadata>(MetadataSymbol, metadata);
   }
 
-  static registerParameterMetadata(cls: Class, method: string | symbol, index: number, metadata: Dependency): void {
+  static registerParameterMetadata(cls: Class, method: string, index: number, metadata: Dependency): void {
     SchemaRegistryIndex.getForRegister(cls).registerParameterMetadata(method, index, MetadataSymbol, metadata);
   }
 
-  static registerFieldMetadata(cls: Class, field: string | symbol, metadata: Dependency): void {
+  static registerFieldMetadata(cls: Class, field: string, metadata: Dependency): void {
     SchemaRegistryIndex.getForRegister(cls).registerFieldMetadata(field, MetadataSymbol, metadata);
   }
 
-  #instances = new Map<ClassId, Map<symbol, unknown>>();
-  #instancePromises = new Map<ClassId, Map<symbol, Promise<unknown>>>();
-  #proxies = new Map<ClassId, Map<symbol | undefined, RetargettingProxy<unknown>>>();
+  #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 {
-    const classId = target.Ⲑid;
     let proxy: RetargettingProxy<unknown>;
+    const targetId = target.Ⲑid;
 
-    if (!this.#proxies.has(classId)) {
-      this.#proxies.set(classId, new Map());
+    if (!this.#proxies.has(targetId)) {
+      this.#proxies.set(targetId, new Map());
     }
 
-    if (!this.#proxies.get(classId)!.has(qualifier)) {
+    if (!this.#proxies.get(targetId)!.has(qualifier)) {
       proxy = new RetargettingProxy(instance);
-      this.#proxies.get(classId)!.set(qualifier, proxy);
+      this.#proxies.get(targetId)!.set(qualifier, proxy);
       console.debug('Registering proxy', { id: target.Ⲑid, qualifier: qualifier.toString() });
     } else {
-      proxy = this.#proxies.get(classId)!.get(qualifier)!;
+      proxy = this.#proxies.get(targetId)!.get(qualifier)!;
       proxy.setTarget(instance);
       console.debug('Updating target', {
         id: target.Ⲑid, qualifier: qualifier.toString(), instanceType: target.name
@@ -90,53 +88,47 @@ export class DependencyRegistryIndex implements RegistryIndex {
     return proxy.get();
   }
 
-  #addClass(cls: Class): void {
+  #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 baseParentId = hasParentBase ? parentClass?.Ⲑid : undefined;
-      this.#resolver.registerClass(config, baseParentId);
-      if (config.autoInject) {
+      const baseParent = hasParentBase ? parentClass : undefined;
+      this.#resolver.registerClass(config, baseParent);
+      if (config.autoInject || forceCreate) {
         // Don't wait
-        this.getInstance(config.candidateType, config.qualifier);
+        Util.queueMacroTask().then(() => {
+          this.getInstance(config.candidateType, config.qualifier);
+        });
       }
     }
   }
 
-  #changedClass(cls: Class, _prev: Class): void {
-    // Reload instances
-    for (const qualifier of this.#proxies.get(cls.Ⲑid)?.keys() ?? []) {
-      // Timing matters due to create instance being asynchronous
-      Util.queueMacroTask().then(() => { this.getInstance(cls, qualifier); });
-    }
-  }
-
   #removeClass(cls: Class): void {
-    const classId = cls.Ⲑid;
-
-    if (this.#instances.has(classId)) {
+    if (this.#instances.has(cls)) {
       for (const [qualifier, config] of this.#resolver.getContainerEntries(cls)) {
-        this.destroyInstance(config.candidateType, qualifier);
+        try {
+          this.destroyInstance(config.candidateType, qualifier);
+        } catch { }
       }
     }
   }
 
 
-  async #resolveDependencyValue(dependency: Dependency, input: SchemaFieldConfig | SchemaParameterConfig, src: Class): Promise<unknown> {
+  async #resolveDependencyValue(dependency: Dependency, input: SchemaFieldConfig | SchemaParameterConfig, cls: 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') {
+    } catch (error) {
+      if (input.required?.active === false && error instanceof InjectionError && error.category === 'notfound') {
         return undefined;
       } else {
-        if (err && err instanceof Error) {
-          err.message = `${err.message} via=${src.Ⲑid}[${input.name?.toString() ?? 'constructor'}]`;
+        if (error && error instanceof Error) {
+          error.message = `${error.message} via=${cls.Ⲑid}[${input.name?.toString() ?? 'constructor'}]`;
         }
-        throw err;
+        throw error;
       }
     }
   }
@@ -148,13 +140,12 @@ export class DependencyRegistryIndex implements RegistryIndex {
   }
 
   process(events: ChangeEvent<Class>[]): void {
-    for (const ev of events) {
-      if (ev.type === 'added') {
-        this.#addClass(ev.curr);
-      } else if (ev.type === 'removing') {
-        this.#removeClass(ev.prev);
-      } else if (ev.type === 'changed') {
-        this.#changedClass(ev.curr, ev.prev);
+    for (const event of events) {
+      if ('previous' in event) {
+        this.#removeClass(event.previous);
+      }
+      if ('current' in event) {
+        this.#addClass(event.current, 'previous' in event);
       }
     }
   }
@@ -163,15 +154,15 @@ export class DependencyRegistryIndex implements RegistryIndex {
    * 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));
+    return this.#resolver.getCandidateEntries(candidateType).map(([_, candidate]) => castTo<InjectableCandidate<T>>(candidate));
   }
 
   /**
    * 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)));
+  getInstances<T>(candidateType: Class<T>, predicate?: (config: InjectableCandidate<T>) => boolean): Promise<T[]> {
+    const inputs = this.getCandidates<T>(candidateType).filter(candidate => !predicate || predicate(candidate));
+    return Promise.all(inputs.map(candidate => this.getInstance<T>(candidate.class, candidate.qualifier)));
   }
 
   /**
@@ -179,7 +170,7 @@ export class DependencyRegistryIndex implements RegistryIndex {
    */
   async fetchDependencyParameters<T>(candidate: InjectableCandidate<T>): Promise<unknown[]> {
     const inputs = SchemaRegistryIndex.has(candidate.class) ?
-      SchemaRegistryIndex.getMethodConfig(candidate.class, candidate.method).parameters : [];
+      SchemaRegistryIndex.get(candidate.class).getMethod(candidate.method).parameters : [];
 
     const promises = inputs
       .map(input => this.#resolveDependencyValue(readMetadata(input) ?? {}, input, candidate.class));
@@ -191,16 +182,16 @@ export class DependencyRegistryIndex implements RegistryIndex {
    * Retrieve mapped dependencies
    */
   async injectFields<T>(candidateType: Class, instance: T, srcClass: Class): Promise<T> {
-    const inputs = SchemaRegistryIndex.has(candidateType) ? SchemaRegistryIndex.getFieldMap(candidateType) : {};
+    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);
+      .filter(([key, input]) => readMetadata(input) !== undefined && (input.access !== 'readonly' && instance[castKey(key)] === undefined))
+      .map(async ([key, input]) => [key, 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);
+    for (const [key, value] of pairs) {
+      instance[castKey(key)] = castTo(value);
     }
     return instance;
   }
@@ -226,8 +217,8 @@ export class DependencyRegistryIndex implements RegistryIndex {
       SchemaRegistryIndex.get(targetType).getMetadata<InjectableClassMetadata>(MetadataSymbol) : undefined;
 
     // Run post constructors
-    for (const op of Object.values(metadata?.postConstruct ?? {})) {
-      await op(inst);
+    for (const operation of Object.values(metadata?.postConstruct ?? {})) {
+      await operation(inst);
     }
 
     // Proxy if necessary
@@ -242,27 +233,27 @@ export class DependencyRegistryIndex implements RegistryIndex {
       throw new AppError('Unable to get instance when target is undefined');
     }
 
-    const { targetId, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier, resolution);
+    const { target, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier, resolution);
 
-    if (!this.#instances.has(targetId)) {
-      this.#instances.set(targetId, new Map());
-      this.#instancePromises.set(targetId, new Map());
+    if (!this.#instances.has(target)) {
+      this.#instances.set(target, new Map());
+      this.#instancePromises.set(target, new Map());
     }
 
-    if (this.#instancePromises.get(targetId)!.has(qualifier)) {
-      return castTo(this.#instancePromises.get(targetId)!.get(qualifier));
+    if (this.#instancePromises.get(target)!.has(qualifier)) {
+      return castTo(this.#instancePromises.get(target)!.get(qualifier));
     }
 
     const instancePromise = this.construct(candidateType, qualifier);
-    this.#instancePromises.get(targetId)!.set(qualifier, instancePromise);
+    this.#instancePromises.get(target)!.set(qualifier, instancePromise);
     try {
       const instance = await instancePromise;
-      this.#instances.get(targetId)!.set(qualifier, instance);
+      this.#instances.get(target)!.set(qualifier, instance);
       return instance;
-    } catch (err) {
+    } catch (error) {
       // Clear it out, don't save failed constructions
-      this.#instancePromises.get(targetId)!.delete(qualifier);
-      throw err;
+      this.#instancePromises.get(target)!.delete(qualifier);
+      throw error;
     }
   }
 
@@ -270,19 +261,19 @@ export class DependencyRegistryIndex implements RegistryIndex {
    * Destroy an instance
    */
   destroyInstance(candidateType: Class, requestedQualifier: symbol): void {
-    const { targetId, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier);
+    const { target, qualifier } = this.#resolver.resolveCandidate(candidateType, requestedQualifier);
 
-    const activeInstance = this.#instances.get(targetId)!.get(qualifier);
+    const activeInstance = this.#instances.get(target)?.get(qualifier);
     if (hasPreDestroy(activeInstance)) {
       activeInstance.preDestroy();
     }
 
     this.#resolver.removeClass(candidateType, qualifier);
-    this.#instances.get(targetId)!.delete(qualifier);
-    this.#instancePromises.get(targetId)!.delete(qualifier);
+    this.#instances.get(target)?.delete(qualifier);
+    this.#instancePromises.get(target)?.delete(qualifier);
 
     // May not exist
-    this.#proxies.get(targetId)?.get(qualifier)?.setTarget(null);
-    console.debug('On uninstall', { id: targetId, qualifier: qualifier.toString(), classId: targetId });
+    this.#proxies.get(target.Ⲑid)?.get(qualifier)?.setTarget(null);
+    console.debug('On uninstall', { id: target, qualifier: qualifier.toString(), classId: target });
   }
 }

package/src/registry/registry-resolver.ts

@@ -4,14 +4,13 @@ import { castTo, Class } from '@travetto/runtime';
 import { getDefaultQualifier, InjectableCandidate, PrimaryCandidateSymbol, ResolutionType } from '../types';
 import { InjectionError } from '../error';
 
-type Resolved<T> = { candidate: InjectableCandidate<T>, qualifier: symbol, targetId: string };
-type ClassId = string;
+type Resolved<T> = { candidate: InjectableCandidate<T>, qualifier: symbol, target: Class };
 
-function setInMap<T>(map: Map<string, Map<typeof key, T>>, src: string, key: symbol | string, dest: T): void {
-  if (!map.has(src)) {
-    map.set(src, new Map());
+function setInMap<T>(map: Map<Class, Map<typeof key, T>>, cls: Class, key: symbol | string, dest: T): void {
+  if (!map.has(cls)) {
+    map.set(cls, new Map());
   }
-  map.get(src)!.set(key, dest);
+  map.get(cls)!.set(key, dest);
 }
 
 export class DependencyRegistryResolver {
@@ -21,17 +20,17 @@ export class DependencyRegistryResolver {
   #defaultSymbols = new Set<symbol>();
 
   /**
-   * Maps from the requested type id to the candidates
+   * Maps from the requested type to the candidates
    */
-  #byCandidateType = new Map<ClassId, Map<symbol, InjectableCandidate>>();
+  #byCandidateType = new Map<Class, Map<symbol, InjectableCandidate>>();
 
   /**
-   * Maps from inbound class id (file) to the candidates
+   * Maps from inbound class file) to the candidates
    */
-  #byContainerType = new Map<ClassId, Map<symbol, InjectableCandidate>>();
+  #byContainerType = new Map<Class, Map<symbol, InjectableCandidate>>();
 
   #resolveQualifier<T>(type: Class<T>, resolution?: ResolutionType): symbol | undefined {
-    const qualifiers = this.#byCandidateType.get(type.Ⲑid) ?? new Map<symbol, InjectableCandidate>();
+    const qualifiers = this.#byCandidateType.get(type) ?? new Map<symbol, InjectableCandidate>();
 
     const resolved = [...qualifiers.keys()];
 
@@ -39,15 +38,17 @@ export class DependencyRegistryResolver {
     if (qualifiers.has(PrimaryCandidateSymbol)) {
       return PrimaryCandidateSymbol;
     } else {
-      const filtered = resolved.filter(x => !!x).filter(x => this.#defaultSymbols.has(x));
+      const filtered = resolved
+        .filter(qualifier => !!qualifier)
+        .filter(qualifier => this.#defaultSymbols.has(qualifier));
       // If there is only one default symbol
       if (filtered.length === 1) {
         return filtered[0];
       } else if (filtered.length > 1) {
         // If dealing with sub types, prioritize exact matches
         const exact = this.getCandidateEntries(type)
-          .map(([_, x]) => x)
-          .filter(x => x.candidateType === type);
+          .map(([_, candidate]) => candidate)
+          .filter(candidate => candidate.candidateType === type);
 
         if (exact.length === 1) {
           return exact[0].qualifier;
@@ -65,13 +66,11 @@ export class DependencyRegistryResolver {
   /**
    * Register a class with the dependency resolver
    */
-  registerClass(config: InjectableCandidate, baseParentId?: string): void {
+  registerClass(config: InjectableCandidate, baseParent?: Class): void {
     const candidateType = config.candidateType;
-    const candidateClassId = candidateType.Ⲑid;
     const target = config.target ?? candidateType;
 
-    const targetClassId = target.Ⲑid;
-    const isSelfTarget = candidateClassId === targetClassId;
+    const isSelfTarget = target === candidateType;
     const qualifier = config.qualifier ?? getDefaultQualifier(candidateType);
 
     // Record qualifier if its the default for the class
@@ -80,42 +79,41 @@ export class DependencyRegistryResolver {
     }
 
     // Register inbound config by method and class
-    setInMap(this.#byContainerType, config.class.Ⲑid, config.method, config);
+    setInMap(this.#byContainerType, config.class, config.method, config);
 
-    setInMap(this.#byCandidateType, targetClassId, qualifier, config);
-    setInMap(this.#byCandidateType, candidateClassId, qualifier, config);
+    setInMap(this.#byCandidateType, target, qualifier, config);
+    setInMap(this.#byCandidateType, candidateType, qualifier, config);
 
     // Track interface aliases as targets
     const interfaces = SchemaRegistryIndex.has(candidateType) ?
       SchemaRegistryIndex.get(candidateType).get().interfaces : [];
 
-    for (const { Ⲑid: interfaceId } of interfaces) {
-      setInMap(this.#byCandidateType, interfaceId, qualifier, config);
+    for (const type of interfaces) {
+      setInMap(this.#byCandidateType, type, qualifier, config);
     }
 
     // If targeting self (default @Injectable behavior)
-    if (isSelfTarget && baseParentId) {
-      setInMap(this.#byCandidateType, baseParentId, qualifier, config);
+    if (isSelfTarget && baseParent) {
+      setInMap(this.#byCandidateType, baseParent, qualifier, config);
     }
 
     // Registry primary candidates
     if (config.primary) {
-      if (baseParentId) {
-        setInMap(this.#byCandidateType, baseParentId, PrimaryCandidateSymbol, config);
+      if (baseParent) {
+        setInMap(this.#byCandidateType, baseParent, PrimaryCandidateSymbol, config);
       }
 
       // Register primary for self
-      setInMap(this.#byCandidateType, targetClassId, PrimaryCandidateSymbol, config);
+      setInMap(this.#byCandidateType, target, PrimaryCandidateSymbol, config);
 
       // Register primary if only one interface provided and no parent config
-      if (interfaces.length === 1 && (!baseParentId || !this.#byContainerType.has(baseParentId))) {
+      if (interfaces.length === 1 && (!baseParent || !this.#byContainerType.has(baseParent))) {
         const [primaryInterface] = interfaces;
-        const primaryClassId = primaryInterface.Ⲑid;
-        setInMap(this.#byCandidateType, primaryClassId, PrimaryCandidateSymbol, config);
+        setInMap(this.#byCandidateType, primaryInterface, PrimaryCandidateSymbol, config);
       } else if (isSelfTarget) {
         // Register primary for all interfaces if self targeting
-        for (const { Ⲑid: interfaceId } of interfaces) {
-          setInMap(this.#byCandidateType, interfaceId, PrimaryCandidateSymbol, config);
+        for (const type of interfaces) {
+          setInMap(this.#byCandidateType, type, PrimaryCandidateSymbol, config);
         }
       }
     }
@@ -127,7 +125,7 @@ export class DependencyRegistryResolver {
    * @param qualifier
    */
   resolveCandidate<T>(candidateType: Class<T>, qualifier?: symbol, resolution?: ResolutionType): Resolved<T> {
-    const qualifiers = this.#byCandidateType.get(candidateType.Ⲑid) ?? new Map<symbol, InjectableCandidate>();
+    const qualifiers = this.#byCandidateType.get(candidateType) ?? new Map<symbol, InjectableCandidate>();
 
     let config: InjectableCandidate;
 
@@ -152,24 +150,21 @@ export class DependencyRegistryResolver {
     return {
       candidate: castTo(config),
       qualifier,
-      targetId: (config.target ?? config.candidateType).Ⲑid
+      target: (config.target ?? config.candidateType)
     };
   }
 
   removeClass(cls: Class, qualifier: symbol): void {
-    const classId = cls.Ⲑid;
     this.#defaultSymbols.delete(qualifier);
-    this.#byCandidateType.get(classId)!.delete(qualifier);
-    this.#byContainerType.get(classId)!.delete(qualifier);
+    this.#byCandidateType.get(cls)!.delete(qualifier);
+    this.#byContainerType.get(cls)!.delete(qualifier);
   }
 
   getCandidateEntries(candidateType: Class): [symbol, InjectableCandidate][] {
-    const candidateTypeId = candidateType.Ⲑid;
-    return [...this.#byCandidateType.get(candidateTypeId)?.entries() ?? []];
+    return [...this.#byCandidateType.get(candidateType)?.entries() ?? []];
   }
 
   getContainerEntries(containerType: Class): [symbol, InjectableCandidate][] {
-    const containerTypeId = containerType.Ⲑid;
-    return [...this.#byContainerType.get(containerTypeId)?.entries() ?? []];
+    return [...this.#byContainerType.get(containerType)?.entries() ?? []];
   }
 }

package/src/types.ts

@@ -32,7 +32,7 @@ export interface InjectableCandidate<T = unknown> {
   /**
    * Method that is injectable on class
    */
-  method: string | symbol;
+  method: string;
   /**
    * Method handle
    */
@@ -74,7 +74,7 @@ export interface InjectableConfig<T = unknown> {
   /**
    * Candidates that are injectable
    */
-  candidates: Record<string | symbol, InjectableCandidate>;
+  candidates: Record<string, InjectableCandidate>;
 }
 
 export function getDefaultQualifier(cls: Class): symbol {
@@ -85,5 +85,5 @@ export function getDefaultQualifier(cls: Class): symbol {
 export const PrimaryCandidateSymbol = Symbol();
 
 export type InjectableClassMetadata = {
-  postConstruct: Record<string | symbol, (<T>(inst: T) => Promise<void>)>;
+  postConstruct: Record<string, (<T>(inst: T) => Promise<void>)>;
 };