@athenna/http 1.7.7 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/http",
-  "version": "1.7.7",
+  "version": "1.8.0",
   "description": "The Athenna Http server. Built on top of fastify.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -54,14 +54,17 @@
     "#tests/*": "./tests/*.js"
   },
   "dependencies": {
-    "@athenna/artisan": "1.5.8",
-    "@athenna/config": "1.1.9",
-    "@athenna/ioc": "1.2.8",
-    "@athenna/logger": "1.3.6",
-    "@athenna/common": "1.0.0",
-    "fastify": "3.27.4",
-    "fastify-cors": "6.0.3",
-    "fastify-rate-limit": "5.8.0"
+    "@athenna/artisan": "1.5.9",
+    "@athenna/common": "1.0.1",
+    "@athenna/config": "1.2.0",
+    "@athenna/ioc": "1.2.9",
+    "@athenna/logger": "1.3.7",
+    "@fastify/cors": "8.1.1",
+    "@fastify/helmet": "10.0.2",
+    "@fastify/rate-limit": "7.5.0",
+    "@fastify/swagger": "8.1.0",
+    "@fastify/swagger-ui": "1.1.0",
+    "fastify": "4.9.2"
   },
   "devDependencies": {
     "@japa/assert": "1.3.4",

package/src/Context/Response.js

@@ -35,6 +35,28 @@ export class Response {
     this.#response.send(data)
   }
 
+  /**
+   * Terminate the request sending the response body.
+   *
+   * @param {any} [data]
+   * @return {void}
+   */
+  json(data) {
+    this.#response.send(data)
+  }
+
+  /**
+   * Apply helmet in response.
+   *
+   * @param {import('@fastify/helmet').FastifyHelmetOptions} [options]
+   * @return {void}
+   */
+  async helmet(options) {
+    await this.#response.helmet(options)
+
+    return this
+  }
+
   /**
    * Set the response status code.
    *

package/src/Handlers/FastifyHandler.js

@@ -25,25 +25,27 @@ export class FastifyHandler {
 
       if (!req.data) req.data = {}
 
-      let body = payload
+      const isJson = Is.Json(payload)
 
-      if (Is.Json(payload)) {
-        body = JSON.parse(body)
+      if (isJson) {
+        payload = JSON.parse(payload)
       }
 
-      body = await handler({
+      payload = await handler({
         request,
         response,
-        body,
+        body: payload,
         status: res.statusCode,
         params: req.params,
         queries: req.query,
         data: req.data,
       })
 
-      if (Is.Object(body)) body = JSON.stringify(body)
+      if (isJson) {
+        payload = JSON.stringify(payload)
+      }
 
-      return body
+      return payload
     }
   }
 
@@ -54,7 +56,7 @@ export class FastifyHandler {
    * @return {any}
    */
   static createDoneHandler(handler) {
-    return (req, res, done) => {
+    return async (req, res) => {
       const request = new Request(req)
       const response = new Response(res)
 
@@ -66,7 +68,6 @@ export class FastifyHandler {
         params: req.params,
         queries: req.query,
         data: req.data,
-        next: done,
       })
     }
   }
@@ -78,7 +79,7 @@ export class FastifyHandler {
    * @return {any}
    */
   static createOnResponseHandler(handler) {
-    return (req, res, done) => {
+    return async (req, res) => {
       const request = new Request(req)
       const response = new Response(res)
 
@@ -94,7 +95,6 @@ export class FastifyHandler {
         headers: res.getHeaders(),
         status: res.statusCode,
         responseTime: res.getResponseTime(),
-        next: done,
       })
     }
   }
@@ -106,7 +106,7 @@ export class FastifyHandler {
    * @return {any}
    */
   static createErrorHandler(handler) {
-    return (error, req, res) => {
+    return async (error, req, res) => {
       const request = new Request(req)
       const response = new Response(res)
 

package/src/Handlers/HttpExceptionHandler.js

@@ -52,7 +52,7 @@ export class HttpExceptionHandler {
     }
 
     const isInternalServerError = statusCode === 500
-    const isDebugMode = Config.get('app.debug')
+    const isDebugMode = Config.get('app.debug', false)
 
     if (isInternalServerError && !isDebugMode) {
       body.name = 'Internal server error'
@@ -61,15 +61,15 @@ export class HttpExceptionHandler {
       delete body.stack
     }
 
+    response.status(statusCode).send(body)
+
     if (
       this.ignoreCodes.includes(code) ||
       this.ignoreStatuses.includes(statusCode)
     ) {
-      return response.status(statusCode).send(body)
+      return
     }
 
-    response.status(statusCode).send(body)
-
     if (error.prettify) {
       const prettyError = await error.prettify()
 
@@ -80,7 +80,7 @@ export class HttpExceptionHandler {
 
     const exception = new Exception(body.message, body.statusCode, body.code)
 
-    exception.stack = body.stack
+    exception.stack = error.stack
 
     const prettyError = await exception.prettify()
 

package/src/Kernels/HttpKernel.js

@@ -97,7 +97,33 @@ export class HttpKernel {
       return
     }
 
-    Server.registerCors(Config.get('http.cors'))
+    await Server.registerCors(Config.get('http.cors'))
+  }
+
+  /**
+   * Register helmet plugin.
+   *
+   * @return {Promise<void>}
+   */
+  async registerHelmet() {
+    if (Config.get('http.noHelmet')) {
+      return
+    }
+
+    await Server.registerHelmet(Config.get('http.helmet'))
+  }
+
+  /**
+   * Register swagger plugin.
+   *
+   * @return {Promise<void>}
+   */
+  async registerSwagger() {
+    if (Config.get('http.noSwagger')) {
+      return
+    }
+
+    await Server.registerSwagger(Config.get('http.swagger'))
   }
 
   /**
@@ -110,7 +136,7 @@ export class HttpKernel {
       return
     }
 
-    Server.registerRateLimit(Config.get('http.rateLimit'))
+    await Server.registerRateLimit(Config.get('http.rateLimit'))
   }
 
   /**
@@ -142,8 +168,6 @@ export class HttpKernel {
 
     Server.use(async ctx => {
       await Log.channel('request').info(ctx)
-
-      return ctx.next()
     }, 'terminate')
   }
 
@@ -159,8 +183,6 @@ export class HttpKernel {
 
     Server.use(async ctx => {
       ctx.data.requestId = Uuid.generate('ath')
-
-      return ctx.next()
     }, 'handle')
   }
 }

package/src/Router/Route.js

@@ -7,7 +7,7 @@
  * file that was distributed with this source code.
  */
 
-import { Is } from '@athenna/common'
+import { Is, Options, Route as RouteHelper } from '@athenna/common'
 import { removeSlashes } from '#src/Utils/removeSlashes'
 import { isMiddlewareContract } from '#src/Utils/isMiddlewareContract'
 import { UndefinedMethodException } from '#src/Exceptions/UndefinedMethodException'
@@ -62,6 +62,20 @@ export class Route {
    */
   #prefixes
 
+  /**
+   * Helmet options of this route.
+   *
+   * @type {any}
+   */
+  #helmetOptions
+
+  /**
+   * Swagger options of this route.
+   *
+   * @type {any}
+   */
+  #swaggerOptions
+
   /**
    * Creates a new instance of Route.
    *
@@ -79,6 +93,11 @@ export class Route {
     this.#handler = handler
     this.#routeMiddlewares = { handlers: [], terminators: [], interceptors: [] }
 
+    this.#helmetOptions = {}
+    this.#swaggerOptions = {}
+
+    RouteHelper.getParamsName(url).forEach(param => this.param(param))
+
     if (name) {
       this.name = name
     }
@@ -164,11 +183,174 @@ export class Route {
     return this
   }
 
+  /**
+   * Set up all helmet options for route.
+   *
+   * @param {any} options
+   * @param {boolean} [override]
+   * @return {Route}
+   */
+  helmet(options, override = true) {
+    if (!override) {
+      this.#helmetOptions = Options.create(this.#helmetOptions, options)
+
+      return this
+    }
+
+    this.#helmetOptions = options
+
+    return this
+  }
+
+  /**
+   * Set up all swagger options for route.
+   *
+   * @param {any} options
+   * @param {boolean} [override]
+   * @return {Route}
+   */
+  swagger(options, override = true) {
+    if (!override) {
+      this.#swaggerOptions = Options.create(this.#swaggerOptions, options)
+
+      return this
+    }
+
+    this.#swaggerOptions = options
+
+    return this
+  }
+
+  /**
+   * Set a summary for the route swagger docs.
+   *
+   * @param {string} summary
+   * @return {Route}
+   */
+  summary(summary) {
+    this.#swaggerOptions.summary = summary
+
+    return this
+  }
+
+  /**
+   * Set a description for the route swagger docs.
+   *
+   * @param {string} description
+   * @return {Route}
+   */
+  description(description) {
+    this.#swaggerOptions.description = description
+
+    return this
+  }
+
+  /**
+   * Set tags for the route swagger docs.
+   *
+   * @param {string} tags
+   * @return {Route}
+   */
+  tags(...tags) {
+    if (!this.#swaggerOptions.tags) {
+      this.#swaggerOptions.tags = []
+    }
+
+    tags.forEach(tag => this.#swaggerOptions.tags.push(tag))
+
+    return this
+  }
+
+  /**
+   * Set body param for the route swagger docs.
+   *
+   * @param {string} name
+   * @param {string} [type]
+   * @param {string} [description]
+   * @return {Route}
+   */
+  body(name, type = 'string', description = '') {
+    if (!this.#swaggerOptions.body) {
+      this.#swaggerOptions.body = {}
+      this.#swaggerOptions.body.type = 'object'
+      this.#swaggerOptions.body.properties = {}
+    }
+
+    this.#swaggerOptions.body.properties[name] = { type, description }
+
+    return this
+  }
+
+  /**
+   * Set param for the route swagger docs.
+   *
+   * @param {string} name
+   * @param {string} [type]
+   * @param {string} [description]
+   * @return {Route}
+   */
+  param(name, type = 'string', description = '') {
+    if (!this.#swaggerOptions.params) {
+      this.#swaggerOptions.params = {}
+      this.#swaggerOptions.params.type = 'object'
+      this.#swaggerOptions.params.properties = {}
+    }
+
+    this.#swaggerOptions.params.properties[name] = { type, description }
+
+    return this
+  }
+
+  /**
+   * Set query string for the route swagger docs.
+   *
+   * @param {string} name
+   * @param {string} [type]
+   * @param {string} [description]
+   * @return {Route}
+   */
+  queryString(name, type = 'string', description = '') {
+    if (!this.#swaggerOptions.queryString) {
+      this.#swaggerOptions.querystring = {}
+      this.#swaggerOptions.querystring.type = 'object'
+      this.#swaggerOptions.querystring.properties = {}
+    }
+
+    this.#swaggerOptions.querystring.properties[name] = { type, description }
+
+    return this
+  }
+
+  /**
+   * Set response for the route swagger docs.
+   *
+   * @param {number|any} statusCode
+   * @param {any} [response]
+   * @return {Route}
+   */
+  response(statusCode, response) {
+    if (!this.#swaggerOptions.response) {
+      this.#swaggerOptions.response = {}
+    }
+
+    if (!response) {
+      this.#swaggerOptions.response.default = response
+
+      return this
+    }
+
+    this.#swaggerOptions.response[statusCode] = response
+
+    return this
+  }
+
   toJSON() {
     const json = {
       url: this.#getUrl(),
       methods: this.#methods,
       middlewares: this.#routeMiddlewares,
+      helmetOptions: this.#helmetOptions,
+      swaggerOptions: this.#swaggerOptions,
     }
 
     if (Is.String(this.#handler)) {

package/src/Router/RouteGroup.js

@@ -13,14 +13,14 @@ export class RouteGroup {
   /**
    * All routes registered in the group.
    *
-   * @type {(import('./Route.js').Route | RouteResource | RouteGroup)[]}
+   * @type {(Route | RouteResource | RouteGroup)[]}
    */
   routes
 
   /**
    * Creates a new instance of RouteGroup.
    *
-   * @param {(import('./Route.js').Route | RouteResource | RouteGroup)[]} routes
+   * @param {(Route | RouteResource | RouteGroup)[]} routes
    */
   constructor(routes) {
     this.routes = routes
@@ -54,6 +54,34 @@ export class RouteGroup {
     return this
   }
 
+  /**
+   * Set up helmet options for route group.
+   *
+   * @param {any} options
+   * @return {RouteGroup}
+   */
+  helmet(options) {
+    this.routes.forEach(route => {
+      this.#invoke(route, 'helmet', [options, false])
+    })
+
+    return this
+  }
+
+  /**
+   * Set up swagger options for route group.
+   *
+   * @param {any} options
+   * @return {RouteGroup}
+   */
+  swagger(options) {
+    this.routes.forEach(route => {
+      this.#invoke(route, 'swagger', [options, false])
+    })
+
+    return this
+  }
+
   /**
    * Invoke a method from route.
    *

package/src/Router/RouteResource.js

@@ -76,10 +76,10 @@ export class RouteResource {
   /**
    * Register only the methods in the array.
    *
-   * @param {string[]} names
+   * @param {string} names
    * @return {RouteResource}
    */
-  only(names) {
+  only(...names) {
     this.#filter(names, true).forEach(route => (route.deleted = true))
 
     return this
@@ -88,22 +88,76 @@ export class RouteResource {
   /**
    * Register all methods except the methods in the array.
    *
-   * @param {string[]} names
+   * @param {string} names
    * @return {RouteResource}
    */
-  except(names) {
+  except(...names) {
     this.#filter(names, false).forEach(route => (route.deleted = true))
 
     return this
   }
 
+  /**
+   * Set up helmet options for route resource.
+   *
+   * @param {string|any} action
+   * @param {any} [options]
+   * @return {RouteResource}
+   */
+  helmet(action, options) {
+    if (!options) {
+      this.routes.forEach(route => route.helmet(options))
+
+      return this
+    }
+
+    const resourceName = `${this.#resourceName}.${action}`
+
+    this.routes.forEach(route => {
+      if (route.name !== resourceName) {
+        return
+      }
+
+      route.helmet(options)
+    })
+
+    return this
+  }
+
+  /**
+   * Set up swagger options for route resource method.
+   *
+   * @param {string|any} action
+   * @param {any} [options]
+   * @return {RouteResource}
+   */
+  swagger(action, options) {
+    if (!options) {
+      this.routes.forEach(route => route.swagger(options))
+
+      return this
+    }
+
+    const resourceName = `${this.#resourceName}.${action}`
+
+    this.routes.forEach(route => {
+      if (route.name !== resourceName) {
+        return
+      }
+
+      route.swagger(options)
+    })
+
+    return this
+  }
+
   /**
    * Create the route.
    *
    * @param {string} url
    * @param {string[]} methods
    * @param {string} action
-   * return {void}
+   * @return {void}
    */
   #makeRoute(url, methods, action) {
     let handler = ''

package/src/Router/Router.js

@@ -91,6 +91,17 @@ export class Router {
     return route
   }
 
+  /**
+   * Register a new vanila route using fastify options
+   * directly.
+   *
+   * @param {import('fastify').RouteOptions} options
+   * @return {void}
+   */
+  vanilaRoute(options) {
+    Server.getFastify().route(options)
+  }
+
   /**
    * Creates a new route group.
    *
@@ -256,6 +267,10 @@ export class Router {
           route.url,
           route.handler,
           route.middlewares,
+          {
+            helmet: route.helmetOptions,
+            schema: route.swaggerOptions,
+          },
         )
       })
     })

package/src/index.d.ts

@@ -8,12 +8,34 @@
  */
 
 import { Facade } from '@athenna/ioc'
-import { FastifyReply, FastifyRequest } from 'fastify'
 import { Exception } from '@athenna/common'
+import { OpenAPIV2, OpenAPIV3 } from 'openapi-types'
+import { FastifyHelmetOptions } from '@fastify/helmet'
+import { FastifyReply, FastifyRequest, RouteOptions } from 'fastify'
 
 export const Server: Facade & Http
 export const Route: Facade & Router.Router
 
+interface FastifySwaggerSchema {
+  hide?: boolean
+  deprecated?: boolean
+  tags?: string[]
+  description?: string
+  summary?: string
+  body?: any
+  response?: any
+  consumes?: string[]
+  produces?: string[]
+  externalDocs?:
+    | OpenAPIV2.ExternalDocumentationObject
+    | OpenAPIV3.ExternalDocumentationObject
+  security?: Array<{ [securityLabel: string]: string[] }>
+  /**
+   * OpenAPI operation unique identifier
+   */
+  operationId?: string
+}
+
 export class HttpKernel {
   /**
    * The application's global HTTP middlewares.
@@ -47,6 +69,20 @@ export class HttpKernel {
    */
   registerCors(): Promise<void>
 
+  /**
+   * Register helmet plugin.
+   *
+   * @return {Promise<void>}
+   */
+  registerHelmet(): Promise<void>
+
+  /**
+   * Register swagger plugin.
+   *
+   * @return {Promise<void>}
+   */
+  registerSwagger(): Promise<void>
+
   /**
    * Register rate limit plugin.
    *
@@ -127,19 +163,35 @@ export class Http {
   /**
    * Register the cors plugin to fastify server.
    *
-   * @param {import('fastify-cors').FastifyCorsOptions} [options]
+   * @param {import('@fastify/cors').FastifyCorsOptions} [options]
    * @return {Http}
    */
-  registerCors(options?: import('fastify-cors').FastifyCorsOptions): Http
+  registerCors(options?: import('@fastify/cors').FastifyCorsOptions): Http
+
+  /**
+   * Register the helmet plugin to fastify server.
+   *
+   * @param {import('@fastify/helmet').FastifyHelmetOptions} [options]
+   * @return {Http}
+   */
+  registerHelmet(options?: import('@fastify/helmet').FastifyHelmetOptions): Http
+
+  /**
+   * Register the swagger plugin to fastify server.
+   *
+   * @param {import('@fastify/swagger').SwaggerOptions} [options]
+   * @return {Http}
+   */
+  registerSwagger(options?: import('@fastify/swagger').SwaggerOptions): Http
 
   /**
    * Register the rate limit plugin to fastify server.
    *
-   * @param {import('fastify-rate-limit').RateLimitPluginOptions} [options]
+   * @param {import('@fastify/rate-limit').RateLimitOptions} [options]
    * @return {Http}
    */
   registerRateLimit(
-    options?: import('fastify-rate-limit').RateLimitPluginOptions,
+    options?: import('@fastify/rate-limit').RateLimitOptions,
   ): Http
 
   /**
@@ -322,6 +374,93 @@ declare module Router {
       prepend?: boolean,
     ): this
 
+    /**
+     * Set up all helmet options for route.
+     *
+     * @param {any} options
+     * @return {Route}
+     */
+    helmet(options: FastifyHelmetOptions): this
+
+    /**
+     * Set up all swagger options for route.
+     *
+     * @param {any} options
+     * @return {Route}
+     */
+    swagger(options: FastifySwaggerSchema): this
+
+    /**
+     * Set a summary for the route swagger docs.
+     *
+     * @param {string} summary
+     * @return {Route}
+     */
+    summary(summary: string): this
+
+    /**
+     * Set a description for the route swagger docs.
+     *
+     * @param {string} description
+     * @return {Route}
+     */
+    description(description: string): this
+
+    /**
+     * Set tags for the route swagger docs.
+     *
+     * @param {string} tags
+     * @return {Route}
+     */
+    tags(...tags: string[]): this
+
+    /**
+     * Set body param for the route swagger docs.
+     *
+     * @param {string} name
+     * @param {string} [type]
+     * @param {string} [description]
+     * @return {Route}
+     */
+    body(name: string, type?: string, description?: string): Route
+
+    /**
+     * Set param for the route swagger docs.
+     *
+     * @param {string} name
+     * @param {string} [type]
+     * @param {string} [description]
+     * @return {Route}
+     */
+    param(name, type?: string, description?: string): Route
+
+    /**
+     * Set query string for the route swagger docs.
+     *
+     * @param {string} name
+     * @param {string} [type]
+     * @param {string} [description]
+     * @return {Route}
+     */
+    queryString(name, type?: string, description?: string): Route
+
+    /**
+     * Set response for the route swagger docs.
+     *
+     * @param {any} response
+     * @return {Route}
+     */
+    response(response: any): this
+
+    /**
+     * Set response for the route swagger docs.
+     *
+     * @param {number} statusCode
+     * @param {any} response
+     * @return {Route}
+     */
+    response(statusCode: number, response: any): this
+
     toJSON(): any
   }
 
@@ -360,9 +499,57 @@ declare module Router {
       prepend?: boolean,
     ): this
 
+    /**
+     * Register only the methods in the array.
+     *
+     * @param {string} names
+     * @return {RouteResource}
+     */
     only(names: string[]): this
+    only(...names: string[]): this
 
+    /**
+     * Register all methods except the methods in the array.
+     *
+     * @param {string} names
+     * @return {RouteResource}
+     */
     except(names: string[]): this
+    except(...names: string[]): this
+
+    /**
+     * Set up helmet options for route resource.
+     *
+     * @param {FastifyHelmetOptions} options
+     * @return {RouteResource}
+     */
+    helmet(options: FastifyHelmetOptions): this
+
+    /**
+     * Set up helmet options for route resource.
+     *
+     * @param {string} action
+     * @param {FastifyHelmetOptions} options
+     * @return {RouteResource}
+     */
+    helmet(action: string, options: FastifyHelmetOptions): this
+
+    /**
+     * Set up swagger options for route resource method.
+     *
+     * @param {FastifySwaggerSchema} options
+     * @return {RouteResource}
+     */
+    swagger(options: FastifySwaggerSchema): this
+
+    /**
+     * Set up swagger options for route resource method.
+     *
+     * @param {string} action
+     * @param {FastifySwaggerSchema} options
+     * @return {RouteResource}
+     */
+    swagger(action: string, options: FastifySwaggerSchema): this
   }
 
   export class RouteGroup {
@@ -401,6 +588,22 @@ declare module Router {
       type?: 'terminate',
       prepend?: boolean,
     ): this
+
+    /**
+     * Set up helmet options for route group.
+     *
+     * @param {any} options
+     * @return {RouteGroup}
+     */
+    helmet(options: FastifyHelmetOptions): this
+
+    /**
+     * Set up swagger options for route group.
+     *
+     * @param {any} options
+     * @return {RouteGroup}
+     */
+    swagger(options: FastifySwaggerSchema): this
   }
 
   export class Router {
@@ -433,6 +636,15 @@ declare module Router {
       handler: string | HandlerContract,
     ): Route
 
+    /**
+     * Register a new vanila route using fastify options
+     * directly.
+     *
+     * @param {import('fastify').RouteOptions} options
+     * @return {void}
+     */
+    vanilaRoute(options: RouteOptions): void
+
     /**
      * Creates a new route group.
      *
@@ -549,44 +761,192 @@ declare module Router {
 }
 
 export interface RequestContract {
-  ip: string
-  method: string
-  hostUrl: string
-  baseUrl: string
-  originalUrl: string
-  body: any
-  params: any
-  queries: any
-  headers: any
+  /**
+   * Get the request ip.
+   *
+   * @return {string}
+   */
+  get ip(): string
+  /**
+   * Get the request method.
+   *
+   * @return {string}
+   */
+  get method(): string
 
-  param(param: string, defaultValue?: string): string | undefined
+  /**
+   * Get the host url from request.
+   *
+   * @return {string}
+   */
+  get hostUrl(): string
 
-  query(query: string, defaultValue?: string): string | undefined
+  /**
+   * Get the base request url.
+   *
+   * @return {string}
+   */
+  get baseUrl(): string
+
+  /**
+   * Get the original request url.
+   *
+   * @return {string}
+   */
+  get originalUrl(): string
+
+  /**
+   * Get all body from request.
+   *
+   * @return {any}
+   */
+  get body(): any
+
+  /**
+   * Get all params from request.
+   *
+   * @return {any}
+   */
+  get params(): any
+
+  /**
+   * Get all queries from request.
+   *
+   * @return {any}
+   */
+  get queries(): any
+
+  /**
+   * Get all headers from request.
+   *
+   * @return {any}
+   */
+  get headers(): any
+
+  /**
+   * Get a value from the request params or the default value.
+   *
+   * @param {string} param
+   * @param {string} [defaultValue]
+   * @return {any}
+   */
+  param(param, defaultValue): any
 
-  header(header: string, defaultValue?: string): string | string[] | undefined
+  /**
+   * Get a value from the request query param or the default value.
+   *
+   * @param {string} query
+   * @param {string} [defaultValue]
+   * @return {any}
+   */
+  query(query, defaultValue): any
 
-  payload(payload: string, defaultValue?: string): any | undefined
+  /**
+   * Get a value from the request header or the default value.
+   *
+   * @param {string} header
+   * @param {string} [defaultValue]
+   * @return {any}
+   */
+  header(header, defaultValue): any
 
+  /**
+   * Get a value from the request body or the default value.
+   *
+   * @param {string} payload
+   * @param {string} [defaultValue]
+   * @return {any}
+   */
+  payload(payload, defaultValue): any
+  /**
+   * Get the default fastify request object.
+   *
+   * @return {import('fastify').FastifyRequest}
+   */
   getFastifyRequest(): FastifyRequest
 }
 
 export interface ResponseContract {
-  send(data?: any): Promise<void> | void
+  /**
+   * Terminate the request sending the response body.
+   *
+   * @param {any} [data]
+   * @return {void}
+   */
+  send(data?: any): Promise<void>
 
-  json(data?: any): Promise<void> | void
+  /**
+   * Terminate the request sending the response body.
+   *
+   * @param {any} [data]
+   * @return {void}
+   */
+  json(data?: any): Promise<void>
 
+  /**
+   * Apply helmet in response.
+   *
+   * @param {import('@fastify/helmet').FastifyHelmetOptions} [options]
+   * @return {void}
+   */
+  helmet(options?: FastifyHelmetOptions): Promise<void>
+
+  /**
+   * Set the response status code.
+   *
+   * @param {number} code
+   * @return {Response}
+   */
   status(code: number): this
 
+  /**
+   * Remove some header from the response.
+   *
+   * @param {string} header
+   * @return {Response}
+   */
   removeHeader(header: string): this
 
+  /**
+   * Add some header to the response.
+   *
+   * @param {string} header
+   * @param {any} value
+   * @return {Response}
+   */
   header(header: string, value: any): this
 
+  /**
+   * Only add some header to the response if it's not defined yet.
+   *
+   * @param {string} header
+   * @param {any} value
+   * @return {Response}
+   */
   safeHeader(header: string, value: any): this
 
+  /**
+   * Redirect the response to other url with different status code.
+   *
+   * @param {string} url
+   * @return {void}
+   */
   redirectTo(url: string): Promise<void> | void
 
-  redirectTo(url: string, statusCode: number): Promise<void> | void
+  /**
+   * Redirect the response to other url with different status code.
+   *
+   * @param {string} url
+   * @param {number} statusCode
+   * @return {void}
+   */
+  redirectTo(url: string, statusCode: number): Promise<void>
 
+  /**
+   * Get the default fastify response object.
+   *
+   * @return {import('fastify').FastifyReply}
+   */
   getFastifyResponse(): FastifyReply
 }
 
@@ -606,10 +966,6 @@ export class HttpLoader {
   static loadTemplates(): any[]
 }
 
-export interface NextContract {
-  (...params: any[]): void
-}
-
 export interface ContextContract {
   request: RequestContract
   response: ResponseContract
@@ -633,7 +989,6 @@ export interface HandleContextContract {
   data: any
   params: any
   queries: any
-  next: NextContract
 }
 
 export interface InterceptContextContract {
@@ -656,7 +1011,6 @@ export interface TerminateContextContract {
   headers: any
   status: number
   responseTime: number
-  next: NextContract
 }
 
 export interface ErrorHandlerContract {

package/src/index.js

@@ -10,8 +10,7 @@
 import { Options } from '@athenna/common'
 
 import fastify from 'fastify'
-import fastifyCors from 'fastify-cors'
-import fastifyRateLimit from 'fastify-rate-limit'
+
 import { FastifyHandler } from '#src/Handlers/FastifyHandler'
 
 export * from './Facades/Route.js'
@@ -82,12 +81,12 @@ export class Http {
   /**
    * Register a new fastify plugin.
    *
-   * @param {import('fastify').FastifyPluginCallback<import('fastify').FastifyPluginOptions>} plugin
-   * @param {import('fastify').FastifyRegisterOptions<import('fastify').FastifyPluginOptions>} [options]
+   * @param {any} plugin
+   * @param {any} [options]
    * @return {Http}
    */
-  register(plugin, options) {
-    this.#server.register(plugin, options)
+  async register(plugin, options = {}) {
+    await this.#server.register(plugin, options)
 
     return this
   }
@@ -95,25 +94,46 @@ export class Http {
   /**
    * Register the cors plugin to fastify server.
    *
-   * @param {import('fastify-cors').FastifyCorsOptions} [options]
+   * @param {import('@fastify/cors').FastifyCorsOptions} [options]
    * @return {Http}
    */
-  registerCors(options) {
-    this.register(fastifyCors, options)
+  async registerCors(options) {
+    return this.register(import('@fastify/cors'), options)
+  }
 
-    return this
+  /**
+   * Register the helmet plugin to fastify server.
+   *
+   * @param {import('@fastify/helmet').FastifyHelmetOptions} [options]
+   * @return {Http}
+   */
+  async registerHelmet(options) {
+    return this.register(import('@fastify/helmet'), options)
   }
 
   /**
-   * Register the rate limit plugin to fastify server.
+   * Register the swagger plugin to fastify server.
    *
-   * @param {import('fastify-rate-limit').RateLimitPluginOptions} [options]
+   * @param {{
+   *    ui: import('@fastify/swagger-ui').FastifySwaggerUiOptions,
+   *    configurations: import('@fastify/swagger').SwaggerOptions
+   *  }} [options]
    * @return {Http}
    */
-  registerRateLimit(options) {
-    this.register(fastifyRateLimit, options)
+  async registerSwagger(options = {}) {
+    await this.register(import('@fastify/swagger'), options.configurations)
 
-    return this
+    return this.register(import('@fastify/swagger-ui'), options.ui)
+  }
+
+  /**
+   * Register the rate limit plugin to fastify server.
+   *
+   * @param {import('@fastify/rate-limit').RateLimitOptions} [options]
+   * @return {Http}
+   */
+  async registerRateLimit(options) {
+    return this.register(import('@fastify/rate-limit'), options)
   }
 
   /**
@@ -186,7 +206,7 @@ export class Http {
   async listen(port = 1335, host = '0.0.0.0') {
     this.#isListening = true
 
-    return this.#server.listen(port, host)
+    return this.#server.listen({ port, host })
   }
 
   /**
@@ -209,9 +229,10 @@ export class Http {
    * @param {string[]} methods
    * @param {any} handler
    * @param {any} [middlewares]
+   * @param {import('fastify').RouteOptions} [otherOptions]
    * @return {void}
    */
-  route(url, methods, handler, middlewares) {
+  route(url, methods, handler, middlewares, otherOptions = {}) {
     const { handlers, terminators, interceptors } = Options.create(
       middlewares,
       {
@@ -230,6 +251,7 @@ export class Http {
       handler: FastifyHandler.createRequestHandler(handler),
       preHandler: handlers.map(m => FastifyHandler.createDoneHandler(m)),
       onSend: interceptors.map(m => FastifyHandler.createOnSendHandler(m)),
+      ...otherOptions,
     })
   }
 
@@ -239,10 +261,11 @@ export class Http {
    * @param {string} url
    * @param {any} handler
    * @param {any} [middlewares]
+   * @param {import('fastify').RouteOptions} [otherOptions]
    * @return {void}
    */
-  get(url, handler, middlewares) {
-    this.route(url, ['GET'], handler, middlewares)
+  get(url, handler, middlewares, otherOptions) {
+    this.route(url, ['GET'], handler, middlewares, otherOptions)
   }
 
   /**
@@ -251,10 +274,11 @@ export class Http {
    * @param {string} url
    * @param {any} handler
    * @param {any} [middlewares]
+   * @param {import('fastify').RouteOptions} [otherOptions]
    * @return {void}
    */
-  head(url, handler, middlewares) {
-    this.route(url, ['HEAD'], handler, middlewares)
+  head(url, handler, middlewares, otherOptions) {
+    this.route(url, ['HEAD'], handler, middlewares, otherOptions)
   }
 
   /**
@@ -263,10 +287,11 @@ export class Http {
    * @param {string} url
    * @param {any} handler
    * @param {any} [middlewares]
+   * @param {import('fastify').RouteOptions} [otherOptions]
    * @return {void}
    */
-  post(url, handler, middlewares) {
-    this.route(url, ['POST'], handler, middlewares)
+  post(url, handler, middlewares, otherOptions) {
+    this.route(url, ['POST'], handler, middlewares, otherOptions)
   }
 
   /**
@@ -275,10 +300,11 @@ export class Http {
    * @param {string} url
    * @param {any} handler
    * @param {any} [middlewares]
+   * @param {import('fastify').RouteOptions} [otherOptions]
    * @return {void}
    */
-  put(url, handler, middlewares) {
-    this.route(url, ['PUT'], handler, middlewares)
+  put(url, handler, middlewares, otherOptions) {
+    this.route(url, ['PUT'], handler, middlewares, otherOptions)
   }
 
   /**
@@ -287,10 +313,11 @@ export class Http {
    * @param {string} url
    * @param {any} handler
    * @param {any} [middlewares]
+   * @param {import('fastify').RouteOptions} [otherOptions]
    * @return {void}
    */
-  patch(url, handler, middlewares) {
-    this.route(url, ['PATCH'], handler, middlewares)
+  patch(url, handler, middlewares, otherOptions) {
+    this.route(url, ['PATCH'], handler, middlewares, otherOptions)
   }
 
   /**
@@ -299,10 +326,11 @@ export class Http {
    * @param {string} url
    * @param {any} handler
    * @param {any} [middlewares]
+   * @param {import('fastify').RouteOptions} [otherOptions]
    * @return {void}
    */
-  delete(url, handler, middlewares) {
-    this.route(url, ['DELETE'], handler, middlewares)
+  delete(url, handler, middlewares, otherOptions) {
+    this.route(url, ['DELETE'], handler, middlewares, otherOptions)
   }
 
   /**
@@ -311,9 +339,10 @@ export class Http {
    * @param {string} url
    * @param {any} handler
    * @param {any} [middlewares]
+   * @param {import('fastify').RouteOptions} [otherOptions]
    * @return {void}
    */
-  options(url, handler, middlewares) {
-    this.route(url, ['OPTIONS'], handler, middlewares)
+  options(url, handler, middlewares, otherOptions) {
+    this.route(url, ['OPTIONS'], handler, middlewares, otherOptions)
   }
 }

package/templates/middleware.edge

@@ -10,16 +10,16 @@ export class {{ namePascal }} {
     * in your controller.
     *
     * @param {import('@athenna/http').HandleContextContract} ctx
+    * @return {Promise<void>}
     */
-    async handle({ next }) {
-      next()
-    }
+    async handle(ctx) {}
 
     /**
     * Intercept method is executed before the response
     * has been sent.
     *
     * @param {import('@athenna/http').InterceptContextContract} ctx
+    * @return {Promise<any>}
     */
     async intercept({ body }) {
       body.intercepted = true
@@ -32,9 +32,7 @@ export class {{ namePascal }} {
     * has been sent.
     *
     * @param {import('@athenna/http').TerminateContextContract} ctx
-    * @return any
+    * @return {Promise<void>}
     */
-    async terminate({ next }) {
-      next()
-    }
+    async terminate(ctx) {}
 }