set http status code before running interceptors

added unit test and integration test
changes http adapter to not send  http status in reply

Author: toonvanstrijp

integration/hello-world/e2e/interceptors.spec.ts

@@ -28,6 +28,19 @@ export class TransformInterceptor {
   }
 }
 
+@Injectable()
+export class StatusInterceptor {
+
+  constructor(private statusCode: number){}
+
+  intercept(context: ExecutionContext, next: CallHandler) {
+    const ctx = context.switchToHttp();
+    const res = ctx.getResponse();
+    res.status(this.statusCode);
+    return next.handle().pipe(map(data => ({ data })));
+  }
+}
+
 function createTestModule(interceptor) {
   return Test.createTestingModule({
     imports: [ApplicationModule],
@@ -87,6 +100,17 @@ describe('Interceptors', () => {
       .expect(200, { data: 'Hello world!' });
   });
 
+  it(`should modify response status`, async () => {
+    app = (await createTestModule(
+      new StatusInterceptor(400),
+    )).createNestApplication();
+
+    await app.init();
+    return request(app.getHttpServer())
+      .get('/hello')
+      .expect(400, { data: 'Hello world!' });
+  });
+
   afterEach(async () => {
     await app.close();
   });

integration/hello-world/src/hello/hello.controller.ts

@@ -1,5 +1,5 @@
 import { HelloService } from './hello.service';
-import { Controller, Get, Header, Param } from '@nestjs/common';
+import { Controller, Get, Header, Param, Post } from '@nestjs/common';
 import { Observable, of } from 'rxjs';
 import { UserByIdPipe } from './users/user-by-id.pipe';
 

packages/common/interfaces/http/http-server.interface.ts

@@ -42,7 +42,8 @@ export interface HttpServer<TRequest = any, TResponse = any> {
   options(path: string, handler: RequestHandler<TRequest, TResponse>): any;
   listen(port: number | string, callback?: () => void): any;
   listen(port: number | string, hostname: string, callback?: () => void): any;
-  reply(response: any, body: any, statusCode: number): any;
+  reply(response: any, body: any): any;
+  status(response: any, statusCode: number): any;
   render(response: any, view: string, options: any): any;
   setHeader(response: any, name: string, value: string): any;
   setErrorHandler?(handler: Function): any;

packages/core/adapters/http-adapter.ts

@@ -82,7 +82,8 @@ export abstract class AbstractHttpAdapter<
   abstract setViewEngine(engine: string);
   abstract getRequestMethod(request);
   abstract getRequestUrl(request);
-  abstract reply(response, body: any, statusCode: number);
+  abstract status(response, statusCode: number);
+  abstract reply(response, body: any);
   abstract render(response, view: string, options: any);
   abstract setErrorHandler(handler: Function);
   abstract setNotFoundHandler(handler: Function);

packages/core/exceptions/base-exception-filter.ts

@@ -31,7 +31,8 @@ export class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
         statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
         message: MESSAGES.UNKNOWN_EXCEPTION_MESSAGE,
       };
-      applicationRef.reply(host.getArgByIndex(1), body, body.statusCode);
+      applicationRef.status(host.getArgByIndex(1), body.statusCode);
+      applicationRef.reply(host.getArgByIndex(1), body);
       if (this.isExceptionObject(exception)) {
         return BaseExceptionFilter.logger.error(
           exception.message,
@@ -48,7 +49,8 @@ export class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {
           message: res,
         };
 
-    applicationRef.reply(host.getArgByIndex(1), message, exception.getStatus());
+    applicationRef.status(host.getArgByIndex(1), exception.getStatus());
+    applicationRef.reply(host.getArgByIndex(1), message);
   }
 
   public isExceptionObject(err: any): err is Error {

packages/core/router/router-execution-context.ts

@@ -83,7 +83,7 @@ export class RouterExecutionContext {
       fnHandleResponse,
       paramtypes,
       getParamsMetadata,
-    } = this.getMetadata(instance, callback, methodName, module, requestMethod);
+    } = this.getMetadata(instance, callback, methodName, module);
     const paramsOptions = this.contextUtils.mergeParamsMetatypes(
       getParamsMetadata(module, contextId, inquirerId),
       paramtypes,
@@ -131,6 +131,14 @@ export class RouterExecutionContext {
       const args = this.contextUtils.createNullArray(argsLength);
       fnCanActivate && (await fnCanActivate([req, res]));
 
+      const httpCode = this.reflectHttpStatusCode(callback);
+
+      const httpStatusCode = httpCode
+        ? httpCode
+        : this.responseController.getStatusByMethod(requestMethod);
+
+      this.responseController.status(res, httpStatusCode);
+
       const result = await this.interceptorsConsumer.intercept(
         interceptors,
         [req, res],
@@ -146,8 +154,7 @@ export class RouterExecutionContext {
     instance: Controller,
     callback: (...args: any[]) => any,
     methodName: string,
-    module: string,
-    requestMethod: RequestMethod,
+    module: string
   ): HandlerMetadata {
     const cacheMetadata = this.handlerMetadataStorage.get(instance, methodName);
     if (cacheMetadata) {
@@ -165,7 +172,6 @@ export class RouterExecutionContext {
       instance,
       methodName,
     );
-    const httpCode = this.reflectHttpStatusCode(callback);
     const getParamsMetadata = (
       moduleKey: string,
       contextId = STATIC_CONTEXT,
@@ -184,14 +190,10 @@ export class RouterExecutionContext {
       ({ type }) =>
         type === RouteParamtypes.RESPONSE || type === RouteParamtypes.NEXT,
     );
-    const httpStatusCode = httpCode
-      ? httpCode
-      : this.responseController.getStatusByMethod(requestMethod);
 
     const fnHandleResponse = this.createHandleResponseFn(
       callback,
-      isResponseHandled,
-      httpStatusCode,
+      isResponseHandled
     );
     const handlerMetadata: HandlerMetadata = {
       argsLength,
@@ -341,8 +343,7 @@ export class RouterExecutionContext {
 
   public createHandleResponseFn(
     callback: (...args: any[]) => any,
-    isResponseHandled: boolean,
-    httpStatusCode: number,
+    isResponseHandled: boolean
   ) {
     const renderTemplate = this.reflectRenderTemplate(callback);
     const responseHeaders = this.reflectResponseHeaders(callback);
@@ -358,10 +359,9 @@ export class RouterExecutionContext {
     return async <TResult, TResponse>(result: TResult, res: TResponse) => {
       hasCustomHeaders &&
         this.responseController.setHeaders(res, responseHeaders);
-
       result = await this.responseController.transformToResult(result);
       !isResponseHandled &&
-        (await this.responseController.apply(result, res, httpStatusCode));
+        (await this.responseController.apply(result, res));
     };
   }
 }

packages/core/router/router-response-controller.ts

@@ -11,10 +11,9 @@ export class RouterResponseController {
 
   public async apply<TInput = any, TResponse = any>(
     result: TInput,
-    response: TResponse,
-    httpStatusCode: number,
+    response: TResponse
   ) {
-    return this.applicationRef.reply(response, result, httpStatusCode);
+    return this.applicationRef.reply(response, result);
   }
 
   public async render<TInput = any, TResponse = any>(
@@ -50,4 +49,11 @@ export class RouterResponseController {
       this.applicationRef.setHeader(response, name, value),
     );
   }
+
+  public status<TResponse = any>(
+    response: TResponse,
+    statusCode: number
+  ) {
+    this.applicationRef.status(response, statusCode);
+  }
 }

packages/core/test/exceptions/exceptions-handler.spec.ts

@@ -31,14 +31,18 @@ describe('ExceptionsHandler', () => {
 
   describe('next', () => {
     beforeEach(() => {
+      sinon
+        .stub(adapter, 'status')
+        .callsFake((responseRef: any, statusCode: number) => {
+          return responseRef.status(statusCode);
+        });
       sinon
         .stub(adapter, 'reply')
-        .callsFake((responseRef: any, body: any, statusCode: number) => {
-          const res = responseRef.status(statusCode);
+        .callsFake((responseRef: any, body: any) => {
           if (isNil(body)) {
-            return res.send();
+            return responseRef.send();
           }
-          return isObject(body) ? res.json(body) : res.send(String(body));
+          return isObject(body) ? responseRef.json(body) : responseRef.send(String(body));
         });
     });
     it('should method send expected response status code and message when exception is unknown', () => {

packages/core/test/router/router-response-controller.spec.ts

@@ -18,44 +18,42 @@ describe('RouterResponseController', () => {
   describe('apply', () => {
     let response: {
       send: sinon.SinonSpy;
-      status?: sinon.SinonSpy;
+      status: sinon.SinonSpy;
       json: sinon.SinonSpy;
     };
     beforeEach(() => {
-      response = { send: sinon.spy(), json: sinon.spy() };
-      response.status = sinon.stub().returns(response);
+      response = { send: sinon.spy(), json: sinon.spy(), status: sinon.spy() };
     });
     describe('when result is', () => {
       beforeEach(() => {
         sinon
           .stub(adapter, 'reply')
-          .callsFake((responseRef: any, body: any, statusCode: number) => {
-            const res = responseRef.status(statusCode);
+          .callsFake((responseRef: any, body: any) => {
             if (isNil(body)) {
-              return res.send();
+              return responseRef.send();
             }
-            return isObject(body) ? res.json(body) : res.send(String(body));
+            return isObject(body) ? responseRef.json(body) : responseRef.send(String(body));
           });
       });
       describe('nil', () => {
         it('should call send()', async () => {
           const value = null;
-          await routerResponseController.apply(value, response, 200);
+          await routerResponseController.apply(value, response);
           expect(response.send.called).to.be.true;
         });
       });
       describe('string', () => {
         it('should call send(value)', async () => {
           const value = 'string';
-          await routerResponseController.apply(value, response, 200);
+          await routerResponseController.apply(value, response);
           expect(response.send.called).to.be.true;
           expect(response.send.calledWith(String(value))).to.be.true;
         });
       });
       describe('object', () => {
         it('should call json(value)', async () => {
           const value = { test: 'test' };
-          await routerResponseController.apply(value, response, 200);
+          await routerResponseController.apply(value, response);
           expect(response.json.called).to.be.true;
           expect(response.json.calledWith(value)).to.be.true;
         });
@@ -149,4 +147,22 @@ describe('RouterResponseController', () => {
       ).to.be.true;
     });
   });
+
+  describe('status', () => {
+    let statusStub: sinon.SinonStub;
+
+    beforeEach(() => {
+      statusStub = sinon.stub(adapter, 'status').callsFake(() => ({}));
+    });
+
+    it('should set status', () => {
+      const response = {};
+      const statusCode = 400;
+
+      routerResponseController.setStatus(response, statusCode);
+      expect(
+        statusStub.calledWith(response, statusCode),
+      ).to.be.true;
+    });
+  });
 });

packages/core/test/utils/noop-adapter.spec.ts

@@ -11,7 +11,8 @@ export class NoopHttpAdapter extends AbstractHttpAdapter {
   setViewEngine(engine: string): any {}
   getRequestMethod(request: any): any {}
   getRequestUrl(request: any): any {}
-  reply(response: any, body: any, statusCode: number): any {}
+  reply(response: any, body: any): any {}
+  status(response: any, statusCode: number): any {}
   render(response: any, view: string, options: any): any {}
   setErrorHandler(handler: Function): any {}
   setNotFoundHandler(handler: Function): any {}