@travetto/di 5.0.0-rc.0 → 5.0.0-rc.10

package/README.md

@@ -16,7 +16,7 @@ yarn add @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 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#L31) and [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L74) 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 implementation.
+The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) and [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L70) 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 implementation.
 
 **Code: Example Injectable**
 ```typescript
@@ -77,7 +77,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#L74) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L31).
+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#L70) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29).
 
 **Code: Example InjectableFactory**
 ```typescript
@@ -100,10 +100,10 @@ Given the `static` method `initService`, the function will be provided as a vali
 
 **Code: Example Conditional Dependency**
 ```typescript
-import { Env } from '@travetto/base';
+import { Runtime } from '@travetto/runtime';
 import { Inject, Injectable } from '@travetto/di';
 
-@Injectable({ enabled: Env.production })
+@Injectable({ enabled: Runtime.production })
 class ProductionLogger {
   async log() {
     console.log('This will only run in production');
@@ -125,12 +125,12 @@ class RuntimeService {
 
 In this example, the enabled flag is specified in relationship to the deployment environment.  When coupled with optional properties, and optional chaining, allows for seamless inclusion of optional dependencies at runtime.
 
-**Note**: Other modules are able to provide aliases to [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L31) that also provide additional functionality.  For example, the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") module @Config or the [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") module @Controller 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#L29) that also provide additional functionality.  For example, the [Configuration](https://github.com/travetto/travetto/tree/main/module/config#readme "Configuration support") module @Config or the [RESTful API](https://github.com/travetto/travetto/tree/main/module/rest#readme "Declarative api for RESTful APIs with support for the dependency injection module.") module @Controller 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#L31) 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#L29) 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#L31) 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#L29) decorator, which denotes a desire to inject a value directly.  These will be set post construction. 
 
 **Code: Example Injectable with dependencies as Inject fields**
 ```typescript
@@ -148,7 +148,7 @@ class CustomService {
 }
 ```
 
-The [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L31) 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#L29) constructor params, which will be provided as the instance is being constructed.
 
 **Code: Example Injectable with dependencies in constructor**
 ```typescript
@@ -165,7 +165,7 @@ class CustomService {
 }
 ```
 
-Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L74) params, which are comparable to constructor params
+Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L70) params, which are comparable to constructor params
 
 **Code: Example InjectableFactory with parameters as dependencies**
 ```typescript
@@ -223,9 +223,9 @@ class Config {
 ```
 
 ## Non-Framework Dependencies
-The module is built around the framework's management of class registration, and being able to decorate the code with [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L31) decorators. There may also be a desire to leverage external code and pull it into the dependency injection framework.  This could easily be achieved using a wrapper class that is owned by the framework. 
+The module is built around the framework's management of class registration, and being able to decorate the code with [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) decorators. There may also be a desire to leverage external code and pull it into the dependency injection framework.  This could easily be achieved using a wrapper class that is owned by the framework. 
 
-It is also possible to directly reference external types, and they will be converted into unique symbols.  These symbols cannot be used manually, but can be leveraged using [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L31) decorators.
+It is also possible to directly reference external types, and they will be converted into unique symbols.  These symbols cannot be used manually, but can be leveraged using [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L29) decorators.
 
 **Code: Example External Dependencies**
 ```typescript
@@ -233,6 +233,7 @@ import { EventEmitter } from 'node:events';
 import { Writable } from 'node:stream';
 
 import { Inject, Injectable, InjectableFactory } from '@travetto/di';
+import { asFull } from '@travetto/runtime';
 
 class Source {
   @InjectableFactory()
@@ -242,12 +243,12 @@ class Source {
 
   @InjectableFactory(Symbol.for('custom-1'))
   static writable(): Writable {
-    return {} as Writable;
+    return asFull({});
   }
 
   @InjectableFactory(Symbol.for('custom-2'))
   static writableAlt(): Writable {
-    return {} as Writable;
+    return asFull({});
   }
 }
 

package/package.json

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

package/src/decorator.ts

@@ -1,11 +1,10 @@
-import type { Class, ClassInstance } from '@travetto/base';
+import { asConstructable, asFull, TypedFunction, type Class } from '@travetto/runtime';
 
 import { InjectableFactoryConfig, InjectableConfig, Dependency } from './types';
 import { DependencyRegistry, ResolutionType } from './registry';
 
 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;
+  let out: Partial<T> = {};
   if (args) {
     if (Array.isArray(args)) {
       for (const arg of args) {
@@ -16,11 +15,10 @@ function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Par
         }
       }
     } else {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      out = args as T;
+      out = args;
     }
   }
-  return out;
+  return asFull(out);
 }
 
 /**
@@ -30,11 +28,11 @@ function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Par
  */
 export function Injectable(first?: Partial<InjectableConfig> | symbol, ...args: (Partial<InjectableConfig> | undefined)[]) {
   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);
