Merge branch 'feature-add-redirect-decorator' of https://github.com/johnbiundo/nest into johnbiundo-feature-add-redirect-decorator

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/helpers/handler-metadata-storage.ts

@@ -2,6 +2,7 @@ import { Controller } from '@nestjs/common/interfaces';
 import * as hash from 'object-hash';
 import { ContextId } from './../injector/instance-wrapper';
 import { ParamProperties } from './context-utils';
+import { RedirectResponse } from '../router/router-response-controller';
 
 export const HANDLER_METADATA_SYMBOL = Symbol.for('handler_metadata:cache');
 
@@ -11,6 +12,7 @@ export interface HandlerMetadata {
   httpStatusCode: number;
   responseHeaders: any[];
   hasCustomHeaders: boolean;
+  httpRedirectResponse: RedirectResponse;
   getParamsMetadata: (
     moduleKey: string,
     contextId?: ContextId,

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

@@ -11,6 +11,7 @@ import {
   HTTP_CODE_METADATA,
   RENDER_METADATA,
   ROUTE_ARGS_METADATA,
+  REDIRECT_METADATA,
 } from '@nestjs/common/constants';
 import { RouteParamsMetadata } from '@nestjs/common/decorators';
 import { RouteParamtypes } from '@nestjs/common/enums/route-paramtypes.enum';
@@ -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';
 
@@ -86,6 +88,7 @@ export class RouterExecutionContext {
       httpStatusCode,
       responseHeaders,
       hasCustomHeaders,
+      httpRedirectResponse,
     } = this.getMetadata(instance, callback, methodName, module, requestMethod);
 
     const paramsOptions = this.contextUtils.mergeParamsMetatypes(
@@ -205,19 +208,26 @@ export class RouterExecutionContext {
     const responseHeaders = this.reflectResponseHeaders(callback);
     const hasCustomHeaders = !isEmpty(responseHeaders);
 
+    const httpRedirectResponse = this.reflectRedirect(callback);
+
     const handlerMetadata: HandlerMetadata = {
       argsLength,
       fnHandleResponse,
       paramtypes,
       getParamsMetadata,
       httpStatusCode,
       hasCustomHeaders,
+      httpRedirectResponse,
       responseHeaders,
     };
     this.handlerMetadataStorage.set(instance, methodName, handlerMetadata);
     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);
   }
@@ -360,6 +370,13 @@ export class RouterExecutionContext {
     isResponseHandled: boolean,
     httpStatusCode?: number,
   ) {
+    const redirectResponse = this.reflectRedirect(callback);
+    if (redirectResponse && redirectResponse.url) {
+      return async <TResult, TResponse>(result: TResult, res: TResponse) => {
+        await this.responseController.redirect(result, res, redirectResponse);
+      };
+    }
+
     const renderTemplate = this.reflectRenderTemplate(callback);
 
     if (renderTemplate) {

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

@@ -298,6 +298,7 @@ describe('RouterExecutionContext', () => {
         const value = 'test';
         const response = { render: sinon.spy() };
 
+        sinon.stub(contextCreator, 'reflectRedirect').returns(undefined);
         sinon.stub(contextCreator, 'reflectResponseHeaders').returns([]);
         sinon.stub(contextCreator, 'reflectRenderTemplate').returns(template);
 
@@ -312,6 +313,7 @@ describe('RouterExecutionContext', () => {
         const result = Promise.resolve('test');
         const response = { render: sinon.spy() };
 
+        sinon.stub(contextCreator, 'reflectRedirect').returns(undefined);
         sinon.stub(contextCreator, 'reflectResponseHeaders').returns([]);
         sinon.stub(contextCreator, 'reflectRenderTemplate').returns(undefined);
 
@@ -321,5 +323,49 @@ describe('RouterExecutionContext', () => {
         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() };
+
+        sinon.stub(contextCreator, 'reflectRedirect').returns(redirectResponse);
+
+        const handler = contextCreator.createHandleResponseFn(null, true, 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, 'reflectRedirect').returns(undefined);
+        sinon.stub(contextCreator, 'reflectResponseHeaders').returns([]);
+        sinon.stub(contextCreator, 'reflectRenderTemplate').returns(undefined);
+
+        const handler = contextCreator.createHandleResponseFn(null, true, 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 {}