Merge pull request #162 from doktordirk/resolver-meta

Fixing parameter decorators

Author: EisenbergEffect

doc/article/en-US/dependency-injection-basics.md

@@ -325,14 +325,14 @@ As mentioned above, the DI container uses `Resolvers` internally to provide all
 * `NewInstance` - Used to inject a new instance of a dependency, without regard for existing instances in the container.
   * ex. `NewInstance.of(CustomClass).as(Another)`
 
-If using TypeScript, keep in mind that `@autoinject` won't allow you to use `Resolvers`. Instead, you may use argument decorators, without duplicating argument order, which you otherwise have to maintain when using the class decorator or the static `inject` property. Available function parameter decorators are:
+If using TypeScript, keep in mind that `@autoinject` won't allow you to use `Resolvers`. Instead, you may use argument decorators, without duplicating argument order, which you otherwise have to maintain when using the class decorator or the static `inject` property. You also can use `inject` as argument decorator for your own custom resolvers, eg `constructor(@inject(NewInstance.of(HttpClient)) public client: HttpClient){...}`. Available build-in function parameter decorators are:
 
 * `lazy(key)`
 * `all(key)`
 * `optional(checkParent?)`
 * `parent`
 * `factory(key, asValue?)`
-* `newInstance(key?)`
+* `newInstance(asKey?, dynamicDependencies: [any])`
 
 Here's an example of how we might express a dependency on `HttpClient` that we may or may not actually need to use, depending on runtime scenarios:
 

src/injection.js