+    const config = {
+      ...collapseConfig<Partial<InjectableConfig>>(first, ...args),
+      class: target
+    };
+    DependencyRegistry.registerClass(target, config);
     return target;
   };
 }
@@ -43,8 +41,7 @@ export type InjectConfig = { qualifier?: symbol, optional?: boolean, resolution?
 
 export function InjectArgs(configs?: InjectConfig[][]) {
   return <T extends Class>(target: T): void => {
-    DependencyRegistry.registerConstructor(target,
-      configs?.map(x => collapseConfig(...x)));
+    DependencyRegistry.registerConstructor(target, configs?.map(x => collapseConfig(...x)));
   };
 }
 
@@ -56,11 +53,10 @@ export function InjectArgs(configs?: InjectConfig[][]) {
 export function Inject(first?: InjectConfig | symbol, ...args: (InjectConfig | undefined)[]) {
   return (target: unknown, propertyKey?: string, idx?: number | PropertyDescriptor): void => {
     if (typeof idx !== 'number') { // Only register if on property
-      const config: InjectConfig = collapseConfig(first, ...args);
+      const config = collapseConfig<Dependency>(first, ...args);
 
       DependencyRegistry.registerProperty(
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        (target as ClassInstance).constructor, propertyKey as string, config as Dependency
+        asConstructable(target).constructor, propertyKey!, config
       );
     }
   };
@@ -72,8 +68,7 @@ export function Inject(first?: InjectConfig | symbol, ...args: (InjectConfig | u
  * @augments `@travetto/di:InjectableFactory`
  */
 export function InjectableFactory(first?: Partial<InjectableFactoryConfig> | symbol, ...args: (Partial<InjectableFactoryConfig> | undefined)[]) {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return <T extends Class>(target: T, property: string | symbol, descriptor: TypedPropertyDescriptor<((..._: any[]) => any)>): void => {
+  return <T extends Class>(target: T, property: string | symbol, descriptor: TypedPropertyDescriptor<TypedFunction>): void => {
     const config: InjectableFactoryConfig = collapseConfig(first, ...args);
     DependencyRegistry.registerFactory({
       ...config,

package/src/error.ts

@@ -1,4 +1,4 @@
-import { AppError } from '@travetto/base';
+import { AppError } from '@travetto/runtime';
 import { ClassTarget } from './types';
 
 function getName(symbol: symbol): string {

package/src/registry.ts

@@ -1,6 +1,5 @@
-import { Class, ClassInstance, ConcreteClass, Env } from '@travetto/base';
+import { Class, Runtime, asConstructable, castTo, classConstruct, describeFunction, asFull, castKey, TypedFunction } from '@travetto/runtime';
 import { MetadataRegistry, RootRegistry, ChangeEvent } from '@travetto/registry';
-import { RuntimeIndex } from '@travetto/manifest';
 
 import { Dependency, InjectableConfig, ClassTarget, InjectableFactoryConfig } from './types';
 import { InjectionError } from './error';
@@ -15,13 +14,11 @@ export type ResolutionType = 'strict' | 'loose' | 'any';
 const PrimaryCandidateⲐ = Symbol.for('@travetto/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'];
+  return !!o && typeof o === 'object' && 'postConstruct' in o && typeof o.postConstruct === 'function';
 }
 
 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'];
+  return !!o && typeof o === 'object' && 'preDestroy' in o && typeof o.preDestroy === 'function';
 }
 
 /**
@@ -70,8 +67,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
           } else if (filtered.length > 1) {
             // If dealing with sub types, prioritize exact matches
             const exact = this
-              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-              .getCandidateTypes(target as Class)
+              .getCandidateTypes(castTo<Class>(target))
               .filter(x => x.class === target);
             if (exact.length === 1) {
               qualifier = exact[0].qualifier;
@@ -99,8 +95,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       }
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const config = this.get(cls!) as InjectableConfig<T>;
+    const config: InjectableConfig<T> = castTo(this.get(cls!));
     return {
       qualifier,
       config,
@@ -139,15 +134,13 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
    */
   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
+      .filter(k => instance[castKey<T>(k)] === 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];
+        instance[castKey<T>(keys[i])] = castTo(deps[i]);
       }
     }
   }
@@ -164,16 +157,14 @@ 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);
+      classConstruct(managed.class, consValues);
 
     // And auto-wire fields
     await this.resolveFieldDependencies(managed, inst);
 
     // 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);
+      const resolved = this.get(asConstructable(inst).constructor);
 
       if (resolved) {
         await this.resolveFieldDependencies(resolved, inst);
@@ -200,8 +191,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     }
 
     if (this.instancePromises.get(classId)!.has(qualifier)) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return this.instancePromises.get(classId)!.get(qualifier) as unknown as T;
+      return castTo(this.instancePromises.get(classId)!.get(qualifier));
     }
 
     const instancePromise = this.construct(target, qualifier);
@@ -237,7 +227,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
 
   override async init(): Promise<void> {
     await super.init();
-    if (Env.dynamic) {
+    if (Runtime.dynamic) {
       const { DependencyRegistration } = await import('../support/dynamic.injection');
       DependencyRegistration.init(this);
     }
@@ -291,27 +281,24 @@ 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;
+    return castTo(this.instances.get(classId)!.get(qualifier));
   }
 
   /**
    * Get all available candidate types for the target
    */
-  getCandidateTypes<T>(target: Class<T>): InjectableConfig<T>[] {
+  getCandidateTypes<T, U = T>(target: Class<U>): InjectableConfig<T>[] {
     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>);
+    return castTo(uniqueQualifiers.map(id => this.get(id)));
   }
 
   /**
    * Get candidate instances by target type, with an optional filter
    */
   getCandidateInstances<T>(target: Class, predicate?: (cfg: InjectableConfig<T>) => boolean): Promise<T[]> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const inputs = this.getCandidateTypes<T>(target as Class<T>).filter(x => !predicate || predicate(x));
+    const inputs = this.getCandidateTypes<T>(target).filter(x => !predicate || predicate(x));
     return Promise.all(inputs.map(l => this.getInstance<T>(l.class, l.qualifier)));
   }
 
@@ -354,9 +341,10 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     }
     if (pConfig.dependencies) {
       config.dependencies = {
-        fields: {},
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        ...pConfig.dependencies as Omit<InjectableConfig['dependencies'], 'fields'>
+        ...pConfig.dependencies,
+        fields: {
+          ...pConfig.dependencies.fields
+        }
       };
     }
   }
@@ -367,7 +355,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   registerFactory(config: Omit<InjectableFactoryConfig, 'qualifier'> & {
     id: string;
     qualifier?: undefined | symbol;
-    fn: (...args: unknown[]) => unknown;
+    fn: TypedFunction;
   }): void {
     const finalConfig: Partial<InjectableConfig> = {};
 
@@ -389,8 +377,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;
+    const cls = asFull<Class>({ Ⲑid: config.id });
 
     finalConfig.class = cls;
 
@@ -400,8 +387,7 @@ 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);
+    this.factories.get(config.src.Ⲑid)!.set(cls, asFull(finalConfig));
   }
 
   /**
@@ -424,18 +410,17 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   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>;
+    const config: InjectableConfig<T> = castTo(this.getOrCreatePending(cls));
 
     if (!(typeof config.enabled === 'boolean' ? config.enabled : config.enabled())) {
       return config; // Do not setup if disabled
     }
 
     // Allow for the factory to fulfill the target
-    let parentClass = config.factory ? config.target : Object.getPrototypeOf(cls);
+    let parentClass: Function = config.factory ? config.target : Object.getPrototypeOf(cls);
 
     if (config.factory) {
-      while (RuntimeIndex.getFunctionMetadata(Object.getPrototypeOf(parentClass))?.abstract) {
+      while (describeFunction(Object.getPrototypeOf(parentClass))?.abstract) {
         parentClass = Object.getPrototypeOf(parentClass);
       }
       if (!this.targetToClass.has(classId)) {
@@ -465,7 +450,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       }
     }
 
-    if (RuntimeIndex.getFunctionMetadata(cls)?.abstract) { // Skip out early, only needed to inherit
+    if (describeFunction(cls)?.abstract) { // Skip out early, only needed to inherit
       return config;
     }
 
@@ -500,7 +485,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     }
 
     // If targeting self (default @Injectable behavior)
-    if ((classId === targetId || config.factory) && (parentConfig || RuntimeIndex.getFunctionMetadata(parentClass)?.abstract)) {
+    if ((classId === targetId || config.factory) && (parentConfig || describeFunction(parentClass)?.abstract)) {
       const parentId = parentClass.Ⲑid;
 
       if (!this.targetToClass.has(parentId)) {
@@ -558,8 +543,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Inject fields into instance
    */
-  // 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> {
+  async injectFields<T extends { constructor: Class<T> }>(o: T, cls = o.constructor): Promise<void> {
     this.verifyInitialized();
     // Compute fields to be auto-wired
     return await this.resolveFieldDependencies(this.get(cls), o);
@@ -573,8 +557,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   ): Promise<Awaited<ReturnType<T['run']>>> {
     await RootRegistry.init();
     const inst = await this.getInstance<T>(cls);
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return inst.run(...args) as Awaited<ReturnType<T['run']>>;
+    return castTo<Awaited<ReturnType<T['run']>>>(inst.run(...args));
   }
 }
 

