[#39] Refactoring: improve error handling

- created DecoratorUtils.getSubjectName() and used it in DecoratorUsageError-s
- throwing  DecoratorUsageError when decorators used on wrong [class/method/property] , solving issue [#22]
- changed @autowire() to @Autowired()

Author: damjangelovski

src/index.ts

@@ -7,7 +7,7 @@ export {ComponentScan} from "./lib/decorators/ComponentScanDecorator";
 export {Import} from "./lib/decorators/ImportDecorator";
 export {Configuration} from "./lib/decorators/ConfigurationDecorator";
 export {Controller} from "./lib/decorators/ControllerDecorator";
-export {Inject, Value, Autowire} from "./lib/decorators/InjectionDecorators";
+export {Inject, Value, Autowired} from "./lib/decorators/InjectionDecorators";
 export {PostConstruct, PreDestroy} from "./lib/decorators/LifeCycleHooksDecorators"
 export {Profile} from "./lib/decorators/ComponentDecorator";
 export {PropertySource} from "./lib/decorators/PropertySourceDecorator";

src/lib/decorators/ComponentDecorator.ts

@@ -2,6 +2,7 @@ import { InjectUtil, InjectionData } from "./InjectionDecorators";
 import { CONTROLLER_DECORATOR_TOKEN } from "./ControllerDecorator";
 import { INTERCEPTOR_DECORATOR_TOKEN } from "../interceptors/InterceptorDecorator";
 import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorUtil, DecoratorType } from "../helpers/DecoratorUtils";
 
 export class ComponentData {
     classToken: Symbol;
@@ -20,6 +21,11 @@ const COMPONENT_DECORATOR_TOKEN = Symbol('component_decorator_token');
 
 export function Component() {
     return function (target) {
+        let args = Array.prototype.slice.call(arguments);
+        if (!DecoratorUtil.isType(DecoratorType.CLASS, args)) {
+            let subjectName = DecoratorUtil.getSubjectName(args);
+            throw new DecoratorUsageError(`@Component can be set only on a class! (${subjectName})`);
+        }
         let componentData = new ComponentData();
         componentData.injectionData = InjectUtil.initIfDoesntExist(target.prototype);
         target[COMPONENT_DECORATOR_TOKEN] = componentData;
@@ -29,7 +35,8 @@ export function Component() {
 export function Profile(profile: string) {
     return function (target) {
         if (!ComponentUtil.isComponent(target)) {
-            throw new DecoratorUsageError(`@Profile can be set only on @Component! (${target.name})`);
+            let subjectName = DecoratorUtil.getSubjectName(Array.prototype.slice.call(arguments));
+            throw new DecoratorUsageError(`@Profile can be set only on @Component! (${subjectName})`);
         }
         ComponentUtil.getComponentData(target).profile = profile;
     };

src/lib/decorators/ComponentScanDecorator.ts

@@ -5,6 +5,7 @@ import { ConfigurationData, ConfigurationUtil } from "./ConfigurationDecorator";
 import { ComponentUtil } from "./ComponentDecorator";
 import { RequireUtils } from "../helpers/RequireUtils";
 import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorUtil } from "../helpers/DecoratorUtils";
 
 /**
  *A decorator for setting up project files to be component-scanned.
@@ -14,7 +15,8 @@ import { DecoratorUsageError } from "../errors/DecoratorUsageError";
 export function ComponentScan(path) {
     return function (target) {
         if (!ConfigurationUtil.isConfigurationClass(target)) {
-            throw new DecoratorUsageError(`@ComponentScan is allowed on @Configuration classes only! (${target.name})`);
+            let subjectName = DecoratorUtil.getSubjectName(Array.prototype.slice.call(arguments));
+            throw new DecoratorUsageError(`@ComponentScan is allowed on @Configuration classes only! (${subjectName})`);
         }
         ConfigurationUtil.addComponentScanPath(target, path);
     };

src/lib/decorators/ConfigurationDecorator.ts

@@ -2,6 +2,7 @@ import { ComponentFactory } from "../di/ComponentFactory";
 import { PropertySourceUtil } from "./PropertySourceDecorator";
 import { ComponentScanUtil } from "./ComponentScanDecorator";
 import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorUtil, DecoratorType } from "../helpers/DecoratorUtils";
 
 const CONFIGURATION_HOLDER_TOKEN = Symbol('configuration_holder_token');
 
@@ -38,6 +39,10 @@ export class ConfigurationData {
 
 export function Configuration() {
     return function (target) {
+        if (!DecoratorUtil.isType(DecoratorType.CLASS, Array.prototype.slice.call(arguments))) {
+            let subjectName = DecoratorUtil.getSubjectName(Array.prototype.slice.call(arguments));
+            throw new DecoratorUsageError(`@Configuration can be set only on classes! (${subjectName})`);
+        }
         if (target[CONFIGURATION_HOLDER_TOKEN]) {
             throw new DecoratorUsageError(`Duplicate @Configuration decorator' (${target.name})`);
         }
@@ -51,7 +56,8 @@ export class ConfigurationUtil {
 
     static getConfigurationData(target): ConfigurationData {
         if (!this.isConfigurationClass(target)) {
-            throw new Error(`${target.name} is not a @Configuration class`);
+            let subjectName = DecoratorUtil.getSubjectName(Array.prototype.slice.call(arguments));
+            throw new Error(`${subjectName} is not a @Configuration class`);
         }
         return target[CONFIGURATION_HOLDER_TOKEN];
     }

src/lib/decorators/ControllerDecorator.ts

@@ -1,8 +1,14 @@
 import { Component } from "./ComponentDecorator";
+import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorUtil, DecoratorType } from "../helpers/DecoratorUtils";
 export const CONTROLLER_DECORATOR_TOKEN = Symbol('controller_decorator_token');
 
 export function Controller() {
     return function (target) {
+        if (!DecoratorUtil.isType(DecoratorType.CLASS, Array.prototype.slice.call(arguments))) {
+            let subjectName = DecoratorUtil.getSubjectName(Array.prototype.slice.call(arguments));
+            throw new DecoratorUsageError(`@Configuration can be set only on classes! (${subjectName})`);
+        }
         Component()(target);
         target[CONTROLLER_DECORATOR_TOKEN] = true;
     };

src/lib/decorators/ImportDecorator.ts

@@ -1,6 +1,7 @@
 import { ConfigurationUtil } from "./ConfigurationDecorator";
 import { BadArgumentError } from "../errors/BadArgumentError";
 import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorUtil } from "../helpers/DecoratorUtils";
 
 /**
  * Decorator used for composing configuration classes by importing other configuration classes.
@@ -11,8 +12,8 @@ import { DecoratorUsageError } from "../errors/DecoratorUsageError";
 export function Import(...configurationClasses) {
     return function (targetConfigurationClass) {
         if (!ConfigurationUtil.isConfigurationClass(targetConfigurationClass)) {
-            // tslint:disable-next-line
-            throw new DecoratorUsageError(`@Import is allowed on @Configuration classes only! (${targetConfigurationClass.name})`);
+            let subjectName = DecoratorUtil.getSubjectName(Array.prototype.slice.call(arguments));
+            throw new DecoratorUsageError(`@Import is allowed on @Configuration classes only! (${subjectName})`);
         }
         let targetConfigurationData = ConfigurationUtil.getConfigurationData(targetConfigurationClass);
         for (let configurationClass of configurationClasses) {

src/lib/decorators/InjectionDecorators.ts

@@ -1,6 +1,8 @@
 import { ComponentUtil } from "./ComponentDecorator";
 import { TypeUtils } from "../helpers/TypeUtils";
 import { InjectionError } from "../errors/InjectionError";
+import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorType, DecoratorUtil } from "../helpers/DecoratorUtils";
 
 const INJECT_DECORATOR_TOKEN = Symbol('injector_decorator_token');
 
@@ -24,15 +26,22 @@ export class InjectionData {
 }
 
 export function Inject(dependencyToken?: Symbol) {
-    return function (target: any, fieldName: string) {
+    return function (...args) {
+        if (!DecoratorUtil.isType(DecoratorType.PROPERTY, args)) {
+            let subject = DecoratorUtil.getSubjectName(args);
+            throw new DecoratorUsageError(`@Inject can be set only on properties of a @Component class! (${subject})`);
+        }
+        let target = args[0];
+        let fieldName = args[1];
         let token = dependencyToken;
         let type = (<any> Reflect).getMetadata('design:type', target, fieldName);
         if (!token) {
             // fallback to field type
             if (ComponentUtil.isComponent(type)) {
                 token = ComponentUtil.getClassToken(type);
             } else {
-                throw new InjectionError(`Cannot inject dependency which is not a @Component! (${type.name})`);
+                let sub = DecoratorUtil.getSubjectName(args);
+                throw new InjectionError(`Cannot inject dependency (${type.name}) which is not a @Component! (${sub})`);
             }
         }
         // NOTE assumption: if type not declared or any then type is Object and isArray is false
@@ -41,12 +50,23 @@ export function Inject(dependencyToken?: Symbol) {
     };
 }
 
-export function Autowire() {
-    return Inject();
+export function Autowired() {
+    return function (...args) {
+        if (!DecoratorUtil.isType(DecoratorType.PROPERTY, args)) {
+            let subj = DecoratorUtil.getSubjectName(args);
+            throw new DecoratorUsageError(`@Autowired can be set only on properties of a @Component class! (${subj})`);
+        }
+        return Inject()(...args);
+    };
 }
 
 export function Value(preopertyKey) {
     return function (target: any, fieldName: string) {
+        let args = Array.prototype.slice.call(arguments);
+        if (!DecoratorUtil.isType(DecoratorType.PROPERTY, args)) {
+            let subject = DecoratorUtil.getSubjectName(args);
+            throw new DecoratorUsageError(`@Value can be set only on properties of a @Component class! (${subject})`);
+        }
         InjectUtil.initIfDoesntExist(target).properties.set(fieldName, preopertyKey);
     };
 }

src/lib/decorators/LifeCycleHooksDecorators.ts

@@ -1,4 +1,5 @@
 import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorUtil, DecoratorType } from "../helpers/DecoratorUtils";
 
 const LIFE_CYCLE_HOOKS_TOKEN = Symbol('life_cycle_hooks_token');
 
@@ -12,11 +13,17 @@ export class LifeCycleHooksConfig {
  */
 export function PostConstruct() {
     return function (target, methodName, descriptor: PropertyDescriptor) {
+        let args = Array.prototype.slice.call(arguments);
+        if (!DecoratorUtil.isType(DecoratorType.METHOD, args)) {
+            let sub = DecoratorUtil.getSubjectName(args);
+            throw new DecoratorUsageError(`@PostConstruct can be set only on methods of a @Component class! (${sub})`);
+        }
         let conf = LifeCycleHooksUtil.initIfDoesntExist(target);
         if (conf.postConstructMethod) {
             let errorParams = [conf.postConstructMethod, methodName].join(', ');
+            let subjectName = DecoratorUtil.getSubjectName(args);
             // tslint:disable-next-line
-            throw new DecoratorUsageError(`@PostConstruct used on multiple methods (${errorParams}) within a component`);
+            throw new DecoratorUsageError(`@PostConstruct used on multiple methods (${errorParams}) within a @Component (${subjectName})`);
         }
         conf.postConstructMethod = methodName;
     };
@@ -27,10 +34,17 @@ export function PostConstruct() {
  */
 export function PreDestroy() {
     return function (target, methodName, descriptor: PropertyDescriptor) {
+        let args = Array.prototype.slice.call(arguments);
+        if (!DecoratorUtil.isType(DecoratorType.METHOD, args)) {
+            let subject = DecoratorUtil.getSubjectName(args);
+            throw new DecoratorUsageError(`@PreDestroy can be set only on methods of a @Component class! (${subject})`);
+        }
         let conf = LifeCycleHooksUtil.initIfDoesntExist(target);
         if (conf.preDestroyMethod) {
             let errorParams = [conf.preDestroyMethod, methodName].join(', ');
-            throw new DecoratorUsageError(`@PreDestroy used on multiple methods within a component (${errorParams})`);
+            let subjectName = DecoratorUtil.getSubjectName(args);
+            // tslint:disable-next-line
+            throw new DecoratorUsageError(`@PreDestroy used on multiple methods (${errorParams}) within a @Component (${subjectName})`);
         }
         conf.preDestroyMethod = methodName;
     };

src/lib/decorators/PropertySourceDecorator.ts

@@ -3,6 +3,7 @@ import { ConfigurationUtil } from "./ConfigurationDecorator";
 import { GeneralUtils } from "../helpers/GeneralUtils";
 import {RequireUtils} from "../helpers/RequireUtils";
 import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorUtil } from "../helpers/DecoratorUtils";
 
 /**
  * A decorator for defining a JSON property source for the configuration properties.
@@ -12,8 +13,8 @@ import { DecoratorUsageError } from "../errors/DecoratorUsageError";
 export function PropertySource(path: string) {
     return function (target) {
         if (!ConfigurationUtil.isConfigurationClass(target)) {
-            // tslint:disable-next-line
-            throw new DecoratorUsageError(`@PropertySource can be used only on @Configuration classes! (${target.name})`);
+            let subject = DecoratorUtil.getSubjectName(Array.prototype.slice.call(arguments));
+            throw new DecoratorUsageError(`@PropertySource is allowed on @Configuration classes only! (${subject})`);
         }
         ConfigurationUtil.addPropertySourcePath(target, path);
     };

src/lib/decorators/QualifierDecorator.ts

@@ -1,10 +1,12 @@
 import { ComponentUtil } from "./ComponentDecorator";
 import { DecoratorUsageError } from "../errors/DecoratorUsageError";
+import { DecoratorUtil } from "../helpers/DecoratorUtils";
 
 export function Qualifier(token: Symbol) {
     return function (target) {
         if (!ComponentUtil.isComponent(target)) {
-            throw new DecoratorUsageError(`@Qualifier can be used only on @Component classes! (${target.name})`);
+            let subjectName = DecoratorUtil.getSubjectName(Array.prototype.slice.call(arguments));
+            throw new DecoratorUsageError(`@Qualifier can be used only on @Component classes! (${subjectName})`);
         }
         ComponentUtil.getAliasTokens(target).push(token);
     };