#98 Wrong injections order when using Inject decorator

Author: basedalexander

src/lib/decorators.ts

@@ -10,17 +10,17 @@ export function Injectable(injections?: ProviderToken[]) {
         MetadataAnnotator.defineMetadata(INJECTABLE_MD_KEY, true, target);
 
         if (injections && Array.isArray(injections)) {
-            const injectionMd: IInjectionMd[] = MetadataAnnotator.getMetadata(INJECTIONS_MD_KEY, target) || [];
-            injections.forEach(token => injectionMd.push(token));
-            MetadataAnnotator.defineMetadata(INJECTIONS_MD_KEY, injectionMd, target);
+            const injectionsMd: IInjectionMd[] = MetadataAnnotator.getMetadata(INJECTIONS_MD_KEY, target) || [];
+            injections.forEach(token => injectionsMd.push(token));
+            MetadataAnnotator.defineMetadata(INJECTIONS_MD_KEY, injectionsMd, target);
         }
     };
 }
 
 export function Inject(token: any) {
     return (target: object, propertyKey: string | symbol, parameterIndex: number) => {
         const injections: IInjectionMd[] = MetadataAnnotator.getMetadata(INJECTIONS_MD_KEY, target) || [];
-        injections.push(token);
+        injections[parameterIndex] = token;
         MetadataAnnotator.defineMetadata(INJECTIONS_MD_KEY, injections, target);
     };
 }

src/tests/decorators.spec.ts

@@ -131,6 +131,37 @@ describe('Decorators', () => {
 
             expect(A.works).to.be.true;
         });
+
+        it('should inject parameters in the right order', () => {
+            @Injectable()
+            class A {}
+
+            @Injectable()
+            class B {}
+
+            @Injectable()
+            class C {
+                constructor(
+                    @Inject(A) public a: A,
+                    @Inject(B) public b: B
+                ) {
+
+                }
+            }
+
+            const providers = [
+                { token: A, useClass: A },
+                { token: B, useClass: B },
+                { token: C, useClass: C }
+            ];
+
+            container.register(providers);
+
+            const c = container.resolve(C);
+
+            expect(c.a).to.be.instanceof(A);
+            expect(c.b).to.be.instanceof(B);
+        });
     });
 
     describe('@Injectable()', () => {
@@ -152,5 +183,36 @@ describe('Decorators', () => {
             container.register(A);
             expect(() => container.resolve(A)).to.throw();
         });
+
+        it('should inject parameters in the right order when using alternative way of declaring dependencies', () => {
+            @Injectable()
+            class A {}
+
+            @Injectable()
+            class B {}
+
+            @Injectable([A, B])
+            class C {
+                constructor(
+                    public a: A,
+                    public b: B
+                ) {
+
+                }
+            }
+
+            const providers = [
+                { token: A, useClass: A },
+                { token: B, useClass: B },
+                { token: C, useClass: C }
+            ];
+
+            container.register(providers);
+
+            const c = container.resolve(C);
+
+            expect(c.a).to.be.instanceof(A);
+            expect(c.b).to.be.instanceof(B);
+        });
     });
 });