Add route to .resolve() of Target and Middleware resolvers

dist/lib/contracts/MiddlewareResolver.d.ts

@@ -1,7 +1,8 @@
 /// <reference path="../definitions/Middleware.d.ts" />
+/// <reference path="../definitions/IRoute.d.ts" />
 declare namespace NajsFramework.Contracts.Routing {
     interface MiddlewareResolver<V = any, M = NajsRouting.Middleware> {
         isValid(middleware: M): boolean;
-        resolve(middleware: M): V | V[];
+        resolve(middleware: M, route: NajsRouting.IRoute<any, V>): V | V[];
     }
 }

dist/lib/contracts/MiddlewareResolver.js

@@ -1 +1,2 @@
 /// <reference path="../definitions/Middleware.ts" />
+/// <reference path="../definitions/IRoute.ts" />

dist/lib/contracts/TargetResolver.d.ts

@@ -1,7 +1,8 @@
 /// <reference path="../definitions/Target.d.ts" />
+/// <reference path="../definitions/IRoute.d.ts" />
 declare namespace NajsFramework.Contracts.Routing {
     interface TargetResolver<V = any, T = NajsRouting.Target> {
         isValid(target: T): boolean;
-        resolve(target: T): V;
+        resolve(target: T, route: NajsRouting.IRoute<T, any>): V;
     }
 }

dist/lib/contracts/TargetResolver.js

@@ -1 +1,2 @@
 /// <reference path="../definitions/Target.ts" />
+/// <reference path="../definitions/IRoute.ts" />

dist/lib/routing/RouteBuilder.d.ts

@@ -22,11 +22,11 @@ export declare class RouteBuilder<T = Target, M = Middleware> implements IRouteB
     validateByResolvers(item: M | T, resolvers: Array<{
         isValid(item: M | T): boolean;
     }>): boolean;
