@deepkit/http 1.0.1-alpha.58 → 1.0.1-alpha.62

package/dist/esm/tests/router.spec.js

@@ -7,17 +7,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
+import { __ΩHttpRegExp as __ΩHttpRegExp } from '../src/model';
+import { __ΩRouteParameterResolverContext as __ΩRouteParameterResolverContext } from '../src/router';
+import { __ΩHttpBody as __ΩHttpBody } from '../src/model';
+import { __ΩHttpQuery as __ΩHttpQuery } from '../src/model';
+import { __ΩHttpQueries as __ΩHttpQueries } from '../src/model';
+import { __ΩGroup as __ΩGroup } from '@deepkit/type';
+import { __ΩMinLength as __ΩMinLength } from '@deepkit/type';
+import { __ΩHttpBodyValidation as __ΩHttpBodyValidation } from '../src/model';
 import { expect, test } from '@jest/globals';
-import 'reflect-metadata';
-import { dotToUrlPath, Router } from '../src/router';
+import { dotToUrlPath, Router, UploadedFile } from '../src/router';
 import { http, httpClass } from '../src/decorator';
-import { getClassSchema, t } from '@deepkit/type';
-import { httpWorkflow, JSONResponse } from '../src/http';
+import { HttpBadRequestError, httpWorkflow, JSONResponse } from '../src/http';
 import { eventDispatcher } from '@deepkit/event';
-import { inject } from '@deepkit/injector';
 import { HttpRequest } from '../src/model';
 import { getClassName, sleep } from '@deepkit/core';
 import { createHttpKernel } from './utils';
