Merge branch 'ToonvanStrijp-feature/change-http-code-interceptor'

Author: kamilmysliwiec

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

@@ -28,6 +28,34 @@ 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 })));
+  }
+}
+
+@Injectable()
+export class HeaderInterceptor {
+  constructor(private headers: object) {}
+
+  intercept(context: ExecutionContext, next: CallHandler) {
+    const ctx = context.switchToHttp();
+    const res = ctx.getResponse();
+    for (const key in this.headers) {
+      if (this.headers.hasOwnProperty(key)) {
+        res.header(key, this.headers[key]);
+      }
+    }
+    return next.handle().pipe(map(data => ({ data })));
+  }
+}
+
 function createTestModule(interceptor) {
   return Test.createTestingModule({
     imports: [ApplicationModule],
@@ -87,6 +115,33 @@ 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!' });
+  });
+
+  it(`should modify Authorization header`, async () => {
+    const customHeaders = {
+      Authorization: 'jwt',
+    };
+
+    app = (await createTestModule(
+      new HeaderInterceptor(customHeaders),
+    )).createNestApplication();
+
+    await app.init();
+    return request(app.getHttpServer())
+      .get('/hello')
+      .expect(200)
+      .expect('Authorization', 'jwt');
+  });
+
   afterEach(async () => {
     await app.close();
   });

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

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

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, statusCode?: number): 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, statusCode?: number);
   abstract render(response, view: string, options: any);
   abstract setErrorHandler(handler: Function);
   abstract setNotFoundHandler(handler: Function);

packages/core/helpers/handler-metadata-storage.ts

@@ -7,6 +7,9 @@ export const HANDLER_METADATA_SYMBOL = Symbol.for('handler_metadata:cache');
 export interface HandlerMetadata {
   argsLength: number;
   paramtypes: any[];
+  httpStatusCode: number;
+  responseHeaders: any[];
+  hasCustomHeaders: boolean;
   getParamsMetadata: (
     moduleKey: string,
     contextId?: ContextId,

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

@@ -83,7 +83,11 @@ export class RouterExecutionContext {
       fnHandleResponse,
       paramtypes,
       getParamsMetadata,
+      httpStatusCode,
+      responseHeaders,
+      hasCustomHeaders,
     } = this.getMetadata(instance, callback, methodName, module, requestMethod);
+
     const paramsOptions = this.contextUtils.mergeParamsMetatypes(
       getParamsMetadata(module, contextId, inquirerId),
       paramtypes,
@@ -131,6 +135,10 @@ export class RouterExecutionContext {
       const args = this.contextUtils.createNullArray(argsLength);
       fnCanActivate && (await fnCanActivate([req, res]));
 
+      this.responseController.setStatus(res, httpStatusCode);
+      hasCustomHeaders &&
+        this.responseController.setHeaders(res, responseHeaders);
+
       const result = await this.interceptorsConsumer.intercept(
         interceptors,
         [req, res],
@@ -165,7 +173,6 @@ export class RouterExecutionContext {
       instance,
       methodName,
     );
-    const httpCode = this.reflectHttpStatusCode(callback);
     const getParamsMetadata = (
       moduleKey: string,
       contextId = STATIC_CONTEXT,
@@ -184,20 +191,28 @@ 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,
     );
+
+    const httpCode = this.reflectHttpStatusCode(callback);
+    const httpStatusCode = httpCode
+      ? httpCode
+      : this.responseController.getStatusByMethod(requestMethod);
+
+    const responseHeaders = this.reflectResponseHeaders(callback);
+    const hasCustomHeaders = !isEmpty(responseHeaders);
+
     const handlerMetadata: HandlerMetadata = {
       argsLength,
       fnHandleResponse,
       paramtypes,
       getParamsMetadata,
+      httpStatusCode,
+      hasCustomHeaders,
+      responseHeaders,
     };
     this.handlerMetadataStorage.set(instance, methodName, handlerMetadata);
     return handlerMetadata;
@@ -342,23 +357,16 @@ export class RouterExecutionContext {
   public createHandleResponseFn(
     callback: (...args: any[]) => any,
     isResponseHandled: boolean,
-    httpStatusCode: number,
+    httpStatusCode?: number,
   ) {
     const renderTemplate = this.reflectRenderTemplate(callback);
-    const responseHeaders = this.reflectResponseHeaders(callback);
-    const hasCustomHeaders = !isEmpty(responseHeaders);
 
     if (renderTemplate) {
       return async <TResult, TResponse>(result: TResult, res: TResponse) => {
-        hasCustomHeaders &&
-          this.responseController.setHeaders(res, responseHeaders);
         await this.responseController.render(result, res, renderTemplate);
       };
     }
     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));

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

@@ -12,7 +12,7 @@ export class RouterResponseController {
   public async apply<TInput = any, TResponse = any>(
     result: TInput,
     response: TResponse,
-    httpStatusCode: number,
+    httpStatusCode?: number,
   ) {
     return this.applicationRef.reply(response, result, httpStatusCode);
   }
@@ -50,4 +50,8 @@ export class RouterResponseController {
       this.applicationRef.setHeader(response, name, value),
     );
   }
+
+  public setStatus<TResponse = any>(response: TResponse, statusCode: number) {
+    this.applicationRef.status(response, statusCode);
+  }
 }

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

@@ -33,12 +33,14 @@ describe('ExceptionsHandler', () => {
     beforeEach(() => {
       sinon
         .stub(adapter, 'reply')
-        .callsFake((responseRef: any, body: any, statusCode: number) => {
-          const res = responseRef.status(statusCode);
+        .callsFake((responseRef: any, body: any, statusCode?: number) => {
+          if (statusCode) {
+            responseRef.status(statusCode);
+          }
           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-execution-context.spec.ts

@@ -281,7 +281,7 @@ describe('RouterExecutionContext', () => {
         sinon.stub(contextCreator, 'reflectResponseHeaders').returns([]);
         sinon.stub(contextCreator, 'reflectRenderTemplate').returns(template);
 
-        const handler = contextCreator.createHandleResponseFn(null, true, 100);
+        const handler = contextCreator.createHandleResponseFn(null, true, 200);
         await handler(value, response);
 
         expect(response.render.calledWith(template, value)).to.be.true;
@@ -295,7 +295,7 @@ describe('RouterExecutionContext', () => {
         sinon.stub(contextCreator, 'reflectResponseHeaders').returns([]);
         sinon.stub(contextCreator, 'reflectRenderTemplate').returns(undefined);
 
-        const handler = contextCreator.createHandleResponseFn(null, true, 100);
+        const handler = contextCreator.createHandleResponseFn(null, true, 200);
         handler(result, response);
 
         expect(response.render.called).to.be.false;

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

@@ -22,19 +22,22 @@ describe('RouterResponseController', () => {
       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, statusCode?: number) => {
+            if (statusCode) {
+              responseRef.status(statusCode);
+            }
             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', () => {
@@ -149,4 +152,20 @@ 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;
+    });
+  });
 });