Add support for returning Buffer and streams from action

Author: MichalLytek

src/driver/BaseDriver.ts

@@ -1,5 +1,5 @@
 import {ValidatorOptions} from "class-validator";
-import {ClassTransformOptions} from "class-transformer";
+import {ClassTransformOptions, classToPlain} from "class-transformer";
 
 import {HttpError} from "../http-error/HttpError";
 import {CurrentUserChecker} from "../CurrentUserChecker";
@@ -127,6 +127,25 @@ export abstract class BaseDriver {
     // Protected Methods
     // -------------------------------------------------------------------------
 
+    protected transformResult(result: any, action: ActionMetadata, options: Action): any {
+        // check if we need to transform result
+        const shouldTransform = (this.useClassTransformer && result != null) // transform only if enabled and value exist
+            && result instanceof Object // don't transform primitive types (string/number/boolean)
+            && !(
+                result instanceof Buffer // don't transform binary data
+                ||
+                result.pipe instanceof Function // don't transform streams
+            );
+
+        // transform result if needed
+        if (shouldTransform) {
+            const options = action.responseClassTransformOptions || this.classToPlainTransformOptions;
+            result = classToPlain(result, options);
+        }
+
+        return result;
+    }
+
     protected processJsonError(error: any) {
         if (!this.isDefaultErrorHandlingEnabled)
             return error;

src/driver/express/ExpressDriver.ts

@@ -226,11 +226,8 @@ export class ExpressDriver extends BaseDriver {
      */
     handleSuccess(result: any, action: ActionMetadata, options: Action): void {
 
-        // check if we need to transform result and do it
-        if (result && result instanceof Object && this.useClassTransformer) {
-            const options = action.responseClassTransformOptions || this.classToPlainTransformOptions;
-            result = classToPlain(result, options);
-        }
+        // transform result if needed
+        result = this.transformResult(result, action, options);
 
         // set http status code
         if (result === undefined && action.undefinedResultCode && action.undefinedResultCode instanceof Function) {
@@ -297,6 +294,12 @@ export class ExpressDriver extends BaseDriver {
             }
             options.next();
         }
+        else if (result instanceof Buffer) {
+            options.response.send(result);
+        }
+        else if (result.pipe instanceof Function) {
+            result.pipe(options.response);
+        }
         else { // send regular result
             if (action.isJsonTyped) {
                 options.response.json(result);

src/driver/koa/KoaDriver.ts

@@ -209,11 +209,8 @@ export class KoaDriver extends BaseDriver {
      */
     handleSuccess(result: any, action: ActionMetadata, options: Action): void {
 
-        // check if we need to transform result and do it
-        if (this.useClassTransformer && result && result instanceof Object) {
-            const options = action.responseClassTransformOptions || this.classToPlainTransformOptions;
-            result = classToPlain(result, options);
-        }
+        // transform result if needed
+        result = this.transformResult(result, action, options);
 
         // set http status code
         if (result === undefined && action.undefinedResultCode && action.undefinedResultCode instanceof Function) {

test/functional/special-result-send.spec.ts

@@ -0,0 +1,66 @@
+import "reflect-metadata";
+
+import {createReadStream} from "fs";
+import * as path from "path";
+import {createExpressServer, createKoaServer, getMetadataArgsStorage} from "../../src/index";
+import {assertRequest} from "./test-utils";
+import {InterceptorInterface} from "../../src/InterceptorInterface";
+import {Interceptor} from "../../src/decorator/Interceptor";
+import {UseInterceptor} from "../../src/decorator/UseInterceptor";
+import {Controller} from "../../src/decorator/Controller";
+import {Get} from "../../src/decorator/Get";
+import {Action} from "../../src/Action";
+import {ContentType} from "../../src/decorator/ContentType";
+const chakram = require("chakram");
+const expect = chakram.expect;
+
+describe("special result value treatment", () => {
+
+    const rawData = [0xFF, 0x66, 0xAA, 0xCC];
+
+    before(() => {
+
+        // reset metadata args storage
+        getMetadataArgsStorage().reset();
+
+        @Controller()
+        class HandledController {
+
+            @Get("/stream")
+            @ContentType("text/plain")
+            getStream() {
+                return createReadStream(path.resolve(__dirname, "../../../../test/resources/sample-text-file.txt"));
+            }
+
+            @Get("/buffer")
+            getBuffer() {
+                return new Buffer(rawData);
+            }
+        }
+
+    });
+
+    let expressApp: any, koaApp: any;
+    before(done => expressApp = createExpressServer().listen(3001, done));
+    after(done => expressApp.close(done));
+    before(done => koaApp = createKoaServer().listen(3002, done));
+    after(done => koaApp.close(done));
+
+    describe("should pipe stream to response", () => {
+        assertRequest([3001, 3002], "get", "stream", response => {
+            expect(response).to.be.status(200);
+            expect(response).to.have.header("content-type", (contentType: string) => {
+                expect(contentType).to.match(/text\/plain/);
+            });
+            expect(response.body).to.be.equal("Hello World!");
+        });
+    });
+
+    describe("should send raw binary data", () => {
+        assertRequest([3001, 3002], "get", "buffer", response => {
+            expect(response).to.be.status(200);
+            expect(response).to.have.header("content-type", "application/octet-stream");
+            expect(response.body).to.be.equal(new Buffer(rawData).toString());
+        });
+    });
+});

test/resources/sample-text-file.txt

@@ -0,0 +1 @@
+Hello World!