Improve annotations

src/annotation/decorator_utils.ts

@@ -1,68 +1,87 @@
 import * as ERROR_MSGS from "../constants/error_msgs";
 import * as METADATA_KEY from "../constants/metadata_keys";
 import { interfaces } from "../interfaces/interfaces";
+import { getFirstArrayDuplicate } from "../utils/js";
 
 function tagParameter(
-    annotationTarget: any,
-    propertyName: string,
+    annotationTarget: Object,
+    propertyName: string | symbol | undefined,
     parameterIndex: number,
-    metadata: interfaces.Metadata
+    metadata: interfaces.MetadataOrMetadataArray
 ) {
-    const metadataKey = METADATA_KEY.TAGGED;
-    _tagParameterOrProperty(metadataKey, annotationTarget, propertyName, metadata, parameterIndex);
+    if(propertyName !== undefined) {
+        throw new Error(ERROR_MSGS.INVALID_DECORATOR_OPERATION);
+    }
+    _tagParameterOrProperty(METADATA_KEY.TAGGED, annotationTarget, parameterIndex.toString(), metadata);
 }
 
 function tagProperty(
-    annotationTarget: any,
-    propertyName: string,
-    metadata: interfaces.Metadata
+    annotationTarget: Object,
+    propertyName: string | symbol,
+    metadata: interfaces.MetadataOrMetadataArray
 ) {
-    const metadataKey = METADATA_KEY.TAGGED_PROP;
-    _tagParameterOrProperty(metadataKey, annotationTarget.constructor, propertyName, metadata);
+    _tagParameterOrProperty(METADATA_KEY.TAGGED_PROP, annotationTarget.constructor, propertyName, metadata);
+}
+
+function _ensureNoMetadataKeyDuplicates(metadata: interfaces.MetadataOrMetadataArray):interfaces.Metadata[]{
+    let metadatas: interfaces.Metadata[] = [];
+    if(Array.isArray(metadata)){
+        metadatas = metadata;
+        const duplicate = getFirstArrayDuplicate(metadatas.map(md => md.key));
+        if(duplicate !== undefined) {
+            throw new Error(`${ERROR_MSGS.DUPLICATED_METADATA} ${duplicate.toString()}`);
+        }
+    }else{
+        metadatas = [metadata];
+    }
+    return metadatas;
 }
 
 function _tagParameterOrProperty(
     metadataKey: string,
-    annotationTarget: any,
-    propertyName: string,
-    metadata: interfaces.Metadata,
-    parameterIndex?: number
+    annotationTarget: Object,
+    key: string | symbol,
+    metadata: interfaces.MetadataOrMetadataArray,
 ) {
+    const metadatas: interfaces.Metadata[] = _ensureNoMetadataKeyDuplicates(metadata);
 
-    let paramsOrPropertiesMetadata: interfaces.ReflectResult = {};
-    const isParameterDecorator = (typeof parameterIndex === "number");
-    const key: string = (parameterIndex !== undefined && isParameterDecorator) ? parameterIndex.toString() : propertyName;
-
-    // if the decorator is used as a parameter decorator, the property name must be provided
-    if (isParameterDecorator && propertyName !== undefined) {
-        throw new Error(ERROR_MSGS.INVALID_DECORATOR_OPERATION);
-    }
-
+    let paramsOrPropertiesMetadata:Record<string | symbol, interfaces.Metadata[] | undefined>  = {};
     // read metadata if available
     if (Reflect.hasOwnMetadata(metadataKey, annotationTarget)) {
         paramsOrPropertiesMetadata = Reflect.getMetadata(metadataKey, annotationTarget);
     }
 
-    // get metadata for the decorated parameter by its index
-    let paramOrPropertyMetadata: interfaces.Metadata[] = paramsOrPropertiesMetadata[key];
+    let paramOrPropertyMetadata: interfaces.Metadata[] | undefined = paramsOrPropertiesMetadata[key as any];
 
-    if (!Array.isArray(paramOrPropertyMetadata)) {
+    if (paramOrPropertyMetadata === undefined) {
         paramOrPropertyMetadata = [];
     } else {
         for (const m of paramOrPropertyMetadata) {
-            if (m.key === metadata.key) {
+            if (metadatas.some(md => md.key === m.key)) {
                 throw new Error(`${ERROR_MSGS.DUPLICATED_METADATA} ${m.key.toString()}`);
             }
         }
     }
 
     // set metadata
-    paramOrPropertyMetadata.push(metadata);
-    paramsOrPropertiesMetadata[key] = paramOrPropertyMetadata;
+    paramOrPropertyMetadata.push(...metadatas);
+    paramsOrPropertiesMetadata[key as any] = paramOrPropertyMetadata;
     Reflect.defineMetadata(metadataKey, paramsOrPropertiesMetadata, annotationTarget);
 
 }
 
+function createTaggedDecorator(
+    metadata:interfaces.MetadataOrMetadataArray,
+) {
+    return (target:Object, targetKey:string | symbol | undefined, indexOrPropertyDescriptor?:number | TypedPropertyDescriptor<unknown>) => {
+        if (typeof indexOrPropertyDescriptor === "number") {
+            tagParameter(target, targetKey, indexOrPropertyDescriptor, metadata);
+        } else {
+            tagProperty(target, targetKey as string | symbol, metadata);
+        }
+    };
+}
+
 function _decorate(decorators: any[], target: any): void {
     Reflect.decorate(decorators, target);
 }
@@ -90,4 +109,4 @@ function decorate(
     }
 }
 
-export { decorate, tagParameter, tagProperty };
+export { decorate, tagParameter, tagProperty, createTaggedDecorator };

src/annotation/inject.ts

@@ -1,37 +1,6 @@
-import { UNDEFINED_INJECT_ANNOTATION } from "../constants/error_msgs";
 import * as METADATA_KEY from "../constants/metadata_keys";
-import { interfaces } from "../interfaces/interfaces";
-import { Metadata } from "../planning/metadata";
-import { tagParameter, tagProperty } from "./decorator_utils";
+import { injectBase } from "./inject_base";
 
-export type ServiceIdentifierOrFunc = interfaces.ServiceIdentifier<any> | LazyServiceIdentifer;
-
-export class LazyServiceIdentifer<T = any> {
-  private _cb: () => interfaces.ServiceIdentifier<T>;
-  public constructor(cb: () => interfaces.ServiceIdentifier<T>) {
-      this._cb = cb;
-  }
-
-  public unwrap() {
-    return this._cb();
-  }
-}
-
-function inject(serviceIdentifier: ServiceIdentifierOrFunc) {
-  return function(target: any, targetKey: string, index?: number | PropertyDescriptor): void {
-    if (serviceIdentifier === undefined) {
-      throw new Error(UNDEFINED_INJECT_ANNOTATION(target.name));
-    }
-
-    const metadata = new Metadata(METADATA_KEY.INJECT_TAG, serviceIdentifier);
-
-    if (typeof index === "number") {
-      tagParameter(target, targetKey, index, metadata);
-    } else {
-      tagProperty(target, targetKey, metadata);
-    }
-
-  };
-}
+const inject = injectBase(METADATA_KEY.INJECT_TAG);
 
 export { inject };

src/annotation/inject_base.ts

@@ -0,0 +1,19 @@
+import { UNDEFINED_INJECT_ANNOTATION } from "../constants/error_msgs";
+import { Metadata } from "../planning/metadata";
+import { createTaggedDecorator } from "./decorator_utils";
+import { ServiceIdentifierOrFunc } from "./lazy_service_identifier";
+
+export function injectBase(metadataKey:string){
+  return (serviceIdentifier: ServiceIdentifierOrFunc) => {
+    return (target: Object,
+       targetKey:string | symbol | undefined, indexOrPropertyDescriptor?:number | TypedPropertyDescriptor<unknown>) => {
+      if (serviceIdentifier === undefined) {
+        const className = typeof target === "function" ? target.name : target.constructor.name;
+        throw new Error(UNDEFINED_INJECT_ANNOTATION(className));
+      }
+      return createTaggedDecorator(
+        new Metadata(metadataKey, serviceIdentifier)
+      )(target, targetKey,indexOrPropertyDescriptor);
+    };
+  }
+}

src/annotation/lazy_service_identifier.ts

@@ -0,0 +1,14 @@
+import { interfaces } from "../interfaces/interfaces";
+
+export type ServiceIdentifierOrFunc = interfaces.ServiceIdentifier<any> | LazyServiceIdentifer;
+
+export class LazyServiceIdentifer<T = any> {
+  private _cb: () => interfaces.ServiceIdentifier<T>;
+  public constructor(cb: () => interfaces.ServiceIdentifier<T>) {
+    this._cb = cb;
+  }
+
+  public unwrap() {
+    return this._cb();
+  }
+}

src/annotation/multi_inject.ts

@@ -1,20 +1,6 @@
 import * as METADATA_KEY from "../constants/metadata_keys";
-import { interfaces } from "../interfaces/interfaces";
-import { Metadata } from "../planning/metadata";
-import { tagParameter, tagProperty } from "./decorator_utils";
+import { injectBase } from "./inject_base";
 
-function multiInject(serviceIdentifier: interfaces.ServiceIdentifier<any>) {
-  return function(target: any, targetKey: string, index?: number) {
-
-    const metadata = new Metadata(METADATA_KEY.MULTI_INJECT_TAG, serviceIdentifier);
-
-    if (typeof index === "number") {
-      tagParameter(target, targetKey, index, metadata);
-    } else {
-      tagProperty(target, targetKey, metadata);
-    }
-
-  };
-}
+const multiInject = injectBase(METADATA_KEY.MULTI_INJECT_TAG);
 
 export { multiInject };

src/annotation/named.ts

@@ -1,17 +1,10 @@
 import * as METADATA_KEY from "../constants/metadata_keys";
 import { Metadata } from "../planning/metadata";
-import { tagParameter, tagProperty } from "./decorator_utils";
+import { createTaggedDecorator } from "./decorator_utils";
 
 // Used to add named metadata which is used to resolve name-based contextual bindings.
 function named(name: string | number | symbol) {
-    return function(target: any, targetKey: string, index?: number) {
-        const metadata = new Metadata(METADATA_KEY.NAMED_TAG, name);
-        if (typeof index === "number") {
-            tagParameter(target, targetKey, index, metadata);
-        } else {
-            tagProperty(target, targetKey, metadata);
-        }
-    };
+    return createTaggedDecorator(new Metadata(METADATA_KEY.NAMED_TAG, name));
 }
 
 export { named };

src/annotation/optional.ts

@@ -1,19 +1,9 @@
 import * as METADATA_KEY from "../constants/metadata_keys";
 import { Metadata } from "../planning/metadata";
-import { tagParameter, tagProperty } from "./decorator_utils";
+import { createTaggedDecorator } from "./decorator_utils";
 
 function optional() {
-    return function(target: any, targetKey: string, index?: number) {
-
-        const metadata = new Metadata(METADATA_KEY.OPTIONAL_TAG, true);
-
-        if (typeof index === "number") {
-            tagParameter(target, targetKey, index, metadata);
-        } else {
-            tagProperty(target, targetKey, metadata);
-        }
-
-    };
+    return createTaggedDecorator(new Metadata(METADATA_KEY.OPTIONAL_TAG, true));
 }
 
 export { optional };

src/annotation/tagged.ts

@@ -1,16 +1,9 @@
 import { Metadata } from "../planning/metadata";
-import { tagParameter, tagProperty } from "./decorator_utils";
+import { createTaggedDecorator } from "./decorator_utils";
 
 // Used to add custom metadata which is used to resolve metadata-based contextual bindings.
 function tagged(metadataKey: string | number | symbol, metadataValue: any) {
-    return function(target: any, targetKey: string, index?: number) {
-        const metadata = new Metadata(metadataKey, metadataValue);
-        if (typeof index === "number") {
-            tagParameter(target, targetKey, index, metadata);
-        } else {
-            tagProperty(target, targetKey, metadata);
-        }
-    };
+    return createTaggedDecorator(new Metadata(metadataKey, metadataValue));
 }
 
 export { tagged };

src/interfaces/interfaces.ts

@@ -111,9 +111,7 @@ namespace interfaces {
         setCurrentRequest(request: Request): void;
     }
 
-    export interface ReflectResult {
-        [key: string]: Metadata[];
-    }
+    export type MetadataOrMetadataArray = Metadata | Metadata[];
 
     export interface Metadata {
         key: string | number | symbol;
@@ -160,6 +158,7 @@ namespace interfaces {
         serviceIdentifier: ServiceIdentifier<any>;
         type: TargetType;
         name: QueryableString;
+        identifier: string | symbol;
         metadata: Metadata[];
         getNamedTag(): interfaces.Metadata | null;
         getCustomTags(): interfaces.Metadata[] | null;

src/inversify.ts

@@ -3,10 +3,12 @@ export const METADATA_KEY = keys;
 export { Container } from "./container/container";
 export { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum } from "./constants/literal_types";
 export { AsyncContainerModule, ContainerModule } from "./container/container_module";
+export { createTaggedDecorator } from "./annotation/decorator_utils"
 export { injectable } from "./annotation/injectable";
 export { tagged } from "./annotation/tagged";
 export { named } from "./annotation/named";
-export { inject, LazyServiceIdentifer } from "./annotation/inject";
+export { inject } from "./annotation/inject";
+export { LazyServiceIdentifer } from "./annotation/lazy_service_identifier"
 export { optional } from "./annotation/optional";
 export { unmanaged } from "./annotation/unmanaged";
 export { multiInject } from "./annotation/multi_inject";

src/planning/reflection_utils.ts

@@ -1,4 +1,4 @@
-import { LazyServiceIdentifer } from "../annotation/inject";
+import { LazyServiceIdentifer } from "../annotation/lazy_service_identifier";
 import * as ERROR_MSGS from "../constants/error_msgs";
 import { TargetTypeEnum } from "../constants/literal_types";
 import * as METADATA_KEY from "../constants/metadata_keys";
@@ -48,7 +48,7 @@ function getTargets(
     );
 
     // Target instances that represent properties to be injected
-    const propertyTargets = getClassPropsAsTargets(metadataReader, func);
+    const propertyTargets = getClassPropsAsTargets(metadataReader, func, constructorName);
 
     const targets = [
         ...constructorTargets,
@@ -130,11 +130,22 @@ function getConstructorArgsAsTargets(
     return targets;
 }
 
-function getClassPropsAsTargets(metadataReader: interfaces.MetadataReader, constructorFunc: Function) {
+function _getServiceIdentifierForProperty(inject:any,multiInject:any,propertyName:string | symbol, className: string):any {
+    const serviceIdentifier = (inject || multiInject);
+    if(serviceIdentifier === undefined) {
+        const msg = `${ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION} for property ${String(propertyName)} in class ${className}.`;
+        throw new Error(msg);
+    }
+    return serviceIdentifier;
+}
+
+function getClassPropsAsTargets(metadataReader: interfaces.MetadataReader, constructorFunc: Function, constructorName:string) {
 
-    const classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc);
+    const classPropsMetadata:any = metadataReader.getPropertiesMetadata(constructorFunc);
     let targets: interfaces.Target[] = [];
-    const keys = Object.keys(classPropsMetadata);
+    const symbolKeys = Object.getOwnPropertySymbols(classPropsMetadata);
+    const stringKeys:(string | symbol)[] = Object.keys(classPropsMetadata);
+    const keys:(string | symbol)[] = stringKeys.concat(symbolKeys);
 
     for (const key of keys) {
 
@@ -144,14 +155,13 @@ function getClassPropsAsTargets(metadataReader: interfaces.MetadataReader, const
         // the metadata formatted for easier access
         const metadata = formatTargetMetadata(classPropsMetadata[key]);
 
-        // the name of the property being injected
-        const targetName = metadata.targetName || key;
+        const identifier = metadata.targetName || key;
 
         // Take types to be injected from user-generated metadata
-        const serviceIdentifier = (metadata.inject || metadata.multiInject);
+        const serviceIdentifier = _getServiceIdentifierForProperty(metadata.inject,metadata.multiInject,key,constructorName);
 
         // The property target
-        const target = new Target(TargetTypeEnum.ClassProperty, targetName, serviceIdentifier);
+        const target = new Target(TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);
         target.metadata = targetMetadata;
         targets.push(target);
     }
@@ -161,7 +171,7 @@ function getClassPropsAsTargets(metadataReader: interfaces.MetadataReader, const
 
     if (baseConstructor !== Object) {
 
-        const baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor);
+        const baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor,constructorName);
 
         targets = [
             ...targets,