@athenna/http 1.4.3 → 1.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/http",
-  "version": "1.4.3",
+  "version": "1.4.6",
   "description": "The Athenna Http server. Built on top of fastify.",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -30,7 +30,9 @@
     "src/*.js",
     "src/*.d.ts",
     "src/**/*.js",
-    "src/**/*.d.ts"
+    "src/**/*.d.ts",
+    "templates/*",
+    "templates/**/*"
   ],
   "type": "module",
   "main": "./src/index.js",
@@ -52,10 +54,10 @@
     "#tests/*": "./tests/*.js"
   },
   "dependencies": {
-    "@athenna/artisan": "1.2.7",
-    "@athenna/ioc": "1.2.0",
-    "@athenna/logger": "1.2.5",
-    "@secjs/utils": "1.9.4",
+    "@athenna/artisan": "1.2.9",
+    "@athenna/ioc": "1.2.2",
+    "@athenna/logger": "1.2.7",
+    "@secjs/utils": "1.9.7",
     "fastify": "3.27.4",
     "fastify-cors": "6.0.3",
     "fastify-rate-limit": "5.8.0"

package/src/Commands/Make/Controller.js

@@ -7,20 +7,27 @@
  * file that was distributed with this source code.
  */
 
-import { join } from 'node:path'
-import { Folder, Path, String } from '@secjs/utils'
+import { Path, String } from '@secjs/utils'
 import { Artisan, Command, TemplateHelper } from '@athenna/artisan'
 
 export class MakeController extends Command {
   /**
    * The name and signature of the console command.
+   *
+   * @return {string}
    */
-  signature = 'make:controller <name>'
+  get signature() {
+    return 'make:controller <name>'
+  }
 
   /**
    * The console command description.
+   *
+   * @return {string}
    */
-  description = 'Make a new controller file.'
+  get description() {
+    return 'Make a new controller file.'
+  }
 
   /**
    * Set additional flags in the commander instance.
@@ -45,10 +52,6 @@ export class MakeController extends Command {
    * @return {Promise<void>}
    */
   async handle(name, options) {
-    TemplateHelper.setTemplatesFolder(
-      new Folder(join(__dirname, '..', '..', '..', 'templates')).loadSync(),
-    )
-
     const resource = 'Controller'
     const subPath = Path.app(`Http/${String.pluralize(resource)}`)
 
@@ -66,7 +69,5 @@ export class MakeController extends Command {
     if (options.lint) {
       await Artisan.call(`eslint:fix ${file.path} --resource ${resource}`)
     }
-
-    TemplateHelper.setOriginalTemplatesFolder()
   }
 }

package/src/Commands/Make/Middleware.js

@@ -7,20 +7,27 @@
  * file that was distributed with this source code.
  */
 
-import { join } from 'node:path'
-import { Folder, Path, String } from '@secjs/utils'
+import { Path, String } from '@secjs/utils'
 import { Artisan, Command, TemplateHelper } from '@athenna/artisan'
 
 export class MakeMiddleware extends Command {
   /**
    * The name and signature of the console command.
+   *
+   * @return {string}
    */
-  signature = 'make:middleware <name>'
+  get signature() {
+    return 'make:middleware <name>'
+  }
 
   /**
    * The console command description.
+   *
+   * @return {string}
    */
-  description = 'Make a new middleware file.'
+  get description() {
+    return 'Make a new middleware file.'
+  }
 
   /**
    * Set additional flags in the commander instance.
@@ -47,10 +54,6 @@ export class MakeMiddleware extends Command {
    * @return {Promise<void>}
    */
   async handle(name, options) {
-    TemplateHelper.setTemplatesFolder(
-      new Folder(join(__dirname, '..', '..', '..', 'templates')).loadSync(),
-    )
-
     const resource = 'Middleware'
     const subPath = Path.app(`Http/${String.pluralize(resource)}`)
 
@@ -70,14 +73,12 @@ export class MakeMiddleware extends Command {
     }
 
     if (options.register) {
-      await TemplateHelper.replaceObjectProperty(
+      await TemplateHelper.replaceObjectGetter(
         Path.http('Kernel.js'),
-        'namedMiddlewares =',
+        'namedMiddlewares',
         file.name,
         `#app/Http/Middlewares/${file.name}`,
       )
     }
-
-    TemplateHelper.setOriginalTemplatesFolder()
   }
 }

package/src/Commands/Route/List.js

@@ -7,20 +7,29 @@
  * file that was distributed with this source code.
  */
 
-import { pathToFileURL } from 'node:url'
 import { Command } from '@athenna/artisan'
-import { Exec, Path, String } from '@secjs/utils'
+import { Module, Path, String } from '@secjs/utils'
+
+import { Route } from '#src/index'
 
 export class RouteList extends Command {
   /**
    * The name and signature of the console command.
+   *
+   * @return {string}
    */
-  signature = 'route:list'
+  get signature() {
+    return 'route:list'
+  }
 
   /**
    * The console command description.
+   *
+   * @return {string}
    */
-  description = 'List all the routes of your application.'
+  get description() {
+    return 'List all the routes of your application.'
+  }
 
   /**
    * Set additional flags in the commander instance.
@@ -46,11 +55,7 @@ export class RouteList extends Command {
   async handle(options) {
     this.simpleLog('[ ROUTE LISTING ]', 'rmNewLineStart', 'bold', 'green')
 
-    const Route = ioc.safeUse('Athenna/Core/HttpRoute')
-
-    const Kernel = await Exec.getModule(
-      import(pathToFileURL(Path.http('Kernel.js')).href),
-    )
+    const Kernel = await Module.getFrom(Path.http('Kernel.js'))
 
     const kernel = new Kernel()
 

package/src/Exceptions/BadGatewayException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class BadGatewayException extends HttpException {
+  /**
+   * Creates a new instance of BadGatewayException.
+   *
+   * @example
+   *  throw new BadGatewayException()
+   *  This exception uses the 502 status code and the "E_BAD_GATEWAY_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Bad gateway error',
+    code = 'E_BAD_GATEWAY_ERROR',
+    help = null,
+  ) {
+    super(content, 502, code, help)
+  }
+}

package/src/Exceptions/BadRequestException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class BadRequestException extends HttpException {
+  /**
+   * Creates a new instance of BadRequestException.
+   *
+   * @example
+   *  throw new BadRequestException()
+   *  This exception uses the 400 status code and the "E_BAD_REQUEST_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Bad request error',
+    code = 'E_BAD_REQUEST_ERROR',
+    help = null,
+  ) {
+    super(content, 400, code, help)
+  }
+}

package/src/Exceptions/ForbiddenException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class ForbiddenException extends HttpException {
+  /**
+   * Creates a new instance of ForbiddenException.
+   *
+   * @example
+   *  throw new ForbiddenException()
+   *  This exception uses the 403 status code and the "E_FORBIDDEN_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Forbidden error',
+    code = 'E_FORBIDDEN_ERROR',
+    help = null,
+  ) {
+    super(content, 403, code, help)
+  }
+}

package/src/Exceptions/HttpException.js

@@ -0,0 +1,33 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { Exception } from '@secjs/utils'
+
+export class HttpException extends Exception {
+  /**
+   * Creates a new instance of HttpException.
+   *
+   * @example
+   *  throw new HttpException()
+   *  This exception uses the 500 status code and the "E_HTTP_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {number} [status]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Http error',
+    status = 500,
+    code = 'E_HTTP_ERROR',
+    help = null,
+  ) {
+    super(content, status, code, help)
+  }
+}

package/src/Exceptions/InternalServerException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class InternalServerException extends HttpException {
+  /**
+   * Creates a new instance of InternalServerException.
+   *
+   * @example
+   *  throw new InternalServerException()
+   *  This exception uses the 500 status code and the "E_INTERNAL_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Internal server error',
+    code = 'E_INTERNAL_ERROR',
+    help = null,
+  ) {
+    super(content, 500, code, help)
+  }
+}

package/src/Exceptions/MethodNotAllowedException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class MethodNotAllowedException extends HttpException {
+  /**
+   * Creates a new instance of MethodNotAllowedException.
+   *
+   * @example
+   *  throw new MethodNotAllowedException()
+   *  This exception uses the 405 status code and the "E_METHOD_NOT_ALLOWED_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Method not allowed error',
+    code = 'E_METHOD_NOT_ALLOWED_ERROR',
+    help = null,
+  ) {
+    super(content, 405, code, help)
+  }
+}

package/src/Exceptions/NotAcceptableException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class NotAcceptableException extends HttpException {
+  /**
+   * Creates a new instance of NotAcceptableException.
+   *
+   * @example
+   *  throw new NotAcceptableException()
+   *  This exception uses the 406 status code and the "E_NOT_ACCEPTABLE_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Not acceptable error',
+    code = 'E_NOT_ACCEPTABLE_ERROR',
+    help = null,
+  ) {
+    super(content, 406, code, help)
+  }
+}

package/src/Exceptions/NotFoundException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class NotFoundException extends HttpException {
+  /**
+   * Creates a new instance of NotFoundException.
+   *
+   * @example
+   *  throw new NotFoundException()
+   *  This exception uses the 404 status code and the "E_NOT_FOUND_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Not found error',
+    code = 'E_NOT_FOUND_ERROR',
+    help = null,
+  ) {
+    super(content, 404, code, help)
+  }
+}

package/src/Exceptions/NotImplementedException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class NotImplementedException extends HttpException {
+  /**
+   * Creates a new instance of NotImplementedException.
+   *
+   * @example
+   *  throw new NotImplementedException()
+   *  This exception uses the 501 status code and the "E_NOT_IMPLEMENTED_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Not implemented error',
+    code = 'E_NOT_IMPLEMENTED_ERROR',
+    help = null,
+  ) {
+    super(content, 501, code, help)
+  }
+}

package/src/Exceptions/PayloadTooLargeException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class PayloadTooLargeException extends HttpException {
+  /**
+   * Creates a new instance of PayloadTooLargeException.
+   *
+   * @example
+   *  throw new PayloadTooLargeException()
+   *  This exception uses the 413 status code and the "E_PAYLOAD_TOO_LARGE_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Payload too large error',
+    code = 'E_PAYLOAD_TOO_LARGE_ERROR',
+    help = null,
+  ) {
+    super(content, 413, code, help)
+  }
+}

package/src/Exceptions/RequestTimeoutException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class RequestTimeoutException extends HttpException {
+  /**
+   * Creates a new instance of RequestTimeoutException.
+   *
+   * @example
+   *  throw new RequestTimeoutException()
+   *  This exception uses the 408 status code and the "E_REQUEST_TIMEOUT_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Request timeout error',
+    code = 'E_REQUEST_TIMEOUT_ERROR',
+    help = null,
+  ) {
+    super(content, 408, code, help)
+  }
+}

package/src/Exceptions/ServiceUnavailableException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class ServiceUnavailableException extends HttpException {
+  /**
+   * Creates a new instance of ServiceUnavailableException.
+   *
+   * @example
+   *  throw new ServiceUnavailableException()
+   *  This exception uses the 503 status code and the "E_SERVICE_UNAVAILABLE_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Service unavailable error',
+    code = 'E_SERVICE_UNAVAILABLE_ERROR',
+    help = null,
+  ) {
+    super(content, 503, code, help)
+  }
+}

package/src/Exceptions/UnauthorizedException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class UnauthorizedException extends HttpException {
+  /**
+   * Creates a new instance of UnauthorizedException.
+   *
+   * @example
+   *  throw new UnauthorizedException()
+   *  This exception uses the 401 status code and the "E_UNAUTHORIZED_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Unauthorized error',
+    code = 'E_UNAUTHORIZED_ERROR',
+    help = null,
+  ) {
+    super(content, 401, code, help)
+  }
+}

package/src/Exceptions/UnprocessableEntityException.js

@@ -0,0 +1,31 @@
+/**
+ * @athenna/logger
+ *
+ * (c) João Lenon <lenon@athenna.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { HttpException } from '#src/Exceptions/HttpException'
+
+export class UnprocessableEntityException extends HttpException {
+  /**
+   * Creates a new instance of UnprocessableEntityException.
+   *
+   * @example
+   *  throw new UnprocessableEntityException()
+   *  This exception uses the 422 status code and the "E_UNPROCESSABLE_ENTITY_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(
+    content = 'Unprocessable entity error',
+    code = 'E_UNPROCESSABLE_ENTITY_ERROR',
+    help = null,
+  ) {
+    super(content, 422, code, help)
+  }
+}

package/src/Kernels/HttpKernel.js

@@ -1,8 +1,7 @@
 import { Log } from '@athenna/logger'
-import { Config, Exec, Path, Uuid } from '@secjs/utils'
+import { Config, Module, Path, Uuid } from '@secjs/utils'
 
 import { Server } from '#src/Facades/Server'
-import { pathToFileURL } from 'url'
 
 export class HttpKernel {
   /**
@@ -10,18 +9,22 @@ export class HttpKernel {
    *
    * This middlewares are run during every request to your http server.
    *
-   * @type {any | Promise<any>}
+   * @return {any[] | Promise<any[]>}
    */
-  globalMiddlewares
+  get globalMiddlewares() {
+    return []
+  }
 
   /**
    * The application's named HTTP middlewares.
    *
    * Here you define all your named middlewares to use inside routes/http file.
    *
-   * @type {Record<string, any | Promise<any>>}
+   * @return {Record<string, any | Promise<any>>}
    */
-  namedMiddlewares
+  get namedMiddlewares() {
+    return {}
+  }
 
   /**
    * Register all global and named middlewares to the server.
@@ -29,35 +32,36 @@ export class HttpKernel {
    * @return void
    */
   async registerMiddlewares() {
+    const subAlias = 'App/Http/Middlewares'
+
     /**
      * Binding the named middlewares inside the container and
      * creating a simple alias to use it inside Route.
      */
     for (const key of Object.keys(this.namedMiddlewares)) {
-      const Middleware = await Exec.getModule(this.namedMiddlewares[key])
+      const midModule = this.namedMiddlewares[key]
+
+      const { alias, module } = await Module.getWithAlias(midModule, subAlias)
 
-      if (!ioc.hasDependency(`App/Http/Middlewares/${Middleware.name}`)) {
-        ioc.bind(`App/Http/Middlewares/${Middleware.name}`, Middleware)
+      if (!ioc.hasDependency(alias)) {
+        ioc.bind(alias, module)
       }
 
-      ioc.alias(
-        `App/Http/Middlewares/Names/${key}`,
-        `App/Http/Middlewares/${Middleware.name}`,
-      )
+      ioc.alias(`App/Http/Middlewares/Names/${key}`, alias)
     }
 
     /**
      * Binding the global middlewares inside the container and
      * resolving it inside the Http server using "use" method.
      */
-    for (const module of this.globalMiddlewares) {
-      let Middleware = await Exec.getModule(module)
+    for (const midModule of this.globalMiddlewares) {
+      const { alias, module } = await Module.getWithAlias(midModule, subAlias)
 
-      if (!ioc.hasDependency(`App/Http/Middlewares/${Middleware.name}`)) {
-        ioc.bind(`App/Http/Middlewares/${Middleware.name}`, Middleware)
+      if (!ioc.hasDependency(alias)) {
+        ioc.bind(alias, module)
       }
 
-      Middleware = ioc.safeUse(`App/Http/Middlewares/${Middleware.name}`)
+      const Middleware = ioc.safeUse(alias)
 
       if (Middleware.handle) {
         Server.use(Middleware.handle, 'handle')
@@ -109,9 +113,8 @@ export class HttpKernel {
       return
     }
 
-    const path = Path.app(`Http/Exceptions/Handler.js`)
+    const Handler = await Module.getFrom(Path.http('Exceptions/Handler.js'))
 
-    const Handler = await Exec.getModule(import(pathToFileURL(path).href))
     const handler = new Handler()
 
     Server.setErrorHandler(handler.handle.bind(handler))

package/src/Providers/ControllerProvider.js

@@ -7,7 +7,7 @@
  * file that was distributed with this source code.
  */
 
-import { Exec, Folder, Path } from '@secjs/utils'
+import { Module, Path } from '@secjs/utils'
 import { ServiceProvider } from '@athenna/ioc'
 
 export class ControllerProvider extends ServiceProvider {
@@ -18,23 +18,12 @@ export class ControllerProvider extends ServiceProvider {
    */
   async boot() {
     const path = Path.app('Http/Controllers')
+    const subAlias = 'App/Http/Controllers'
 
-    if (!(await Folder.exists(path))) {
-      return
-    }
+    const controllers = await Module.getAllFromWithAlias(path, subAlias)
 
-    const controllers = (await new Folder(path).load()).getFilesByPattern(
-      '*/**/*.js',
-    )
-
-    const promises = controllers.map(({ href }) => {
-      return Exec.getModule(import(href)).then(Controller => {
-        const alias = `App/Http/Controllers/${Controller.name}`
-
-        this.container.singleton(alias, Controller)
-      })
+    controllers.forEach(({ alias, module }) => {
+      this.container.singleton(alias, module)
     })
-
-    await Promise.all(promises)
   }
 }

package/src/Providers/MiddlewareProvider.js

@@ -7,8 +7,8 @@
  * file that was distributed with this source code.
  */
 
+import { Module, Path } from '@secjs/utils'
 import { ServiceProvider } from '@athenna/ioc'
-import { Exec, Folder, Path } from '@secjs/utils'
 
 export class MiddlewareProvider extends ServiceProvider {
   /**
@@ -18,23 +18,12 @@ export class MiddlewareProvider extends ServiceProvider {
    */
   async boot() {
     const path = Path.app('Http/Middlewares')
+    const subAlias = 'App/Http/Middlewares'
 
-    if (!(await Folder.exists(path))) {
-      return
-    }
+    const middlewares = await Module.getAllFromWithAlias(path, subAlias)
 
-    const middlewares = (await new Folder(path).load()).getFilesByPattern(
-      '*/**/*.js',
-    )
-
-    const promises = middlewares.map(({ href }) => {
-      return Exec.getModule(import(href)).then(Middleware => {
-        const alias = `App/Http/Middlewares/${Middleware.name}`
-
-        this.container.singleton(alias, Middleware)
-      })
+    middlewares.forEach(({ alias, module }) => {
+      this.container.singleton(alias, module)
     })
-
-    await Promise.all(promises)
   }
 }

package/src/index.d.ts

@@ -9,6 +9,7 @@
 
 import { Facade } from '@athenna/ioc'
 import { FastifyReply, FastifyRequest } from 'fastify'
+import { Exception } from '@secjs/utils'
 
 export const Server: Facade & Http
 export const Route: Facade & Router.Router
@@ -665,3 +666,214 @@ export interface MiddlewareContract {
   intercept?: InterceptHandlerContract
   terminate?: TerminateHandlerContract
 }
+
+export class HttpException extends Exception {
+  /**
+   * Creates a new instance of HttpException.
+   *
+   * @example
+   *  throw new HttpException()
+   *  This exception uses the 500 status code and the "E_HTTP_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {number} [status]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, status?: number, code?: string, help?: string | null)
+}
+
+export class BadGatewayException extends Exception {
+  /**
+   * Creates a new instance of BadGatewayException.
+   *
+   * @example
+   *  throw new BadGatewayException()
+   *  This exception uses the 502 status code and the "E_BAD_GATEWAY_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class BadRequestException extends Exception {
+  /**
+   * Creates a new instance of BadRequestException.
+   *
+   * @example
+   *  throw new BadRequestException()
+   *  This exception uses the 400 status code and the "E_BAD_REQUEST_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class ForbiddenException extends Exception {
+  /**
+   * Creates a new instance of ForbiddenException.
+   *
+   * @example
+   *  throw new ForbiddenException()
+   *  This exception uses the 403 status code and the "E_FORBIDDEN_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class InternalServerException extends Exception {
+  /**
+   * Creates a new instance of InternalServerException.
+   *
+   * @example
+   *  throw new InternalServerException()
+   *  This exception uses the 500 status code and the "E_INTERNAL_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class MethodNotAllowedException extends Exception {
+  /**
+   * Creates a new instance of MethodNotAllowedException.
+   *
+   * @example
+   *  throw new MethodNotAllowedException()
+   *  This exception uses the 405 status code and the "E_METHOD_NOT_ALLOWED_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class NotAcceptableException extends Exception {
+  /**
+   * Creates a new instance of NotAcceptableException.
+   *
+   * @example
+   *  throw new NotAcceptableException()
+   *  This exception uses the 406 status code and the "E_NOT_ACCEPTABLE_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class NotFoundException extends Exception {
+  /**
+   * Creates a new instance of NotFoundException.
+   *
+   * @example
+   *  throw new NotFoundException()
+   *  This exception uses the 404 status code and the "E_NOT_FOUND_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class NotImplementedException extends Exception {
+  /**
+   * Creates a new instance of NotImplementedException.
+   *
+   * @example
+   *  throw new NotImplementedException()
+   *  This exception uses the 501 status code and the "E_NOT_IMPLEMENTED_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class PayloadTooLargeException extends Exception {
+  /**
+   * Creates a new instance of PayloadTooLargeException.
+   *
+   * @example
+   *  throw new PayloadTooLargeException()
+   *  This exception uses the 413 status code and the "E_PAYLOAD_TOO_LARGE_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class RequestTimeoutException extends Exception {
+  /**
+   * Creates a new instance of RequestTimeoutException.
+   *
+   * @example
+   *  throw new RequestTimeoutException()
+   *  This exception uses the 408 status code and the "E_REQUEST_TIMEOUT_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class ServiceUnavailableException extends Exception {
+  /**
+   * Creates a new instance of ServiceUnavailableException.
+   *
+   * @example
+   *  throw new ServiceUnavailableException()
+   *  This exception uses the 503 status code and the "E_SERVICE_UNAVAILABLE_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class UnauthorizedException extends Exception {
+  /**
+   * Creates a new instance of UnauthorizedException.
+   *
+   * @example
+   *  throw new UnauthorizedException()
+   *  This exception uses the 401 status code and the "E_UNAUTHORIZED_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}
+
+export class UnprocessableEntityException extends Exception {
+  /**
+   * Creates a new instance of UnprocessableEntityException.
+   *
+   * @example
+   *  throw new UnprocessableEntityException()
+   *  This exception uses the 422 status code and the "E_UNPROCESSABLE_ENTITY_ERROR" code.
+   *
+   * @param {string} [content]
+   * @param {string} [code]
+   * @param {string|null} [help]
+   */
+  constructor(content?: string, code?: string, help?: string | null)
+}

package/src/index.js

@@ -24,6 +24,21 @@ export * from './Commands/Make/Controller.js'
 export * from './Commands/Make/Middleware.js'
 export * from './Helpers/HttpCommandsLoader.js'
 
+export * from './Exceptions/BadGatewayException.js'
+export * from './Exceptions/BadRequestException.js'
+export * from './Exceptions/ForbiddenException.js'
+export * from './Exceptions/HttpException.js'
+export * from './Exceptions/InternalServerException.js'
+export * from './Exceptions/MethodNotAllowedException.js'
+export * from './Exceptions/NotAcceptableException.js'
+export * from './Exceptions/NotFoundException.js'
+export * from './Exceptions/NotImplementedException.js'
+export * from './Exceptions/PayloadTooLargeException.js'
+export * from './Exceptions/RequestTimeoutException.js'
+export * from './Exceptions/ServiceUnavailableException.js'
+export * from './Exceptions/UnauthorizedException.js'
+export * from './Exceptions/UnprocessableEntityException.js'
+
 export class Http {
   /**
    * Holds the fastify server instance.

package/templates/__name__Controller.js.ejs

@@ -0,0 +1,52 @@
+export class <%= namePascal %>Controller {
+    /**
+    * Resolve any dependency of the service container
+    * inside the constructor.
+    */
+    constructor() {}
+
+    /**
+    * Index method
+    *
+    * @param {import('@athenna/http').ContextContract} ctx
+    */
+    async index({ response }) {
+      return response.status(200).send([{}])
+    }
+
+    /**
+    * Store method
+    *
+    * @param {import('@athenna/http').ContextContract} ctx
+    */
+    async store({ response }) {
+      return response.status(201).send({})
+    }
+
+    /**
+    * Show method
+    *
+    * @param {import('@athenna/http').ContextContract} ctx
+    */
+    async show({ response }) {
+      return response.status(200).send({})
+    }
+
+    /**
+    * Update method
+    *
+    * @param {import('@athenna/http').ContextContract} ctx
+    */
+    async update({ response, params }) {
+      return response.status(200).send({ id: params.id })
+    }
+
+    /**
+    * Delete method
+    *
+    * @param {import('@athenna/http').ContextContract} ctx
+    */
+    async delete({ response }) {
+      return response.status(204)
+    }
+}

package/templates/__name__Middleware.js.ejs

@@ -0,0 +1,40 @@
+export class <%= namePascal %>Middleware {
+    /**
+    * Resolve any dependency of the service container
+    * inside the constructor.
+    */
+    constructor() {}
+
+    /**
+    * Handle method is executed before the request gets
+    * in your controller.
+    *
+    * @param {import('@athenna/http').HandleContextContract} ctx
+    */
+    async handle({ next }) {
+      next()
+    }
+
+    /**
+    * Intercept method is executed before the response
+    * has been sent.
+    *
+    * @param {import('@athenna/http').InterceptContextContract} ctx
+    */
+    async intercept({ body }) {
+      body.intercepted = true
+
+      return body
+    }
+
+    /**
+    * Terminate method is executed after the response
+    * has been sent.
+    *
+    * @param {import('@athenna/http').TerminateContextContract} ctx
+    * @return any
+    */
+    async terminate({ next }) {
+      next()
+    }
+}