package/src/types.ts

@@ -1,4 +1,4 @@
-import { Class } from '@travetto/base';
+import { Class } from '@travetto/runtime';
 
 export type ClassTarget<T = unknown> = Class<T> | Function;
 

package/support/dynamic.injection.ts

@@ -1,5 +1,4 @@
-import { Class, ClassInstance } from '@travetto/base';
-import { RuntimeIndex } from '@travetto/manifest';
+import { Class, describeFunction } from '@travetto/runtime';
 import { RetargettingProxy } from '@travetto/registry';
 
 import type { DependencyRegistry, ResolutionType, Resolved } from '../src/registry';
@@ -21,7 +20,7 @@ class $DynamicDependencyRegistry {
    */
   proxyInstance<T>(target: ClassTarget<T>, qual: symbol | undefined, instance: T): T {
     const { qualifier, id: classId } = this.#registryResolveTarget(target, qual);
-    let proxy: RetargettingProxy<T>;
+    let proxy: RetargettingProxy<unknown>;
 
     if (!this.#proxies.has(classId)) {
       this.#proxies.set(classId, new Map());
@@ -34,18 +33,16 @@ class $DynamicDependencyRegistry {
         console.debug('Registering proxy', { id: target.Ⲑid, qualifier: qualifier.toString() });
       }
     } else {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      proxy = this.#proxies.get(classId)!.get(qualifier) as RetargettingProxy<T>;
+      proxy = this.#proxies.get(classId)!.get(qualifier)!;
       proxy.setTarget(instance);
       if (this.#registry.trace) {
         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
+          id: target.Ⲑid, qualifier: qualifier.toString(), instanceType: target.name
         });
       }
     }
 
