Update to RC.8

CHANGELOG.md

@@ -1,3 +1,8 @@
+## 1.0.0-RC7 (08.04.2017)
+
+- MiddlewareBuilder: `use()` deprecated, use `apply()` instead
+- MiddlewareBuilder: new `apply()` method
+
 ## 1.0.0-RC4 (08.04.2017)
 
 - Support for @Post, @Get, @Delete, @Put, @All decorators

example/modules/users/users.module.ts

@@ -1,13 +1,8 @@
 import { Module } from './../../../src/';
 import { UsersController } from './users.controller';
 import { UsersService } from './users.service';
-import { AuthMiddleware } from './auth.middleware';
 import { MiddlewareBuilder } from '../../../src/core/middlewares/builder';
-import { ProvideValues } from '../../../src/common/utils/provide-values.util';
-
-const ProvideRoles = ProvideValues({
-    role: ['admin', 'user']
-});
+import { AuthMiddleware } from './auth.middleware';
 
 @Module({
     controllers: [ UsersController ],
@@ -21,12 +16,16 @@ export class UsersModule {
     }
 
     configure(builder: MiddlewareBuilder) {
-        builder.use({
+       builder.apply(AuthMiddleware)
+            .with('admin', 'creator', 'editor')
+            .forRoutes(UsersController);
+
+       /* builder.use({
             middlewares: [
-                ProvideRoles(AuthMiddleware)
+               AuthMiddleware
             ],
-            forRoutes: [ UsersController]
-        });
+            forRoutes: [ UsersController ]
+        });*/
     }
 }
 

src/common/test/utils/bind-resolve-values.util.spec.ts

@@ -0,0 +1,29 @@
+import 'mocha';
+import 'reflect-metadata';
+import { expect } from 'chai';
+import { BindResolveMiddlewareValues } from '../../utils/bind-resolve-values.util';
+import { NestMiddleware } from '../../../core/middlewares/interfaces/nest-middleware.interface';
+
+describe('BindResolveMiddlewareValues', () => {
+    let type,
+        arg1 = 3,
+        arg2 = 4;
+
+    class Test implements NestMiddleware {
+        resolve(a, b) {
+            return () => [a, b];
+        }
+    }
+
+    beforeEach(() => {
+        type = BindResolveMiddlewareValues([ arg1, arg2 ])(Test);
+    });
+    it('should pass values to resolve() method', () => {
+        const obj = new type();
+        const hof = obj.resolve();
+        expect(hof()).to.deep.equal([arg1, arg2]);
+    });
+    it('should set name of metatype', () => {
+        expect(type.name).to.eq((<any>Test).name + JSON.stringify([ arg1, arg2 ]));
+    });
+});

src/common/test/utils/component.decorator.spec.ts

@@ -1,5 +1,4 @@
 import 'reflect-metadata';
-import 'mocha';
 import { expect } from 'chai';
 import { Component } from '../../utils/component.decorator';
 

src/common/test/utils/provide-values.util.spec.ts → src/common/test/utils/merge-with-values.util.spec.ts

@@ -1,13 +1,13 @@
 import 'reflect-metadata';
 import { expect } from 'chai';
-import { ProvideValues } from '../../utils/provide-values.util';
+import { MergeWithValues } from '../../utils/merge-with-values.util';
 
-describe('ProvideValues', () => {
+describe('MergeWithValues', () => {
     let type, data = { test: [ 1, 2, 3 ] };
     class Test {}
 
     beforeEach(() => {
-        type = ProvideValues(data)(Test);
+        type = MergeWithValues(data)(Test);
     });
     it('should enrich prototype with given values', () => {
         expect(type.prototype).to.contain(data);

src/common/utils/bind-resolve-values.util.ts

@@ -0,0 +1,15 @@
+import { Constructor } from './merge-with-values.util';
+import { NestMiddleware } from '../../core/middlewares/interfaces/nest-middleware.interface';
+
+export const BindResolveMiddlewareValues = <T extends Constructor<NestMiddleware>>(data: Array<any>) => {
+    return (metatype: T): any => {
+        const type = class extends metatype {
+            resolve() {
+                return super.resolve(...data);
+            }
+        };
+        const token = metatype.name + JSON.stringify(data);
+        Object.defineProperty(type, 'name', { value: token });
+        return type;
+    }
+};

src/common/utils/index.ts

@@ -5,4 +5,4 @@ export * from './module.decorator';
 export * from './dependencies.decorator';
 export * from './inject.decorator';
 export { Component as Middleware } from './component.decorator';
-export * from './provide-values.util';
+export * from './merge-with-values.util';

src/common/utils/provide-values.util.ts → src/common/utils/merge-with-values.util.ts

@@ -1,19 +1,19 @@
 import 'reflect-metadata';
 
-interface Constructor<T> {
+export interface Constructor<T> {
     new(...args: any[]): T
 }
 
-export const ProvideValues = <T extends Constructor<{}>>(data) => {
-    return (metatype: T) => {
+export const MergeWithValues = <T extends Constructor<{}>>(data: { [param: string]: any }) => {
+    return (metatype: T): any => {
         const type = class extends metatype {
             constructor(...args) {
-                super(args);
+                super(...args);
             }
         };
         const token = metatype.name + JSON.stringify(data);
         Object.defineProperty(type, 'name', { value: token });
         Object.assign(type.prototype, data);
         return type;
     }
-};
+};

src/core/middlewares/builder.ts

@@ -1,22 +1,66 @@
 import { MiddlewareConfiguration } from './interfaces/middleware-configuration.interface';
 import { InvalidMiddlewareConfigurationException } from '../../errors/exceptions/invalid-middleware-configuration.exception';
-import { isUndefined } from '../../common/utils/shared.utils';
+import { isUndefined, isNil } from '../../common/utils/shared.utils';
+import { BindResolveMiddlewareValues } from '../../common/utils/bind-resolve-values.util';
+import { Logger } from '../../common/services/logger.service';
+import { Metatype } from '../../common/interfaces/metatype.interface';
 
 export class MiddlewareBuilder {
-    private storedConfiguration = new Set<MiddlewareConfiguration>();
+    private middlewaresCollection = new Set<MiddlewareConfiguration>();
+    private logger = new Logger(MiddlewareBuilder.name);
 
+    apply(metatypes: Metatype<any> | Array<Metatype<any>>): MiddlewareConfigProxy {
+        let resolveParams = null;
+        const configProxy = {
+            with: (...data) => {
+                resolveParams = data;
+                return configProxy as MiddlewareConfigProxy;
+            },
+            forRoutes: (routes) => {
+                if (isUndefined(routes)) {
+                    throw new InvalidMiddlewareConfigurationException();
+                }
+                const configuration = {
+                    middlewares: this.bindValuesToResolve(metatypes, resolveParams),
+                    forRoutes: [].concat(routes)
+                };
+                this.middlewaresCollection.add(<MiddlewareConfiguration>configuration);
+                return this;
+            }
+        };
+        return configProxy;
+    }
+
+    /**
+     * @deprecated
+     * Since version RC.6 this method is deprecated. Use apply() instead.
+     */
     use(configuration: MiddlewareConfiguration) {
+        this.logger.warn('DEPRECATED! Since version RC.6 `use()` method is deprecated. Use `apply()` instead.');
+
         const { middlewares, forRoutes } = configuration;
         if (isUndefined(middlewares) || isUndefined(forRoutes)) {
             throw new InvalidMiddlewareConfigurationException();
         }
 
-        this.storedConfiguration.add(configuration);
+        this.middlewaresCollection.add(configuration);
         return this;
     }
 
     build() {
-        return [ ...this.storedConfiguration ];
+        return [ ...this.middlewaresCollection ];
+    }
+
+    private bindValuesToResolve(middlewares: Metatype<any> | Array<Metatype<any>>, resolveParams: Array<any>) {
+        if (isNil(resolveParams)) {
+            return middlewares;
+        }
+        const bindArgs = BindResolveMiddlewareValues(resolveParams);
+        return [].concat(middlewares).map(bindArgs);
     }
+}
 
+export interface MiddlewareConfigProxy {
+    with: (...data) => MiddlewareConfigProxy;
+    forRoutes: (routes) => MiddlewareBuilder;
 }

src/core/middlewares/interfaces/nest-middleware.interface.ts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from 'express';
 
 export interface NestMiddleware {
-    resolve: () => (req?: Request, res?: Response, next?: NextFunction) => void;
+    resolve(...args): (req?: Request, res?: Response, next?: NextFunction) => void;
 }

src/core/test/middlewares/builder.spec.ts

@@ -8,38 +8,70 @@ describe('MiddlewareBuilder', () => {
     beforeEach(() => {
         builder = new MiddlewareBuilder();
     });
-
-    it('should store configuration passed as argument', () => {
-        builder.use(<any>{
-            middlewares: 'Test',
-            forRoutes: 'Test'
+    describe('apply', () => {
+        let configProxy;
+        beforeEach(() => {
+            configProxy = builder.apply([]);
+        });
+        it('should return configuration proxy', () => {
+            expect(configProxy).to.have.keys('with', 'forRoutes');
         });
+        describe('configuration proxy', () => {
+            it('should returns itself on "with()" call', () => {
+                expect(configProxy.with()).to.be.eq(configProxy);
+            });
+            describe('when "forRoutes()" called', () => {
+                class Test {}
+                it('should throws "InvalidMiddlewareConfigurationException" when passed argument is undefined', () => {
+                   expect(() => configProxy.forRoutes()).to.throws(
+                       InvalidMiddlewareConfigurationException
+                   );
+                });
+                it('should store configuration passed as argument', () => {
+                    configProxy.forRoutes(Test);
 
-        expect(builder.build()).to.deep.equal([{
-            middlewares: 'Test',
-            forRoutes: 'Test'
-        }]);
+                    expect(builder.build()).to.deep.equal([{
+                        middlewares: [],
+                        forRoutes: [ Test ]
+                    }]);
+                });
+            });
+        });
     });
 
-    it('should be possible to chain "use" calls', () => {
-        builder.use(<any>{
-            middlewares: 'Test',
-            forRoutes: 'Test'
-        }).use(<any>{
-            middlewares: 'Test',
-            forRoutes: 'Test'
+    describe('use', () => {
+        it('should store configuration passed as argument', () => {
+            builder.use(<any>{
+                middlewares: 'Test',
+                forRoutes: 'Test'
+            });
+
+            expect(builder.build()).to.deep.equal([{
+                middlewares: 'Test',
+                forRoutes: 'Test'
+            }]);
         });
-        expect(builder.build()).to.deep.equal([<any>{
-            middlewares: 'Test',
-            forRoutes: 'Test'
-        }, <any>{
-            middlewares: 'Test',
-            forRoutes: 'Test'
-        }]);
-    });
 
-    it('should throw exception when middleware configuration object is invalid', () => {
-        expect(builder.use.bind(builder, 'test')).throws(InvalidMiddlewareConfigurationException);
-    });
+        it('should be possible to chain "use" calls', () => {
+            builder.use(<any>{
+                middlewares: 'Test',
+                forRoutes: 'Test'
+            }).use(<any>{
+                middlewares: 'Test',
+                forRoutes: 'Test'
+            });
+            expect(builder.build()).to.deep.equal([<any>{
+                middlewares: 'Test',
+                forRoutes: 'Test'
+            }, <any>{
+                middlewares: 'Test',
+                forRoutes: 'Test'
+            }]);
+        });
 
+        it('should throw exception when middleware configuration object is invalid', () => {
+            expect(builder.use.bind(builder, 'test')).throws(InvalidMiddlewareConfigurationException);
+        });
+
+    });
 });