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

package/README.md

@@ -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.1",
   "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.1"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.0.0-rc.0"
+    "@travetto/transformer": "^7.0.0-rc.1"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

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]);
 }
@@ -62,25 +60,25 @@ export class DependencyRegistryIndex implements RegistryIndex {
     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,36 +88,30 @@ 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 { }
       }
     }
   }
@@ -149,12 +141,11 @@ 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') {
+      if ('prev' in ev) {
         this.#removeClass(ev.prev);
-      } else if (ev.type === 'changed') {
-        this.#changedClass(ev.curr, ev.prev);
+      }
+      if ('curr' in ev) {
+        this.#addClass(ev.curr, 'prev' in ev);
       }
     }
   }
@@ -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,7 +182,7 @@ 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))
@@ -242,26 +233,26 @@ 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) {
       // Clear it out, don't save failed constructions
-      this.#instancePromises.get(targetId)!.delete(qualifier);
+      this.#instancePromises.get(target)!.delete(qualifier);
       throw err;
     }
   }
@@ -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,10 +4,9 @@ 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 {
+function setInMap<T>(map: Map<Class, Map<typeof key, T>>, src: Class, key: symbol | string, dest: T): void {
   if (!map.has(src)) {
     map.set(src, new Map());
   }
@@ -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()];
 
@@ -65,13 +64,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 +77,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 +123,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 +148,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() ?? []];
   }
 }