Merge branch 'johnbiundo-feature-add-redirect-decorator' into 6.6.0

Author: kamilmysliwiec

packages/common/decorators/http/index.ts

@@ -3,4 +3,5 @@ export * from './route-params.decorator';
 export * from './http-code.decorator';
 export * from './create-route-param-metadata.decorator';
 export * from './render.decorator';
-export * from './header.decorator';
+export * from './header.decorator';
+export * from './redirect.decorator';

packages/common/decorators/http/redirect.decorator.ts

@@ -3,9 +3,13 @@ import { REDIRECT_METADATA } from '../../constants';
 /**
  * Redirects request.
  */
-export function Redirect(url: string): MethodDecorator {
+export function Redirect(url: string, statusCode?: number): MethodDecorator {
   return (target: object, key, descriptor) => {
-    Reflect.defineMetadata(REDIRECT_METADATA, url, descriptor.value);
+    Reflect.defineMetadata(
+      REDIRECT_METADATA,
+      { statusCode, url },
+      descriptor.value,
+    );
     return descriptor;
   };
 }

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

@@ -45,6 +45,7 @@ export interface HttpServer<TRequest = any, TResponse = any> {
   reply(response: any, body: any, statusCode?: number): any;
   status(response: any, statusCode: number): any;
   render(response: any, view: string, options: any): any;
+  redirect(response: any, statusCode: number, url: string): any;
   setHeader(response: any, name: string, value: string): any;
   setErrorHandler?(handler: Function): any;
   setNotFoundHandler?(handler: Function): any;

packages/common/test/decorators/redirect.decorator.spec.ts

@@ -1,17 +1,24 @@
 import { expect } from 'chai';
 import { Redirect } from '../../decorators/http/redirect.decorator';
 import { REDIRECT_METADATA } from '../../constants';
+import { HttpStatus } from '@nestjs/common';
 
 describe('@Redirect', () => {
   const url = 'http://test.com';
+  const statusCode = HttpStatus.FOUND;
 
   class Test {
-    @Redirect(url)
+    @Redirect(url, statusCode)
     public static test() {}
   }
 
-  it('should enhance method with expected template string', () => {
+  it('should enhance method with expected redirect url string', () => {
     const metadata = Reflect.getMetadata(REDIRECT_METADATA, Test.test);
-    expect(metadata).to.be.eql(url);
+    expect(metadata.url).to.be.eql(url);
+  });
+
+  it('should enhance method with expected response code', () => {
+    const metadata = Reflect.getMetadata(REDIRECT_METADATA, Test.test);
+    expect(metadata.statusCode).to.be.eql(statusCode);
   });
 });

packages/core/adapters/http-adapter.ts

@@ -85,6 +85,7 @@ export abstract class AbstractHttpAdapter<
   abstract status(response, statusCode: number);
   abstract reply(response, body: any, statusCode?: number);
   abstract render(response, view: string, options: any);
+  abstract redirect(response, statusCode: number, url: string);
   abstract setErrorHandler(handler: Function);
   abstract setNotFoundHandler(handler: Function);
   abstract setHeader(response, name: string, value: string);

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

@@ -9,6 +9,7 @@ import {
   CUSTOM_ROUTE_AGRS_METADATA,
   HEADERS_METADATA,
   HTTP_CODE_METADATA,
+  REDIRECT_METADATA,
   RENDER_METADATA,
   ROUTE_ARGS_METADATA,
 } from '@nestjs/common/constants';
@@ -36,6 +37,7 @@ import { PipesContextCreator } from '../pipes/pipes-context-creator';
 import { IRouteParamsFactory } from './interfaces/route-params-factory.interface';
 import {
   CustomHeader,
+  RedirectResponse,
   RouterResponseController,
 } from './router-response-controller';
 
@@ -192,9 +194,11 @@ export class RouterExecutionContext {
         type === RouteParamtypes.RESPONSE || type === RouteParamtypes.NEXT,
     );
 
+    const httpRedirectResponse = this.reflectRedirect(callback);
     const fnHandleResponse = this.createHandleResponseFn(
       callback,
       isResponseHandled,
+      httpRedirectResponse,
     );
 
     const httpCode = this.reflectHttpStatusCode(callback);
@@ -204,7 +208,6 @@ export class RouterExecutionContext {
 
     const responseHeaders = this.reflectResponseHeaders(callback);
     const hasCustomHeaders = !isEmpty(responseHeaders);
-
     const handlerMetadata: HandlerMetadata = {
       argsLength,
       fnHandleResponse,
@@ -218,6 +221,10 @@ export class RouterExecutionContext {
     return handlerMetadata;
   }
 
+  public reflectRedirect(callback: (...args: any[]) => any): RedirectResponse {
+    return Reflect.getMetadata(REDIRECT_METADATA, callback);
+  }
+
   public reflectHttpStatusCode(callback: (...args: any[]) => any): number {
     return Reflect.getMetadata(HTTP_CODE_METADATA, callback);
   }
@@ -358,15 +365,20 @@ export class RouterExecutionContext {
   public createHandleResponseFn(
     callback: (...args: any[]) => any,
     isResponseHandled: boolean,
+    redirectResponse?: RedirectResponse,
     httpStatusCode?: number,
   ) {
     const renderTemplate = this.reflectRenderTemplate(callback);
-
     if (renderTemplate) {
       return async <TResult, TResponse>(result: TResult, res: TResponse) => {
         await this.responseController.render(result, res, renderTemplate);
       };
     }
+    if (redirectResponse && redirectResponse.url) {
+      return async <TResult, TResponse>(result: TResult, res: TResponse) => {
+        await this.responseController.redirect(result, res, redirectResponse);
+      };
+    }
     return async <TResult, TResponse>(result: TResult, res: TResponse) => {
       result = await this.responseController.transformToResult(result);
       !isResponseHandled &&

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

@@ -6,6 +6,10 @@ export interface CustomHeader {
   value: string;
 }
 
+export interface RedirectResponse {
+  url: string;
+  statusCode: number;
+}
 export class RouterResponseController {
   constructor(private readonly applicationRef: HttpServer) {}
 
@@ -17,20 +21,36 @@ export class RouterResponseController {
     return this.applicationRef.reply(response, result, httpStatusCode);
   }
 
+  public async redirect<TInput = any, TResponse = any>(
+    resultOrDeferred: TInput,
+    response: TResponse,
+    redirectResponse: RedirectResponse,
+  ) {
+    const result = await this.transformToResult(resultOrDeferred);
+    const statusCode =
+      result && result.statusCode
+        ? result.statusCode
+        : redirectResponse.statusCode
+        ? redirectResponse.statusCode
+        : HttpStatus.FOUND;
+    const url = result && result.url ? result.url : redirectResponse.url;
+    this.applicationRef.redirect(response, statusCode, url);
+  }
+
   public async render<TInput = any, TResponse = any>(
-    resultOrDeffered: TInput,
+    resultOrDeferred: TInput,
     response: TResponse,
     template: string,
   ) {
-    const result = await this.transformToResult(resultOrDeffered);
+    const result = await this.transformToResult(resultOrDeferred);
     this.applicationRef.render(response, template, result);
   }
 
-  public async transformToResult(resultOrDeffered: any) {
-    if (resultOrDeffered && isFunction(resultOrDeffered.subscribe)) {
-      return resultOrDeffered.toPromise();
+  public async transformToResult(resultOrDeferred: any) {
+    if (resultOrDeferred && isFunction(resultOrDeferred.subscribe)) {
+      return resultOrDeferred.toPromise();
     }
-    return resultOrDeffered;
+    return resultOrDeferred;
   }
 
   public getStatusByMethod(requestMethod: RequestMethod): number {

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

@@ -301,7 +301,12 @@ describe('RouterExecutionContext', () => {
         sinon.stub(contextCreator, 'reflectResponseHeaders').returns([]);
         sinon.stub(contextCreator, 'reflectRenderTemplate').returns(template);
 
-        const handler = contextCreator.createHandleResponseFn(null, true, 200);
+        const handler = contextCreator.createHandleResponseFn(
+          null,
+          true,
+          undefined,
+          200,
+        );
         await handler(value, response);
 
         expect(response.render.calledWith(template, value)).to.be.true;
@@ -315,11 +320,67 @@ describe('RouterExecutionContext', () => {
         sinon.stub(contextCreator, 'reflectResponseHeaders').returns([]);
         sinon.stub(contextCreator, 'reflectRenderTemplate').returns(undefined);
 
-        const handler = contextCreator.createHandleResponseFn(null, true, 200);
+        const handler = contextCreator.createHandleResponseFn(
+          null,
+          true,
+          undefined,
+          200,
+        );
         handler(result, response);
 
         expect(response.render.called).to.be.false;
       });
     });
+    describe('when "redirectResponse" is present', () => {
+      beforeEach(() => {
+        sinon
+          .stub(adapter, 'redirect')
+          .callsFake((response, statusCode: number, url: string) => {
+            return response.redirect(statusCode, url);
+          });
+      });
+      it('should call "res.redirect()" with expected args', async () => {
+        const redirectResponse = {
+          url: 'http://test.com',
+          statusCode: 302,
+        };
+        const response = { redirect: sinon.spy() };
+
+        const handler = contextCreator.createHandleResponseFn(
+          () => {},
+          true,
+          redirectResponse,
+          200,
+        );
+        await handler(redirectResponse, response);
+
+        expect(
+          response.redirect.calledWith(
+            redirectResponse.statusCode,
+            redirectResponse.url,
+          ),
+        ).to.be.true;
+      });
+    });
+
+    describe('when "redirectResponse" is undefined', () => {
+      it('should not call "res.render()"', () => {
+        const result = Promise.resolve('test');
+        const response = { redirect: sinon.spy() };
+
+        sinon.stub(contextCreator, 'reflectResponseHeaders').returns([]);
+        sinon.stub(contextCreator, 'reflectRenderTemplate').returns(undefined);
+
+        const handler = contextCreator.createHandleResponseFn(
+          null,
+          true,
+          undefined,
+          200,
+        );
+        handler(result, response);
+
+        expect(response.redirect.called).to.be.false;
+      });
+    });
   });
 });

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

@@ -14,6 +14,7 @@ export class NoopHttpAdapter extends AbstractHttpAdapter {
   reply(response: any, body: any): any {}
   status(response: any, statusCode: number): any {}
   render(response: any, view: string, options: any): any {}
+  redirect(response: any, statusCode: number, url: string) {}
   setErrorHandler(handler: Function): any {}
   setNotFoundHandler(handler: Function): any {}
   setHeader(response: any, name: string, value: string): any {}

packages/platform-express/adapters/express-adapter.ts

@@ -36,6 +36,10 @@ export class ExpressAdapter extends AbstractHttpAdapter {
     return response.render(view, options);
   }
 
+  public redirect(response: any, statusCode: number, url: string) {
+    return response.redirect(statusCode, url);
+  }
+
   public setErrorHandler(handler: Function) {
     return this.use(handler);
   }