@@ -6,46 +6,25 @@ import {_emptyParameters} from './container';
 */
 export function autoinject(potentialTarget?: any): any {
   let deco = function(target) {
-    let previousInject = target.inject ? target.inject.slice() : null; //make a copy of target.inject to avoid changing parent inject
-    let autoInject: any = metadata.getOwn(metadata.paramTypes, target) || _emptyParameters;
-    if (!previousInject) {
-      target.inject = autoInject;
-    } else {
-      for (let i = 0; i < autoInject.length; i++) {
-        //check if previously injected.
-        if (previousInject[i] && previousInject[i] !== autoInject[i]) {
-          const prevIndex = previousInject.indexOf(autoInject[i]);
-          if (prevIndex > -1) {
-            previousInject.splice(prevIndex, 1);
-          }
-          previousInject.splice((prevIndex > -1 && prevIndex < i) ? i - 1 : i, 0, autoInject[i]);
-        } else if (!previousInject[i]) {//else add
-          previousInject[i] = autoInject[i];
-        }
-      }
-      target.inject = previousInject;
+    if (!target.hasOwnProperty('inject')) {
+      target.inject = (metadata.getOwn(metadata.paramTypes, target) || _emptyParameters).slice();
     }
   };
 
   return potentialTarget ? deco(potentialTarget) : deco;
 }
 
 /**
-* Decorator: Specifies the dependencies that should be injected by the DI Container into the decoratored class/function.
+* Decorator: Specifies the dependencies that should be injected by the DI Container into the decorated class/function.
 */
 export function inject(...rest: any[]): any {
   return function(target, key, descriptor) {
-    // handle when used as a parameter
-    if (typeof descriptor === 'number' && rest.length === 1) {
-      let params = target.inject;
-      if (typeof params === 'function') {
-        throw new Error('Decorator inject cannot be used with "inject()".  Please use an array instead.');
-      }
-      if (!params) {
-        params = metadata.getOwn(metadata.paramTypes, target).slice();
-        target.inject = params;
+    // handle when used as a constructor parameter decorator
+    if (typeof descriptor === 'number') {
+      autoinject(target);
+      if (rest.length === 1) {
+        target.inject[descriptor] = rest[0];
       }
-      params[descriptor] = rest[0];
       return;
     }
     // if it's true then we injecting rest into function and not Class constructor

src/resolvers.js

@@ -1,5 +1,6 @@
 import {protocol} from 'aurelia-metadata';
 import {Container} from './container';
+import {autoinject} from './injection';
 
 /**
 * Decorator: Indicates that the decorated class/object is a custom resolver.
@@ -25,6 +26,53 @@ export interface Resolver {
   get(container: Container, key: any): any;
 }
 
+/**
+* Used to resolve instances, singletons, transients, aliases
+*/
+@resolver()
+export class StrategyResolver {
+  strategy: StrategyResolver | number;
+  state: any;
+
+  /**
+  * Creates an instance of the StrategyResolver class.
+  * @param strategy The type of resolution strategy.
+  * @param state The state associated with the resolution strategy.
+  */
+  constructor(strategy, state) {
+    this.strategy = strategy;
+    this.state = state;
+  }
+
+  /**
+  * Called by the container to allow custom resolution of dependencies for a function/class.
+  * @param container The container to resolve from.
+  * @param key The key that the resolver was registered as.
+  * @return Returns the resolved object.
+  */
+  get(container: Container, key: any): any {
+    switch (this.strategy) {
+    case 0: //instance
+      return this.state;
+    case 1: //singleton
+      let singleton = container.invoke(this.state);
+      this.state = singleton;
+      this.strategy = 0;
+      return singleton;
+    case 2: //transient
+      return container.invoke(this.state);
+    case 3: //function
+      return this.state(container, key, this);
+    case 4: //array
+      return this.state[0].get(container, key);
+    case 5: //alias
+      return container.get(this.state);
+    default:
+      throw new Error('Invalid strategy: ' + this.strategy);
+    }
+  }
+}
+
 /**
 * Used to allow functions/classes to specify lazy resolution logic.
 */
@@ -140,7 +188,6 @@ export class Optional {
   }
 }
 
-
 /**
 * Used to inject the dependency from the parent container instead of the current one.
 */
@@ -178,50 +225,6 @@ export class Parent {
   }
 }
 
-@resolver()
-export class StrategyResolver {
-  strategy: StrategyResolver | number;
-  state: any;
-
-  /**
-  * Creates an instance of the StrategyResolver class.
-  * @param strategy The type of resolution strategy.
-  * @param state The state associated with the resolution strategy.
-  */
-  constructor(strategy, state) {
-    this.strategy = strategy;
-    this.state = state;
-  }
-
-  /**
-  * Called by the container to allow custom resolution of dependencies for a function/class.
-  * @param container The container to resolve from.
-  * @param key The key that the resolver was registered as.
-  * @return Returns the resolved object.
-  */
-  get(container: Container, key: any): any {
-    switch (this.strategy) {
-    case 0: //instance
-      return this.state;
-    case 1: //singleton
-      let singleton = container.invoke(this.state);
-      this.state = singleton;
-      this.strategy = 0;
-      return singleton;
-    case 2: //transient
-      return container.invoke(this.state);
-    case 3: //function
-      return this.state(container, key, this);
-    case 4: //array
-      return this.state[0].get(container, key);
-    case 5: //alias
-      return container.get(this.state);
-    default:
-      throw new Error('Invalid strategy: ' + this.strategy);
-    }
-  }
-}
-
 /**
 * Used to allow injecting dependencies but also passing data to the constructor.
 */
@@ -270,8 +273,12 @@ export class Factory {
 */
 @resolver()
 export class NewInstance {
-  key;
-  asKey;
+  /** @internal */
+  key: any;
+  /** @internal */
+  asKey: any;
+  /** @internal */
+  dynamicDependencies: any[];
 
   /**
   * Creates an instance of the NewInstance class.
@@ -327,26 +334,24 @@ export class NewInstance {
   }
 }
 
-export function getDecoratorDependencies(target, name) {
-  let dependencies = target.inject;
-  if (typeof dependencies === 'function') {
-    throw new Error('Decorator ' + name + ' cannot be used with "inject()".  Please use an array instead.');
-  }
-  if (!dependencies) {
-    dependencies = metadata.getOwn(metadata.paramTypes, target).slice();
-    target.inject = dependencies;
-  }
+/**
+* Used by parameter decorators to call autoinject for the target and retrieve the target's inject property.
+* @param target The target class.
+* @return Returns the target's own inject property.
+*/
+export function getDecoratorDependencies(target) {
+  autoinject(target);
 
-  return dependencies;
+  return target.inject;
 }
 
 /**
 * Decorator: Specifies the dependency should be lazy loaded
 */
 export function lazy(keyValue: any) {
   return function(target, key, index) {
-    let params = getDecoratorDependencies(target, 'lazy');
-    params[index] = Lazy.of(keyValue);
+    let inject = getDecoratorDependencies(target);
+    inject[index] = Lazy.of(keyValue);
   };
 }
 
@@ -355,8 +360,8 @@ export function lazy(keyValue: any) {
 */
 export function all(keyValue: any) {
   return function(target, key, index) {
-    let params = getDecoratorDependencies(target, 'all');
-    params[index] = All.of(keyValue);
+    let inject = getDecoratorDependencies(target);
+    inject[index] = All.of(keyValue);
   };
 }
 
@@ -366,8 +371,8 @@ export function all(keyValue: any) {
 export function optional(checkParentOrTarget: boolean = true) {
   let deco = function(checkParent: boolean) {
     return function(target, key, index) {
-      let params = getDecoratorDependencies(target, 'optional');
-      params[index] = Optional.of(params[index], checkParent);
+      let inject = getDecoratorDependencies(target);
+      inject[index] = Optional.of(inject[index], checkParent);
     };
   };
   if (typeof checkParentOrTarget === 'boolean') {
@@ -380,18 +385,18 @@ export function optional(checkParentOrTarget: boolean = true) {
 * Decorator: Specifies the dependency to look at the parent container for resolution
 */
 export function parent(target, key, index) {
-  let params = getDecoratorDependencies(target, 'parent');
-  params[index] = Parent.of(params[index]);
+  let inject = getDecoratorDependencies(target);
+  inject[index] = Parent.of(inject[index]);
 }
 
 /**
 * Decorator: Specifies the dependency to create a factory method, that can accept optional arguments
 */
 export function factory(keyValue: any, asValue?: any) {
   return function(target, key, index) {
-    let params = getDecoratorDependencies(target, 'factory');
+    let inject = getDecoratorDependencies(target);
     let factory = Factory.of(keyValue);
-    params[index] = asValue ? factory.as(asValue) : factory;
+    inject[index] = asValue ? factory.as(asValue) : factory;
   };
 }
 
@@ -401,10 +406,10 @@ export function factory(keyValue: any, asValue?: any) {
 export function newInstance(asKeyOrTarget?: any, ...dynamicDependencies: any[]) {
   let deco = function(asKey?: any) {
     return function(target, key, index) {
-      let params = getDecoratorDependencies(target, 'newInstance');
-      params[index] = NewInstance.of(params[index], ...dynamicDependencies);
+      let inject = getDecoratorDependencies(target);
+      inject[index] = NewInstance.of(inject[index], ...dynamicDependencies);
       if (!!asKey) {
-        params[index].as(asKey);
+        inject[index].as(asKey);
       }
     };
   };