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

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()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/di",
-  "version": "7.0.0-rc.1",
+  "version": "7.0.0-rc.3",
   "description": "Dependency registration/management and injection support.",
   "keywords": [
     "ast-transformations",
@@ -27,10 +27,10 @@
     "directory": "module/di"
   },
   "dependencies": {
-    "@travetto/registry": "^7.0.0-rc.1"
+    "@travetto/registry": "^7.0.0-rc.3"
   },
   "peerDependencies": {
-    "@travetto/transformer": "^7.0.0-rc.1"
+    "@travetto/transformer": "^7.0.0-rc.3"
   },
   "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

@@ -1,5 +1,5 @@
-import { ChangeEvent, RegistryIndex, RegistryIndexStore, Registry, RetargettingProxy } from '@travetto/registry';
-import { AppError, castKey, castTo, Class, describeFunction, getParentClass, hasFunction, Runtime, TypedObject, Util } from '@travetto/runtime';
+import { RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { AppError, castKey, castTo, Class, describeFunction, getParentClass, hasFunction, TypedObject } from '@travetto/runtime';
 import { SchemaFieldConfig, SchemaParameterConfig, SchemaRegistryIndex } from '@travetto/schema';
 
 import { Dependency, InjectableCandidate, InjectableClassMetadata, InjectableConfig, ResolutionType } from '../types';
@@ -32,63 +32,55 @@ export class DependencyRegistryIndex implements RegistryIndex {
     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[]> {
+  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 getOptional(cls: Class): InjectableConfig | undefined {
-    return this.#instance.store.getOptional(cls)?.get();
+  static injectFields<T extends { constructor: Class<T> }>(item: T, cls = item.constructor): Promise<T> {
+    return this.#instance.injectFields(cls, item, cls);
   }
 
   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 {
+  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);
   }
 
-  #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());
+  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 (error) {
+      if (input.required?.active === false && error instanceof InjectionError && error.category === 'notfound') {
+        return undefined;
+      } else {
+        if (error && error instanceof Error) {
+          error.message = `${error.message} via=${cls.Ⲑid}[${input.name?.toString() ?? 'constructor'}]`;
+        }
+        throw error;
+      }
     }
+  }
 
-    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
-      });
-    }
+  store = new RegistryIndexStore(DependencyRegistryAdapter);
+
+  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
 
-    return proxy.get();
+  getConfig(cls: Class): InjectableConfig {
+    return this.store.get(cls).get();
   }
 
-  #addClass(cls: Class, forceCreate: boolean = false): void {
+  onCreate(cls: Class): void {
     const adapter = this.store.get(cls);
 
     for (const config of adapter.getCandidateConfigs()) {
@@ -97,55 +89,17 @@ export class DependencyRegistryIndex implements RegistryIndex {
       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'}]`;
+  // Setup instances after change set complete
+  onChangeSetComplete(classes: Class[]): void {
+    for (const cls of classes) {
+      const adapter = this.store.get(cls);
+      for (const config of adapter.getCandidateConfigs()) {
+        if (config.autoInject) {
+          this.getInstance(config.candidateType, config.qualifier);
         }
-        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);
       }
     }
   }
@@ -154,15 +108,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)));
   }
 
   /**
@@ -185,13 +139,13 @@ export class DependencyRegistryIndex implements RegistryIndex {
     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;
   }
@@ -217,12 +171,12 @@ 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
-    return Runtime.dynamic ? this.#proxyInstance(targetType, qualifier, inst) : inst;
+    return inst;
   }
 
   /**
@@ -250,10 +204,10 @@ export class DependencyRegistryIndex implements RegistryIndex {
       const instance = await instancePromise;
       this.#instances.get(target)!.set(qualifier, instance);
       return instance;
-    } catch (err) {
+    } catch (error) {
       // Clear it out, don't save failed constructions
       this.#instancePromises.get(target)!.delete(qualifier);
-      throw err;
+      throw error;
     }
   }
 
@@ -273,7 +227,6 @@ export class DependencyRegistryIndex implements RegistryIndex {
     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 });
   }
 }

package/src/registry/registry-resolver.ts

@@ -6,11 +6,11 @@ import { InjectionError } from '../error';
 
 type Resolved<T> = { candidate: InjectableCandidate<T>, qualifier: symbol, target: Class };
 
-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());
+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 {
@@ -38,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;

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>)>;
 };