@travetto/di 2.1.5 → 2.2.2

package/README.md

@@ -8,10 +8,10 @@
 npm install @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 type signafiers. The primary goal of dependency injection is to allow for separation of concerns of object creation and it's usage.
+[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#L30) and [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L72) 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 implementations (e.g. [MongoModelService](https://github.com/travetto/travetto/tree/main/module/model-mongo/src/service.ts#L44) provides itself as an injectable candidate for [ModelCrudSupport](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts).
+The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L32) and [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L75) 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 implementations (e.g. [MongoModelService](https://github.com/travetto/travetto/tree/main/module/model-mongo/src/service.ts#L49) provides itself as an injectable candidate for [ModelCrudSupport](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts).
 
 **Code: Example Injectable**
 ```typescript
@@ -72,7 +72,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#L72) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L30).
+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#L75) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L32).
 
 **Code: Example InjectableFactory**
 ```typescript
@@ -93,15 +93,15 @@ class Config {
 
 Given the `static` method `initService`, the function will be provided as a valid candidate for `CoolService`.  Instead of calling the constructor of the type directly, this function will work as a factory for producing the injectable.
 
-**Note**: Other modules are able to provide aliases to [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L30) that also provide additional functionality.  For example, the [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L9) or the [@Controller](https://github.com/travetto/travetto/tree/main/module/rest/src/decorator/controller.ts#L9) 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#L32) that also provide additional functionality.  For example, the [@Config](https://github.com/travetto/travetto/tree/main/module/config/src/decorator.ts#L9) or the [@Controller](https://github.com/travetto/travetto/tree/main/module/rest/src/decorator/controller.ts#L9) 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#L30) 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#L32) 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#L30) 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#L32) decorator, which denotes a desire to inject a value directly.  These will be set post construction.
 
-**Code: Example Injectable with dependencies as [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L30) fields**
+**Code: Example Injectable with dependencies as [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L32) fields**
 ```typescript
 import { Injectable, Inject } from '@travetto/di';
 import { DependentService } from './dep';
@@ -117,7 +117,7 @@ class CustomService {
 }
 ```
 
-The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L30) 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#L32) constructor params, which will be provided as the instance is being constructed.
 
 **Code: Example Injectable with dependencies in constructor**
 ```typescript
@@ -134,7 +134,7 @@ class CustomService {
 }
 ```
 
-Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L72) params, which are comparable to constructor params
+Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L75) params, which are comparable to constructor params
 
 **Code: Example InjectableFactory with parameters as dependencies**
 ```typescript
@@ -154,7 +154,7 @@ class Config {
 
 If you are building modules for others to consume, often times it is possible to end up with multiple implementations for the same class.  
 
-**Code: Example Multiple Candiate Types**
+**Code: Example Multiple Candidate Types**
 ```typescript
 import { Injectable, Inject } from '@travetto/di';
 
@@ -178,7 +178,7 @@ class ContractConsumer {
 
 By default, if there is only one candidate without qualification, then that candidate will be used.  If multiple candidates are found, then the injection system will bail.  To overcome this the end user will need to specify which candidate type should be considered `primary`:
 
-**Code: Example Multiple Candiate Types**
+**Code: Example Multiple Candidate Types**
 ```typescript
 import { InjectableFactory } from '@travetto/di';
 import { Contract, ComplexContract } from './injectable-multiple-default';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/di",
   "displayName": "Dependency Injection",
-  "version": "2.1.5",
+  "version": "2.2.2",
   "description": "Dependency registration/management and injection support.",
   "keywords": [
     "ast-transformations",
@@ -29,12 +29,12 @@
     "directory": "module/di"
   },
   "dependencies": {
-    "@travetto/transformer": "^2.1.4",
-    "@travetto/registry": "^2.1.5"
+    "@travetto/transformer": "^2.2.2",
+    "@travetto/registry": "^2.2.2"
   },
   "devDependencies": {
-    "@travetto/config": "^2.1.5",
-    "@travetto/schema": "^2.1.5"
+    "@travetto/config": "^2.2.2",
+    "@travetto/schema": "^2.2.2"
   },
   "docDependencies": {
     "@travetto/model-mongo": true,

package/src/decorator.ts

@@ -4,7 +4,8 @@ import { MethodDescriptor } from '@travetto/base/src/internal/types';
 import { InjectableFactoryConfig, InjectableConfig, Dependency } from './types';
 import { DependencyRegistry, ResolutionType } from './registry';
 
-function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Partial<InjectConfig> | undefined)[]) {
+function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Partial<InjectConfig> | undefined)[]): T {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   let out = {} as T;
   if (args) {
     if (Array.isArray(args)) {
@@ -16,6 +17,7 @@ function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Par
         }
       }
     } else {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       out = args as T;
     }
   }
@@ -28,10 +30,11 @@ function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Par
  * @augments `@trv:di/Injectable`
  */
 export function Injectable(first?: Partial<InjectableConfig> | symbol, ...args: (Partial<InjectableConfig> | undefined)[]) {
-  return <T extends Class>(target: T) => {
-    const config = collapseConfig(first, ...args) as Partial<InjectableConfig>;
+  return <T extends Class>(target: T): T => {
+    const config = collapseConfig<Partial<InjectableConfig>>(first, ...args);
 
     config.class = target;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     DependencyRegistry.registerClass(target, config as InjectableConfig);
     return target;
   };
@@ -40,7 +43,7 @@ export function Injectable(first?: Partial<InjectableConfig> | symbol, ...args:
 export type InjectConfig = { qualifier?: symbol, optional?: boolean, resolution?: ResolutionType };
 
 export function InjectArgs(configs?: InjectConfig[][]) {
-  return <T extends Class>(target: T) => {
+  return <T extends Class>(target: T): void => {
     DependencyRegistry.registerConstructor(target,
       configs?.map(x => collapseConfig(...x)));
   };
@@ -52,14 +55,14 @@ export function InjectArgs(configs?: InjectConfig[][]) {
  * @augments `@trv:di/Inject`
  */
 export function Inject(first?: InjectConfig | symbol, ...args: (InjectConfig | undefined)[]) {
-  return (target: unknown, propertyKey: string | symbol, idx?: number | PropertyDescriptor) => {
+  return (target: unknown, propertyKey: string | symbol, idx?: number | PropertyDescriptor): void => {
     if (typeof idx !== 'number') { // Only register if on property
       const config: InjectConfig = collapseConfig(first, ...args);
 
       DependencyRegistry.registerProperty(
-        (target as ClassInstance).constructor,
-        propertyKey as string,
-        config as Dependency);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        (target as ClassInstance).constructor, propertyKey as string, config as Dependency
+      );
     }
   };
 }
@@ -70,7 +73,7 @@ export function Inject(first?: InjectConfig | symbol, ...args: (InjectConfig | u
  * @augments `@trv:di/InjectableFactory`
  */
 export function InjectableFactory(first?: Partial<InjectableFactoryConfig> | symbol, ...args: (Partial<InjectableFactoryConfig> | undefined)[]) {
-  return <T extends Class>(target: T, property: string | symbol, descriptor: MethodDescriptor) => {
+  return <T extends Class>(target: T, property: string | symbol, descriptor: MethodDescriptor): void => {
     const config: InjectableFactoryConfig = collapseConfig(first, ...args);
     DependencyRegistry.registerFactory({
       ...config,

package/src/error.ts

@@ -1,7 +1,7 @@
 import { AppError } from '@travetto/base';
 import { ClassTarget } from './types';
 
-function getName(symbol: symbol) {
+function getName(symbol: symbol): string {
   return symbol.toString().split(/[()]/g)[1];
 }
 

package/src/registry.ts

@@ -14,10 +14,12 @@ export type ResolutionType = 'strict' | 'loose' | 'any';
 const PrimaryCandidateⲐ = Symbol.for('@trv:di/primary');
 
 function hasPostConstruct(o: unknown): o is { postConstruct: () => Promise<unknown> } {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['postConstruct'];
 }
 
 function hasPreDestroy(o: unknown): o is { preDestroy: () => unknown } {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return !!o && !!(o as Record<string, unknown>)['preDestroy'];
 }
 
@@ -67,7 +69,10 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
             qualifier = filtered[0];
           } else if (filtered.length > 1) {
             // If dealing with sub types, prioritize exact matches
-            const exact = this.getCandidateTypes(target as Class).filter(x => x.class === target);
+            const exact = this
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+              .getCandidateTypes(target as Class)
+              .filter(x => x.class === target);
             if (exact.length === 1) {
               qualifier = exact[0].qualifier;
             } else {
@@ -94,6 +99,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       }
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = this.get(cls!) as InjectableConfig<T>;
     return {
       qualifier,
@@ -105,7 +111,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Retrieve all dependencies
    */
-  protected async fetchDependencies(managed: InjectableConfig, deps?: Dependency[]) {
+  protected async fetchDependencies(managed: InjectableConfig, deps?: Dependency[]): Promise<unknown[]> {
     if (!deps || !deps.length) {
       return [];
     }
@@ -113,12 +119,15 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     const promises = deps.map(async x => {
       try {
         return await this.getInstance(x.target, x.qualifier, x.resolution);
-      } catch (e) {
-        if (x.optional && e instanceof InjectionError && e.category === 'notfound') {
+      } catch (err) {
+        if (!err || !(err instanceof Error)) {
+          throw err;
+        }
+        if (x.optional && err instanceof InjectionError && err.category === 'notfound') {
           return undefined;
         } else {
-          e.message = `${e.message} via=${managed.class.ᚕid}`;
-          throw e;
+          err.message = `${err.message} via=${managed.class.ᚕid}`;
+          throw err;
         }
       }
     });
@@ -129,14 +138,16 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Resolve all field dependencies
    */
-  protected async resolveFieldDependencies<T>(config: InjectableConfig<T>, instance: T) {
+  protected async resolveFieldDependencies<T>(config: InjectableConfig<T>, instance: T): Promise<void> {
     const keys = Object.keys(config.dependencies.fields ?? {})
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       .filter(k => instance[k as keyof T] === undefined); // Filter out already set ones
 
     // And auto-wire
     if (keys.length) {
       const deps = await this.fetchDependencies(config, keys.map(x => config.dependencies.fields[x]));
       for (let i = 0; i < keys.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         instance[keys[i] as keyof T] = deps[i] as T[keyof T];
       }
     }
@@ -154,6 +165,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     // Create instance
     const inst = managed.factory ?
       managed.factory(...consValues) :
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       new (managed.class as ConcreteClass<T>)(...consValues);
 
     // And auto-wire fields
@@ -161,6 +173,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
 
     // If factory with field properties on the sub class
     if (managed.factory) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const resolved = this.get((inst as ClassInstance<T>).constructor);
 
       if (resolved) {
@@ -179,7 +192,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Create the instance
    */
-  protected async createInstance<T>(target: ClassTarget<T>, qualifier: symbol) {
+  protected async createInstance<T>(target: ClassTarget<T>, qualifier: symbol): Promise<T> {
     const classId = this.resolveTarget(target, qualifier).id;
 
     if (!this.instances.has(classId)) {
@@ -188,7 +201,8 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     }
 
     if (this.instancePromises.get(classId)!.has(qualifier)) {
-      return this.instancePromises.get(classId)!.get(qualifier);
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return this.instancePromises.get(classId)!.get(qualifier) as unknown as T;
     }
 
     const instancePromise = this.construct(target, qualifier);
@@ -197,17 +211,17 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       const instance = await instancePromise;
       this.instances.get(classId)!.set(qualifier, instance);
       return instance;
-    } catch (e) {
+    } catch (err) {
       // Clear it out, don't save failed constructions
       this.instancePromises.get(classId)!.delete(qualifier);
-      throw e;
+      throw err;
     }
   }
 
   /**
    * Destroy an instance
    */
-  protected destroyInstance(cls: Class, qualifier: symbol) {
+  protected destroyInstance(cls: Class, qualifier: symbol): void {
     const classId = cls.ᚕid;
 
     const activeInstance = this.instances.get(classId)!.get(qualifier);
@@ -225,7 +239,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Handle initial installation for the entire registry
    */
-  override initialInstall() {
+  override initialInstall(): Class[] {
     const finalizing = this.pendingFinalize;
     this.pendingFinalize = [];
 
@@ -233,13 +247,13 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       this.install(cls, { type: 'added', curr: cls });
     }
 
-    return [] as Class[];
+    return [];
   }
 
   /**
    * Register a cls as pending
    */
-  createPending(cls: Class) {
+  createPending(cls: Class): Partial<InjectableConfig> {
     if (!this.resolved) {
       this.pendingFinalize.push(cls);
     }
@@ -265,23 +279,25 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     if (!this.instances.has(classId) || !this.instances.get(classId)!.has(qualifier)) {
       await this.createInstance(target, qualifier); // Wait for proxy
     }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return this.instances.get(classId)!.get(qualifier)! as T;
   }
 
   /**
    * Get all available candidate types for the target
    */
-  getCandidateTypes<T>(target: Class<T>) {
+  getCandidateTypes<T>(target: Class<T>): InjectableConfig[] {
     const targetId = target.ᚕid;
     const qualifiers = this.targetToClass.get(targetId)!;
     const uniqueQualifiers = qualifiers ? Array.from(new Set(qualifiers.values())) : [];
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return uniqueQualifiers.map(id => this.get(id)! as InjectableConfig<T>);
   }
 
   /**
    * Register a constructor with dependencies
    */
-  registerConstructor<T>(cls: Class<T>, dependencies?: Dependency[]) {
+  registerConstructor<T>(cls: Class<T>, dependencies?: Dependency[]): void {
     const conf = this.getOrCreatePending(cls);
     conf.dependencies!.cons = dependencies;
   }
@@ -289,7 +305,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Register a property as a dependency
    */
-  registerProperty<T>(cls: Class<T>, field: string, dependency: Dependency) {
+  registerProperty<T>(cls: Class<T>, field: string, dependency: Dependency): void {
     const conf = this.getOrCreatePending(cls);
     conf.dependencies!.fields[field] = dependency;
   }
@@ -297,27 +313,28 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Register a class
    */
-  registerClass<T>(cls: Class<T>, pconfig: Partial<InjectableConfig<T>> = {}) {
-    const config = this.getOrCreatePending(pconfig.class ?? cls);
+  registerClass<T>(cls: Class<T>, pConfig: Partial<InjectableConfig<T>> = {}): void {
+    const config = this.getOrCreatePending(pConfig.class ?? cls);
 
     config.class = cls;
-    config.qualifier = pconfig.qualifier ?? config.qualifier ?? Symbol.for(cls.ᚕid);
-    if (pconfig.interfaces) {
-      config.interfaces?.push(...pconfig.interfaces);
+    config.qualifier = pConfig.qualifier ?? config.qualifier ?? Symbol.for(cls.ᚕid);
+    if (pConfig.interfaces) {
+      config.interfaces?.push(...pConfig.interfaces);
     }
-    if (pconfig.primary !== undefined) {
-      config.primary = pconfig.primary;
+    if (pConfig.primary !== undefined) {
+      config.primary = pConfig.primary;
     }
-    if (pconfig.factory) {
-      config.factory = pconfig.factory ?? config.factory;
+    if (pConfig.factory) {
+      config.factory = pConfig.factory ?? config.factory;
     }
-    if (pconfig.target) {
-      config.target = pconfig.target;
+    if (pConfig.target) {
+      config.target = pConfig.target;
     }
-    if (pconfig.dependencies) {
+    if (pConfig.dependencies) {
       config.dependencies = {
         fields: {},
-        ...pconfig.dependencies as Omit<InjectableConfig['dependencies'], 'fields'>
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        ...pConfig.dependencies as Omit<InjectableConfig['dependencies'], 'fields'>
       };
     }
   }
@@ -329,7 +346,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     id: string;
     qualifier?: undefined | symbol;
     fn: (...args: unknown[]) => unknown;
-  }) {
+  }): void {
     const finalConfig: Partial<InjectableConfig> = {};
 
     finalConfig.factory = config.fn;
@@ -349,6 +366,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     }
 
     // Create mock cls for DI purposes
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const cls = { ᚕid: config.id } as Class;
 
     finalConfig.class = cls;
@@ -359,13 +377,14 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       this.factories.set(config.src.ᚕid, new Map());
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     this.factories.get(config.src.ᚕid)!.set(cls, finalConfig as InjectableConfig);
   }
 
   /**
    * On Install event
    */
-  override onInstall<T>(cls: Class<T>, e: ChangeEvent<Class<T>>) {
+  override onInstall<T>(cls: Class<T>, e: ChangeEvent<Class<T>>): void {
     super.onInstall(cls, e);
 
     // Install factories separate from classes
@@ -379,9 +398,10 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Handle installing a class
    */
-  onInstallFinalize<T>(cls: Class<T>) {
+  onInstallFinalize<T>(cls: Class<T>): InjectableConfig<T> {
     const classId = cls.ᚕid;
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = this.getOrCreatePending(cls) as InjectableConfig<T>;
 
     // Allow for the factory to fulfill the target
@@ -475,11 +495,11 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
 
       // Register primary if only one interface provided and no parent config
       if (config.interfaces.length === 1 && !parentConfig) {
-        const [intf] = config.interfaces;
-        if (!this.targetToClass.has(intf.ᚕid)) {
-          this.targetToClass.set(intf.ᚕid, new Map());
+        const [primaryInterface] = config.interfaces;
+        if (!this.targetToClass.has(primaryInterface.ᚕid)) {
+          this.targetToClass.set(primaryInterface.ᚕid, new Map());
         }
-        this.targetToClass.get(intf.ᚕid)!.set(PrimaryCandidateⲐ, classId);
+        this.targetToClass.get(primaryInterface.ᚕid)!.set(PrimaryCandidateⲐ, classId);
       }
     }
 
@@ -489,7 +509,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Handle uninstalling a class
    */
-  override onUninstallFinalize(cls: Class) {
+  override onUninstallFinalize(cls: Class): void {
     const classId = cls.ᚕid;
 
     if (!this.classToTarget.has(cls.ᚕid)) {
@@ -506,7 +526,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Reset registry
    */
-  override onReset() {
+  override onReset(): void {
     super.onReset();
     this.pendingFinalize = [];
     this.instances.clear();
@@ -519,7 +539,8 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Inject fields into instance
    */
-  async injectFields<T extends { constructor: Class<T> }>(o: T, cls = o.constructor as Class<T>) {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  async injectFields<T extends { constructor: Class<T> }>(o: T, cls = o.constructor as Class<T>): Promise<void> {
     this.verifyInitialized();
     // Compute fields to be auto-wired
     return await this.resolveFieldDependencies(this.get(cls), o);

package/support/dynamic.injection.ts

@@ -2,12 +2,12 @@ import { RetargettingProxy } from '@travetto/base/src/internal/proxy';
 import { Class, ClassInstance } from '@travetto/base';
 
 import type { DependencyRegistry } from '../src/registry';
-import type { ClassTarget } from '../src/types';
+import type { ClassTarget, InjectableConfig } from '../src/types';
 
 /**
  * Wraps the Dependency Registry to support proxying instances
  */
-export function init($DependencyRegistry: Class<typeof DependencyRegistry>) {
+export function init($DependencyRegistry: Class<typeof DependencyRegistry>): typeof $DependencyRegistry {
 
   /**
    * Extending the $DependencyRegistry class to add some functionality for watching
@@ -20,35 +20,37 @@ export function init($DependencyRegistry: Class<typeof DependencyRegistry>) {
      */
     protected proxyInstance<T>(target: ClassTarget<T>, qual: symbol | undefined, instance: T): T {
       const { qualifier, id: classId } = this.resolveTarget(target, qual);
-      let proxy: RetargettingProxy<unknown>;
+      let proxy: RetargettingProxy<T>;
 
       if (!this.#proxies.has(classId)) {
         this.#proxies.set(classId, new Map());
       }
 
       if (!this.#proxies.get(classId)!.has(qualifier)) {
-        proxy = new RetargettingProxy<unknown>(instance);
+        proxy = new RetargettingProxy<T>(instance);
         this.#proxies.get(classId)!.set(qualifier, proxy);
         console.debug('Registering proxy', { id: target.ᚕid, qualifier: qualifier.toString() });
       } else {
-        proxy = this.#proxies.get(classId)!.get(qualifier)! as RetargettingProxy<unknown>;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        proxy = this.#proxies.get(classId)!.get(qualifier) as RetargettingProxy<T>;
         proxy.setTarget(instance);
         console.debug('Updating target', {
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           id: target.ᚕid, qualifier: qualifier.toString(), instanceType: (instance as unknown as ClassInstance<T>).constructor.name as string
         });
       }
 
-      return proxy.get() as T;
+      return proxy.get();
     }
 
     /**
      * Create instance and wrap in a proxy
      */
-    protected async createInstance<T>(target: ClassTarget<T>, qualifier: symbol) {
+    protected async createInstance<T>(target: ClassTarget<T>, qualifier: symbol): Promise<T> {
       const instance = await super.createInstance(target, qualifier);
       const classId = this.resolveTarget(target, qualifier).id;
       // Reset as proxy instance
-      const proxied = this.proxyInstance(target, qualifier, instance);
+      const proxied = this.proxyInstance<T>(target, qualifier, instance);
       this.instances.get(classId)!.set(qualifier, proxied);
       return proxied;
     }
@@ -56,7 +58,7 @@ export function init($DependencyRegistry: Class<typeof DependencyRegistry>) {
     /**
      * Reload proxy if in watch mode
      */
-    onInstallFinalize<T>(cls: Class<T>) {
+    onInstallFinalize<T>(cls: Class<T>): InjectableConfig<T> {
       const config = super.onInstallFinalize(cls);
       // If already loaded, reload
       const classId = cls.ᚕid;
@@ -74,7 +76,7 @@ export function init($DependencyRegistry: Class<typeof DependencyRegistry>) {
       return config;
     }
 
-    destroyInstance(cls: Class, qualifier: symbol) {
+    destroyInstance(cls: Class, qualifier: symbol): void {
       const classId = cls.ᚕid;
       const proxy = this.#proxies.get(classId)!.get(qualifier);
       super.destroyInstance(cls, qualifier);
@@ -83,7 +85,7 @@ export function init($DependencyRegistry: Class<typeof DependencyRegistry>) {
       }
     }
 
-    onReset() {
+    onReset(): void {
       super.onReset();
       this.#proxies.clear();
     }

package/support/invoke.ts

@@ -1,10 +1,15 @@
 import { EnvInit } from '@travetto/base/bin/init';
 
-export async function invoke(...[mod, cls, method, qualifier]: (string | undefined)[]) {
+export async function invoke(...[mod, cls, method, qualifier]: (string | undefined)[]): Promise<unknown> {
   EnvInit.init();
   await (await import('@travetto/base')).PhaseManager.run('init');
   const inst = await (await import('../src/registry')).DependencyRegistry
-    .getInstance((await import(mod!))[cls!], qualifier ? Symbol.for(qualifier) : qualifier as undefined);
+    .getInstance(
+      (await import(mod!))[cls!],
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      qualifier ? Symbol.for(qualifier) : qualifier as undefined
+    );
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return await (inst as Record<string, () => Promise<unknown>>)[method!]();
 }
 

package/support/transformer.injectable.ts

@@ -16,13 +16,14 @@ export class InjectableTransformer {
   /**
    * Handle a specific declaration param/property
    */
-  static processDeclaration(state: TransformerState, param: ts.ParameterDeclaration | ts.SetAccessorDeclaration | ts.PropertyDeclaration) {
+  static processDeclaration(state: TransformerState, param: ts.ParameterDeclaration | ts.SetAccessorDeclaration | ts.PropertyDeclaration): ts.Expression[] {
     const existing = state.findDecorator(this, param, 'Inject', INJECTABLE_MOD);
 
     if (!(existing || ts.isParameter(param))) {
       return [];
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const callExpr = existing?.expression as ts.CallExpression;
     const args: ts.Expression[] = [...(callExpr?.arguments ?? [])];
 
@@ -43,17 +44,17 @@ export class InjectableTransformer {
    * Mark class as Injectable
    */
   @OnClass('Injectable')
-  static registerInjectable(state: TransformerState, node: ts.ClassDeclaration) {
-    const cons = node.members.find(x => ts.isConstructorDeclaration(x)) as ts.ConstructorDeclaration;
+  static registerInjectable(state: TransformerState, node: ts.ClassDeclaration): typeof node {
+    const cons = node.members.find((x): x is ts.ConstructorDeclaration => ts.isConstructorDeclaration(x));
     const injectArgs = cons &&
       state.fromLiteral(cons.parameters.map(x => this.processDeclaration(state, x)));
 
     // Extract all interfaces
     const interfaces: ts.Node[] = [];
-    for (const impls of node.heritageClauses ?? []) {
-      if (impls.token === ts.SyntaxKind.ImplementsKeyword) {
-        for (const intType of impls.types) {
-          const resolvedType = state.resolveType(intType);
+    for (const clause of node.heritageClauses ?? []) {
+      if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+        for (const typeExpression of clause.types) {
+          const resolvedType = state.resolveType(typeExpression);
           if (resolvedType.key === 'external') {
             const resolved = state.getOrImport(resolvedType);
             interfaces.push(resolved);
@@ -85,7 +86,7 @@ export class InjectableTransformer {
    * Handle Inject annotations for fields/args
    */
   @OnProperty('Inject')
-  static registerInjectProperty(state: TransformerState, node: ts.PropertyDeclaration, dm?: DecoratorMeta) {
+  static registerInjectProperty(state: TransformerState, node: ts.PropertyDeclaration, dm?: DecoratorMeta): typeof node {
     const decl = state.findDecorator(this, node, 'Inject', INJECTABLE_MOD);
 
     // Doing decls
@@ -106,7 +107,7 @@ export class InjectableTransformer {
   * Handle Inject annotations for fields/args
   */
   @OnSetter('Inject')
-  static registerInjectSetter(state: TransformerState, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) {
+  static registerInjectSetter(state: TransformerState, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta): typeof node {
     const decl = state.findDecorator(this, node, 'Inject', INJECTABLE_MOD);
 
     // Doing decls
@@ -126,7 +127,7 @@ export class InjectableTransformer {
    * Handle InjectableFactory creation
    */
   @OnStaticMethod('InjectableFactory')
-  static registerFactory(state: TransformerState, node: ts.MethodDeclaration, dm?: DecoratorMeta) {
+  static registerFactory(state: TransformerState, node: ts.MethodDeclaration, dm?: DecoratorMeta): typeof node {
     if (!dm?.dec) {
       return node;
     }
@@ -148,6 +149,7 @@ export class InjectableTransformer {
 
     args.unshift(state.extendObjectLiteral({
       dependencies,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       src: (node.parent as ts.ClassDeclaration).name,
       target
     }));