Merge pull request #65 from inversify/fix

Implements inversify/InversifyJS/issues/674#issuecomment-349302658

README.md

@@ -296,6 +296,55 @@ class Shuriken implements Weapon {
 }
 ```
 
+### Using @provideFluent multiple times
+
+If you try to apply `@provideFluent` multiple times:
+
+```ts
+let container = new Container();
+let provideFluent = fluentProvide(container);
+
+const provideSingleton = (identifier: any) => {
+    return provideFluent(identifier)
+    .inSingletonScope()
+    .done();
+};
+
+function shouldThrow() {
+    @provideSingleton("Ninja")
+    @provideSingleton("SilentNinja")
+    class Ninja {}
+    return Ninja;
+}
+```
+
+The library will throw an exception:
+
+> Cannot apply @provideFluent decorator multiple times but is has been used multiple times in Ninja Please use @done(true) if you are trying to declare multiple bindings!
+
+We throw an exception to ensure that you are are not trying to apply `@fluentProvide` multiple times by mistake.
+
+You can overcome this by passing the `force` argument to `done()`:
+
+```ts
+let container = new Container();
+let provideFluent = fluentProvide(container);
+
+const provideSingleton = (identifier: any) => {
+    return provideFluent(identifier)
+    .inSingletonScope()
+    .done(true); // IMPORTANT!
+};
+
+function shouldThrow() {
+    @provideSingleton("Ninja")
+    @provideSingleton("SilentNinja")
+    class Ninja {}
+    return Ninja;
+}
+```
+
+
 ## The auto provide utility
 This library includes a small utility apply to add the default `@provide` decorator to all
 the public properties of a module:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "inversify-binding-decorators",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "An utility that allows developers to declare InversifyJS bindings using ES2016 decorators",
   "main": "lib/index.js",
   "jsnext:main": "es/index.js",

src/decorator/provide.ts

@@ -20,8 +20,11 @@ function provide(container: interfaces.Container) {
         try {
           decorate(injectable(), target);
         } catch (e) {
-          throw new Error(`${e.message} ` +
-          "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
+          throw new Error(
+            "Cannot apply @provide decorator multiple times but is has been used " +
+            `multiple times in ${target.name} ` +
+            "Please use @provide(ID, true) if you are trying to declare multiple bindings!"
+          );
         }
      }
 

src/interfaces/interfaces.ts

@@ -3,7 +3,7 @@ import { interfaces as inversifyInterfaces } from "inversify";
 namespace interfaces {
 
     export interface ProvideDoneSyntax {
-        done(): (target: any) => any;
+        done(force?: boolean): (target: any) => any;
     }
 
     export interface ProvideInSyntax<T> extends ProvideDoneSyntax {

src/syntax/provide_done_syntax.ts

@@ -1,6 +1,6 @@
 import interfaces from "../interfaces/interfaces";
 import { decorate, injectable } from "inversify";
-import { interfaces as inversifyInterfaces } from "inversify";
+import { interfaces as inversifyInterfaces, METADATA_KEY } from "inversify";
 
 class ProvideDoneSyntax<T> implements interfaces.ProvideDoneSyntax {
 
@@ -10,10 +10,30 @@ class ProvideDoneSyntax<T> implements interfaces.ProvideDoneSyntax {
         this._binding = binding;
     }
 
-    public done() {
-        return (target: any) => {
-            decorate(injectable(), target);
-            this._binding.implementationType = target;
+    public done(force?: boolean) {
+        const that = this;
+        return function (target: any) {
+
+            const isAlreadyDecorated = Reflect.hasOwnMetadata(METADATA_KEY.PARAM_TYPES, target);
+            const redecorateWithInject = force === true;
+
+            if (redecorateWithInject === true && isAlreadyDecorated === false) {
+                decorate(injectable(), target);
+            } else if (redecorateWithInject === true && isAlreadyDecorated === true) {
+                // Do nothing
+            } else {
+                try {
+                    decorate(injectable(), target);
+                } catch (e) {
+                    throw new Error(
+                        "Cannot apply @provideFluent decorator multiple times but is has been used " +
+                        `multiple times in ${target.name} ` +
+                        "Please use @done(true) if you are trying to declare multiple bindings!"
+                    );
+                }
+            }
+
+            that._binding.implementationType = target;
             return target;
         };
     }

src/syntax/provide_in_syntax.ts

@@ -32,10 +32,10 @@ class ProvideInSyntax<T> implements interfaces.ProvideInSyntax<T> {
         return new ProvideWhenOnSyntax(provideWhenSyntax, provideOnSyntax);
     }
 
-    public done() {
+    public done(force?: boolean) {
         let binding: inversifyInterfaces.Binding<T> = (<any>this._bindingInSyntax)._binding;
         let provideDoneSyntax = new ProvideDoneSyntax<T>(binding);
-        return provideDoneSyntax.done();
+        return provideDoneSyntax.done(force);
     }
 
 }

src/syntax/provide_in_when_on_syntax.ts

@@ -85,8 +85,8 @@ class ProvideInWhenOnSyntax<T> implements interfaces.ProvideInWhenOnSyntax<T>  {
         return this._provideInSyntax.inTransientScope();
     }
 
-    public done() {
-        return this._provideInSyntax.done();
+    public done(force?: boolean) {
+        return this._provideInSyntax.done(force);
     }
 
 }

src/syntax/provide_on_syntax.ts

@@ -20,8 +20,8 @@ class ProvideOnSyntax<T> implements interfaces.ProvideOnSyntax<T> {
         return new ProvideWhenSyntax(bindingWhenSyntax, this._provideDoneSyntax);
     }
 
-    public done() {
-        return this._provideDoneSyntax.done();
+    public done(force?: boolean) {
+        return this._provideDoneSyntax.done(force);
     }
 
 }

src/syntax/provide_when_on_syntax.ts

@@ -74,8 +74,8 @@ class ProvideWhenOnSyntax<T> implements interfaces.ProvideWhenOnSyntax<T>  {
         return this._provideOnSyntax.onActivation(fn);
     }
 
-    public done() {
-        return this._provideWhenSyntax.done();
+    public done(force?: boolean) {
+        return this._provideWhenSyntax.done(force);
     }
 
 }

src/syntax/provide_when_syntax.ts

@@ -85,8 +85,8 @@ class ProvideWhenSyntax<T> implements interfaces.ProvideWhenSyntax<T> {
         return new ProvideOnSyntax<T>(bindingOnSyntax, this._provideDoneSyntax);
     }
 
-    public done() {
-        return this._provideDoneSyntax.done();
+    public done(force?: boolean) {
+        return this._provideDoneSyntax.done(force);
     }
 
 }

test/decorator/fluent_provide.test.ts

@@ -5,17 +5,14 @@ import "reflect-metadata";
 
 describe("fluentProvide", () => {
 
-    let container = new Container();
-
     it("Should return a configurable decorator", () => {
-
+        let container = new Container();
         let provide = fluentProvide(container);
         expect(typeof provide).eqls("function");
-
     });
 
     it("Should return an instance of ProvideInWhenOnSyntax once it is configured", () => {
-
+        let container = new Container();
         let provide = fluentProvide(container);
         let provideInWhenOnSyntax = provide("SomeTypeID");
         expect((<any>provideInWhenOnSyntax)._provideInSyntax).not.to.be.eqls(null);
@@ -24,6 +21,53 @@ describe("fluentProvide", () => {
         expect((<any>provideInWhenOnSyntax)._provideInSyntax).not.to.be.eqls(undefined);
         expect((<any>provideInWhenOnSyntax)._provideWhenSyntax).not.to.be.eqls(undefined);
         expect((<any>provideInWhenOnSyntax)._provideOnSyntax).not.to.be.eqls(undefined);
+    });
+
+    it("Should throw if @fluentProvide is applied more than once without force flag", () => {
+
+        let container = new Container();
+        let provideFluent = fluentProvide(container);
+
+        const provideSingleton = (identifier: any) => {
+          return provideFluent(identifier)
+            .inSingletonScope()
+            .done();
+        };
+
+        function shouldThrow() {
+            @provideSingleton("Ninja")
+            @provideSingleton("SilentNinja")
+            class Ninja {}
+            return Ninja;
+        }
+
+        expect(shouldThrow).to.throw(
+            "Cannot apply @provideFluent decorator multiple times but is has been used " +
+            "multiple times in Ninja " +
+            "Please use @done(true) if you are trying to declare multiple bindings!"
+        );
+
+    });
+
+    it("Should work if @provide is applied more than once with force flag", () => {
+
+        let container = new Container();
+        let provideFluent = fluentProvide(container);
+
+        const provideSingleton = (identifier: any) => {
+            return provideFluent(identifier)
+            .inSingletonScope()
+            .done(true); // IMPORTANT!
+        };
+
+        function shouldThrow() {
+            @provideSingleton("Ninja")
+            @provideSingleton("SilentNinja")
+            class Ninja {}
+            return Ninja;
+        }
+
+        expect(shouldThrow).not.to.throw();
 
     });
 

test/decorator/provide.test.ts

@@ -29,7 +29,7 @@ describe("provide", () => {
 
     });
 
-    it("Should throw if applied more than once without force flag", () => {
+    it("Should throw if @provide is applied more than once without force flag", () => {
 
         const myContainer = new Container();
         const provide = _provide(myContainer);
@@ -42,12 +42,14 @@ describe("provide", () => {
         }
 
         expect(shouldThrow).to.throw(
-            "Cannot apply @injectable decorator multiple times. " +
-            "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
+            "Cannot apply @provide decorator multiple times but is has been used " +
+            "multiple times in Ninja " +
+            "Please use @provide(ID, true) if you are trying to declare multiple bindings!"
+        );
 
     });
 
-    it("Should work if applied more than once with force flag", () => {
+    it("Should work if @provide is applied more than once with force flag", () => {
 
         const myContainer = new Container();
         const provide = _provide(myContainer);