@e22m4u/ts-rest-router 0.0.6 → 0.1.0

package/src/controller-registry.spec.ts

@@ -1,59 +1,78 @@
+/* eslint mocha/no-sibling-hooks: 0 */
 import {expect} from 'chai';
 import {get} from './decorators/index.js';
 import {post} from './decorators/index.js';
+import {body} from './decorators/index.js';
+import {after} from './decorators/index.js';
+import {query} from './decorators/index.js';
+import {param} from './decorators/index.js';
+import {cookie} from './decorators/index.js';
+import {params} from './decorators/index.js';
+import {before} from './decorators/index.js';
+import {header} from './decorators/index.js';
+import {cookies} from './decorators/index.js';
+import {queries} from './decorators/index.js';
+import {headers} from './decorators/index.js';
+import {bodyProp} from './decorators/index.js';
 import {HookName} from '@e22m4u/js-trie-router';
 import {controller} from './decorators/index.js';
 import {TrieRouter} from '@e22m4u/js-trie-router';
 import {HttpMethod} from '@e22m4u/js-trie-router';
+import {ParsedQuery} from '@e22m4u/js-trie-router';
+import {ParsedCookie} from '@e22m4u/js-trie-router';
+import {ParsedParams} from '@e22m4u/js-trie-router';
+import {ParsedHeaders} from '@e22m4u/js-trie-router';
 import {RouteRegistry} from '@e22m4u/js-trie-router';
+import {RequestParser} from '@e22m4u/js-trie-router';
+import {RequestContext} from '@e22m4u/js-trie-router';
 import {createRequestMock} from '@e22m4u/js-trie-router';
-import {ControllerReflector} from './decorators/index.js';
+import {createResponseMock} from '@e22m4u/js-trie-router';
 import {ControllerRegistry} from './controller-registry.js';
 
 const PRE_HANDLER_1 = () => undefined;
 const PRE_HANDLER_2 = () => undefined;
-const PRE_HANDLER_3 = () => undefined;
-const PRE_HANDLER_4 = () => undefined;
+// const PRE_HANDLER_3 = () => undefined;
+// const PRE_HANDLER_4 = () => undefined;
 
 const POST_HANDLER_1 = () => undefined;
 const POST_HANDLER_2 = () => undefined;