-    resolveMiddleware(middleware: M): any;
-    resolveTarget(target: T): any;
-    resolveByResolvers(item: M | T, resolvers: Array<{
+    resolveMiddleware(middleware: M, route: IRoute<T, M>): any;
+    resolveTarget(target: T, route: IRoute<T, M>): any;
+    resolveByResolvers(item: M | T, route: IRoute<T, M>, resolvers: Array<{
         isValid(item: M | T): boolean;
-        resolve(item: M | T): any;
+        resolve(item: M | T, route: any): any;
     }>): any;
     getRoutes(parent?: IRoute<T, M>): IRouteData<T, M>[];
     isContainer(): boolean;

dist/lib/routing/RouteBuilder.js

@@ -30,19 +30,19 @@ class RouteBuilder {
         }
         return false;
     }
-    resolveMiddleware(middleware) {
-        return this.resolveByResolvers(middleware, this.manager.getMiddlewareResolvers());
+    resolveMiddleware(middleware, route) {
+        return this.resolveByResolvers(middleware, route, this.manager.getMiddlewareResolvers());
     }
-    resolveTarget(target) {
-        return this.resolveByResolvers(target, this.manager.getTargetResolvers());
+    resolveTarget(target, route) {
+        return this.resolveByResolvers(target, route, this.manager.getTargetResolvers());
     }
-    resolveByResolvers(item, resolvers) {
+    resolveByResolvers(item, route, resolvers) {
         if (resolvers.length === 0) {
             return undefined;
         }
         for (const resolver of resolvers) {
             if (resolver.isValid(item)) {
-                return resolver.resolve(item);
+                return resolver.resolve(item, route);
             }
         }
         return undefined;
@@ -51,8 +51,8 @@ class RouteBuilder {
         if (this.children.length === 0) {
             const data = this.route.getData(parent);
             if (data) {
-                data['resolvedMiddleware'] = data.middleware.map(middleware => this.resolveMiddleware(middleware));
-                data['resolvedTarget'] = this.resolveTarget(data.target);
+                data['resolvedMiddleware'] = data.middleware.map(middleware => this.resolveMiddleware(middleware, data));
+                data['resolvedTarget'] = this.resolveTarget(data.target, data);
                 return [data];
             }
             return [];

dist/test/routing/RouteBuilder.test.js

@@ -87,7 +87,7 @@ describe('RouteBuilder', function () {
         it('returns undefined if there is no resolvers provided by RouteManager', function () {
             const manager = new RouteManager_1.RouteManager();
             const builder = new RouteBuilder_1.RouteBuilder(manager);
-            expect(builder.resolveMiddleware('any')).toBeUndefined();
+            expect(builder.resolveMiddleware('any', {})).toBeUndefined();
         });
         it('loops middlewareResolvers provided by RouteManager then returns .resolve() if .isValid() of any resolver returns true', function () {
             const resolverA = {
@@ -120,16 +120,16 @@ describe('RouteBuilder', function () {
                 .registerMiddlewareResolver(resolverB, 'b')
                 .registerMiddlewareResolver(resolverC, 'c');
             const builder = new RouteBuilder_1.RouteBuilder(manager);
-            expect(builder.resolveMiddleware('a')).toEqual('a-resolved');
-            expect(builder.resolveMiddleware('b')).toEqual('b-resolved');
-            expect(builder.resolveMiddleware('any')).toBeUndefined();
+            expect(builder.resolveMiddleware('a', {})).toEqual('a-resolved');
+            expect(builder.resolveMiddleware('b', {})).toEqual('b-resolved');
+            expect(builder.resolveMiddleware('any', {})).toBeUndefined();
         });
     });
     describe('.resolveTarget()', function () {
         it('returns undefined if there is no resolvers provided by RouteManager', function () {
             const manager = new RouteManager_1.RouteManager();
             const builder = new RouteBuilder_1.RouteBuilder(manager);
-            expect(builder.resolveTarget('any')).toBeUndefined();
+            expect(builder.resolveTarget('any', {})).toBeUndefined();
         });
         it('loops targetResolvers provided by RouteManager then returns .resolve() if .isValid() of any resolver returns true', function () {
             const resolverA = {
@@ -162,9 +162,9 @@ describe('RouteBuilder', function () {
                 .registerTargetResolver(resolverB, 'b')
                 .registerTargetResolver(resolverC, 'c');
             const builder = new RouteBuilder_1.RouteBuilder(manager);
-            expect(builder.resolveTarget('a')).toEqual('a-resolved');
-            expect(builder.resolveTarget('b')).toEqual('b-resolved');
-            expect(builder.resolveTarget('any')).toBeUndefined();
+            expect(builder.resolveTarget('a', {})).toEqual('a-resolved');
+            expect(builder.resolveTarget('b', {})).toEqual('b-resolved');
+            expect(builder.resolveTarget('any', {})).toBeUndefined();
         });
     });
     describe('.getRoutes()', function () {
@@ -198,6 +198,9 @@ describe('RouteBuilder', function () {
                     resolvedTarget: 'target-resolved'
                 }
             ]);
+            expect(resolveMiddlewareStub.firstCall.calledWith('a', routeRata)).toBe(true);
+            expect(resolveMiddlewareStub.secondCall.calledWith('b', routeRata)).toBe(true);
+            expect(resolveTargetStub.calledWith('target', routeRata)).toBe(true);
         });
         it('calls "route".mergeParentData() then map children with it\'s .getRoutes() function', function () {
             const manager = new RouteManager_1.RouteManager();

dist/test/syntax/resolvers/MiddlewareDummyResolver.d.ts

@@ -1,5 +1,5 @@
 /// <reference path="../../../lib/contracts/MiddlewareResolver.d.ts" />
 export declare class MiddlewareDummyResolver implements NajsFramework.Contracts.Routing.MiddlewareResolver<any, string> {
     isValid(middleware: string): boolean;
-    resolve(middleware: string): string;
+    resolve(middleware: string, route: any): string;
 }

dist/test/syntax/resolvers/MiddlewareDummyResolver.js

@@ -5,7 +5,7 @@ class MiddlewareDummyResolver {
     isValid(middleware) {
         return true;
     }
-    resolve(middleware) {
+    resolve(middleware, route) {
         return middleware + '-resolved';
     }
 }

dist/test/syntax/resolvers/TargetDummyResolver.d.ts

@@ -1,5 +1,5 @@
 /// <reference path="../../../lib/contracts/TargetResolver.d.ts" />
 export declare class TargetDummyResolver implements NajsFramework.Contracts.Routing.TargetResolver<any, string> {
     isValid(target: string): boolean;
-    resolve(target: string): string;
+    resolve(target: string, route: any): string;
 }

dist/test/syntax/resolvers/TargetDummyResolver.js

@@ -5,7 +5,7 @@ class TargetDummyResolver {
     isValid(target) {
         return true;
     }
-    resolve(target) {
+    resolve(target, route) {
         return target + '-resolved';
     }
 }

lib/contracts/MiddlewareResolver.ts

@@ -1,9 +1,10 @@
 /// <reference path="../definitions/Middleware.ts" />
+/// <reference path="../definitions/IRoute.ts" />
 
 namespace NajsFramework.Contracts.Routing {
   export interface MiddlewareResolver<V = any, M = NajsRouting.Middleware> {
     isValid(middleware: M): boolean
 
-    resolve(middleware: M): V | V[]
+    resolve(middleware: M, route: NajsRouting.IRoute<any, V>): V | V[]
   }
 }

lib/contracts/TargetResolver.ts

@@ -1,9 +1,10 @@
 /// <reference path="../definitions/Target.ts" />
+/// <reference path="../definitions/IRoute.ts" />
 
 namespace NajsFramework.Contracts.Routing {
   export interface TargetResolver<V = any, T = NajsRouting.Target> {
     isValid(target: T): boolean
 
-    resolve(target: T): V
+    resolve(target: T, route: NajsRouting.IRoute<T, any>): V
   }
 }

lib/routing/RouteBuilder.ts

@@ -49,22 +49,26 @@ export class RouteBuilder<T = Target, M = Middleware> implements IRouteBuilder<T
     return false
   }
 
-  resolveMiddleware(middleware: M): any {
-    return this.resolveByResolvers(middleware, this.manager.getMiddlewareResolvers())
+  resolveMiddleware(middleware: M, route: IRoute<T, M>): any {
+    return this.resolveByResolvers(middleware, route, this.manager.getMiddlewareResolvers())
   }
 
-  resolveTarget(target: T): any {
-    return this.resolveByResolvers(target, this.manager.getTargetResolvers())
+  resolveTarget(target: T, route: IRoute<T, M>): any {
+    return this.resolveByResolvers(target, route, this.manager.getTargetResolvers())
   }
 
-  resolveByResolvers(item: M | T, resolvers: Array<{ isValid(item: M | T): boolean; resolve(item: M | T): any }>): any {
+  resolveByResolvers(
+    item: M | T,
+    route: IRoute<T, M>,
+    resolvers: Array<{ isValid(item: M | T): boolean; resolve(item: M | T, route: any): any }>
+  ): any {
     if (resolvers.length === 0) {
       return undefined
     }
 
     for (const resolver of resolvers) {
       if (resolver.isValid(item)) {
-        return resolver.resolve(item)
+        return resolver.resolve(item, route)
       }
     }
     return undefined
@@ -74,8 +78,8 @@ export class RouteBuilder<T = Target, M = Middleware> implements IRouteBuilder<T
     if (this.children.length === 0) {
       const data = this.route.getData(parent as any)
       if (data) {
-        data['resolvedMiddleware'] = data.middleware!.map(middleware => this.resolveMiddleware(middleware))
-        data['resolvedTarget'] = this.resolveTarget(data.target!)
+        data['resolvedMiddleware'] = data.middleware.map(middleware => this.resolveMiddleware(middleware, data))
+        data['resolvedTarget'] = this.resolveTarget(data.target, data)
         return [data as IRouteData<T, M>]
       }
       return []

test/routing/RouteBuilder.test.ts

@@ -97,7 +97,7 @@ describe('RouteBuilder', function() {
     it('returns undefined if there is no resolvers provided by RouteManager', function() {
       const manager = new RouteManager()
       const builder = new RouteBuilder(manager)
-      expect(builder.resolveMiddleware('any')).toBeUndefined()
+      expect(builder.resolveMiddleware('any', {} as any)).toBeUndefined()
     })
 
     it('loops middlewareResolvers provided by RouteManager then returns .resolve() if .isValid() of any resolver returns true', function() {
@@ -134,17 +134,17 @@ describe('RouteBuilder', function() {
         .registerMiddlewareResolver(resolverB, 'b')
         .registerMiddlewareResolver(resolverC, 'c')
       const builder = new RouteBuilder(manager)
-      expect(builder.resolveMiddleware('a')).toEqual('a-resolved')
-      expect(builder.resolveMiddleware('b')).toEqual('b-resolved')
-      expect(builder.resolveMiddleware('any')).toBeUndefined()
+      expect(builder.resolveMiddleware('a', {} as any)).toEqual('a-resolved')
+      expect(builder.resolveMiddleware('b', {} as any)).toEqual('b-resolved')
+      expect(builder.resolveMiddleware('any', {} as any)).toBeUndefined()
     })
   })
 
   describe('.resolveTarget()', function() {
     it('returns undefined if there is no resolvers provided by RouteManager', function() {
       const manager = new RouteManager()
       const builder = new RouteBuilder(manager)
-      expect(builder.resolveTarget('any')).toBeUndefined()
+      expect(builder.resolveTarget('any', {} as any)).toBeUndefined()
     })
 
     it('loops targetResolvers provided by RouteManager then returns .resolve() if .isValid() of any resolver returns true', function() {
@@ -181,9 +181,9 @@ describe('RouteBuilder', function() {
         .registerTargetResolver(resolverB, 'b')
         .registerTargetResolver(resolverC, 'c')
       const builder = new RouteBuilder(manager)
-      expect(builder.resolveTarget('a')).toEqual('a-resolved')
-      expect(builder.resolveTarget('b')).toEqual('b-resolved')
-      expect(builder.resolveTarget('any')).toBeUndefined()
+      expect(builder.resolveTarget('a', {} as any)).toEqual('a-resolved')
+      expect(builder.resolveTarget('b', {} as any)).toEqual('b-resolved')
+      expect(builder.resolveTarget('any', {} as any)).toBeUndefined()
     })
   })
 
@@ -220,6 +220,9 @@ describe('RouteBuilder', function() {
           resolvedTarget: 'target-resolved'
         }
       ])
+      expect(resolveMiddlewareStub.firstCall.calledWith('a', routeRata)).toBe(true)
+      expect(resolveMiddlewareStub.secondCall.calledWith('b', routeRata)).toBe(true)
+      expect(resolveTargetStub.calledWith('target', routeRata)).toBe(true)
     })
 
     it('calls "route".mergeParentData() then map children with it\'s .getRoutes() function', function() {

test/syntax/resolvers/MiddlewareDummyResolver.ts

@@ -5,7 +5,7 @@ export class MiddlewareDummyResolver implements NajsFramework.Contracts.Routing.
     return true
   }
 
-  resolve(middleware: string) {
+  resolve(middleware: string, route: any) {
     return middleware + '-resolved'
   }
 }

test/syntax/resolvers/TargetDummyResolver.ts

@@ -5,7 +5,7 @@ export class TargetDummyResolver implements NajsFramework.Contracts.Routing.Targ
     return true
   }
 
-  resolve(target: string) {
+  resolve(target: string, route: any) {
     return target + '-resolved'
   }
 }