feat(response): allow to use a route identifier to redirect (#16)

Author: RomainLanz

adonis-typings/response.ts

@@ -10,6 +10,7 @@
 declare module '@ioc:Adonis/Core/Response' {
   import { ServerResponse, IncomingMessage } from 'http'
   import { MacroableConstructorContract } from 'macroable'
+  import { MakeUrlOptions } from '@ioc:Adonis/Core/Route'
   import { EncryptionContract } from '@ioc:Adonis/Core/Encryption'
   import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
 
@@ -106,7 +107,9 @@ declare module '@ioc:Adonis/Core/Response' {
     ): void
 
     location (url: string): this
-    redirect (url: string, reflectQueryParams?: boolean, statusCode?: number): void
+
+    redirect (): RedirectContract
+    redirect (path: string, forwardQueryString?: boolean, statusCode?: number): void
 
     cookie (key: string, value: any, options?: Partial<CookieOptions>): this
     plainCookie (key: string, value: any, options?: Partial<CookieOptions>): this
@@ -166,6 +169,20 @@ declare module '@ioc:Adonis/Core/Response' {
     httpVersionNotSupported (body: any, generateEtag?: boolean): void
   }
 
+  /**
+   * Redirect interface
+   */
+  export interface RedirectContract {
+    status (statusCode: number): this
+    withQs (): this
+    withQs (values: { [key: string]: any }): this
+    withQs (name: string, value: any): this
+
+    back (): void
+    toRoute (routeIdentifier: string, urlOptions?: MakeUrlOptions, domain?: string): void
+    toPath (url: string): void
+  }
+
   /**
    * Config accepted by response the class
    */

package-lock.json

@@ -42,6 +42,7 @@
     "@types/node": "^13.13.0",
     "@types/pluralize": "0.0.29",
     "@types/proxy-addr": "^2.0.0",
+    "@types/qs": "^6.9.2",
     "@types/supertest": "^2.0.8",
     "autocannon": "^4.6.0",
     "commitizen": "^4.0.4",
@@ -109,7 +110,7 @@
     "on-finished": "^2.3.0",
     "pluralize": "^8.0.0",
     "proxy-addr": "^2.0.6",
-    "qs": "^6.9.3",
+    "qs": "^6.9.4",
     "quick-lru": "^5.1.0",
     "type-is": "^1.6.18",
     "vary": "^1.1.2"

package.json

@@ -13,7 +13,7 @@ import { Socket } from 'net'
 import { inspect } from 'util'
 import proxyAddr from 'proxy-addr'
 import { Macroable } from 'macroable'
-import { RouteNode } from '@ioc:Adonis/Core/Route'
+import { RouteNode, RouterContract } from '@ioc:Adonis/Core/Route'
 import { ServerConfig } from '@ioc:Adonis/Core/Server'
 import { IncomingMessage, ServerResponse } from 'http'
 import { LoggerContract } from '@ioc:Adonis/Core/Logger'
@@ -76,6 +76,7 @@ export class HttpContext extends Macroable implements HttpContextContract {
     logger: LoggerContract,
     profiler: ProfilerRowContract,
     encryption: EncryptionContract,
+    router: RouterContract,
     req?: IncomingMessage,
     res?: ServerResponse,
     serverConfig?: ServerConfig,
@@ -120,7 +121,7 @@ export class HttpContext extends Macroable implements HttpContextContract {
       etag: serverConfig.etag,
       cookie: serverConfig.cookie,
       jsonpCallbackName: serverConfig.jsonpCallbackName,
-    })
+    }, router)
 
     /**
      * Creating new ctx instance

src/HttpContext/index.ts

@@ -0,0 +1,107 @@
+/*
+ * @adonisjs/http-server
+ *
+ * (c) Harminder Virk <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/// <reference path="../../adonis-typings/index.ts" />
+
+import { parse } from 'url'
+import { stringify } from 'qs'
+import encodeurl from 'encodeurl'
+import { IncomingMessage } from 'http'
+
+import { RedirectContract, ResponseContract } from '@ioc:Adonis/Core/Response'
+import { RouterContract, MakeUrlOptions } from '@ioc:Adonis/Core/Route'
+
+export class Redirect implements RedirectContract {
+  private forwardQueryString = false
+  private statusCode = 302
+  private queryString: { [key: string]: any } = {}
+
+  constructor (
+    private request: IncomingMessage,
+    private response: ResponseContract,
+    private router: RouterContract
+  ) {
+  }
+
+  /**
+   * Set a custom status code.
+   */
+  public status (statusCode: number): this {
+    this.statusCode = statusCode
+    return this
+  }
+
+  /**
+   * Forward the current QueryString or define one.
+   */
+  public withQs (): this
+  public withQs (values: { [key: string]: any }): this
+  public withQs (name: string, value: any): this
+  public withQs (name?: { [key: string]: any } | string, value?: any): this {
+    if (typeof name === 'undefined') {
+      this.forwardQueryString = true
+      return this
+    }
+
+    if (typeof name === 'string') {
+      this.queryString[name] = value
+      return this
+    }
+
+    this.queryString = name
+    return this
+  }
+
+  /**
+   * Redirect to the previous path.
+   */
+  public back () {
+    const url = (this.request.headers['referer'] || this.request.headers['referrer'] || '/') as string
+
+    return this.toPath(url)
+  }
+
+  /**
+   * Redirect the request using a route identifier.
+   */
+  public toRoute (routeIdentifier: string, urlOptions?: MakeUrlOptions, domain?: string) {
+    const route = this.router.lookup(routeIdentifier, domain)
+
+    if (!route) {
+      throw new Error(`Unable to lookup route for "${routeIdentifier}" identifier`)
+    }
+
+    const url = this.router.makeUrl(routeIdentifier, urlOptions, domain) as string
+    return this.toPath(url)
+  }
+
+  /**
+   * Redirect the request using a path.
+   */
+  public toPath (url: string) {
+    let query
+
+    // Extract the current QueryString if we want to forward it.
+    if (this.forwardQueryString) {
+      const { query: extractedQuery } = parse(this.request.url!, false)
+      query = extractedQuery
+    }
+
+    // If we define our own QueryString, use it instead of the one forwarded.
+    if (Object.keys(this.queryString).length > 0) {
+      query = stringify(this.queryString)
+    }
+
+    url = query ? `${url}?${query}` : url
+    this.response.location(encodeurl(url))
+    this.response.safeStatus(this.statusCode)
+    this.response.type('text/plain; charset=utf-8')
+    this.response.send(`Redirecting to ${url}`)
+  }
+}

