@travetto/di 6.0.0 → 7.0.0-rc.0

package/src/registry/registry-resolver.ts

@@ -0,0 +1,175 @@
+import { SchemaRegistryIndex } from '@travetto/schema';
+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;
+
+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());
+  }
+  map.get(src)!.set(key, dest);
+}
+
+export class DependencyRegistryResolver {
+  /**
+   * Default symbols
+   */
+  #defaultSymbols = new Set<symbol>();
+
+  /**
+   * Maps from the requested type id to the candidates
+   */
+  #byCandidateType = new Map<ClassId, Map<symbol, InjectableCandidate>>();
+
+  /**
+   * Maps from inbound class id (file) to the candidates
+   */
+  #byContainerType = new Map<ClassId, Map<symbol, InjectableCandidate>>();
+
+  #resolveQualifier<T>(type: Class<T>, resolution?: ResolutionType): symbol | undefined {
+    const qualifiers = this.#byCandidateType.get(type.Ⲑid) ?? new Map<symbol, InjectableCandidate>();
+
+    const resolved = [...qualifiers.keys()];
+
+    // If primary found
+    if (qualifiers.has(PrimaryCandidateSymbol)) {
+      return PrimaryCandidateSymbol;
+    } else {
+      const filtered = resolved.filter(x => !!x).filter(x => this.#defaultSymbols.has(x));
+      // 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);
+
+        if (exact.length === 1) {
+          return exact[0].qualifier;
+        } else {
+          if (resolution === 'any') {
+            return filtered[0];
+          } else {
+            throw new InjectionError('Dependency has multiple candidates', type, filtered);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Register a class with the dependency resolver
+   */
+  registerClass(config: InjectableCandidate, baseParentId?: string): void {
+    const candidateType = config.candidateType;
+    const candidateClassId = candidateType.Ⲑid;
+    const target = config.target ?? candidateType;
+
+    const targetClassId = target.Ⲑid;
+    const isSelfTarget = candidateClassId === targetClassId;
+    const qualifier = config.qualifier ?? getDefaultQualifier(candidateType);
+
+    // Record qualifier if its the default for the class
+    if (config.qualifier === getDefaultQualifier(candidateType)) {
+      this.#defaultSymbols.add(config.qualifier);
+    }
+
+    // Register inbound config by method and class
+    setInMap(this.#byContainerType, config.class.Ⲑid, config.method, config);
+
+    setInMap(this.#byCandidateType, targetClassId, qualifier, config);
+    setInMap(this.#byCandidateType, candidateClassId, 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);
+    }
+
+    // If targeting self (default @Injectable behavior)
+    if (isSelfTarget && baseParentId) {
+      setInMap(this.#byCandidateType, baseParentId, qualifier, config);
+    }
+
+    // Registry primary candidates
+    if (config.primary) {
+      if (baseParentId) {
+        setInMap(this.#byCandidateType, baseParentId, PrimaryCandidateSymbol, config);
+      }
+
+      // Register primary for self
+      setInMap(this.#byCandidateType, targetClassId, PrimaryCandidateSymbol, config);
+
+      // Register primary if only one interface provided and no parent config
+      if (interfaces.length === 1 && (!baseParentId || !this.#byContainerType.has(baseParentId))) {
+        const [primaryInterface] = interfaces;
+        const primaryClassId = primaryInterface.Ⲑid;
+        setInMap(this.#byCandidateType, primaryClassId, 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);
+        }
+      }
+    }
+  }
+
+  /**
+   * Resolve the target given a qualifier
+   * @param candidateType
+   * @param qualifier
+   */
+  resolveCandidate<T>(candidateType: Class<T>, qualifier?: symbol, resolution?: ResolutionType): Resolved<T> {
+    const qualifiers = this.#byCandidateType.get(candidateType.Ⲑid) ?? new Map<symbol, InjectableCandidate>();
+
+    let config: InjectableCandidate;
+
+    if (qualifier && qualifiers.has(qualifier)) {
+      config = qualifiers.get(qualifier)!;
+    } else {
+      qualifier ??= this.#resolveQualifier(candidateType, resolution);
+
+      if (!qualifier) {
+        throw new InjectionError('Dependency not found', candidateType);
+      } else if (!qualifiers.has(qualifier)) {
+        if (!this.#defaultSymbols.has(qualifier) && resolution === 'loose') {
+          console.debug('Unable to find specific dependency, falling back to general instance', { qualifier, target: candidateType.Ⲑid });
+          return this.resolveCandidate(candidateType);
+        }
+        throw new InjectionError('Dependency not found', candidateType, [qualifier]);
+      } else {
+        config = qualifiers.get(qualifier!)!;
+      }
+    }
+
+    return {
+      candidate: castTo(config),
+      qualifier,
+      targetId: (config.target ?? config.candidateType).Ⲑid
+    };
+  }
+
+  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);
+  }
+
+  getCandidateEntries(candidateType: Class): [symbol, InjectableCandidate][] {
+    const candidateTypeId = candidateType.Ⲑid;
+    return [...this.#byCandidateType.get(candidateTypeId)?.entries() ?? []];
+  }
+
+  getContainerEntries(containerType: Class): [symbol, InjectableCandidate][] {
+    const containerTypeId = containerType.Ⲑid;
+    return [...this.#byContainerType.get(containerTypeId)?.entries() ?? []];
+  }
+}

package/src/types.ts

@@ -1,96 +1,89 @@
 import { Class } from '@travetto/runtime';
 
-export type ClassTarget<T = unknown> = Class<T> | Function;
-
-export type PostConstructHandler<T> = (value: T) => (void | Promise<void>);
+export type ResolutionType = 'strict' | 'loose' | 'any';
 
 /**
  * State of a Dependency
  */
-interface Core<T = unknown> {
+export interface Dependency<T = unknown> {
+  /**
+   * Whether or not resolution of dependency should be flexible,
+   * or should be strict.  Default is strict.
+   */
+  resolution?: ResolutionType;
   /**
    * Actual reference to a Class
    */
-  target: ClassTarget<T>;
+  target?: Class<T>;
   /**
    * Qualifier symbol
    */
-  qualifier: symbol;
+  qualifier?: symbol;
 }
 
 /**
- * State of a Dependency Target
+ * Injectable candidate
  */
-interface CoreTarget<T = unknown> extends Core<T> {
+export interface InjectableCandidate<T = unknown> {
   /**
-   * Is this injectable enabled
+   * Reference for the class
    */
-  enabled?: boolean | (() => boolean);
+  class: Class<T>;
   /**
-   * Is this the primary instance
+   * Method that is injectable on class
    */
-  primary?: boolean;
+  method: string | symbol;
   /**
-   * Should the target be auto-created
+   * Method handle
    */
-  autoCreate?: boolean;
-}
-
-/**
- * State of a Dependency
- */
-export interface Dependency<T = unknown> extends Core<T> {
+  factory: (...args: unknown[]) => T | Promise<T>;
   /**
-   * Whether or not the dependency is optional
+   * The type of the candidate
    */
-  optional?: boolean;
-
+  candidateType: Class;
   /**
-   * Whether or not resolution of dependency should be flexible,
-   * or should be strict.  Default is strict.
-   */
-  resolution?: 'loose' | 'strict';
-}
-
-/**
- * Injectable configuration
- */
-export interface InjectableConfig<T = unknown> extends CoreTarget<T> {
-  /**
-   * Reference for the class
+   * Is this injectable enabled
    */
-  class: Class<T>;
+  enabled?: boolean | (() => boolean);
   /**
-   * Factory function for the injectable
+   * Is this the primary instance
    */
-  factory?: (...args: unknown[]) => T;
+  primary?: boolean;
   /**
-   * List of dependencies as fields or as constructor arguments
+   * Should the target be constructed on startup
    */
-  dependencies: {
-    cons?: Dependency[];
-    fields: Record<string, Dependency>;
-  };
+  autoInject?: boolean;
   /**
-   * List of interface types
+   * Actual reference to a Class
    */
-  interfaces: Class[];
+  target?: Class;
   /**
-   * Post construct handlers
+   * Qualifier symbol
    */
-  postConstruct: Record<string | symbol, PostConstructHandler<unknown>>;
+  qualifier?: symbol;
 }
 
 /**
- * Factory configuration
+ * Full injectable configuration for a class
  */
-export interface InjectableFactoryConfig<T = unknown> extends CoreTarget<T> {
+export interface InjectableConfig<T = unknown> {
   /**
-   * Src of the factory method
+   * Reference for the class
    */
-  src: Class<T>;
+  class: Class<T>;
   /**
-   * List of all dependencies as function arguments
+   * Candidates that are injectable
    */
-  dependencies?: Dependency[];
-}
+  candidates: Record<string | symbol, InjectableCandidate>;
+}
+
+export function getDefaultQualifier(cls: Class): symbol {
+  return Symbol.for(cls.Ⲑid);
+}
+
+
+export const PrimaryCandidateSymbol = Symbol();
+
+export type InjectableClassMetadata = {
+  postConstruct: Record<string | symbol, (<T>(inst: T) => Promise<void>)>;
+};

package/support/test/suite.ts

@@ -1,21 +1,22 @@
-import { castTo, Class, ClassInstance } from '@travetto/runtime';
-import { RootRegistry } from '@travetto/registry';
-import { SuiteRegistry } from '@travetto/test';
+import { Class } from '@travetto/runtime';
+import { Registry } from '@travetto/registry';
+import { SuiteRegistryIndex } from '@travetto/test';
 
-import { DependencyRegistry } from '../../src/registry.ts';
+import { DependencyRegistryIndex } from '../../src/registry/registry-index.ts';
 
 /**
  * Registers a suite as injectable
+ * @kind decorator
  */
 export function InjectableSuite() {
-  return (target: Class) => {
-    SuiteRegistry.registerPendingListener(
-      target,
-      async function (this: unknown) {
-        await RootRegistry.init();
-        await DependencyRegistry.injectFields(castTo<ClassInstance>(this), target);
-      },
-      'beforeEach'
-    );
+  return (cls: Class) => {
+    SuiteRegistryIndex.getForRegister(cls).register({
+      beforeEach: [
+        async function (this: unknown) {
+          await Registry.init();
+          await DependencyRegistryIndex.injectFields(this, cls);
+        },
+      ]
+    });
   };
 }