@travetto/di 3.3.1 → 3.3.2

package/README.md

@@ -98,6 +98,33 @@ 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.
 
+**Code: Example Conditional Dependency**
+```typescript
+import { GlobalEnv } from '@travetto/base';
+import { Inject, Injectable } from '@travetto/di';
+
+@Injectable({ enabled: !GlobalEnv.devMode })
+class ProductionLogger {
+  async log() {
+    console.log('This will only run in production');
+  }
+}
+
+@Injectable()
+class RuntimeService {
+  @Inject()
+  logger?: ProductionLogger;
+
+  action(): void {
+    // Only injected when available, in prod
+    this.logger?.log();
+    // Do work
+  }
+}
+```
+
+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.
 
 ## Injection

package/package.json

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

package/src/registry.ts

@@ -271,6 +271,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
 
     return {
       class: cls,
+      enabled: true,
       target: cls,
       interfaces: [],
       dependencies: {
@@ -297,7 +298,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   /**
    * Get all available candidate types for the target
    */
-  getCandidateTypes<T>(target: Class<T>): InjectableConfig[] {
+  getCandidateTypes<T>(target: Class<T>): InjectableConfig<T>[] {
     const targetId = target.Ⲑid;
     const qualifiers = this.targetToClass.get(targetId)!;
     const uniqueQualifiers = qualifiers ? Array.from(new Set(qualifiers.values())) : [];
@@ -305,6 +306,15 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     return uniqueQualifiers.map(id => this.get(id)! as InjectableConfig<T>);
   }
 
+  /**
+   * 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));
+    return Promise.all(inputs.map(l => this.getInstance<T>(l.class, l.qualifier)));
+  }
+
   /**
    * Register a constructor with dependencies
    */
@@ -327,6 +337,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   registerClass<T>(cls: Class<T>, pConfig: Partial<InjectableConfig<T>> = {}): void {
     const config = this.getOrCreatePending(pConfig.class ?? cls);
 
+    config.enabled = pConfig.enabled ?? config.enabled;
     config.class = cls;
     config.qualifier = pConfig.qualifier ?? config.qualifier ?? Symbol.for(cls.Ⲑid);
     if (pConfig.interfaces) {
@@ -360,6 +371,7 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
   }): void {
     const finalConfig: Partial<InjectableConfig> = {};
 
+    finalConfig.enabled = config.enabled ?? true;
     finalConfig.factory = config.fn;
     finalConfig.target = config.target;
     finalConfig.qualifier = config.qualifier;
@@ -415,6 +427,10 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = this.getOrCreatePending(cls) as InjectableConfig<T>;
 
+    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);
 
@@ -539,19 +555,6 @@ class $DependencyRegistry extends MetadataRegistry<InjectableConfig> {
     }
   }
 
-  /**
-   * Reset registry
-   */
-  override onReset(): void {
-    super.onReset();
-    this.pendingFinalize = [];
-    this.instances.clear();
-    this.instancePromises.clear();
-    this.targetToClass.clear();
-    this.classToTarget.clear();
-    this.factories.clear();
-  }
-
   /**
    * Inject fields into instance
    */

package/src/types.ts

@@ -36,6 +36,10 @@ export interface Dependency<T = unknown> extends Core<T> {
  * Injectable configuration
  */
 export interface InjectableConfig<T = unknown> extends Core<T> {
+  /**
+   * Is this injectable enabled
+   */
+  enabled: boolean | (() => boolean);
   /**
    * Reference for the class
    */
@@ -65,6 +69,10 @@ export interface InjectableConfig<T = unknown> extends Core<T> {
  * Factory configuration
  */
 export interface InjectableFactoryConfig<T = unknown> extends Core<T> {
+  /**
+   * Is this injectable enabled
+   */
+  enabled: boolean | (() => boolean);
   /**
    * Src of the factory method
    */

package/support/dynamic.injection.ts

@@ -14,7 +14,6 @@ class $DynamicDependencyRegistry {
   #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;
 
   /**
    * Proxy the created instance
@@ -86,22 +85,15 @@ class $DynamicDependencyRegistry {
     }
   }
 
-  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);
   }
 }