-    return proxy.get();
+    return proxy.get<T>();
   }
 
   /**
@@ -69,7 +66,7 @@ class $DynamicDependencyRegistry {
     const classId = cls.Ⲑid;
 
     if (
-      !RuntimeIndex.getFunctionMetadata(cls)?.abstract &&
+      !describeFunction(cls)?.abstract &&
       this.#proxies.has(classId) &&
       this.#proxies.get(classId)!.has(config.qualifier)
     ) {

package/support/test/suite.ts

@@ -1,4 +1,4 @@
-import { Class, ClassInstance } from '@travetto/base';
+import { castTo, Class, ClassInstance } from '@travetto/runtime';
 import { RootRegistry } from '@travetto/registry';
 import { SuiteRegistry } from '@travetto/test';
 
@@ -11,9 +11,9 @@ export function InjectableSuite() {
   return (target: Class) => {
     SuiteRegistry.registerPendingListener(
       target,
-      async function (this: Record<string, Function>) {
+      async function (this: unknown) {
         await RootRegistry.init();
-        await DependencyRegistry.injectFields(this as ClassInstance, target);
+        await DependencyRegistry.injectFields(castTo<ClassInstance>(this), target);
       },
       'beforeEach'
     );

package/support/transformer.injectable.ts

@@ -21,9 +21,11 @@ export class InjectableTransformer {
       return [];
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const callExpr = existing?.expression as ts.CallExpression;
-    const args: ts.Expression[] = [...(callExpr?.arguments ?? [])];
+    const args: ts.Expression[] = [];
+
+    if (existing && ts.isCallExpression(existing.expression)) {
+      args.push(...existing.expression.arguments);
+    }
 
     const payload: { target?: unknown, qualifier?: unknown, optional?: boolean } = {};
 
@@ -140,6 +142,11 @@ export class InjectableTransformer {
       return node;
     }
 
+    const parent = node.parent;
+    if (ts.isObjectLiteralExpression(parent)) {
+      return node;
+    }
+
     const dec = dm?.dec;
 
     // Extract config
@@ -148,8 +155,7 @@ export class InjectableTransformer {
     // Read target from config or resolve
     const config: { dependencies: unknown[], target?: unknown, qualifier?: unknown, src?: unknown } = {
       dependencies,
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      src: (node.parent as ts.ClassDeclaration).name,
+      src: parent.name,
     };
     let ret = state.resolveReturnType(node);
     if (ret.key === 'literal' && ret.ctor === Promise && ret.typeArguments) {