@deepkit/http 1.0.1-alpha.54 → 1.0.1-alpha.59

package/src/router.ts

@@ -77,18 +77,6 @@ export class UploadedFile {
     // @t.string.required.nullable hash!: string | 'sha1' | 'md5' | 'sha256' | null;
 }
 
-function parseBody(form: any, req: IncomingMessage, files: { [name: string]: UploadedFile }) {
-    return asyncOperation((resolve, reject) => {
-        form.parse(req, (err: any, fields: any, files: any) => {
-            if (err) {
-                reject(err);
-            } else {
-                resolve({ fields, files });
-            }
-        });
-    });
-}
-
 export interface RouteControllerAction {
     //if not set, the root module is used
     module?: AppModule<any>;
@@ -413,12 +401,26 @@ export class Router {
 
     protected routes: RouteConfig[] = [];
 
-    //todo, move some settings to KernelConfig
-    protected form = formidable({
-        multiples: true,
-        hash: 'sha1',
-        enabledPlugins: ['octetstream', 'querystring', 'json'],
-    });
+    private parseBody(req: HttpRequest, files: { [name: string]: UploadedFile }) {
+        const form = formidable({
+            multiples: true,
+            hash: 'sha1',
+            enabledPlugins: ['octetstream', 'querystring', 'json'],
+        });
+        return asyncOperation((resolve, reject) => {
+            if (req.body) {
+                return resolve(req.body);
+            }
+            form.parse(req, (err: any, fields: any, files: any) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    const body = req.body = { ...fields, ...files };
+                    resolve(body);
+                }
+            });
+        });
+    }
 
     constructor(
         controllers: HttpControllers,
@@ -571,11 +573,9 @@ export class Router {
 
         let parseBodyLoading = '';
         if (enableParseBody) {
-            const parseBodyVar = compiler.reserveVariable('parseBody', parseBody);
-            const formVar = compiler.reserveVariable('form', this.form);
+            const parseBodyVar = compiler.reserveVariable('parseBody', this.parseBody.bind(this));
             parseBodyLoading = `
-            const bodyParsed = (await ${parseBodyVar}(${formVar}, request, uploadedFiles));
-            const bodyFields = {...bodyParsed.fields, ...bodyParsed.files};`;
+            const bodyFields = (await ${parseBodyVar}(request, uploadedFiles));`;
             requiresAsyncParameters = true;
         }
 
@@ -626,7 +626,7 @@ export class Router {
         let methodCheck = '';
         if (routeConfig.httpMethods.length) {
             methodCheck = '(' + routeConfig.httpMethods.map(v => {
-                return `_method === '${v.toLowerCase()}'`;
+                return `_method === '${v.toUpperCase()}'`;
             }).join(' || ') + ') && ';
         }
 
@@ -736,8 +736,8 @@ export class Router {
 
         return compiler.build(`
             let _match;
-            const _method = request.getMethod().toLowerCase();
-            const _url = request.getUrl();
+            const _method = request.method || 'GET';
+            const _url = request.url || '/';
             const _qPosition = _url.indexOf('?');
             let uploadedFiles = {};
             const _path = _qPosition === -1 ? _url : _url.substr(0, _qPosition);
@@ -779,13 +779,7 @@ export class Router {
     }
 
     public resolve(method: string, url: string): ResolvedController | undefined {
-        return this.resolveRequest({
-            getUrl() {
-                return url;
-            },
-            getMethod() {
-                return method;
-            },
-        } as any);
+        method = method.toUpperCase();
+        return this.resolveRequest({url, method} as any);
     }
 }

package/tests/model.spec.ts

@@ -0,0 +1,26 @@
+import { expect, test } from '@jest/globals';
+import { HttpRequest } from '../src/model';
+
+test('request model json', async () => {
+    const request = HttpRequest.POST('/').json({ hello: 'world' }).build();
+    const buffers = [];
+
+    for await (const chunk of request) {
+        buffers.push(chunk);
+    }
+
+    const bodyBuffer = Buffer.concat(buffers).toString();
+    expect(bodyBuffer).toBe('{"hello":"world"}');
+});
+
+test('request model body', async () => {
+    const request = HttpRequest.POST('/').body("hello").build();
+    const buffers = [];
+
+    for await (const chunk of request) {
+        buffers.push(chunk);
+    }
+
+    const bodyBuffer = Buffer.concat(buffers).toString();
+    expect(bodyBuffer).toBe('hello');
+});

package/tests/router.spec.ts

@@ -263,6 +263,29 @@ test('router body', async () => {
     expect((await httpKernel.request(HttpRequest.POST('/').json({ username: 'Peter' }))).json).toEqual(['Peter', true, '/']);
 });
 
+test('router body is safe for simultaneous requests', async () => {
+    class Body {
+        @t username!: string;
+    }
+
+    class Controller {
+        @http.POST()
+        anyReq(@http.body() body: Body, req: HttpRequest) {
+            return [body.username, body instanceof Body, req.url];
+        }
+    }
+
+    const httpKernel = createHttpKernel([Controller]);
+
+    const makeReq = () => httpKernel.request(HttpRequest.POST('/').json({ username: 'Peter' }));
+
+    const results = await Promise.all([...new Array(100)].map(() => makeReq().then(res => res.json)));
+
+    expect(results).toEqual(
+        results.map(() => ['Peter', true, '/']),
+    )
+});
+
 
 test('router body double', async () => {
     class Body {
@@ -722,3 +745,39 @@ test('dynamic parameter name', async () => {
     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
+    });
+
+    class Controller {
+        @http.GET('/action1')
+        @t.array(schemaString)
+        action1() {
+            return [{title: 'a'}, {title: 1}];
+        }
+
+        @http.GET('/action2').response(200, `List`, t.array(schemaString))
+        action2() {
+            return [{title: 'a'}, {title: 1}];
+        }
+
+        @http.GET('/action3')
+            .response(200, `List`, t.array(schemaString))
+            .response(400, `Error`, t.array(errorSchema))
+        action3() {
+            return new JSONResponse([{message: 'error'}, {message: 1}]).status(400);
+        }
+    }
+
+    const httpKernel = createHttpKernel([Controller]);
+    expect((await httpKernel.request(HttpRequest.GET('/action1'))).json).toEqual([{title: 'a'}, {title: '1'}]);
+    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'}]);
+});