@travetto/di 3.0.0-rc.2 → 3.0.0-rc.21

package/README.md

@@ -1,5 +1,5 @@
 <!-- This file was generated by @travetto/doc and should not be modified directly -->
-<!-- Please modify https://github.com/travetto/travetto/tree/main/module/di/doc.ts and execute "npx trv doc" to rebuild -->
+<!-- Please modify https://github.com/travetto/travetto/tree/main/module/di/DOC.ts and execute "npx trv doc" to rebuild -->
 # Dependency Injection
 ## Dependency registration/management and injection support.
 
@@ -11,7 +11,7 @@ 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 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#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).
+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.
 
 **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#L75) decorator denotes a `static` class method that produces an [@Injectable](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L32).
+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).
 
 **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#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.
+**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.
 
 ## 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:
+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:
 
-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.
+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.
 
-**Code: Example Injectable with dependencies as [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L32) fields**
+**Code: Example Injectable with dependencies as [@Inject](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L31) 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#L32) 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#L31) 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#L75) params, which are comparable to constructor params
+Via [@InjectableFactory](https://github.com/travetto/travetto/tree/main/module/di/src/decorator.ts#L74) params, which are comparable to constructor params
 
 **Code: Example InjectableFactory with parameters as dependencies**
 ```typescript
@@ -210,3 +210,39 @@ class ManualLookup {
   }
 }
 ```
+
+Additionally, support for interfaces (over class inheritance) is provided, but requires binding the interface to a concrete class as the interface does not exist at runtime.
+
+**Code: Example Interface Injection**
+```typescript
+import { DependencyRegistry, Inject, Injectable, InjectableFactory } from '@travetto/di';
+
+class TargetConcrete { }
+
+/**
+ * @concrete .:TargetConcrete
+ */
+export interface ServiceContract {
+  deleteUser(userId: string): Promise<void>;
+}
+
+class MyCustomService implements ServiceContract {
+  async deleteUser(userId: string): Promise<void> {
+    // Do something
+  }
+}
+
+@Injectable()
+class SpecificService {
+
+  @Inject()
+  service: ServiceContract;
+}
+
+class ManualInvocationOfInterface {
+  @InjectableFactory()
+  static getCustomService(): Promise<ServiceContract> {
+    return DependencyRegistry.getInstance<ServiceContract>(TargetConcrete);
+  }
+}
+```

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@travetto/di",
-  "displayName": "Dependency Injection",
-  "version": "3.0.0-rc.2",
+  "version": "3.0.0-rc.21",
   "description": "Dependency registration/management and injection support.",
   "keywords": [
     "ast-transformations",
@@ -18,27 +17,28 @@
     "name": "Travetto Framework"
   },
   "files": [
-    "index.ts",
+    "__index__.ts",
     "src",
-    "support",
-    "test-support"
+    "support"
   ],
-  "main": "index.ts",
+  "main": "__index__.ts",
   "repository": {
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/di"
   },
   "dependencies": {
-    "@travetto/transformer": "^3.0.0-rc.2",
-    "@travetto/registry": "^3.0.0-rc.2"
+    "@travetto/registry": "^3.0.0-rc.21"
   },
-  "devDependencies": {
-    "@travetto/config": "^3.0.0-rc.2",
-    "@travetto/schema": "^3.0.0-rc.2"
+  "peerDependencies": {
+    "@travetto/transformer": "^3.0.0-rc.20"
   },
-  "docDependencies": {
-    "@travetto/model-mongo": true,
-    "@travetto/rest": true
+  "peerDependenciesMeta": {
+    "@travetto/transformer": {
+      "optional": true
+    }
+  },
+  "travetto": {
+    "displayName": "Dependency Injection"
   },
   "publishConfig": {
     "access": "public"

package/src/decorator.ts

@@ -1,5 +1,4 @@
-import { Class, ClassInstance } from '@travetto/base';
-import { MethodDescriptor } from '@travetto/base/src/internal/types';
+import type { MethodDescriptor, Class, ClassInstance } from '@travetto/base';
 
 import { InjectableFactoryConfig, InjectableConfig, Dependency } from './types';
 import { DependencyRegistry, ResolutionType } from './registry';
@@ -27,7 +26,7 @@ function collapseConfig<T extends { qualifier?: symbol }>(...args: (symbol | Par
 /**
  * Indicate that a class is able to be injected
  *
- * @augments `@trv:di/Injectable`
+ * @augments `@travetto/di:Injectable`
  */
 export function Injectable(first?: Partial<InjectableConfig> | symbol, ...args: (Partial<InjectableConfig> | undefined)[]) {
   return <T extends Class>(target: T): T => {
@@ -52,7 +51,7 @@ export function InjectArgs(configs?: InjectConfig[][]) {
 /**
  * Indicate that a field is able to be injected
  *
- * @augments `@trv:di/Inject`
+ * @augments `@travetto/di:Inject`
  */
 export function Inject(first?: InjectConfig | symbol, ...args: (InjectConfig | undefined)[]) {
   return (target: unknown, propertyKey: string | symbol, idx?: number | PropertyDescriptor): void => {
@@ -70,7 +69,7 @@ export function Inject(first?: InjectConfig | symbol, ...args: (InjectConfig | u
 /**
  * Identifies a static method that is able to produce a dependency
  *
- * @augments `@trv:di/InjectableFactory`
+ * @augments `@travetto/di:InjectableFactory`
  */
 export function InjectableFactory(first?: Partial<InjectableFactoryConfig> | symbol, ...args: (Partial<InjectableFactoryConfig> | undefined)[]) {
   return <T extends Class>(target: T, property: string | symbol, descriptor: MethodDescriptor): void => {
@@ -79,7 +78,7 @@ export function InjectableFactory(first?: Partial<InjectableFactoryConfig> | sym
       ...config,
       dependencies: config.dependencies?.map(x => Array.isArray(x) ? collapseConfig(...x) : collapseConfig(x)),
       fn: descriptor.value!,
-      id: `${target.ᚕid}#${property.toString()}`
+      id: `${target.Ⲑid}#${property.toString()}`
     });
   };
 }

package/src/error.ts

@@ -7,6 +7,6 @@ function getName(symbol: symbol): string {
 
 export class InjectionError extends AppError {
   constructor(message: string, target: ClassTarget, qualifiers?: symbol[]) {
-    super(`${message}: [${target.ᚕid}]${qualifiers ? `[${qualifiers.map(getName)}]` : ''}`, 'notfound');
+    super(`${message}: [${target.Ⲑid}]${qualifiers ? `[${qualifiers.map(getName)}]` : ''}`, 'notfound');
   }
 }

package/src/internal/types.ts

@@ -0,0 +1 @@
+export class AutoCreateTarget { }

package/src/registry.ts

@@ -1,17 +1,18 @@
-import { Class, ClassInstance, ConcreteClass } from '@travetto/base';
+import { Class, ClassInstance, ConcreteClass, GlobalEnv } from '@travetto/base';
 import { MetadataRegistry, RootRegistry, ChangeEvent } from '@travetto/registry';
-import { Dynamic } from '@travetto/base/src/internal/dynamic';
+import { RootIndex } from '@travetto/manifest';
 
 import { Dependency, InjectableConfig, ClassTarget, InjectableFactoryConfig } from './types';
 import { InjectionError } from './error';
+import { AutoCreateTarget } from './internal/types';
 
 type TargetId = string;
 type ClassId = string;
-type Resolved<T> = { config: InjectableConfig<T>, qualifier: symbol, id: string };
+export type Resolved<T> = { config: InjectableConfig<T>, qualifier: symbol, id: string };
 
 export type ResolutionType = 'strict' | 'loose' | 'any';
 
-const PrimaryCandidateⲐ = Symbol.for('@trv:di/primary');
+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
@@ -26,7 +27,6 @@ function hasPreDestroy(o: unknown): o is { preDestroy: () => unknown } {
 /**
  * Dependency registry
  */
-@Dynamic('@travetto/di/support/dynamic.injection')
 class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   protected pendingFinalize: Class[] = [];
 
@@ -50,7 +50,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
    * @param qualifier
    */
   protected resolveTarget<T>(target: ClassTarget<T>, qualifier?: symbol, resolution?: ResolutionType): Resolved<T> {
-    const qualifiers = this.targetToClass.get(target.ᚕid) ?? new Map<symbol, string>();
+    const qualifiers = this.targetToClass.get(target.Ⲑid) ?? new Map<symbol, string>();
 
     let cls: string | undefined;
 
@@ -90,7 +90,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
         throw new InjectionError('Dependency not found', target);
       } 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: target.ᚕid });
+          console.debug('Unable to find specific dependency, falling back to general instance', { qualifier, target: target.Ⲑid });
           return this.resolveTarget(target);
         }
         throw new InjectionError('Dependency not found', target, [qualifier]);
@@ -104,7 +104,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     return {
       qualifier,
       config,
-      id: (config.factory ? config.target : config.class).ᚕid
+      id: (config.factory ? config.target : config.class).Ⲑid
     };
   }
 
@@ -124,7 +124,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
           return undefined;
         } else {
           if (err && err instanceof Error) {
-            err.message = `${err.message} via=${managed.class.ᚕid}`;
+            err.message = `${err.message} via=${managed.class.Ⲑid}`;
           }
           throw err;
         }
@@ -221,7 +221,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
    * Destroy an instance
    */
   protected destroyInstance(cls: Class, qualifier: symbol): void {
-    const classId = cls.ᚕid;
+    const classId = cls.Ⲑid;
 
     const activeInstance = this.instances.get(classId)!.get(qualifier);
     if (hasPreDestroy(activeInstance)) {
@@ -231,8 +231,20 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     this.defaultSymbols.delete(qualifier);
     this.instances.get(classId)!.delete(qualifier);
     this.instancePromises.get(classId)!.delete(qualifier);
-    this.classToTarget.get(cls.ᚕid)!.delete(qualifier);
-    console.debug('On uninstall', { id: cls.ᚕid, qualifier: qualifier.toString(), classId });
+    this.classToTarget.get(cls.Ⲑid)!.delete(qualifier);
+    console.debug('On uninstall', { id: cls.Ⲑid, qualifier: qualifier.toString(), classId });
+  }
+
+  override async init(): Promise<void> {
+    await super.init();
+    if (GlobalEnv.dynamic) {
+      const { DependencyRegistration } = await import('../support/dynamic.injection.js');
+      DependencyRegistration.init(this);
+    }
+    // Allow for auto-creation
+    for (const cfg of await this.getCandidateTypes(AutoCreateTarget)) {
+      await this.getInstance(cfg.class, cfg.qualifier);
+    }
   }
 
   /**
@@ -286,7 +298,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
    * Get all available candidate types for the target
    */
   getCandidateTypes<T>(target: Class<T>): InjectableConfig[] {
-    const targetId = target.ᚕid;
+    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
@@ -316,7 +328,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     const config = this.getOrCreatePending(pConfig.class ?? cls);
 
     config.class = cls;
-    config.qualifier = pConfig.qualifier ?? config.qualifier ?? Symbol.for(cls.ᚕid);
+    config.qualifier = pConfig.qualifier ?? config.qualifier ?? Symbol.for(cls.Ⲑid);
     if (pConfig.interfaces) {
       config.interfaces?.push(...pConfig.interfaces);
     }
@@ -366,18 +378,18 @@ 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 = { Ⲑid: config.id } as Class;
 
     finalConfig.class = cls;
 
     this.registerClass(cls, finalConfig);
 
-    if (!this.factories.has(config.src.ᚕid)) {
-      this.factories.set(config.src.ᚕid, new Map());
+    if (!this.factories.has(config.src.Ⲑid)) {
+      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, finalConfig as InjectableConfig);
   }
 
   /**
@@ -387,8 +399,8 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     super.onInstall(cls, e);
 
     // Install factories separate from classes
-    if (this.factories.has(cls.ᚕid)) {
-      for (const fact of this.factories.get(cls.ᚕid)!.keys()) {
+    if (this.factories.has(cls.Ⲑid)) {
+      for (const fact of this.factories.get(cls.Ⲑid)!.keys()) {
         this.onInstall(fact, e);
       }
     }
@@ -398,7 +410,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
    * Handle installing a class
    */
   onInstallFinalize<T>(cls: Class<T>): InjectableConfig<T> {
-    const classId = cls.ᚕid;
+    const classId = cls.Ⲑid;
 
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = this.getOrCreatePending(cls) as InjectableConfig<T>;
@@ -407,12 +419,17 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     let parentClass = config.factory ? config.target : Object.getPrototypeOf(cls);
 
     if (config.factory) {
-      while (Object.getPrototypeOf(parentClass).ᚕabstract) {
+      while (RootIndex.getFunctionMetadata(Object.getPrototypeOf(parentClass))?.abstract) {
         parentClass = Object.getPrototypeOf(parentClass);
       }
+      if (!this.targetToClass.has(classId)) {
+        this.targetToClass.set(classId, new Map());
+      }
+      // Make explicitly discoverable as self
+      this.targetToClass.get(classId)?.set(config.qualifier, classId);
     }
 
-    const parentConfig = this.get(parentClass.ᚕid);
+    const parentConfig = this.get(parentClass.Ⲑid);
 
     if (parentConfig) {
       config.dependencies.fields = {
@@ -432,7 +449,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       }
     }
 
-    if (cls.ᚕabstract) { // Skip out early, only needed to inherit
+    if (RootIndex.getFunctionMetadata(cls)?.abstract) { // Skip out early, only needed to inherit
       return config;
     }
 
@@ -440,13 +457,13 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       this.classToTarget.set(classId, new Map());
     }
 
-    const targetId = config.target.ᚕid;
+    const targetId = config.target.Ⲑid;
 
     if (!this.targetToClass.has(targetId)) {
       this.targetToClass.set(targetId, new Map());
     }
 
-    if (config.qualifier === Symbol.for(cls.ᚕid)) {
+    if (config.qualifier === Symbol.for(cls.Ⲑid)) {
       this.defaultSymbols.add(config.qualifier);
     }
 
@@ -455,20 +472,20 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
 
     // If aliased
     for (const el of config.interfaces) {
-      if (!this.targetToClass.has(el.ᚕid)) {
-        this.targetToClass.set(el.ᚕid, new Map());
+      if (!this.targetToClass.has(el.Ⲑid)) {
+        this.targetToClass.set(el.Ⲑid, new Map());
       }
-      this.targetToClass.get(el.ᚕid)!.set(config.qualifier, classId);
-      this.classToTarget.get(classId)!.set(Symbol.for(el.ᚕid), el.ᚕid);
+      this.targetToClass.get(el.Ⲑid)!.set(config.qualifier, classId);
+      this.classToTarget.get(classId)!.set(Symbol.for(el.Ⲑid), el.Ⲑid);
 
       if (config.primary && (classId === targetId || config.factory)) {
-        this.targetToClass.get(el.ᚕid)!.set(PrimaryCandidateⲐ, classId);
+        this.targetToClass.get(el.Ⲑid)!.set(PrimaryCandidateⲐ, classId);
       }
     }
 
     // If targeting self (default @Injectable behavior)
-    if ((classId === targetId || config.factory) && (parentConfig || parentClass.ᚕabstract)) {
-      const parentId = parentClass.ᚕid;
+    if ((classId === targetId || config.factory) && (parentConfig || RootIndex.getFunctionMetadata(parentClass)?.abstract)) {
+      const parentId = parentClass.Ⲑid;
 
       if (!this.targetToClass.has(parentId)) {
         this.targetToClass.set(parentId, new Map());
@@ -495,10 +512,10 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
       // Register primary if only one interface provided and no parent config
       if (config.interfaces.length === 1 && !parentConfig) {
         const [primaryInterface] = config.interfaces;
-        if (!this.targetToClass.has(primaryInterface.ᚕid)) {
-          this.targetToClass.set(primaryInterface.ᚕid, new Map());
+        if (!this.targetToClass.has(primaryInterface.Ⲑid)) {
+          this.targetToClass.set(primaryInterface.Ⲑid, new Map());
         }
-        this.targetToClass.get(primaryInterface.ᚕid)!.set(PrimaryCandidateⲐ, classId);
+        this.targetToClass.get(primaryInterface.Ⲑid)!.set(PrimaryCandidateⲐ, classId);
       }
     }
 
@@ -509,9 +526,9 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
    * Handle uninstalling a class
    */
   override onUninstallFinalize(cls: Class): void {
-    const classId = cls.ᚕid;
+    const classId = cls.Ⲑid;
 
-    if (!this.classToTarget.has(cls.ᚕid)) {
+    if (!this.classToTarget.has(cls.Ⲑid)) {
       return;
     }
 

package/src/types.ts

@@ -77,4 +77,9 @@ export interface InjectableFactoryConfig<T = unknown> extends Core<T> {
    * List of all dependencies as function arguments
    */
   dependencies?: Dependency[];
-}
+}
+
+/**
+ * @concrete ./internal/types:AutoCreateTarget
+ */
+export interface AutoCreate { }

package/support/dynamic.injection.ts

@@ -1,95 +1,114 @@
-import { RetargettingProxy } from '@travetto/base/src/internal/proxy';
-import { Class, ClassInstance } from '@travetto/base';
+import { RetargettingProxy, Class, ClassInstance } from '@travetto/base';
+import { RootIndex } from '@travetto/manifest';
 
-import type { DependencyRegistry } from '../src/registry';
+import type { DependencyRegistry, ResolutionType, Resolved } from '../src/registry';
 import type { ClassTarget, InjectableConfig } from '../src/types';
 
 /**
  * Wraps the Dependency Registry to support proxying instances
  */
-export function init($DependencyRegistry: Class<typeof DependencyRegistry>): typeof $DependencyRegistry {
+class $DynamicDependencyRegistry {
+  #proxies = new Map<string, Map<symbol | undefined, RetargettingProxy<unknown>>>();
+  #registry: typeof DependencyRegistry;
+  #registryCreateInstance: <T>(target: ClassTarget<T>, qualifier: symbol) => Promise<T>;
+  #registryResolveTarget: <T>(target: ClassTarget<T>, qualifier?: symbol, resolution?: ResolutionType) => Resolved<T>;
+  #registryOnInstallFinalize: <T>(target: Class<T>) => InjectableConfig<T>;
+  #registryDestroyInstance: <T>(target: Class<T>, qualifier: symbol) => void;
+  #registryOnReset: () => void;
 
   /**
-   * Extending the $DependencyRegistry class to add some functionality for watching
+   * Proxy the created instance
    */
-  const Cls = class extends $DependencyRegistry {
-    #proxies = new Map<string, Map<symbol | undefined, RetargettingProxy<unknown>>>();
+  proxyInstance<T>(target: ClassTarget<T>, qual: symbol | undefined, instance: T): T {
+    const { qualifier, id: classId } = this.#registryResolveTarget(target, qual);
+    let proxy: RetargettingProxy<T>;
 
-    /**
-     * Proxy the created instance
-     */
-    protected proxyInstance<T>(target: ClassTarget<T>, qual: symbol | undefined, instance: T): T {
-      const { qualifier, id: classId } = this.resolveTarget(target, qual);
-      let proxy: RetargettingProxy<T>;
-
-      if (!this.#proxies.has(classId)) {
-        this.#proxies.set(classId, new Map());
-      }
+    if (!this.#proxies.has(classId)) {
+      this.#proxies.set(classId, new Map());
+    }
 
-      if (!this.#proxies.get(classId)!.has(qualifier)) {
-        proxy = new RetargettingProxy<T>(instance);
-        this.#proxies.get(classId)!.set(qualifier, proxy);
-        console.debug('Registering proxy', { id: target.ᚕid, qualifier: qualifier.toString() });
-      } else {
+    if (!this.#proxies.get(classId)!.has(qualifier)) {
+      proxy = new RetargettingProxy<T>(instance);
+      this.#proxies.get(classId)!.set(qualifier, proxy);
+      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.setTarget(instance);
+      console.debug('Updating target', {
         // 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();
+        id: target.Ⲑid, qualifier: qualifier.toString(), instanceType: (instance as unknown as ClassInstance<T>).constructor.name as string
+      });
     }
 
-    /**
-     * Create instance and wrap in a proxy
-     */
-    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<T>(target, qualifier, instance);
-      this.instances.get(classId)!.set(qualifier, proxied);
-      return proxied;
-    }
+    return proxy.get();
+  }
 
-    /**
-     * Reload proxy if in watch mode
-     */
-    onInstallFinalize<T>(cls: Class<T>): InjectableConfig<T> {
-      const config = super.onInstallFinalize(cls);
-      // If already loaded, reload
-      const classId = cls.ᚕid;
+  /**
+   * Create instance and wrap in a proxy
+   */
+  async createInstance<T>(target: ClassTarget<T>, qualifier: symbol): Promise<T> {
+    const instance = await this.#registryCreateInstance(target, qualifier);
+    const classId = this.#registryResolveTarget(target, qualifier).id;
+    // Reset as proxy instance
+    const proxied = this.proxyInstance<T>(target, qualifier, instance);
+    this.#registry['instances'].get(classId)!.set(qualifier, proxied);
+    return proxied;
+  }
 
-      if (
-        !cls.ᚕabstract &&
-        this.#proxies.has(classId) &&
-        this.#proxies.get(classId)!.has(config.qualifier)
-      ) {
-        console.debug('Reloading on next tick');
-        // Timing matters due to create instance being asynchronous
-        process.nextTick(() => this.createInstance(config.target, config.qualifier));
-      }
+  /**
+   * Reload proxy if in watch mode
+   */
+  onInstallFinalize<T>(cls: Class<T>): InjectableConfig<T> {
+    const config = this.#registryOnInstallFinalize(cls);
+    // If already loaded, reload
+    const classId = cls.Ⲑid;
 
-      return config;
+    if (
+      !RootIndex.getFunctionMetadata(cls)?.abstract &&
+      this.#proxies.has(classId) &&
+      this.#proxies.get(classId)!.has(config.qualifier)
+    ) {
+      console.debug('Reloading on next tick');
+      // Timing matters due to create instance being asynchronous
+      process.nextTick(() => this.createInstance(config.target, config.qualifier));
     }
 
-    destroyInstance(cls: Class, qualifier: symbol): void {
-      const classId = cls.ᚕid;
-      const proxy = this.#proxies.get(classId)!.get(qualifier);
-      super.destroyInstance(cls, qualifier);
-      if (proxy) {
-        proxy.setTarget(null);
-      }
-    }
+    return config;
+  }
 
-    onReset(): void {
-      super.onReset();
-      this.#proxies.clear();
+  destroyInstance(cls: Class, qualifier: symbol): void {
+    const classId = cls.Ⲑid;
+    const proxy = this.#proxies.get(classId)!.get(qualifier);
+    this.#registryDestroyInstance(cls, qualifier);
+    if (proxy) {
+      proxy.setTarget(null);
     }
-  };
+  }
+
+  onReset(): void {
+    this.#registryOnReset();
+    this.#proxies.clear();
+  }
+
+  register(registry: typeof DependencyRegistry): void {
+    this.#registry = registry;
+    this.#registryCreateInstance = registry['createInstance'].bind(registry);
+    this.#registryResolveTarget = registry['resolveTarget'].bind(registry);
+    this.#registryOnInstallFinalize = registry['onInstallFinalize'].bind(registry);
+    this.#registryDestroyInstance = registry['destroyInstance'].bind(registry);
+    this.#registryOnReset = registry['onReset'].bind(registry);
+
+    this.#registry['createInstance'] = this.createInstance.bind(this);
+    this.#registry['destroyInstance'] = this.destroyInstance.bind(this);
+    this.#registry['onReset'] = this.onReset.bind(this);
+    this.#registry['onInstallFinalize'] = this.onInstallFinalize.bind(this);
+  }
+}
 
-  return Cls;
-}
+export const DependencyRegistration = {
+  init(registry: typeof DependencyRegistry): void {
+    const dynamic = new $DynamicDependencyRegistry();
+    dynamic.register(registry);
+  }
+};

package/{test-support → support/test}/suite.ts

@@ -2,7 +2,7 @@ import { Class, ClassInstance } from '@travetto/base';
 import { RootRegistry } from '@travetto/registry';
 import { SuiteRegistry } from '@travetto/test';
 
-import { DependencyRegistry } from '../src/registry';
+import { DependencyRegistry } from '../../src/registry';
 
 /**
  * Registers a suite as injectable

package/support/transformer.injectable.ts

@@ -1,7 +1,7 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 import {
-  TransformerState, DecoratorMeta, OnClass, OnProperty, OnStaticMethod, DecoratorUtil, LiteralUtil, TransformerId, OnSetter
+  TransformerState, DecoratorMeta, OnClass, OnProperty, OnStaticMethod, DecoratorUtil, LiteralUtil, OnSetter
 } from '@travetto/transformer';
 
 const INJECTABLE_MOD = '@travetto/di/src/decorator';
@@ -11,8 +11,6 @@ const INJECTABLE_MOD = '@travetto/di/src/decorator';
  */
 export class InjectableTransformer {
 
-  static [TransformerId] = '@trv:di';
-
   /**
    * Handle a specific declaration param/property
    */
@@ -27,15 +25,14 @@ export class InjectableTransformer {
     const callExpr = existing?.expression as ts.CallExpression;
     const args: ts.Expression[] = [...(callExpr?.arguments ?? [])];
 
-    let optional = undefined;
+    let optional: ts.Expression | undefined = undefined;
     if (optional === undefined && !!param.questionToken) {
       optional = state.fromLiteral(true);
     }
 
-    args.unshift(state.fromLiteral({
-      target: state.getOrImport(state.resolveExternalType(ts.isSetAccessorDeclaration(param) ? param.parameters[0] : param)),
-      optional
-    }));
+    const keyParam = ts.isSetAccessorDeclaration(param) ? param.parameters[0] : param;
+    const target = state.getOrImport(state.resolveExternalType(keyParam));
+    args.unshift(state.fromLiteral({ target, optional }));
 
     return args;
   }
@@ -108,12 +105,14 @@ export class InjectableTransformer {
   static registerInjectSetter(state: TransformerState, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta): typeof node {
     const decl = state.findDecorator(this, node, 'Inject', INJECTABLE_MOD);
 
+    const modifiers = DecoratorUtil.spliceDecorators(node, decl, [
+      state.createDecorator(INJECTABLE_MOD, 'Inject', ...this.processDeclaration(state, node)),
+    ], 0);
+
     // Doing decls
     return state.factory.updateSetAccessorDeclaration(
       node,
-      DecoratorUtil.spliceDecorators(node, decl, [
-        state.createDecorator(INJECTABLE_MOD, 'Inject', ...this.processDeclaration(state, node)),
-      ], 0),
+      modifiers,
       node.name,
       node.parameters,
       node.body

package/support/invoke.ts

@@ -1,16 +0,0 @@
-import { EnvInit } from '@travetto/base/bin/init';
-
-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!],
-      // 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!]();
-}
-
-invoke(...process.argv.slice(2));