Add support for returning UInt8Array

Author: MichalLytek

src/driver/BaseDriver.ts

@@ -132,11 +132,11 @@ export abstract class BaseDriver {
         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 instanceof Uint8Array // 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;

src/driver/express/ExpressDriver.ts

@@ -294,8 +294,11 @@ export class ExpressDriver extends BaseDriver {
             }
             options.next();
         }
-        else if (result instanceof Buffer) {
-            options.response.send(result);
+        else if (result instanceof Buffer) { // check if it's binary data (Buffer)
+            options.response.end(result, "binary");
+        }
+        else if (result instanceof Uint8Array) { // check if it's binary data (typed array)
+            options.response.end(Buffer.from(result as any), "binary");
         }
         else if (result.pipe instanceof Function) {
             result.pipe(options.response);

src/driver/koa/KoaDriver.ts

@@ -223,12 +223,7 @@ export class KoaDriver extends BaseDriver {
         } else if (action.successHttpCode) {
             options.response.status = action.successHttpCode;
         }
-
-        // apply http headers
-        Object.keys(action.headers).forEach(name => {
-            options.response.set(name, action.headers[name]);
-        });
-
+        
         if (action.redirect) { // if redirect is set then do it
             if (typeof result === "string") {
                 options.response.redirect(result);
@@ -237,17 +232,12 @@ export class KoaDriver extends BaseDriver {
             } else {
                 options.response.redirect(action.redirect);
             }
-
-            return options.next();
-
         } else if (action.renderedTemplate) { // if template is set then render it // TODO: not working in koa
             const renderOptions = result && result instanceof Object ? result : {};
-
+            
             this.koa.use(async function (ctx: any, next: any) {
                 await ctx.render(action.renderedTemplate, renderOptions);
             });
-
-            return options.next();
         }
         else if (result === undefined) { // throw NotFoundError on undefined response
             const notFoundError = new NotFoundError();
@@ -270,18 +260,24 @@ export class KoaDriver extends BaseDriver {
             } else {
                 options.response.status = 204;
             }
-            
-            return options.next();
+        }
+        else if (result instanceof Uint8Array) { // check if it's binary data (typed array)
+            options.response.body = Buffer.from(result as any);
         }
         else { // send regular result
             if (result instanceof Object) {
                 options.response.body = result;
             } else {
                 options.response.body = result;
             }
-
-            return options.next();
         }
+        
+        // apply http headers
+        Object.keys(action.headers).forEach(name => {
+            options.response.set(name, action.headers[name]);
+        });
+
+        return options.next();
     }
 
     /**

test/functional/action-params.spec.ts

@@ -412,7 +412,7 @@ describe("action parameters", () => {
         });
         assertRequest([3002], "get", "state", response => {
             expect(response).to.be.status(200);
-            expect(response).to.have.header("content-type", "application/json; charset=utf-8");
+            expect(response).to.have.header("content-type", "application/json");
             expect(response.body.username).to.be.equal("pleerock");
         });
         assertRequest([3002], "get", "state/username", response => {

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

@@ -7,7 +7,7 @@ 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 {JsonController} from "../../src/decorator/JsonController";
 import {Get} from "../../src/decorator/Get";
 import {Action} from "../../src/Action";
 import {ContentType} from "../../src/decorator/ContentType";
@@ -23,19 +23,27 @@ describe("special result value treatment", () => {
         // reset metadata args storage
         getMetadataArgsStorage().reset();
 
-        @Controller()
+        @JsonController()
         class HandledController {
 
             @Get("/stream")
             @ContentType("text/plain")
             getStream() {
                 return createReadStream(path.resolve(__dirname, "../../../../test/resources/sample-text-file.txt"));
             }
-
+            
             @Get("/buffer")
+            @ContentType("application/octet-stream")
             getBuffer() {
                 return new Buffer(rawData);
             }
+            
+            @Get("/array")
+            @ContentType("application/octet-stream")
+            getUIntArray() {
+                return new Uint8Array(rawData);
+            }
+
         }
 
     });
@@ -56,11 +64,20 @@ describe("special result value treatment", () => {
         });
     });
 
-    describe("should send raw binary data", () => {
+    describe("should send raw binary data from Buffer", () => {
         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());
         });
     });
+
+    describe("should send raw binary data from UIntArray", () => {
+        assertRequest([3001, 3002], "get", "array", response => {
+            expect(response).to.be.status(200);
+            expect(response).to.have.header("content-type", "application/octet-stream");
+            expect(response.body).to.be.equal(Buffer.from(rawData).toString());
+        });
+    });
+
 });