Rename autoInject => autoInjectable to match injectable

Author: Xapphire13

Diff for: src/decorators.ts

@@ -2,9 +2,8 @@ import "reflect-metadata";
 
 import {instance as globalContainer, typeInfo} from "./dependency-container";
 import { InjectionToken, Provider } from "./providers";
-import { constructor, Dictionary, RegistrationOptions } from "./types";
-
-const injectionTokenMetadataKey = "injectionTokens";
+import { constructor, RegistrationOptions } from "./types";
+import {INJECTION_TOKEN_METADATA_KEY, getParamInfo} from "./reflection-helpers";
 
 /**
  * Class decorator factory that allows the class' dependencies to be injected
@@ -14,13 +13,7 @@ const injectionTokenMetadataKey = "injectionTokens";
  */
 export function injectable<T>(): (target: constructor<T>) => void {
     return function(target: constructor<T>): void {
-        const params: any[] = Reflect.getMetadata("design:paramtypes", target) || [];
-        const injectionTokens: Dictionary<InjectionToken<any>> = Reflect.getOwnMetadata(injectionTokenMetadataKey, target) || {};
-        Object.keys(injectionTokens).forEach(key => {
-            params[+key] = injectionTokens[key];
-        });
-
-        typeInfo.set(target, params);
+        typeInfo.set(target, getParamInfo(target));
     };
 }
 
@@ -32,13 +25,13 @@ export function injectable<T>(): (target: constructor<T>) => void {
  *
  * @return {Function} The class decorator
  */
-export function autoInject(): (target: constructor<any>) => any {
+export function autoInjectable(): (target: constructor<any>) => any {
     return function(target: constructor<any>): constructor<any> {
-        injectable()(target);
+        const paramInfo = getParamInfo(target);
 
         return class extends target {
           constructor(...args: any[]) {
-              super(...args.concat(typeInfo.get(target)!.slice(args.length).map(type => globalContainer.resolve(type))));
+              super(...args.concat(paramInfo.slice(args.length).map(type => globalContainer.resolve(type))));
           }
         }
     }
@@ -51,9 +44,9 @@ export function autoInject(): (target: constructor<any>) => any {
  */
 export function inject(token: InjectionToken<any>): (target: any, propertyKey: string | symbol, parameterIndex: number) => any {
     return function(target: any, _propertyKey: string | symbol, parameterIndex: number): any {
-        const injectionTokens = Reflect.getOwnMetadata(injectionTokenMetadataKey, target) || {};
+        const injectionTokens = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
         injectionTokens[parameterIndex] = token;
-        Reflect.defineMetadata(injectionTokenMetadataKey, injectionTokens, target);
+        Reflect.defineMetadata(INJECTION_TOKEN_METADATA_KEY, injectionTokens, target);
     };
 }
 

Diff for: src/dependency-container.ts

@@ -162,7 +162,7 @@ export class DependencyContainer implements Types.DependencyContainer {
 
         const paramInfo = typeInfo.get(ctor);
 
-        if (!paramInfo) {
+        if (!paramInfo || paramInfo.length === 0) {
             throw `TypeInfo not known for ${ctor}`
         }
 

Diff for: src/reflection-helpers.ts

@@ -0,0 +1,14 @@
+import {InjectionToken} from "./providers";
+import {Dictionary, constructor} from "./types";
+
+export const INJECTION_TOKEN_METADATA_KEY = "injectionTokens";
+
+export function getParamInfo(target: constructor<any>): any[] {
+  const params: any[] = Reflect.getMetadata("design:paramtypes", target) || [];
+  const injectionTokens: Dictionary<InjectionToken<any>> = Reflect.getOwnMetadata(INJECTION_TOKEN_METADATA_KEY, target) || {};
+  Object.keys(injectionTokens).forEach(key => {
+      params[+key] = injectionTokens[key];
+  });
+
+  return params;
+}

Diff for: tests/auto-inject.test.ts renamed to tests/auto-injectable.test.ts

@@ -1,13 +1,13 @@
-import { autoInject, injectable } from "../src/decorators";
+import {autoInjectable, injectable} from "../src/decorators";
 import {instance as globalContainer} from "../src/dependency-container";
 
 afterEach(() => {
   globalContainer.reset();
 });
 
-test("@autoInject allows for injection to be performed without using .resolve()", () => {
+test("@autoInjectable allows for injection to be performed without using .resolve()", () => {
   class Bar {}
-  @autoInject()
+  @autoInjectable()
   class Foo {
     constructor(public myBar?: Bar) {}
   }
@@ -17,9 +17,9 @@ test("@autoInject allows for injection to be performed without using .resolve()"
   expect(myFoo.myBar instanceof Bar).toBeTruthy();
 });
 
-test("@autoInject allows for parameters to be specified manually", () => {
+test("@autoInjectable allows for parameters to be specified manually", () => {
   class Bar {}
-  @autoInject()
+  @autoInjectable()
   class Foo {
     constructor(public myBar?: Bar) {}
   }
@@ -30,10 +30,10 @@ test("@autoInject allows for parameters to be specified manually", () => {
   expect(myFoo.myBar).toBe(myBar);
 });
 
-test("@autoInject injects parameters beyond those specified manually", () => {
+test("@autoInjectable injects parameters beyond those specified manually", () => {
   class Bar {}
   class FooBar {}
-  @autoInject()
+  @autoInjectable()
   class Foo {
     constructor(public myFooBar: FooBar, public myBar?: Bar) {}
   }
@@ -45,12 +45,12 @@ test("@autoInject injects parameters beyond those specified manually", () => {
   expect(myFoo.myBar instanceof Bar).toBeTruthy();
 });
 
-test("@autoInject works when the @autoInject is a polymorphic ancestor", () => {
+test("@autoInjectable works when the @autoInjectable is a polymorphic ancestor", () => {
   class Foo {
     constructor() { }
   }
 
-  @autoInject()
+  @autoInjectable()
   class Ancestor {
     constructor(public myFoo?: Foo) {}
   }
@@ -66,14 +66,14 @@ test("@autoInject works when the @autoInject is a polymorphic ancestor", () => {
   expect(instance.myFoo instanceof Foo).toBeTruthy();
 });
 
-test("@autoInject classes keep behavior from their ancestor's constructors", () => {
+test("@autoInjectable classes keep behavior from their ancestor's constructors", () => {
   const a = 5;
   const b = 4;
   class Foo {
     constructor() { }
   }
 
-  @autoInject()
+  @autoInjectable()
   class Ancestor {
     public a: number;
     constructor(public myFoo?: Foo) {
@@ -96,13 +96,13 @@ test("@autoInject classes keep behavior from their ancestor's constructors", ()
   expect(instance.b).toBe(b);
 });
 
-test("@autoInject classes resolve their @injectable dependencies", () => {
+test("@autoInjectable classes resolve their @injectable dependencies", () => {
   class Foo {}
   @injectable()
   class Bar {
     constructor(public myFoo: Foo) {}
   }
-  @autoInject()
+  @autoInjectable()
   class FooBar {
     constructor(public myBar?: Bar) {}
   }