src/Redirect/index.ts

@@ -12,11 +12,9 @@
 import etag from 'etag'
 import vary from 'vary'
 import fresh from 'fresh'
-import { parse } from 'url'
 import mime from 'mime-types'
 import destroy from 'destroy'
 import { extname } from 'path'
-import encodeurl from 'encodeurl'
 import onFinished from 'on-finished'
 import { Macroable } from 'macroable'
 import { Exception } from '@poppinss/utils'
@@ -31,12 +29,15 @@ import {
   ResponseConfig,
   ResponseStream,
   ResponseContract,
+  RedirectContract,
   ResponseContentType,
 } from '@ioc:Adonis/Core/Response'
 
+import { RouterContract } from '@ioc:Adonis/Core/Route'
 import { EncryptionContract } from '@ioc:Adonis/Core/Encryption'
 import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext'
 
+import { Redirect } from '../Redirect'
 import { CookieSerializer } from '../Cookie/Serializer'
 
 /**
@@ -136,6 +137,7 @@ export class Response extends Macroable implements ResponseContract {
     public response: ServerResponse,
     private encryption: EncryptionContract,
     private config: ResponseConfig,
+    private router: RouterContract
   ) {
     super()
   }
@@ -821,24 +823,37 @@ export class Response extends Macroable implements ResponseContract {
   }
 
   /**
-   * Redirect request to a different URL. Current request `query string` can be forwared
-   * by setting 2nd param to `true`.
+   * Redirect the request.
+   *
+   * @example
+   * ```js
+   * response.redirect('/foo')
+   * response.redirect().toRoute('foo.bar')
+   * response.redirect().back()
+   * ```
    */
+  public redirect (): RedirectContract
+  public redirect (path: string, forwardQueryString?: boolean, statusCode?: number): void
   public redirect (
-    url: string,
-    sendQueryParams?: boolean,
-    statusCode: number = 302,
-  ): void {
-    url = url === 'back'
-      ? (this.request.headers['referer'] || this.request.headers['referrer'] || '/') as string
-      : url
-
-    const { query } = parse(this.request.url!, false)
-    url = sendQueryParams && query ? `${url}?${query}` : url
-    this.location(encodeurl(url))
-    this.safeStatus(statusCode || 302)
-    this.type('text/plain; charset=utf-8')
-    this.send(`Redirecting to ${url}`)
+    path?: string,
+    forwardQueryString: boolean = false,
+    statusCode: number = 302
+  ): RedirectContract | void {
+    const handler = new Redirect(this.request, this, this.router)
+
+    if (forwardQueryString) {
+      handler.withQs()
+    }
+
+    if (path === 'back') {
+      return handler.status(statusCode).back()
+    }
+
+    if (path) {
+      return handler.status(statusCode).toPath(path)
+    }
+
+    return handler
   }
 
   /**

src/Response/index.ts

@@ -153,7 +153,7 @@ export class Server implements ServerContract {
     }
 
     const request = new Request(req, res, this.encryption, this.httpConfig)
-    const response = new Response(req, res, this.encryption, this.httpConfig)
+    const response = new Response(req, res, this.encryption, this.httpConfig, this.router)
 
     const requestAction = this.getProfilerRow(request)
     const ctx = this.getContext(request, response, requestAction)