-const POST_HANDLER_3 = () => undefined;
-const POST_HANDLER_4 = () => undefined;
+// const POST_HANDLER_3 = () => undefined;
+// const POST_HANDLER_4 = () => undefined;
 
 describe('ControllerRegistry', function () {
   it('has a public property with set of controllers', function () {
-    const s = new ControllerRegistry();
-    expect(s).to.have.property('controllers');
-    expect(s.controllers).to.be.instanceof(Set);
+    const S = new ControllerRegistry();
+    expect(S).to.have.property('controllers');
+    expect(S.controllers).to.be.instanceof(Set);
   });
 
   describe('addController', function () {
     it('returns itself', function () {
-      const s = new ControllerRegistry();
+      const S = new ControllerRegistry();
       @controller()
       class MyController {}
-      const res = s.addController(MyController);
-      expect(res).to.be.eq(s);
+      const res = S.addController(MyController);
+      expect(res).to.be.eq(S);
     });
 
     it('adds a given controller to controllers set', function () {
-      const s = new ControllerRegistry();
+      const S = new ControllerRegistry();
       @controller()
       class MyController {}
-      expect(s.hasController(MyController)).to.be.false;
-      s.addController(MyController);
-      expect(s.hasController(MyController)).to.be.true;
+      expect(S.hasController(MyController)).to.be.false;
+      S.addController(MyController);
+      expect(S.hasController(MyController)).to.be.true;
     });
 
-    it('passes action method and path of a given controller to the route', function () {
-      const s = new ControllerRegistry();
+    it('uses http method and action path for a new route', function () {
+      const S = new ControllerRegistry();
       @controller()
       class MyController {
         @get('/myAction')
         foo() {}
       }
-      s.addController(MyController);
-      const reg = s.getService(TrieRouter).getService(RouteRegistry);
+      S.addController(MyController);
+      const reg = S.getService(TrieRouter).getService(RouteRegistry);
       const req = createRequestMock({
         method: HttpMethod.GET,
         path: '/myAction',
@@ -64,8 +83,8 @@ describe('ControllerRegistry', function () {
       expect(matching!.route.path).to.be.eq('/myAction');
     });
 
-    it('creates routes for multiple actions of a given controller', function () {
-      const s = new ControllerRegistry();
+    it('adds multiple routes by the given controller', function () {
+      const S = new ControllerRegistry();
       @controller()
       class MyController {
         @get('/foo')
@@ -73,8 +92,8 @@ describe('ControllerRegistry', function () {
         @post('/bar')
         bar() {}
       }
-      s.addController(MyController);
-      const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
       const fooReq = createRequestMock({
         method: HttpMethod.GET,
         path: '/foo',
@@ -89,16 +108,107 @@ describe('ControllerRegistry', function () {
       expect(barMatching).to.be.not.empty;
     });
 
+    it('uses path prefix of controller root options', function () {
+      const S = new ControllerRegistry();
+      @controller()
+      class MyController {
+        @get('/myAction')
+        myAction() {}
+      }
+      S.addController(MyController, {pathPrefix: '/myPrefix'});
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myPrefix/myAction',
+      });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+    });
+
+    it('uses path prefix of @controller metadata', function () {
+      const S = new ControllerRegistry();
+      @controller('/myController')
+      class MyController {
+        @get('/myAction')
+        myAction() {}
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myController/myAction',
+      });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+    });
+
+    it('uses path prefix of controller root options and @controller metadata', function () {
+      const S = new ControllerRegistry();
+      @controller('/myController')
+      class MyController {
+        @get('/myAction')
+        myAction() {}
+      }
+      S.addController(MyController, {pathPrefix: '/myPrefix'});
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myPrefix/myController/myAction',
+      });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+    });
+
     describe('single pre-handler', function () {
-      it('passes pre-handler of a given options to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses pre-handler of controller root options', function () {
+        const S = new ControllerRegistry();
+        @controller()
+        class MyController {
+          @get('/myAction')
+          myAction() {}
+        }
+        S.addController(MyController, {before: PRE_HANDLER_1});
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+        const req = createRequestMock({
+          method: HttpMethod.GET,
+          path: '/myAction',
+        });
+        const matching = routeReg.matchRouteByRequest(req);
+        expect(matching).to.be.not.empty;
+        const res = matching!.route.hookRegistry.getHooks(HookName.PRE_HANDLER);
+        expect(res).to.be.eql([PRE_HANDLER_1]);
+      });
+
+      it('uses pre-handler of @before metadata applied to controller', function () {
+        const S = new ControllerRegistry();
+        @controller()
+        @before(PRE_HANDLER_1)
+        class MyController {
+          @get('/myAction')
+          myAction() {}
+        }
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+        const req = createRequestMock({
+          method: HttpMethod.GET,
+          path: '/myAction',
+        });
+        const matching = routeReg.matchRouteByRequest(req);
+        expect(matching).to.be.not.empty;
+        const res = matching!.route.hookRegistry.getHooks(HookName.PRE_HANDLER);
+        expect(res).to.be.eql([PRE_HANDLER_1]);
+      });
+
+      it('uses pre-handler of @before metadata applied to action', function () {
+        const S = new ControllerRegistry();
         @controller()
         class MyController {
           @get('/myAction')
+          @before(PRE_HANDLER_1)
           myAction() {}
         }
-        s.addController(MyController, {before: PRE_HANDLER_1});
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -109,15 +219,15 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([PRE_HANDLER_1]);
       });
 
-      it('passes pre-handler of a given controller to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses pre-handler of @controller metadata', function () {
+        const S = new ControllerRegistry();
         @controller({before: PRE_HANDLER_1})
         class MyController {
           @get('/myAction')
           myAction() {}
         }
-        s.addController(MyController);
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -128,15 +238,15 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([PRE_HANDLER_1]);
       });
 
-      it('passes action pre-handler of a given controller to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses pre-handler of @action metadata', function () {
+        const S = new ControllerRegistry();
         @controller()
         class MyController {
           @get('/myAction', {before: PRE_HANDLER_1})
           myAction() {}
         }
-        s.addController(MyController);
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -149,17 +259,57 @@ describe('ControllerRegistry', function () {
     });
 
     describe('multiple pre-handlers', function () {
-      it('passes pre-handlers of a given options to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses pre-handlers of controller root options', function () {
+        const S = new ControllerRegistry();
         @controller()
         class MyController {
           @get('/myAction')
           myAction() {}
         }
-        s.addController(MyController, {
+        S.addController(MyController, {
           before: [PRE_HANDLER_1, PRE_HANDLER_2],
         });
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+        const req = createRequestMock({
+          method: HttpMethod.GET,
+          path: '/myAction',
+        });
+        const matching = routeReg.matchRouteByRequest(req);
+        expect(matching).to.be.not.empty;
+        const res = matching!.route.hookRegistry.getHooks(HookName.PRE_HANDLER);
+        expect(res).to.be.eql([PRE_HANDLER_1, PRE_HANDLER_2]);
+      });
+
+      it('uses pre-handlers of @before metadata applied to controller', function () {
+        const S = new ControllerRegistry();
+        @controller()
+        @before([PRE_HANDLER_1, PRE_HANDLER_2])
+        class MyController {
+          @get('/myAction')
+          myAction() {}
+        }
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+        const req = createRequestMock({
+          method: HttpMethod.GET,
+          path: '/myAction',
+        });
+        const matching = routeReg.matchRouteByRequest(req);
+        expect(matching).to.be.not.empty;
+        const res = matching!.route.hookRegistry.getHooks(HookName.PRE_HANDLER);
+        expect(res).to.be.eql([PRE_HANDLER_1, PRE_HANDLER_2]);
+      });
+
+      it('uses pre-handlers of @before metadata applied to action', function () {
+        const S = new ControllerRegistry();
+        @controller()
+        class MyController {
+          @get('/myAction')
+          @before([PRE_HANDLER_1, PRE_HANDLER_2])
+          myAction() {}
+        }
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -170,8 +320,8 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([PRE_HANDLER_1, PRE_HANDLER_2]);
       });
 
-      it('passes pre-handlers of a given controller to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses pre-handlers of @controller metadata', function () {
+        const S = new ControllerRegistry();
         @controller({
           before: [PRE_HANDLER_1, PRE_HANDLER_2],
         })
@@ -179,8 +329,8 @@ describe('ControllerRegistry', function () {
           @get('/myAction')
           myAction() {}
         }
-        s.addController(MyController);
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -191,8 +341,8 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([PRE_HANDLER_1, PRE_HANDLER_2]);
       });
 
-      it('passes action pre-handlers of a given controller to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses pre-handlers of @action metadata', function () {
+        const S = new ControllerRegistry();
         @controller()
         class MyController {
           @get('/myAction', {
@@ -200,8 +350,8 @@ describe('ControllerRegistry', function () {
           })
           myAction() {}
         }
-        s.addController(MyController);
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -214,15 +364,59 @@ describe('ControllerRegistry', function () {
     });
 
     describe('single post-handler', function () {
-      it('passes post-handler of a given options to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses post-handler of controller root options', function () {
+        const S = new ControllerRegistry();
+        @controller()
+        class MyController {
+          @get('/myAction')
+          myAction() {}
+        }
+        S.addController(MyController, {after: POST_HANDLER_1});
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+        const req = createRequestMock({
+          method: HttpMethod.GET,
+          path: '/myAction',
+        });
+        const matching = routeReg.matchRouteByRequest(req);
+        expect(matching).to.be.not.empty;
+        const res = matching!.route.hookRegistry.getHooks(
+          HookName.POST_HANDLER,
+        );
+        expect(res).to.be.eql([POST_HANDLER_1]);
+      });
+
+      it('uses pre-handler of @after metadata applied to controller', function () {
+        const S = new ControllerRegistry();
+        @controller()
+        @after(POST_HANDLER_1)
+        class MyController {
+          @get('/myAction')
+          myAction() {}
+        }
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+        const req = createRequestMock({
+          method: HttpMethod.GET,
+          path: '/myAction',
+        });
+        const matching = routeReg.matchRouteByRequest(req);
+        expect(matching).to.be.not.empty;
+        const res = matching!.route.hookRegistry.getHooks(
+          HookName.POST_HANDLER,
+        );
+        expect(res).to.be.eql([POST_HANDLER_1]);
+      });
+
+      it('uses pre-handler of @after metadata applied to action', function () {
+        const S = new ControllerRegistry();
         @controller()
         class MyController {
           @get('/myAction')
+          @after(POST_HANDLER_1)
           myAction() {}
         }
-        s.addController(MyController, {after: POST_HANDLER_1});
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -235,15 +429,15 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([POST_HANDLER_1]);
       });
 
-      it('passes post-handler of a given controller to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses post-handler of @controller metadata', function () {
+        const S = new ControllerRegistry();
         @controller({after: POST_HANDLER_1})
         class MyController {
           @get('/myAction')
           myAction() {}
         }
-        s.addController(MyController);
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -256,15 +450,15 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([POST_HANDLER_1]);
       });
 
-      it('passes action post-handler of a given controller to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses post-handler of @action metadata', function () {
+        const S = new ControllerRegistry();
         @controller()
         class MyController {
           @get('/myAction', {after: POST_HANDLER_1})
           myAction() {}
         }
-        s.addController(MyController);
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -279,17 +473,61 @@ describe('ControllerRegistry', function () {
     });
 
     describe('multiple post-handlers', function () {
-      it('passes post-handlers of a given options to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses post-handlers of controller root options', function () {
+        const S = new ControllerRegistry();
         @controller()
         class MyController {
           @get('/myAction')
           myAction() {}
         }
-        s.addController(MyController, {
+        S.addController(MyController, {
           after: [POST_HANDLER_1, POST_HANDLER_2],
         });
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+        const req = createRequestMock({
+          method: HttpMethod.GET,
+          path: '/myAction',
+        });
+        const matching = routeReg.matchRouteByRequest(req);
+        expect(matching).to.be.not.empty;
+        const res = matching!.route.hookRegistry.getHooks(
+          HookName.POST_HANDLER,
+        );
+        expect(res).to.be.eql([POST_HANDLER_1, POST_HANDLER_2]);
+      });
+
+      it('uses pre-handlers of @after metadata applied to controller', function () {
+        const S = new ControllerRegistry();
+        @controller()
+        @after([POST_HANDLER_1, POST_HANDLER_2])
+        class MyController {
+          @get('/myAction')
+          myAction() {}
+        }
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+        const req = createRequestMock({
+          method: HttpMethod.GET,
+          path: '/myAction',
+        });
+        const matching = routeReg.matchRouteByRequest(req);
+        expect(matching).to.be.not.empty;
+        const res = matching!.route.hookRegistry.getHooks(
+          HookName.POST_HANDLER,
+        );
+        expect(res).to.be.eql([POST_HANDLER_1, POST_HANDLER_2]);
+      });
+
+      it('uses pre-handlers of @after metadata applied to action', function () {
+        const S = new ControllerRegistry();
+        @controller()
+        class MyController {
+          @get('/myAction')
+          @after([POST_HANDLER_1, POST_HANDLER_2])
+          myAction() {}
+        }
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -302,8 +540,8 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([POST_HANDLER_1, POST_HANDLER_2]);
       });
 
-      it('passes post-handlers of a given controller to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses post-handlers of @controller metadata', function () {
+        const S = new ControllerRegistry();
         @controller({
           after: [POST_HANDLER_1, POST_HANDLER_2],
         })
@@ -311,8 +549,8 @@ describe('ControllerRegistry', function () {
           @get('/myAction')
           myAction() {}
         }
-        s.addController(MyController);
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -325,8 +563,8 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([POST_HANDLER_1, POST_HANDLER_2]);
       });
 
-      it('passes action post-handlers of a given controller to the route', function () {
-        const s = new ControllerRegistry();
+      it('uses post-handlers of @action metadata', function () {
+        const S = new ControllerRegistry();
         @controller()
         class MyController {
           @get('/myAction', {
@@ -334,8 +572,8 @@ describe('ControllerRegistry', function () {
           })
           myAction() {}
         }
-        s.addController(MyController);
-        const routeReg = s.getService(TrieRouter).getService(RouteRegistry);
+        S.addController(MyController);
+        const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
         const req = createRequestMock({
           method: HttpMethod.GET,
           path: '/myAction',
@@ -348,245 +586,333 @@ describe('ControllerRegistry', function () {
         expect(res).to.be.eql([POST_HANDLER_1, POST_HANDLER_2]);
       });
     });
-  });
 
-  describe('hasController', function () {
-    it('returns false if a given controller is not registered', function () {
-      const s = new ControllerRegistry();
+    it('injects parsed parameters', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
       @controller()
-      class MyController {}
-      expect(s.hasController(MyController)).to.be.false;
+      class MyController {
+        @get('/myAction/:id')
+        myAction(
+          @params()
+          params: ParsedParams,
+        ) {
+          expect(params).to.be.eql({id: '123'});
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myAction/123',
+      });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      ctx.params = matching!.params;
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
     });
 
-    it('returns true if a given controller is registered', function () {
-      const s = new ControllerRegistry();
+    it('injects parsed parameter', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
       @controller()
-      class MyController {}
-      expect(s.hasController(MyController)).to.be.false;
-      s.addController(MyController);
-      expect(s.hasController(MyController)).to.be.true;
+      class MyController {
+        @get('/myAction/:id')
+        myAction(
+          @param('id')
+          param: string,
+        ) {
+          expect(param).to.be.eq('123');
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myAction/123',
+      });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      ctx.params = matching!.params;
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
     });
-  });
 
-  describe('getPathPrefixByControllerMetadata', function () {
-    it('returns an empty string if no prefix is specified', function () {
-      const s = new ControllerRegistry();
+    it('injects parsed queries', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
       @controller()
-      class MyController {}
-      const md = ControllerReflector.getMetadata(MyController)!;
-      const res = s.getPathPrefixByControllerMetadata(md);
-      expect(res).to.be.eq('');
-    });
-
-    it('returns controller path prefix that starts with slash', function () {
-      const s = new ControllerRegistry();
-      @controller({path: 'myPrefix'})
-      class MyController {}
-      const md = ControllerReflector.getMetadata(MyController)!;
-      const res = s.getPathPrefixByControllerMetadata(md);
-      expect(res).to.be.eq('/myPrefix');
+      class MyController {
+        @get('/myAction')
+        myAction(
+          @queries()
+          queries: ParsedQuery,
+        ) {
+          expect(queries).to.be.eql({foo: 'bar'});
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myAction?foo=bar',
+      });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      const reqData = await S.getService(RequestParser).parse(req);
+      Object.assign(ctx, reqData);
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
     });
 
-    it('returns path prefix from options that starts with slash', function () {
-      const s = new ControllerRegistry();
+    it('injects parsed query', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
       @controller()
-      class MyController {}
-      const md = ControllerReflector.getMetadata(MyController)!;
-      const res = s.getPathPrefixByControllerMetadata(md, {
-        pathPrefix: 'myPrefix',
+      class MyController {
+        @get('/myAction')
+        myAction(
+          @query('foo')
+          foo: string,
+        ) {
+          expect(foo).to.be.eql('bar');
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myAction?foo=bar',
       });
-      expect(res).to.be.eq('/myPrefix');
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      const reqData = await S.getService(RequestParser).parse(req);
+      Object.assign(ctx, reqData);
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
     });
 
-    it('combines a path prefix from options and controller', function () {
-      const s = new ControllerRegistry();
-      @controller({path: 'controller'})
-      class MyController {}
-      const md = ControllerReflector.getMetadata(MyController)!;
-      const res = s.getPathPrefixByControllerMetadata(md, {
-        pathPrefix: 'root',
+    it('injects parsed headers', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
+      @controller()
+      class MyController {
+        @get('/myAction')
+        myAction(
+          @headers()
+          headers: ParsedHeaders,
+        ) {
+          expect(headers).to.be.eql({
+            host: 'localhost',
+            foo: 'bar',
+          });
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        host: 'localhost',
+        method: HttpMethod.GET,
+        path: '/myAction',
+        headers: {foo: 'bar'},
       });
-      expect(res).to.be.eq('/root/controller');
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      const reqData = await S.getService(RequestParser).parse(req);
+      Object.assign(ctx, reqData);
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
     });
-  });
 
-  describe('getPreHandlersByControllerMetadata', function () {
-    it('returns an empty array if no handlers are specified', function () {
-      const s = new ControllerRegistry();
+    it('injects parsed header', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
       @controller()
-      class MyController {}
-      const md = ControllerReflector.getMetadata(MyController)!;
-      const res = s.getPreHandlersByControllerMetadata(md);
-      expect(res).to.be.eql([]);
-    });
-
-    describe('single handler', function () {
-      it('returns pre-handlers from a given controller', function () {
-        const s = new ControllerRegistry();
-        @controller({
-          before: PRE_HANDLER_1,
-        })
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPreHandlersByControllerMetadata(md);
-        expect(res).to.be.eql([PRE_HANDLER_1]);
-      });
-
-      it('returns pre-handlers from a given options', function () {
-        const s = new ControllerRegistry();
-        @controller()
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPreHandlersByControllerMetadata(md, {
-          before: PRE_HANDLER_1,
-        });
-        expect(res).to.be.eql([PRE_HANDLER_1]);
+      class MyController {
+        @get('/myAction')
+        myAction(
+          @header('foo')
+          foo: string,
+        ) {
+          expect(foo).to.be.eq('bar');
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myAction',
+        headers: {foo: 'bar'},
       });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      const reqData = await S.getService(RequestParser).parse(req);
+      Object.assign(ctx, reqData);
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
+    });
 
-      it('combines pre-handlers from a given options and controller', function () {
-        const s = new ControllerRegistry();
-        @controller({
-          before: PRE_HANDLER_2,
-        })
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPreHandlersByControllerMetadata(md, {
-          before: PRE_HANDLER_1,
-        });
-        expect(res).to.be.eql([PRE_HANDLER_1, PRE_HANDLER_2]);
+    it('injects parsed cookies', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
+      @controller()
+      class MyController {
+        @get('/myAction')
+        myAction(
+          @cookies()
+          cookies: ParsedCookie,
+        ) {
+          expect(cookies).to.be.eql({foo: 'bar'});
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myAction',
+        headers: {cookie: 'foo=bar;'},
       });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      const reqData = await S.getService(RequestParser).parse(req);
+      Object.assign(ctx, reqData);
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
     });
 
-    describe('multiple handlers', function () {
-      it('returns pre-handlers from a given controller', function () {
-        const s = new ControllerRegistry();
-        @controller({
-          before: [PRE_HANDLER_1, PRE_HANDLER_2],
-        })
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPreHandlersByControllerMetadata(md);
-        expect(res).to.be.eql([PRE_HANDLER_1, PRE_HANDLER_2]);
+    it('injects parsed cookie', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
+      @controller()
+      class MyController {
+        @get('/myAction')
+        myAction(
+          @cookie('foo')
+          foo: string,
+        ) {
+          expect(foo).to.be.eq('bar');
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.GET,
+        path: '/myAction',
+        headers: {cookie: 'foo=bar;'},
       });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      const reqData = await S.getService(RequestParser).parse(req);
+      Object.assign(ctx, reqData);
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
+    });
 
-      it('returns pre-handlers from a given options', function () {
-        const s = new ControllerRegistry();
-        @controller()
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPreHandlersByControllerMetadata(md, {
-          before: [PRE_HANDLER_1, PRE_HANDLER_2],
-        });
-        expect(res).to.be.eql([PRE_HANDLER_1, PRE_HANDLER_2]);
+    it('injects parsed body', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
+      @controller()
+      class MyController {
+        @post('/myAction')
+        myAction(
+          @body()
+          body: object,
+        ) {
+          expect(body).to.be.eql({foo: 'bar'});
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.POST,
+        path: '/myAction',
+        headers: {'content-type': 'application/json'},
+        body: '{"foo":"bar"}',
       });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      const reqData = await S.getService(RequestParser).parse(req);
+      Object.assign(ctx, reqData);
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
+    });
 
-      it('combines pre-handlers from a given options and controller', function () {
-        const s = new ControllerRegistry();
-        @controller({
-          before: [PRE_HANDLER_3, PRE_HANDLER_4],
-        })
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPreHandlersByControllerMetadata(md, {
-          before: [PRE_HANDLER_1, PRE_HANDLER_2],
-        });
-        expect(res).to.be.eql([
-          PRE_HANDLER_1,
-          PRE_HANDLER_2,
-          PRE_HANDLER_3,
-          PRE_HANDLER_4,
-        ]);
+    it('injects parsed body parameter', async function () {
+      let checked = false;
+      const S = new ControllerRegistry();
+      @controller()
+      class MyController {
+        @post('/myAction')
+        myAction(
+          @bodyProp('foo')
+          foo: object,
+        ) {
+          expect(foo).to.be.eq('bar');
+          checked = true;
+        }
+      }
+      S.addController(MyController);
+      const routeReg = S.getService(TrieRouter).getService(RouteRegistry);
+      const req = createRequestMock({
+        method: HttpMethod.POST,
+        path: '/myAction',
+        headers: {'content-type': 'application/json'},
+        body: '{"foo":"bar"}',
       });
+      const matching = routeReg.matchRouteByRequest(req);
+      expect(matching).to.be.not.empty;
+      const res = createResponseMock();
+      const ctx = new RequestContext(S.container, req, res);
+      const reqData = await S.getService(RequestParser).parse(req);
+      Object.assign(ctx, reqData);
+      await matching!.route.handler(ctx);
+      expect(checked).to.be.true;
     });
   });
 
-  describe('getPostHandlersByControllerMetadata', function () {
-    it('returns an empty array if no handlers are specified', function () {
-      const s = new ControllerRegistry();
+  describe('hasController', function () {
+    it('returns false if a given controller is not registered', function () {
+      const S = new ControllerRegistry();
       @controller()
       class MyController {}
-      const md = ControllerReflector.getMetadata(MyController)!;
-      const res = s.getPostHandlersByControllerMetadata(md);
-      expect(res).to.be.eql([]);
-    });
-
-    describe('single handler', function () {
-      it('returns pre-handlers from a given controller', function () {
-        const s = new ControllerRegistry();
-        @controller({
-          after: POST_HANDLER_1,
-        })
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPostHandlersByControllerMetadata(md);
-        expect(res).to.be.eql([POST_HANDLER_1]);
-      });
-
-      it('returns pre-handlers from a given options', function () {
-        const s = new ControllerRegistry();
-        @controller()
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPostHandlersByControllerMetadata(md, {
-          after: POST_HANDLER_1,
-        });
-        expect(res).to.be.eql([POST_HANDLER_1]);
-      });
-
-      it('combines pre-handlers from a given options and controller', function () {
-        const s = new ControllerRegistry();
-        @controller({
-          after: POST_HANDLER_2,
-        })
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPostHandlersByControllerMetadata(md, {
-          after: POST_HANDLER_1,
-        });
-        expect(res).to.be.eql([POST_HANDLER_1, POST_HANDLER_2]);
-      });
+      expect(S.hasController(MyController)).to.be.false;
     });
 
-    describe('multiple handlers', function () {
-      it('returns pre-handlers from a given controller', function () {
-        const s = new ControllerRegistry();
-        @controller({
-          after: [POST_HANDLER_1, POST_HANDLER_2],
-        })
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPostHandlersByControllerMetadata(md);
-        expect(res).to.be.eql([POST_HANDLER_1, POST_HANDLER_2]);
-      });
-
-      it('returns pre-handlers from a given options', function () {
-        const s = new ControllerRegistry();
-        @controller()
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPostHandlersByControllerMetadata(md, {
-          after: [POST_HANDLER_1, POST_HANDLER_2],
-        });
-        expect(res).to.be.eql([POST_HANDLER_1, POST_HANDLER_2]);
-      });
-
-      it('combines pre-handlers from a given options and controller', function () {
-        const s = new ControllerRegistry();
-        @controller({
-          after: [POST_HANDLER_3, POST_HANDLER_4],
-        })
-        class MyController {}
-        const md = ControllerReflector.getMetadata(MyController)!;
-        const res = s.getPostHandlersByControllerMetadata(md, {
-          after: [POST_HANDLER_1, POST_HANDLER_2],
-        });
-        expect(res).to.be.eql([
-          POST_HANDLER_1,
-          POST_HANDLER_2,
-          POST_HANDLER_3,
-          POST_HANDLER_4,
-        ]);
-      });
+    it('returns true if a given controller is registered', function () {
+      const S = new ControllerRegistry();
+      @controller()
+      class MyController {}
+      expect(S.hasController(MyController)).to.be.false;
+      S.addController(MyController);
+      expect(S.hasController(MyController)).to.be.true;
     });
   });
 });