@@ -35,6 +37,7 @@ test('router', async () => {
         any() {
         }
     }
+    Controller.__type = ['helloWorld', 'name', 'hello', 'id', 'userStatic', 'id2', 'userStatic2', 'any', 'P"0!P&2""0#P&2$"0%P&2$&2&"0\'P"0(5'];
     __decorate([
         http.GET(),
         __metadata("design:type", Function),
@@ -81,6 +84,7 @@ test('any', async () => {
         any() {
         }
     }
+    Controller.__type = ['any', 'P"0!5'];
     __decorate([
         http.ANY('/any'),
         __metadata("design:type", Function),
@@ -108,6 +112,7 @@ test('router parameters', async () => {
             return new JSONResponse(path);
         }
     }
+    Controller.__type = ['name', 'string', 'id', 'number', 'yes', 'boolean', () => __ΩHttpRegExp, ".*", 'path', 'any', 'P&2!"0"P\'2#"0$P)2%"0&P&.(o\'#2)"0*5'];
     __decorate([
         http.GET('/user/:name'),
         __metadata("design:type", Function),
@@ -127,9 +132,9 @@ test('router parameters', async () => {
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "boolean", null);
     __decorate([
-        http.GET(':path').regexp('path', '.*'),
+        http.GET(':path'),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String]),
+        __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "any", null);
     const router = Router.forControllers([Controller]);
@@ -137,7 +142,7 @@ test('router parameters', async () => {
     const httpKernel = createHttpKernel([Controller]);
     expect((await httpKernel.request(HttpRequest.GET('/user/peter'))).json).toBe('peter');
     expect((await httpKernel.request(HttpRequest.GET('/user-id/123'))).json).toBe(123);
-    expect((await httpKernel.request(HttpRequest.GET('/user-id/asd'))).json).toMatchObject({ message: 'Validation failed: id(invalid_number): No valid number given, got NaN' });
+    expect((await httpKernel.request(HttpRequest.GET('/user-id/asd'))).json).toMatchObject({ message: 'Validation error:\nid(type): Cannot convert asd to number' });
     expect((await httpKernel.request(HttpRequest.GET('/boolean/1'))).json).toBe(true);
     expect((await httpKernel.request(HttpRequest.GET('/boolean/false'))).json).toBe(false);
     expect((await httpKernel.request(HttpRequest.GET('/any'))).json).toBe('any');
@@ -149,10 +154,11 @@ test('router HttpRequest', async () => {
             return [req.url, path];
         }
     }
+    Controller.__type = [() => HttpRequest, 'req', () => __ΩHttpRegExp, ".*", 'path', 'anyReq', 'PP7!2"&.$o##2%"0&5'];
     __decorate([
-        http.GET(':path').regexp('path', '.*'),
+        http.GET(':path'),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [HttpRequest, String]),
+        __metadata("design:paramtypes", [HttpRequest, Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "anyReq", null);
     const httpKernel = createHttpKernel([Controller]);
@@ -164,11 +170,13 @@ test('router parameter resolver by class', async () => {
             this.username = username;
         }
     }
+    User.__type = ['username', 'constructor', 'P&2!:"0"5'];
     class Group {
         constructor(name) {
             this.name = name;
         }
     }
+    Group.__type = ['name', 'constructor', 'P&2!:"0"5'];
     class UserResolver {
         resolve(context) {
             const value = context.value || context.parameters.username;
@@ -177,6 +185,7 @@ test('router parameter resolver by class', async () => {
             return new User(value);
         }
     }
+    UserResolver.__type = [() => __ΩRouteParameterResolverContext, 'context', 'resolve', 'Pn!2"P""`J0#5'];
     class GroupResolver {
         resolve(context) {
             if (!context.value)
@@ -184,6 +193,7 @@ test('router parameter resolver by class', async () => {
             return new Group(context.value);
         }
     }
+    GroupResolver.__type = [() => __ΩRouteParameterResolverContext, 'context', 'resolve', 'Pn!2"P""`J0#5'];
     let Controller = class Controller {
         route1(user) {
             return [user.username];
@@ -195,6 +205,7 @@ test('router parameter resolver by class', async () => {
             return [user.username, group.name];
         }
     };
+    Controller.__type = [() => User, 'user', 'route1', () => User, 'route2', () => User, () => Group, 'group', 'route3', 'PP7!2""0#PP7$2""0%PP7&2"P7\'2("0)5'];
     __decorate([
         http.GET('user/:username'),
         __metadata("design:type", Function),
@@ -232,11 +243,13 @@ test('router parameter resolver by name', async () => {
             this.username = username;
         }
     }
+    User.__type = ['username', 'constructor', 'P&2!:"0"5'];
     class Group {
         constructor(name) {
             this.name = name;
         }
     }
+    Group.__type = ['name', 'constructor', 'P&2!:"0"5'];
     class UserResolver {
         resolve(context) {
             const value = context.value || context.parameters.username;
@@ -246,6 +259,7 @@ test('router parameter resolver by name', async () => {
             return new User(value);
         }
     }
+    UserResolver.__type = [() => __ΩRouteParameterResolverContext, 'context', 'resolve', 'Pn!2"P""`J0#5'];
     class GroupResolver {
         resolve(context) {
             if (!context.value)
@@ -253,16 +267,19 @@ test('router parameter resolver by name', async () => {
             return new Group(context.value);
         }
     }
+    GroupResolver.__type = [() => __ΩRouteParameterResolverContext, 'context', 'resolve', 'Pn!2"P""`J0#5'];
     class MyAuth {
         constructor(name) {
             this.name = name;
         }
     }
+    MyAuth.__type = ['name', 'constructor', 'P&2!:"0"5'];
     class AuthResolver {
         resolve(context) {
             return new MyAuth('auth');
         }
     }
+    AuthResolver.__type = [() => __ΩRouteParameterResolverContext, 'context', 'resolve', 'Pn!2"P""`J0#5'];
     let Controller = class Controller {
         route1(user) {
             return [user.username];
@@ -277,6 +294,7 @@ test('router parameter resolver by name', async () => {
             return [auth.name, getClassName(auth)];
         }
     };
+    Controller.__type = [() => User, 'user', 'route1', () => User, 'route2', () => User, () => Group, 'group', 'route3', 'auth', 'nonClass', 'PP7!2""0#PP7$2""0%PP7&2"P7\'2("0)P"2*"0+5'];
     __decorate([
         http.GET('user/:username'),
         __metadata("design:type", Function),
@@ -314,46 +332,77 @@ test('router parameter resolver by name', async () => {
     expect((await httpKernel.request(HttpRequest.GET('/invalid'))).bodyString).toEqual('Internal error');
     expect((await httpKernel.request(HttpRequest.GET('/nonClass'))).json).toEqual(['auth', 'MyAuth']);
 });
-test('router body', async () => {
+test('router body class', async () => {
     class Body {
     }
-    __decorate([
-        t,
-        __metadata("design:type", String)
-    ], Body.prototype, "username", void 0);
+    Body.__type = ['username', '&3!5'];
     class Controller {
         anyReq(body, req) {
             return [body.username, body instanceof Body, req.url];
         }
     }
+    Controller.__type = [() => __ΩHttpBody, () => Body, 'body', () => HttpRequest, 'req', 'anyReq', 'PP7"o!"2#P7$2%"0&5'];
     __decorate([
         http.POST(),
-        __param(0, http.body()),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Body, HttpRequest]),
+        __metadata("design:paramtypes", [Object, HttpRequest]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "anyReq", null);
     const httpKernel = createHttpKernel([Controller]);
     expect((await httpKernel.request(HttpRequest.POST('/').json({ username: 'Peter' }))).json).toEqual(['Peter', true, '/']);
 });
-test('router body double', async () => {
+test('router body is safe for simultaneous requests', async () => {
     class Body {
     }
+    Body.__type = ['username', '&3!5'];
+    class Controller {
+        anyReq(body, req) {
+            return [body.username, body instanceof Body, req.url];
+        }
+    }
+    Controller.__type = [() => __ΩHttpBody, () => Body, 'body', () => HttpRequest, 'req', 'anyReq', 'PP7"o!"2#P7$2%"0&5'];
     __decorate([
-        t,
-        __metadata("design:type", String)
-    ], Body.prototype, "username", void 0);
+        http.POST(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, HttpRequest]),
+        __metadata("design:returntype", void 0)
+    ], Controller.prototype, "anyReq", null);
+    const httpKernel = createHttpKernel([Controller]);
+    const makeReq = () => httpKernel.request(HttpRequest.POST('/').json({ username: 'Peter' }));
+    const results = await Promise.all([...new Array(100)].map(() => makeReq().then(Object.assign(res => res.json, { __type: ['res', '', 'P"2!"/"'] }))));
+    expect(results).toEqual(results.map(() => ['Peter', true, '/']));
+});
+test('router body interface', async () => {
+    var __ΩBody = ['username', 'P&4!M'];
+    class Controller {
+        anyReq(body, req) {
+            return [body.username, typeof body.username, req.url];
+        }
+    }
+    Controller.__type = [() => __ΩHttpBody, () => __ΩBody, 'body', () => HttpRequest, 'req', 'anyReq', 'Pn"o!"2#P7$2%"0&5'];
+    __decorate([
+        http.POST(),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object, HttpRequest]),
+        __metadata("design:returntype", void 0)
+    ], Controller.prototype, "anyReq", null);
+    const httpKernel = createHttpKernel([Controller]);
+    expect((await httpKernel.request(HttpRequest.POST('/').json({ username: 'Peter' }))).json).toEqual(['Peter', 'string', '/']);
+});
+test('router body double', async () => {
+    class Body {
+    }
+    Body.__type = ['username', '&3!5'];
     class Controller {
         anyReq(body, body2, req) {
             return [body2.username, body2 instanceof Body && body instanceof Body, req.url];
         }
     }
+    Controller.__type = [() => __ΩHttpBody, () => Body, 'body', () => __ΩHttpBody, () => Body, 'body2', () => HttpRequest, 'req', 'anyReq', 'PP7"o!"2#P7%o$"2&P7\'2("0)5'];
     __decorate([
         http.POST(),
-        __param(0, http.body()),
-        __param(1, http.body()),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Body, Body, HttpRequest]),
+        __metadata("design:paramtypes", [Object, Object, HttpRequest]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "anyReq", null);
     const httpData = httpClass._fetch(Controller);
@@ -362,10 +411,6 @@ test('router body double', async () => {
     const action = [...httpData.getActions()][0];
     expect(action.methodName).toBe('anyReq');
     expect(action.httpMethods).toEqual(['POST']);
-    expect(action.parameters['body']).not.toBeUndefined();
-    expect(action.parameters['body'].name).toBe('body');
-    expect(action.parameters['body2']).not.toBeUndefined();
-    expect(action.parameters['body2'].name).toBe('body2');
     const httpKernel = createHttpKernel([Controller]);
     expect((await httpKernel.request(HttpRequest.POST('/').json({ username: 'Peter' }))).json).toEqual(['Peter', true, '/']);
 });
@@ -379,6 +424,7 @@ test('router groups', async () => {
             c() {
             }
         }
+        Controller.__type = ['a', 'b', 'c', 'P"0!P"0"P"0#5'];
         __decorate([
             http.GET('a').group('a'),
             __metadata("design:type", Function),
@@ -413,6 +459,7 @@ test('router groups', async () => {
             c() {
             }
         };
+        Controller.__type = ['a', 'b', 'c', 'P"0!P"0"P"0#5'];
         __decorate([
             http.GET('a').group('a'),
             __metadata("design:type", Function),
@@ -448,11 +495,11 @@ test('router query', async () => {
             return test;
         }
     }
+    Controller.__type = [() => __ΩHttpQuery, 'test', 'anyReq', 'P\'o!"2"8"0#5'];
     __decorate([
         http.GET('my-action'),
-        __param(0, http.query().optional),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Number]),
+        __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "anyReq", null);
     const httpData = httpClass._fetch(Controller);
@@ -461,9 +508,6 @@ test('router query', async () => {
     const action = [...httpData.getActions()][0];
     expect(action.methodName).toBe('anyReq');
     expect(action.httpMethods).toEqual(['GET']);
-    expect(action.parameters['test']).not.toBeUndefined();
-    expect(action.parameters['test'].name).toBe('test');
-    expect(action.parameters['test'].type).toBe('query');
     const httpKernel = createHttpKernel([Controller]);
     expect((await httpKernel.request(HttpRequest.GET('/my-action?test=123'))).json).toEqual(123);
     expect((await httpKernel.request(HttpRequest.GET('/my-action'))).bodyString).toEqual('');
@@ -471,28 +515,17 @@ test('router query', async () => {
 test('router query all', async () => {
     class AnyReqQuery {
     }
-    __decorate([
-        t.optional,
-        __metadata("design:type", String)
-    ], AnyReqQuery.prototype, "test", void 0);
-    __decorate([
-        t.optional,
-        __metadata("design:type", String)
-    ], AnyReqQuery.prototype, "filter", void 0);
-    __decorate([
-        t.optional,
-        __metadata("design:type", Number)
-    ], AnyReqQuery.prototype, "page", void 0);
+    AnyReqQuery.__type = ['test', 'filter', 'page', '&3!8&3"8\'3#85'];
     class Controller {
         anyReq(anyReqQuery) {
             return anyReqQuery;
         }
     }
+    Controller.__type = [() => __ΩHttpQueries, () => AnyReqQuery, 'anyReqQuery', 'anyReq', 'PP7"o!"2#"0$5'];
     __decorate([
         http.GET('my-action'),
-        __param(0, http.queries()),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [AnyReqQuery]),
+        __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "anyReq", null);
     const httpKernel = createHttpKernel([Controller]);
@@ -503,25 +536,18 @@ test('router query all', async () => {
 test('serializer options', async () => {
     class User {
     }
-    __decorate([
-        t,
-        __metadata("design:type", String)
-    ], User.prototype, "username", void 0);
-    __decorate([
-        t.group('sensitive'),
-        __metadata("design:type", String)
-    ], User.prototype, "password", void 0);
+    User.__type = ['username', () => __ΩGroup, "sensitive", 'password', '&3!P&.#o""K3$5'];
     class Controller {
         anyReq() {
             return { username: 'Peter', password: 'secret' };
         }
     }
+    Controller.__type = [() => User, 'anyReq', 'PP7!0"5'];
     __decorate([
         http.GET().serialization({ groupsExclude: ['sensitive'] }),
-        t.type(User),
         __metadata("design:type", Function),
         __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
+        __metadata("design:returntype", User)
     ], Controller.prototype, "anyReq", null);
     const httpKernel = createHttpKernel([Controller]);
     expect((await httpKernel.request(HttpRequest.GET('/'))).json).toEqual({ username: 'Peter' });
@@ -529,23 +555,16 @@ test('serializer options', async () => {
 test('hook after serializer', async () => {
     class User {
     }
-    __decorate([
-        t,
-        __metadata("design:type", String)
-    ], User.prototype, "username", void 0);
-    __decorate([
-        t.group('sensitive'),
-        __metadata("design:type", String)
-    ], User.prototype, "password", void 0);
+    User.__type = ['username', () => __ΩGroup, "sensitive", 'password', '&3!P&.#o""K3$5'];
     class Controller {
         async anyReq() {
             await sleep(0.1);
             return { username: 'Peter', password: 'secret' };
         }
     }
+    Controller.__type = [() => User, 'anyReq', 'PP7!`0"5'];
     __decorate([
         http.GET().serialization({ groupsExclude: ['sensitive'] }),
-        t.type(User),
         __metadata("design:type", Function),
         __metadata("design:paramtypes", []),
         __metadata("design:returntype", Promise)
@@ -555,6 +574,7 @@ test('hook after serializer', async () => {
             event.result = { processingTime: event.controllerActionTime, data: event.result };
         }
     }
+    Listener.__type = [() => httpWorkflow.onResponse.event, 'event', 'onResponse', 'Pi!2""0#5'];
     __decorate([
         eventDispatcher.listen(httpWorkflow.onResponse),
         __metadata("design:type", Function),
@@ -571,6 +591,7 @@ test('invalid route definition', async () => {
         doIt(user) {
         }
     }
+    Controller.__type = ['user', 'doIt', 'P"2!"0"5'];
     __decorate([
         http.GET(),
         __metadata("design:type", Function),
@@ -578,7 +599,7 @@ test('invalid route definition', async () => {
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "doIt", null);
     const httpKernel = createHttpKernel([Controller]);
-    expect((await httpKernel.request(HttpRequest.GET('/'))).bodyString).toEqual('Not found');
+    expect((await httpKernel.request(HttpRequest.GET('/'))).bodyString).toEqual('Internal error');
 });
 test('inject request storage ClassType', async () => {
     class User {
@@ -586,6 +607,7 @@ test('inject request storage ClassType', async () => {
             this.username = username;
         }
     }
+    User.__type = ['username', 'constructor', 'P&2!:"0"5'];
     class Controller {
         doIt(user) {
             return { isUser: user instanceof User, username: user.username };
@@ -594,6 +616,7 @@ test('inject request storage ClassType', async () => {
             return { isUser: user instanceof User };
         }
     }
+    Controller.__type = [() => User, 'user', 'doIt', () => User, 'doItOptional', 'PP7!2""0#PP7$2"8"0%5'];
     __decorate([
         http.GET(),
         __metadata("design:type", Function),
@@ -602,7 +625,6 @@ test('inject request storage ClassType', async () => {
     ], Controller.prototype, "doIt", null);
     __decorate([
         http.GET('optional'),
-        __param(0, inject().optional),
         __metadata("design:type", Function),
         __metadata("design:paramtypes", [User]),
         __metadata("design:returntype", void 0)
@@ -614,6 +636,7 @@ test('inject request storage ClassType', async () => {
             }
         }
     }
+    Listener.__type = [() => httpWorkflow.onAuth.event, 'event', 'onAuth', 'Pi!2""0#5'];
     __decorate([
         eventDispatcher.listen(httpWorkflow.onAuth),
         __metadata("design:type", Function),
@@ -622,55 +645,16 @@ test('inject request storage ClassType', async () => {
     ], Listener.prototype, "onAuth", null);
     const httpKernel = createHttpKernel([Controller], [
         {
-            provide: User, scope: 'http', deps: [HttpRequest], useFactory(request) {
+            provide: User, scope: 'http',
+            useFactory: Object.assign(function useFactory(request) {
                 return request.store.user;
-            }
+            }, { __type: [() => HttpRequest, 'request', 'useFactory', 'PP7!2""/#'] })
         }
     ], [Listener]);
     expect((await httpKernel.request(HttpRequest.GET('/').headers({ authorization: 'yes' }))).json).toEqual({ isUser: true, username: 'bar' });
     expect((await httpKernel.request(HttpRequest.GET('/').headers({ authorization: 'no' }))).bodyString).toEqual('Internal error');
     expect((await httpKernel.request(HttpRequest.GET('/optional').headers({ authorization: 'no' }))).json).toEqual({ isUser: false });
 });
-test('inject request storage @inject', async () => {
-    class User {
-        constructor(username) {
-            this.username = username;
-        }
-    }
-    class Controller {
-        doIt(user) {
-            return { isUser: user instanceof User, username: user.username };
-        }
-    }
-    __decorate([
-        http.GET(),
-        __param(0, inject('user')),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", void 0)
-    ], Controller.prototype, "doIt", null);
-    class Listener {
-        onAuth(event) {
-            event.request.store.user = new User('bar');
-        }
-    }
-    __decorate([
-        eventDispatcher.listen(httpWorkflow.onAuth),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", void 0)
-    ], Listener.prototype, "onAuth", null);
-    const httpKernel = createHttpKernel([Controller], [
-        {
-            provide: 'user', scope: 'http', deps: [HttpRequest], useFactory(request) {
-                return request.store.user;
-            }
-        }
-    ], [Listener]);
-    const result = (await httpKernel.request(HttpRequest.GET('/'))).json;
-    expect(result.isUser).toBe(true);
-    expect(result.username).toBe('bar');
-});
 test('custom request handling', async () => {
     class Listener {
         onRouteNotFound(event) {
@@ -679,6 +663,7 @@ test('custom request handling', async () => {
                 event.send(new JSONResponse(true, 200));
         }
     }
+    Listener.__type = [() => httpWorkflow.onRouteNotFound.event, 'event', 'onRouteNotFound', 'Pi!2""0#5'];
     __decorate([
         eventDispatcher.listen(httpWorkflow.onRouteNotFound),
         __metadata("design:type", Function),
@@ -698,6 +683,7 @@ test('race condition', async () => {
             call++;
         }
     }
+    Listener.__type = [() => httpWorkflow.onRouteNotFound.event, 'event', 'onRouteNotFound', 'Pi!2""0#5'];
     __decorate([
         eventDispatcher.listen(httpWorkflow.onAuth),
         __metadata("design:type", Function),
@@ -712,6 +698,7 @@ test('race condition', async () => {
             return param2;
         }
     }
+    Controller.__type = ['param1', 'one', 'param2', 'second', 'P&2!"0"P&2#"0$5'];
     __decorate([
         http.GET('/one/:param1'),
         __metadata("design:type", Function),
@@ -738,6 +725,7 @@ test('multiple methods', async () => {
             return true;
         }
     }
+    Controller.__type = ['one', 'P"0!5'];
     __decorate([
         http.GET('/one').POST(),
         __metadata("design:type", Function),
@@ -759,6 +747,7 @@ test('promise serializer', async () => {
             return 1;
         }
     }
+    Controller.__type = ['anyReq1', 'anyReq2', 'P"0!P&`0"5'];
     __decorate([
         http.GET('1'),
         __metadata("design:type", Function),
@@ -767,7 +756,6 @@ test('promise serializer', async () => {
     ], Controller.prototype, "anyReq1", null);
     __decorate([
         http.GET('2'),
-        t.string,
         __metadata("design:type", Function),
         __metadata("design:paramtypes", []),
         __metadata("design:returntype", Promise)
@@ -782,18 +770,28 @@ test('unions', async () => {
             return page;
         }
     }
+    Controller.__type = [() => __ΩHttpQuery, 'page', 'list', 'PP\')Jo!"2""0#5'];
     __decorate([
         http.GET('/list'),
-        __param(0, http.query()),
-        __param(0, t.union(t.number, t.boolean)),
         __metadata("design:type", Function),
         __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "list", null);
     const httpKernel = createHttpKernel([Controller]);
+    expect((await httpKernel.request(HttpRequest.GET('/list?page=0'))).json).toEqual(0);
     expect((await httpKernel.request(HttpRequest.GET('/list?page=1'))).json).toEqual(1);
     expect((await httpKernel.request(HttpRequest.GET('/list?page=2222'))).json).toEqual(2222);
     expect((await httpKernel.request(HttpRequest.GET('/list?page=false'))).json).toEqual(false);
+    expect((await httpKernel.request(HttpRequest.GET('/list?page=true'))).json).toEqual(true);
+    expect((await httpKernel.request(HttpRequest.GET('/list?page=asdasdc'))).json).toMatchObject({
+        'errors': [
+            {
+                'code': 'type',
+                'message': 'No value given',
+                'path': 'page'
+            }
+        ],
+    });
 });
 test('router dotToUrlPath', () => {
     expect(dotToUrlPath('peter')).toBe('peter');
@@ -804,18 +802,7 @@ test('router dotToUrlPath', () => {
 test('router url resolve', async () => {
     class AnyReqQuery {
     }
-    __decorate([
-        t.optional,
-        __metadata("design:type", String)
-    ], AnyReqQuery.prototype, "test", void 0);
-    __decorate([
-        t.optional,
-        __metadata("design:type", String)
-    ], AnyReqQuery.prototype, "filter", void 0);
-    __decorate([
-        t.optional,
-        __metadata("design:type", Number)
-    ], AnyReqQuery.prototype, "page", void 0);
+    AnyReqQuery.__type = ['test', 'filter', 'page', '&3!8&3"8\'3#85'];
     class Controller {
         first() {
             return '';
@@ -836,6 +823,7 @@ test('router url resolve', async () => {
             return params;
         }
     }
+    Controller.__type = ['first', 'peter', 'second', () => __ΩHttpQuery, 'secondQuery', () => __ΩHttpQuery, "changed", 'name', 'secondQuery2', () => __ΩHttpQueries, () => AnyReqQuery, 'params', 'third', () => __ΩHttpQueries, () => AnyReqQuery, "deep", 'third2', 'P"0!P&2""0#P&o$"2""0%P&P.\'4(Mo&#2""0)PP7+o*"2,"0-PP7/P.04(Mo.#2,"015'];
     __decorate([
         http.GET('').name('first'),
         __metadata("design:type", Function),
@@ -850,30 +838,26 @@ test('router url resolve', async () => {
     ], Controller.prototype, "second", null);
     __decorate([
         http.GET('').name('secondQuery'),
-        __param(0, http.query()),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String]),
+        __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "secondQuery", null);
     __decorate([
         http.GET('').name('secondQuery2'),
-        __param(0, http.query('changed')),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String]),
+        __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "secondQuery2", null);
     __decorate([
         http.GET('third').name('third'),
-        __param(0, http.queries()),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [AnyReqQuery]),
+        __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "third", null);
     __decorate([
         http.GET('third2').name('third2'),
-        __param(0, http.queries('deep')),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [AnyReqQuery]),
+        __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "third2", null);
     const router = Router.forControllers([Controller]);
@@ -889,76 +873,28 @@ test('router url resolve', async () => {
     expect(router.resolveUrl('third2', { params: { test: 123, filter: 'peter' } })).toBe('/third2?deep[test]=123&deep[filter]=peter');
 });
 test('destructing params', async () => {
-    class DTO {
-    }
-    __decorate([
-        t.required,
-        __metadata("design:type", String)
-    ], DTO.prototype, "name", void 0);
-    __decorate([
-        t.required,
-        __metadata("design:type", String)
-    ], DTO.prototype, "title", void 0);
+    var __ΩDTO = ['name', 'title', 'P&4!&4"M'];
     class Controller {
         first({ name, title }) {
             return [name, title];
         }
     }
+    Controller.__type = [() => __ΩHttpBody, () => __ΩDTO, 'param0', 'first', 'Pn"o!"2#"0$5'];
     __decorate([
         http.GET(''),
-        __param(0, http.body()),
         __metadata("design:type", Function),
-        __metadata("design:paramtypes", [DTO]),
+        __metadata("design:paramtypes", [Object]),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "first", null);
     const httpKernel = createHttpKernel([Controller]);
     expect((await httpKernel.request(HttpRequest.GET('/').json({ name: 'Peter', title: 'CTO' }))).json).toEqual(['Peter', 'CTO']);
 });
-test('dynamic parameter name', async () => {
-    let Controller = class Controller {
-        first(id) {
-            return [id];
-        }
-        second(id, second) {
-            return [id, second];
-        }
-    };
-    __decorate([
-        http.GET('first/:another'),
-        __param(0, t.description('The identifier').name('another')),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String]),
-        __metadata("design:returntype", void 0)
-    ], Controller.prototype, "first", null);
-    __decorate([
-        http.GET('second/:another2'),
-        __param(0, t.description('The identifier').name('another2')),
-        __param(1, http.query()),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [String, String]),
-        __metadata("design:returntype", void 0)
-    ], Controller.prototype, "second", null);
-    Controller = __decorate([
-        http.controller()
-    ], Controller);
-    const schema = getClassSchema(Controller);
-    expect(schema.getMethodProperties('first')[0].name).toBe('another');
-    expect(schema.getMethodProperties('second')[0].name).toBe('another2');
-    expect(schema.getMethodProperties('second')[1].name).toBe('second');
-    const httpKernel = createHttpKernel([Controller]);
-    expect((await httpKernel.request(HttpRequest.GET('/first/peter'))).json).toEqual(['peter']);
-    expect((await httpKernel.request(HttpRequest.GET('/second/peter?second=true'))).json).toEqual(['peter', 'true']);
-});
 test('use http.response for serialization', async () => {
-    const schemaString = t.schema({
-        title: t.string
-    });
-    const errorSchema = t.schema({
-        message: t.string
-    });
+    var __ΩDefaultResponse = ['title', 'P&4!M'];
+    var __ΩErrorResponse = ['message', 'P&4!M'];
     class Controller {
         action1() {
-            return [{ title: 'a' }, { title: 1 }];
+            return [{ title: 'a' }, { title: '1' }];
         }
         action2() {
             return [{ title: 'a' }, { title: 1 }];
@@ -967,23 +903,23 @@ test('use http.response for serialization', async () => {
             return new JSONResponse([{ message: 'error' }, { message: 1 }]).status(400);
         }
     }
+    Controller.__type = [() => __ΩDefaultResponse, 'action1', 'action2', 'action3', 'Pn!F0"P"0#P"0$5'];
     __decorate([
         http.GET('/action1'),
-        t.array(schemaString),
         __metadata("design:type", Function),
         __metadata("design:paramtypes", []),
-        __metadata("design:returntype", void 0)
+        __metadata("design:returntype", Array)
     ], Controller.prototype, "action1", null);
     __decorate([
-        http.GET('/action2').response(200, `List`, t.array(schemaString)),
+        http.GET('/action2').response(200, `List`, [() => __ΩDefaultResponse, 'n!F']),
         __metadata("design:type", Function),
         __metadata("design:paramtypes", []),
         __metadata("design:returntype", void 0)
     ], Controller.prototype, "action2", null);
     __decorate([
         http.GET('/action3')
-            .response(200, `List`, t.array(schemaString))
-            .response(400, `Error`, t.array(errorSchema)),
+            .response(200, `List`, [() => __ΩDefaultResponse, 'n!F'])
+            .response(400, `Error`, [() => __ΩErrorResponse, 'n!F']),
         __metadata("design:type", Function),
         __metadata("design:paramtypes", []),
         __metadata("design:returntype", void 0)
@@ -993,4 +929,57 @@ test('use http.response for serialization', async () => {
     expect((await httpKernel.request(HttpRequest.GET('/action2'))).json).toEqual([{ title: 'a' }, { title: '1' }]);
     expect((await httpKernel.request(HttpRequest.GET('/action3'))).json).toEqual([{ message: 'error' }, { message: '1' }]);
 });
+test('BodyValidation', async () => {
+    class User {
+    }
+    User.__type = [() => __ΩMinLength, 3, 'username', 'P&."o!"K3#5'];
+    class AddUserDto extends User {
+    }
+    AddUserDto.__type = [() => UploadedFile, 'imageUpload', 'P7!3"85'];
+    class Controller {
+        action1(user) {
+            return user;
+        }
+        action2(user) {
+            if (user.valid()) {
+                return user.value;
+            }
+            throw new HttpBadRequestError('Invalid: ' + user.error.getErrorMessageForPath('username'));
+        }
+        action3(user) {
+            if (user.valid()) {
+                return user.value;
+            }
+            throw new HttpBadRequestError('Invalid: ' + user.error.getErrorMessageForPath('username'));
+        }
+    }
+    Controller.__type = [() => __ΩHttpBody, () => User, 'user', 'action1', () => __ΩHttpBodyValidation, () => User, () => User, 'action2', () => __ΩHttpBodyValidation, () => AddUserDto, () => User, 'action3', 'PP7"o!"2#"0$PP7&o%"2#P7\'0(PP7*o)"2#P7+0,5'];
+    __decorate([
+        http.POST('/action1'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", Object)
+    ], Controller.prototype, "action1", null);
+    __decorate([
+        http.POST('/action2'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", User)
+    ], Controller.prototype, "action2", null);
+    __decorate([
+        http.POST('/action3'),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [Object]),
+        __metadata("design:returntype", User)
+    ], Controller.prototype, "action3", null);
+    const httpKernel = createHttpKernel([Controller]);
+    expect((await httpKernel.request(HttpRequest.POST('/action1').json({ username: 'Peter' }))).json).toEqual({ username: 'Peter' });
+    expect((await httpKernel.request(HttpRequest.POST('/action1').json({ username: 'Pe' }))).json).toEqual({
+        errors: [{ code: 'minLength', message: 'Min length is 3', path: 'username' }], message: 'Validation error:\nusername(minLength): Min length is 3'
+    });
+    expect((await httpKernel.request(HttpRequest.POST('/action2').json({ username: 'Peter' }))).json).toEqual({ username: 'Peter' });
+    expect((await httpKernel.request(HttpRequest.POST('/action2').json({ username: 'Pe' }))).bodyString).toEqual(`{"message":"Invalid: Min length is 3"}`);
+    expect((await httpKernel.request(HttpRequest.POST('/action3').json({ username: 'Peter' }))).json).toEqual({ username: 'Peter' });
+    expect((await httpKernel.request(HttpRequest.POST('/action3').json({ username: 'Pe' }))).bodyString).toEqual(`{"message":"Invalid: Min length is 3"}`);
+});
 //# sourceMappingURL=router.spec.js.map