@athenna/http 4.5.0 → 4.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@athenna/http",
-    "version": "4.5.0",
+    "version": "4.7.0",
     "description": "The Athenna Http server. Built on top of fastify.",
     "license": "MIT",
     "author": "João Lenon <lenon@athenna.io>",
@@ -67,16 +67,16 @@
         "#tests": "./tests/index.js"
     },
     "dependencies": {
-        "fastify": "^4.21.0"
+        "fastify": "^4.22.0"
     },
     "devDependencies": {
-        "@athenna/artisan": "^4.2.0",
-        "@athenna/common": "^4.4.0",
-        "@athenna/config": "^4.3.0",
-        "@athenna/ioc": "^4.1.0",
-        "@athenna/logger": "^4.2.0",
-        "@athenna/test": "^4.4.0",
-        "@athenna/view": "^4.1.0",
+        "@athenna/artisan": "^4.10.0",
+        "@athenna/common": "^4.10.1",
+        "@athenna/config": "^4.4.0",
+        "@athenna/ioc": "^4.4.0",
+        "@athenna/logger": "^4.4.0",
+        "@athenna/test": "^4.7.0",
+        "@athenna/view": "^4.3.0",
         "@fastify/cors": "^8.1.1",
         "@fastify/helmet": "^10.0.2",
         "@fastify/rate-limit": "^7.5.0",
@@ -86,7 +86,6 @@
         "@typescript-eslint/parser": "^5.56.0",
         "c8": "^7.12.0",
         "commitizen": "^4.2.6",
-        "cross-env": "^7.0.3",
         "cz-conventional-changelog": "^3.3.0",
         "eslint": "^8.36.0",
         "eslint-config-prettier": "^8.8.0",
@@ -142,7 +141,7 @@
     },
     "prettier": {
         "singleQuote": true,
-        "trailingComma": "all",
+        "trailingComma": "none",
         "arrowParens": "avoid",
         "endOfLine": "lf",
         "semi": false,
@@ -209,37 +208,34 @@
         "services": [],
         "providers": [],
         "controllers": [
-            "#tests/stubs/controllers/HelloController",
-            "#tests/stubs/controllers/DecoratedController"
+            "#tests/fixtures/controllers/HelloController",
+            "#tests/fixtures/controllers/AnnotatedController"
         ],
         "middlewares": [
-            "#tests/stubs/middlewares/Middleware",
-            "#tests/stubs/middlewares/ImportedMiddleware",
-            "#tests/stubs/middlewares/DecoratedMiddleware",
-            "#tests/stubs/middlewares/DecoratedInterceptor",
-            "#tests/stubs/middlewares/DecoratedTerminator"
+            "#tests/fixtures/middlewares/MyMiddleware",
+            "#tests/fixtures/middlewares/ImportedMiddleware"
         ],
         "namedMiddlewares": {
-            "middleware": "#tests/stubs/middlewares/Middleware",
-            "interceptor": "#tests/stubs/middlewares/Interceptor",
-            "terminator": "#tests/stubs/middlewares/Terminator",
-            "not-found-middleware": "#tests/stubs/middlewares/DecoratedMiddleware",
-            "not-found-interceptor": "#tests/stubs/middlewares/DecoratedInterceptor",
-            "not-found-terminator": "#tests/stubs/middlewares/DecoratedTerminator"
+            "myMiddleware": "#tests/fixtures/middlewares/MyMiddleware",
+            "myInterceptor": "#tests/fixtures/middlewares/MyInterceptor",
+            "myTerminator": "#tests/fixtures/middlewares/MyTerminator",
+            "not-found-middleware": "#tests/fixtures/middlewares/AnnotatedMiddleware",
+            "not-found-interceptor": "#tests/fixtures/middlewares/AnnotatedInterceptor",
+            "not-found-terminator": "#tests/fixtures/middlewares/AnnotatedTerminator"
         },
         "globalMiddlewares": [
-            "#tests/stubs/middlewares/Middleware",
-            "#tests/stubs/middlewares/Interceptor",
-            "#tests/stubs/middlewares/Terminator",
-            "#tests/stubs/middlewares/DecoratedGlobalMiddleware",
-            "#tests/stubs/middlewares/DecoratedGlobalInterceptor",
-            "#tests/stubs/middlewares/DecoratedGlobalTerminator"
+            "#tests/fixtures/middlewares/MyMiddleware",
+            "#tests/fixtures/middlewares/MyInterceptor",
+            "#tests/fixtures/middlewares/MyTerminator",
+            "#tests/fixtures/middlewares/AnnotatedGlobalMiddleware",
+            "#tests/fixtures/middlewares/AnnotatedGlobalInterceptor",
+            "#tests/fixtures/middlewares/AnnotatedGlobalTerminator"
         ],
         "commands": {
             "route:list": {
                 "path": "#src/commands/RouteListCommand",
-                "route": "./tests/stubs/routes/http.js",
-                "kernel": "./tests/stubs/kernels/HttpKernel.js"
+                "route": "./tests/fixtures/routes/http.js",
+                "kernel": "./tests/fixtures/kernels/HttpKernel.js"
             },
             "make:controller": "#src/commands/MakeControllerCommand",
             "make:interceptor": "#src/commands/MakeInterceptorCommand",

package/src/annotations/Controller.js

@@ -9,6 +9,7 @@
 import 'reflect-metadata';
 import { debug } from '#src/debug';
 import { Options } from '@athenna/common';
+import { Annotation } from '@athenna/ioc';
 /**
  * Create a controller inside the service provider.
  */
@@ -16,15 +17,16 @@ export function Controller(options) {
     return (target) => {
         options = Options.create(options, {
             alias: `App/Http/Controllers/${target.name}`,
-            type: 'transient',
+            type: 'transient'
         });
-        const alias = options.alias;
-        const createCamelAlias = false;
-        if (ioc.hasDependency(alias)) {
-            debug('Controller %s was already registered in the service container. Skipping registration via Controller annotation.', alias);
+        debug('Registering controller metadata for the service container %o', {
+            name: target.name,
+            ...options
+        });
+        if (ioc.has(options.alias) || ioc.has(options.camelAlias)) {
+            debug('Skipping registration, controller is already registered.');
             return;
         }
-        ioc[options.type](alias, target, createCamelAlias);
-        Reflect.defineMetadata('ioc:registered', true, target);
+        Annotation.defineMeta(target, options);
     };
 }

package/src/annotations/Interceptor.js

@@ -7,9 +7,9 @@
  * file that was distributed with this source code.
  */
 import 'reflect-metadata';
-import { Server } from '#src/facades/Server';
+import { debug } from '#src/debug';
+import { Annotation } from '@athenna/ioc';
 import { Options, String } from '@athenna/common';
-import { debug } from '#src/debug/index';
 /**
  * Create an interceptor inside the service provider.
  */
@@ -17,24 +17,24 @@ export function Interceptor(options) {
     return (target) => {
         options = Options.create(options, {
             isGlobal: false,
-            name: String.toCamelCase(target.name),
-            alias: `App/Http/Interceptors/${target.name}`,
             type: 'transient',
+            alias: `App/Http/Interceptors/${target.name}`,
+            name: String.toCamelCase(target.name)
+        });
+        options.name = `App/Http/Interceptors/Names/${options.name}`;
+        debug('Registering interceptor metadata for the service container %o', {
+            ...options,
+            name: target.name,
+            namedAlias: options.name
         });
-        const alias = options.alias;
-        const createCamelAlias = false;
-        if (ioc.hasDependency(alias)) {
-            debug('Interceptor %s was already registered in the service container. Skipping registration via Interceptor annotation.', alias);
+        if (ioc.has(options.name)) {
+            debug('Skipping registration, named alias %s is already registered.', options.name);
             return;
         }
-        ioc[options.type](alias, target, createCamelAlias);
-        Reflect.defineMetadata('ioc:registered', true, target);
-        if (!options.isGlobal) {
-            ioc.alias(`App/Http/Interceptors/Names/${options.name}`, alias);
+        if (ioc.has(options.alias)) {
+            debug('Skipping registration, alias %s is already registered.', options.alias);
             return;
         }
-        const Interceptor = ioc.safeUse(alias);
-        debug('Registering %s as a global interceptor via Interceptor annotation.', Interceptor.constructor.name);
-        Server.intercept(Interceptor.intercept);
+        Annotation.defineMeta(target, options);
     };
 }

package/src/annotations/Middleware.js

@@ -7,9 +7,9 @@
  * file that was distributed with this source code.
  */
 import 'reflect-metadata';
-import { Server } from '#src/facades/Server';
+import { debug } from '#src/debug';
+import { Annotation } from '@athenna/ioc';
 import { Options, String } from '@athenna/common';
-import { debug } from '#src/debug/index';
 /**
  * Create a middleware inside the service provider.
  */
@@ -17,24 +17,24 @@ export function Middleware(options) {
     return (target) => {
         options = Options.create(options, {
             isGlobal: false,
-            name: String.toCamelCase(target.name),
-            alias: `App/Http/Middlewares/${target.name}`,
             type: 'transient',
+            alias: `App/Http/Middlewares/${target.name}`,
+            name: String.toCamelCase(target.name)
+        });
+        options.name = `App/Http/Middlewares/Names/${options.name}`;
+        debug('Registering middleware metadata for the service container %o', {
+            ...options,
+            name: target.name,
+            namedAlias: options.name
         });
-        const alias = options.alias;
-        const createCamelAlias = false;
-        if (ioc.hasDependency(alias)) {
-            debug('Middleware %s was already registered in the service container. Skipping registration via Middleware annotation.', alias);
+        if (ioc.has(options.name)) {
+            debug('Skipping registration, named alias %s is already registered.', options.name);
             return;
         }
-        ioc[options.type](alias, target, createCamelAlias);
-        Reflect.defineMetadata('ioc:registered', true, target);
-        if (!options.isGlobal) {
-            ioc.alias(`App/Http/Middlewares/Names/${options.name}`, alias);
+        if (ioc.has(options.alias)) {
+            debug('Skipping registration, alias %s is already registered.', options.alias);
             return;
         }
-        const Middleware = ioc.safeUse(alias);
-        debug('Registering %s as a global middleware via Middleware annotation.', Middleware.constructor.name);
-        Server.middleware(Middleware.handle);
+        Annotation.defineMeta(target, options);
     };
 }

package/src/annotations/Terminator.js

@@ -7,9 +7,9 @@
  * file that was distributed with this source code.
  */
 import 'reflect-metadata';
-import { Server } from '#src/facades/Server';
+import { debug } from '#src/debug';
+import { Annotation } from '@athenna/ioc';
 import { Options, String } from '@athenna/common';
-import { debug } from '#src/debug/index';
 /**
  * Create a terminator inside the service provider.
  */
@@ -17,24 +17,24 @@ export function Terminator(options) {
     return (target) => {
         options = Options.create(options, {
             isGlobal: false,
-            name: String.toCamelCase(target.name),
-            alias: `App/Http/Terminators/${target.name}`,
             type: 'transient',
+            alias: `App/Http/Terminators/${target.name}`,
+            name: String.toCamelCase(target.name)
+        });
+        options.name = `App/Http/Terminators/Names/${options.name}`;
+        debug('Registering terminator metadata for the service container %o', {
+            ...options,
+            name: target.name,
+            namedAlias: options.name
         });
-        const alias = options.alias;
-        const createCamelAlias = false;
-        if (ioc.hasDependency(alias)) {
-            debug('Terminator %s was already registered in the service container. Skipping registration via Terminator annotation.', alias);
+        if (ioc.has(options.name)) {
+            debug('Skipping registration, named alias %s is already registered.', options.name);
             return;
         }
-        ioc[options.type](alias, target, createCamelAlias);
-        Reflect.defineMetadata('ioc:registered', true, target);
-        if (!options.isGlobal) {
-            ioc.alias(`App/Http/Terminators/Names/${options.name}`, alias);
+        if (ioc.has(options.alias)) {
+            debug('Skipping registration, alias %s is already registered.', options.alias);
             return;
         }
-        const Terminator = ioc.safeUse(alias);
-        debug('Registering %s as a global terminator via Terminator annotation.', Terminator.constructor.name);
-        Server.middleware(Terminator.terminate);
+        Annotation.defineMeta(target, options);
     };
 }

package/src/commands/MakeControllerCommand.js

@@ -63,6 +63,6 @@ export class MakeControllerCommand extends BaseCommand {
 }
 __decorate([
     Argument({
-        description: 'The controller name.',
+        description: 'The controller name.'
     })
 ], MakeControllerCommand.prototype, "name", void 0);

package/src/commands/MakeInterceptorCommand.js

@@ -63,6 +63,6 @@ export class MakeInterceptorCommand extends BaseCommand {
 }
 __decorate([
     Argument({
-        description: 'The interceptor name.',
+        description: 'The interceptor name.'
     })
 ], MakeInterceptorCommand.prototype, "name", void 0);

package/src/commands/MakeMiddlewareCommand.js

@@ -63,6 +63,6 @@ export class MakeMiddlewareCommand extends BaseCommand {
 }
 __decorate([
     Argument({
-        description: 'The middleware name.',
+        description: 'The middleware name.'
     })
 ], MakeMiddlewareCommand.prototype, "name", void 0);

package/src/commands/MakeTerminatorCommand.js

@@ -63,6 +63,6 @@ export class MakeTerminatorCommand extends BaseCommand {
 }
 __decorate([
     Argument({
-        description: 'The terminator name.',
+        description: 'The terminator name.'
     })
 ], MakeTerminatorCommand.prototype, "name", void 0);

package/src/commands/RouteListCommand.js

@@ -36,7 +36,7 @@ export class RouteListCommand extends BaseCommand {
                 route.methods.join('|'),
                 route.url,
                 route.name || 'Not found',
-                route.handler.name || 'closure',
+                route.handler.name || 'closure'
             ]);
         });
         table.render();

package/src/exceptions/HttpException.js

@@ -20,7 +20,7 @@ export class HttpException extends Exception {
         options = Options.create(options, {
             status: 500,
             code: 'E_HTTP_ERROR',
-            message: 'An http exception has ocurred.',
+            message: 'An http exception has ocurred.'
         });
         super(options);
     }

package/src/exceptions/NotFoundControllerException.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @athenna/ioc
+ *
+ * (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 '@athenna/common';
+export declare class NotFoundControllerException extends Exception {
+    constructor(alias: string);
+}

package/src/exceptions/NotFoundControllerException.js

@@ -0,0 +1,19 @@
+/**
+ * @athenna/ioc
+ *
+ * (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 '@athenna/common';
+export class NotFoundControllerException extends Exception {
+    constructor(alias) {
+        super({
+            status: 500,
+            code: 'E_NOT_FOUND_CONTROLLER_ERROR',
+            message: `The controller with ${alias} alias has not been found inside the container.`,
+            help: `Remember to register the controller in your .athennarc.json file.`
+        });
+    }
+}

package/src/exceptions/NotFoundMiddlewareException.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @athenna/ioc
+ *
+ * (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 '@athenna/common';
+export declare class NotFoundMiddlewareException extends Exception {
+    constructor(alias: string, namedAlias: string);
+}

package/src/exceptions/NotFoundMiddlewareException.js

@@ -0,0 +1,19 @@
+/**
+ * @athenna/ioc
+ *
+ * (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 '@athenna/common';
+export class NotFoundMiddlewareException extends Exception {
+    constructor(alias, namedAlias) {
+        super({
+            status: 500,
+            code: 'E_NOT_FOUND_MIDDLEWARE_ERROR',
+            message: `The middleware with ${namedAlias} named alias and ${alias} alias has not been found inside the container.`,
+            help: `Remember to register the middleware in your .athennarc.json file.`
+        });
+    }
+}

package/src/exceptions/UndefinedMethodException.js

@@ -13,7 +13,7 @@ export class UndefinedMethodException extends Exception {
             status: 500,
             code: 'E_UNDEFINED_METHOD',
             message: `Cannot register the ${method} method in your Route because it's not defined inside your ${className} class.`,
-            help: `Remember defining the method ${method} inside your ${className} class.`,
+            help: `Remember defining the method ${method} inside your ${className} class.`
         });
     }
 }

package/src/handlers/FastifyHandler.js

@@ -28,7 +28,7 @@ export class FastifyHandler {
                 body: req.body,
                 params: req.params,
                 queries: req.query,
-                headers: req.headers,
+                headers: req.headers
             });
         };
     }
@@ -57,7 +57,7 @@ export class FastifyHandler {
                 body: res.body,
                 params: req.params,
                 queries: req.query,
-                headers: req.headers,
+                headers: req.headers
             });
             res.body = payload;
             if (Is.Object(payload)) {
@@ -82,7 +82,7 @@ export class FastifyHandler {
                 body: res.body || req.body,
                 headers: res.getHeaders(),
                 status: res.statusCode,
-                responseTime: res.getResponseTime(),
+                responseTime: res.getResponseTime()
             });
         };
     }
@@ -101,7 +101,7 @@ export class FastifyHandler {
                 params: req.params,
                 queries: req.query,
                 headers: req.headers,
-                error,
+                error
             });
         };
     }

package/src/handlers/HttpExceptionHandler.js

@@ -30,7 +30,7 @@ export class HttpExceptionHandler {
             code: String.toSnakeCase(error.code || error.name).toUpperCase(),
             name: Json.copy(error.name),
             message: Json.copy(error.message),
-            stack: Json.copy(error.stack),
+            stack: Json.copy(error.stack)
         };
         if (error.help) {
             body.help = Json.copy(error.help);

package/src/kernels/HttpKernel.d.ts

@@ -74,4 +74,13 @@ export declare class HttpKernel {
      * Resolve the import path by meta URL and import it.
      */
     private resolvePath;
+    /**
+     * Register the controllers using the meta information
+     * defined by annotations.
+     */
+    private registerUsingMeta;
+    /**
+     * Get the configuration for the given key.
+     */
+    private getConfig;
 }

package/src/kernels/HttpKernel.js

@@ -12,7 +12,8 @@ import { debug } from '#src/debug';
 import { Log } from '@athenna/logger';
 import { Config } from '@athenna/config';
 import { isAbsolute, resolve } from 'node:path';
-import { File, Exec, Is, Module } from '@athenna/common';
+import { Annotation } from '@athenna/ioc';
+import { File, Exec, Module, String } from '@athenna/common';
 import { HttpExceptionHandler } from '#src/handlers/HttpExceptionHandler';
 const corsPlugin = await Module.safeImport('@fastify/cors');
 const helmetPlugin = await Module.safeImport('@fastify/helmet');
@@ -25,26 +26,38 @@ export class HttpKernel {
      * Register the @fastify/cors plugin in the Http server.
      */
     async registerCors() {
+        if (Config.is('http.cors.enabled', false)) {
+            debug('Not able to register cors plugin. Set the http.cors.enabled configuration as true.');
+            return;
+        }
         if (!corsPlugin) {
             debug('Not able to register cors plugin. Install @fastify/cors package.');
             return;
         }
-        await Server.plugin(corsPlugin, Config.get('http.cors'));
+        await Server.plugin(corsPlugin, this.getConfig('http.cors'));
     }
     /**
      * Register the @fastify/helmet plugin in the Http server.
      */
     async registerHelmet() {
+        if (Config.is('http.helmet.enabled', false)) {
+            debug('Not able to register helmet plugin. Set the http.helmet.enabled configuration as true.');
+            return;
+        }
         if (!helmetPlugin) {
             debug('Not able to register helmet plugin. Install @fastify/helmet package.');
             return;
         }
-        await Server.plugin(helmetPlugin, Config.get('http.helmet'));
+        await Server.plugin(helmetPlugin, this.getConfig('http.helmet'));
     }
     /**
      * Register the @fastify/swagger plugin in the Http server.
      */
     async registerSwagger() {
+        if (Config.is('http.swagger.enabled', false)) {
+            debug('Not able to register swagger plugin. Set the http.swagger.enabled configuration as true.');
+            return;
+        }
         if (swaggerPlugin) {
             debug('Not able to register swagger plugin. Install @fastify/swagger package.');
             await Server.plugin(swaggerPlugin, Config.get('http.swagger.configurations'));
@@ -58,17 +71,26 @@ export class HttpKernel {
      * Register the @fastify/rate-limit plugin in the Http server.
      */
     async registerRateLimit() {
+        if (Config.is('http.rateLimit.enabled', false)) {
+            debug('Not able to register rate limit plugin. Set the http.rateLimit.enabled configuration as true.');
+            return;
+        }
         if (!rateLimitPlugin) {
             debug('Not able to register rate limit plugin. Install @fastify/rate-limit package.');
             return;
         }
-        await Server.plugin(rateLimitPlugin, Config.get('http.rateLimit'));
+        await Server.plugin(rateLimitPlugin, this.getConfig('http.rateLimit'));
     }
     /**
      * Register the cls-rtracer plugin in the Http server.
      */
     async registerRTracer(trace) {
         if (trace === false) {
+            debug('Not able to register rTracer plugin. Set the trace option as true in your http server options.');
+            return;
+        }
+        if (trace === undefined && Config.is('http.rTracer.enabled', false)) {
+            debug('Not able to register rTracer plugin. Set the http.rTracer.enabled configuration as true.');
             return;
         }
         if (!rTracerPlugin) {
@@ -76,14 +98,13 @@ export class HttpKernel {
             return;
         }
         Server.middleware(async (ctx) => (ctx.data.traceId = rTracerPlugin.id()));
-        await Server.plugin(rTracerPlugin.fastifyPlugin, Config.get('http.rTracer'));
+        await Server.plugin(rTracerPlugin.fastifyPlugin, this.getConfig('http.rTracer'));
     }
     /**
      * Register the global log terminator in the Http server.
      */
     async registerLoggerTerminator() {
-        if (!Config.exists('http.logger.enabled') ||
-            Config.is('http.logger.enabled', false)) {
+        if (Config.is('http.logger.enabled', false)) {
             debug('Not able to register http request logger. Enable it in your http.logger.enabled configuration.');
             return;
         }
@@ -97,13 +118,11 @@ export class HttpKernel {
         const controllers = Config.get('rc.controllers', []);
         await Exec.concurrently(controllers, async (path) => {
             const Controller = await this.resolvePath(path);
-            if (Reflect.hasMetadata('ioc:registered', Controller)) {
-                debug('Controller %s already registered by Controller annotation. Skipping registration via HttpKernel.', Controller.name);
+            if (Annotation.isAnnotated(Controller)) {
+                this.registerUsingMeta(Controller);
                 return;
             }
-            const createCamelAlias = false;
-            const alias = `App/Http/Controllers/${Controller.name}`;
-            ioc.bind(alias, Controller, createCamelAlias);
+            ioc.transient(`App/Http/Controllers/${Controller.name}`, Controller);
         });
     }
     /**
@@ -112,30 +131,34 @@ export class HttpKernel {
      * and "rc.globalMiddlewares" exists.
      */
     async registerMiddlewares() {
+        const middlewares = Config.get('rc.middlewares', []);
+        await Exec.concurrently(middlewares, async (path) => {
+            const Middleware = await this.resolvePath(path);
+            if (Annotation.isAnnotated(Middleware)) {
+                this.registerUsingMeta(Middleware);
+                return;
+            }
+            const alias = `App/Http/Middlewares/${Middleware.name}`;
+            const namedAlias = `App/Http/Middlewares/Names/${String.toCamelCase(Middleware.name)}`;
+            ioc.transient(alias, Middleware).alias(namedAlias, alias);
+        });
         await this.registerNamedMiddlewares();
         await this.registerGlobalMiddlewares();
-        if (Config.exists('rc.middlewares')) {
-            await Exec.concurrently(Config.get('rc.middlewares'), this.resolvePath);
-        }
     }
     /**
      * Register all the named middlewares found inside "rc.namedMiddlewares"
      * property.
      */
     async registerNamedMiddlewares() {
-        const namedMiddlewares = Config.get('rc.namedMiddlewares');
-        if (Is.Empty(namedMiddlewares)) {
-            return;
-        }
+        const namedMiddlewares = Config.get('rc.namedMiddlewares', {});
         await Exec.concurrently(Object.keys(namedMiddlewares), async (key) => {
             const Middleware = await this.resolvePath(namedMiddlewares[key]);
-            if (Reflect.hasMetadata('ioc:registered', Middleware)) {
-                debug('Named middleware %s already registered by Middleware annotation. Skipping registration via HttpKernel.', Middleware.name);
+            if (Annotation.isAnnotated(Middleware)) {
+                this.registerUsingMeta(Middleware);
                 return;
             }
-            const createCamelAlias = false;
             const { alias, namedAlias } = this.getNamedMiddlewareAlias(key, Middleware);
-            ioc.bind(alias, Middleware, createCamelAlias).alias(namedAlias, alias);
+            ioc.bind(alias, Middleware).alias(namedAlias, alias);
         });
     }
     /**
@@ -143,20 +166,19 @@ export class HttpKernel {
      * property.
      */
     async registerGlobalMiddlewares() {
-        const globalMiddlewares = Config.get('rc.globalMiddlewares');
-        if (Is.Empty(globalMiddlewares)) {
-            return;
-        }
+        const globalMiddlewares = Config.get('rc.globalMiddlewares', []);
         await Exec.concurrently(globalMiddlewares, async (path) => {
             const Middleware = await this.resolvePath(path);
-            if (Reflect.hasMetadata('ioc:registered', Middleware)) {
-                debug('Global middleware %s already registered by Middleware annotation. Skipping registration via HttpKernel.', Middleware.name);
+            if (Annotation.isAnnotated(Middleware)) {
+                this.registerUsingMeta(Middleware);
                 return;
             }
-            const createCamelAlias = false;
             const { alias, handler, serverMethod } = this.getGlobalMiddlewareAliasAndHandler(Middleware);
-            ioc.bind(alias, Middleware, createCamelAlias);
-            Server[serverMethod](ioc.safeUse(alias)[handler]);
+            ioc.bind(alias, Middleware);
+            Server[serverMethod]((...args) => {
+                const mid = ioc.safeUse(alias);
+                return mid[handler].bind(mid)(...args);
+            });
         });
     }
     /**
@@ -198,19 +220,19 @@ export class HttpKernel {
         if (middleware.handle) {
             return {
                 alias: `App/Http/Middlewares/${Middleware.name}`,
-                namedAlias: `App/Http/Middlewares/Names/${name}`,
+                namedAlias: `App/Http/Middlewares/Names/${name}`
             };
         }
         if (middleware.intercept) {
             return {
                 alias: `App/Http/Interceptors/${Middleware.name}`,
-                namedAlias: `App/Http/Interceptors/Names/${name}`,
+                namedAlias: `App/Http/Interceptors/Names/${name}`
             };
         }
         if (middleware.terminate) {
             return {
                 alias: `App/Http/Terminators/${Middleware.name}`,
-                namedAlias: `App/Http/Terminators/Names/${name}`,
+                namedAlias: `App/Http/Terminators/Names/${name}`
             };
         }
     }
@@ -224,21 +246,21 @@ export class HttpKernel {
             return {
                 handler: 'handle',
                 serverMethod: 'middleware',
-                alias: `App/Http/Middlewares/${Middleware.name}`,
+                alias: `App/Http/Middlewares/${Middleware.name}`
             };
         }
         if (middleware.intercept) {
             return {
                 handler: 'intercept',
                 serverMethod: 'intercept',
-                alias: `App/Http/Interceptors/${Middleware.name}`,
+                alias: `App/Http/Interceptors/${Middleware.name}`
             };
         }
         if (middleware.terminate) {
             return {
                 handler: 'terminate',
                 serverMethod: 'terminate',
-                alias: `App/Http/Terminators/${Middleware.name}`,
+                alias: `App/Http/Terminators/${Middleware.name}`
             };
         }
     }
@@ -248,4 +270,36 @@ export class HttpKernel {
     resolvePath(path) {
         return Module.resolve(`${path}?version=${Math.random()}`, Config.get('rc.meta'));
     }
+    /**
+     * Register the controllers using the meta information
+     * defined by annotations.
+     */
+    registerUsingMeta(target) {
+        const meta = Annotation.getMeta(target);
+        ioc[meta.type](meta.alias, target);
+        if (meta.name && !meta.isGlobal) {
+            ioc.alias(meta.name, meta.alias);
+        }
+        if (meta.camelAlias) {
+            ioc.alias(meta.camelAlias, meta.alias);
+        }
+        if (meta.isGlobal) {
+            const { handler, serverMethod } = this.getGlobalMiddlewareAliasAndHandler(target);
+            Server[serverMethod]((...args) => {
+                const mid = ioc.safeUse(meta.alias);
+                return mid[handler].bind(mid)(...args);
+            });
+        }
+        return meta;
+    }
+    /**
+     * Get the configuration for the given key.
+     */
+    getConfig(key) {
+        const config = Config.get(key);
+        if (Config.exists(`${key}.enabled`)) {
+            delete config.enabled;
+        }
+        return config;
+    }
 }

package/src/providers/HttpRouteProvider.js

@@ -10,6 +10,6 @@ import { Router } from '#src/router/Router';
 import { ServiceProvider } from '@athenna/ioc';
 export class HttpRouteProvider extends ServiceProvider {
     register() {
-        this.container.instance('Athenna/Core/HttpRoute', new Router(), false);
+        this.container.singleton('Athenna/Core/HttpRoute', Router);
     }
 }

package/src/providers/HttpServerProvider.js

@@ -10,7 +10,7 @@ import { ServiceProvider } from '@athenna/ioc';
 import { ServerImpl } from '#src/server/ServerImpl';
 export class HttpServerProvider extends ServiceProvider {
     register() {
-        this.container.instance('Athenna/Core/HttpServer', new ServerImpl(), false);
+        this.container.instance('Athenna/Core/HttpServer', new ServerImpl());
     }
     async shutdown() {
         const Server = this.container.use('Athenna/Core/HttpServer');

package/src/router/Route.js

@@ -8,6 +8,7 @@
  */
 import { Is, Route as RouteHelper } from '@athenna/common';
 import { UndefinedMethodException } from '#src/exceptions/UndefinedMethodException';
+import { NotFoundMiddlewareException } from '#src/exceptions/NotFoundMiddlewareException';
 export class Route {
     constructor(url, methods, handler) {
         this.route = {
@@ -18,9 +19,9 @@ export class Route {
             middlewares: {
                 middlewares: [],
                 terminators: [],
-                interceptors: [],
+                interceptors: []
             },
-            fastify: { schema: {} },
+            fastify: { schema: {} }
         };
         if (Is.String(handler)) {
             const [controller, method] = handler.split('.');
@@ -28,7 +29,13 @@ export class Route {
             if (!dependency[method]) {
                 throw new UndefinedMethodException(method, controller);
             }
-            this.route.handler = dependency[method].bind(dependency);
+            this.route.handler = (...args) => {
+                const service = ioc.safeUse(`App/Http/Controllers/${controller}`);
+                if (!service[method]) {
+                    throw new UndefinedMethodException(method, controller);
+                }
+                return service[method].bind(dependency)(...args);
+            };
         }
         else {
             this.route.handler = handler;
@@ -58,7 +65,7 @@ export class Route {
     vanillaOptions(options) {
         this.route.fastify = {
             ...this.route.fastify,
-            ...options,
+            ...options
         };
         return this;
     }
@@ -81,9 +88,15 @@ export class Route {
     middleware(middleware, prepend = false) {
         const insertionType = prepend ? 'unshift' : 'push';
         if (Is.String(middleware)) {
-            const mid = ioc.use(`App/Http/Middlewares/Names/${middleware}`) ||
-                ioc.safeUse(`App/Http/Middlewares/${middleware}`);
-            this.route.middlewares.middlewares[insertionType](mid.handle.bind(mid));
+            const namedAlias = `App/Http/Middlewares/Names/${middleware}`;
+            const alias = `App/Http/Middlewares/${middleware}`;
+            if (!ioc.has(namedAlias) && !ioc.has(alias)) {
+                throw new NotFoundMiddlewareException(alias, namedAlias);
+            }
+            this.route.middlewares.middlewares[insertionType]((...args) => {
+                const mid = ioc.use(namedAlias) || ioc.safeUse(alias);
+                return mid.handle.bind(mid)(...args);
+            });
             return this;
         }
         if (Is.Function(middleware)) {
@@ -100,9 +113,15 @@ export class Route {
     interceptor(interceptor, prepend = false) {
         const insertionType = prepend ? 'unshift' : 'push';
         if (Is.String(interceptor)) {
-            const inte = ioc.use(`App/Http/Interceptors/Names/${interceptor}`) ||
-                ioc.safeUse(`App/Http/Interceptors/${interceptor}`);
-            this.route.middlewares.interceptors[insertionType](inte.intercept.bind(inte));
+            const namedAlias = `App/Http/Interceptors/Names/${interceptor}`;
+            const alias = `App/Http/Interceptors/${interceptor}`;
+            if (!ioc.has(namedAlias) && !ioc.has(alias)) {
+                throw new NotFoundMiddlewareException(alias, namedAlias);
+            }
+            this.route.middlewares.interceptors[insertionType]((...args) => {
+                const mid = ioc.use(namedAlias) || ioc.safeUse(alias);
+                return mid.intercept.bind(mid)(...args);
+            });
             return this;
         }
         if (Is.Function(interceptor)) {
@@ -119,9 +138,15 @@ export class Route {
     terminator(terminator, prepend = false) {
         const insertionType = prepend ? 'unshift' : 'push';
         if (Is.String(terminator)) {
-            const ter = ioc.use(`App/Http/Terminators/Names/${terminator}`) ||
-                ioc.safeUse(`App/Http/Terminators/${terminator}`);
-            this.route.middlewares.terminators[insertionType](ter.terminate.bind(ter));
+            const namedAlias = `App/Http/Terminators/Names/${terminator}`;
+            const alias = `App/Http/Terminators/${terminator}`;
+            if (!ioc.has(namedAlias) && !ioc.has(alias)) {
+                throw new NotFoundMiddlewareException(alias, namedAlias);
+            }
+            this.route.middlewares.terminators[insertionType]((...args) => {
+                const mid = ioc.use(namedAlias) || ioc.safeUse(alias);
+                return mid.terminate.bind(mid)(...args);
+            });
             return this;
         }
         if (Is.Function(terminator)) {
@@ -262,7 +287,7 @@ export class Route {
         if (!this.route.fastify.schema.body) {
             this.route.fastify.schema.body = {
                 type: 'object',
-                properties: {},
+                properties: {}
             };
         }
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -282,7 +307,7 @@ export class Route {
         if (!this.route.fastify.schema.params) {
             this.route.fastify.schema.params = {
                 type: 'object',
-                properties: {},
+                properties: {}
             };
         }
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -302,7 +327,7 @@ export class Route {
         if (!this.route.fastify.schema.querystring) {
             this.route.fastify.schema.querystring = {
                 type: 'object',
-                properties: {},
+                properties: {}
             };
         }
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -371,7 +396,7 @@ export class Route {
         if (!this.route.fastify.schema.externalDocs) {
             this.route.fastify.schema.externalDocs = {
                 url: '',
-                description: '',
+                description: ''
             };
         }
         this.route.fastify.schema.externalDocs.url = url;
@@ -419,7 +444,7 @@ export class Route {
             prefixes: this.route.prefixes,
             handler: this.route.handler,
             middlewares: this.route.middlewares,
-            fastify: this.route.fastify,
+            fastify: this.route.fastify
         };
     }
     getUrl() {

package/src/server/ServerImpl.js

@@ -136,7 +136,7 @@ export class ServerImpl {
         options.middlewares = Options.create(options.middlewares, {
             middlewares: [],
             terminators: [],
-            interceptors: [],
+            interceptors: []
         });
         if (options.methods.length === 2 && options.methods.includes('HEAD')) {
             this.route({ ...options, methods: ['GET'] });
@@ -145,8 +145,8 @@ export class ServerImpl {
                 methods: ['HEAD'],
                 fastify: {
                     ...options.fastify,
-                    schema: { ...options.fastify.schema, hide: true },
-                },
+                    schema: { ...options.fastify.schema, hide: true }
+                }
             });
             return;
         }
@@ -159,7 +159,7 @@ export class ServerImpl {
             preHandler: options.middlewares.middlewares.map(m => FastifyHandler.handle(m)),
             onSend: options.middlewares.interceptors.map(m => FastifyHandler.intercept(m)),
             onResponse: options.middlewares.terminators.map(m => FastifyHandler.terminate(m)),
-            ...options.fastify,
+            ...options.fastify
         });
     }
     /**

package/src/types/controllers/ControllerOptions.d.ts

@@ -8,18 +8,26 @@
  */
 export type ControllerOptions = {
     /**
-     * The alias that will be used to register the dependency inside
-     * the service provider. Athenna will not create camel alias from
-     * the alias set here.
+     * The alias that will be used to register the controller inside
+     * the service container.
      *
      * @default App/Http/Controllers/YourControllerClassName
      */
     alias?: string;
+    /**
+     * The camel alias that will be used as an alias of the real
+     * controller alias. Camel alias is important when you want to
+     * work with constructor injection. By default, Athenna doesn't
+     * create camel alias for controllers.
+     *
+     * @default undefined
+     */
+    camelAlias?: string;
     /**
      * The registration type that will be used to register your controller
-     * inside the service provider.
+     * inside the service container.
      *
-     * @default transient
+     * @default 'transient'
      */
     type?: 'fake' | 'scoped' | 'singleton' | 'transient';
 };

package/src/types/middlewares/MiddlewareOptions.d.ts

@@ -8,18 +8,26 @@
  */
 export type MiddlewareOptions = {
     /**
-     * The alias that will be used to register the dependency inside
-     * the service provider. Athenna will not create camel alias from
-     * the alias set here.
+     * The alias that will be used to register the middleware inside
+     * the service container.
      *
      * @default App/Http/Middlewares/YourMiddlewareClassName
      */
     alias?: string;
+    /**
+     * The camel alias that will be used as an alias of the real
+     * middleware alias. Camel alias is important when you want to
+     * work with constructor injection. By default, Athenna doesn't
+     * create camel alias for middlewares.
+     *
+     * @default undefined
+     */
+    camelAlias?: string;
     /**
      * The registration type that will be used to register your middleware
-     * inside the service provider.
+     * inside the service container.
      *
-     * @default transient
+     * @default 'transient'
      */
     type?: 'fake' | 'scoped' | 'singleton' | 'transient';
     /**
@@ -34,7 +42,7 @@ export type MiddlewareOptions = {
      * is true, Athenna will ignore this property. Athenna will always set the default
      * name of your middleware as the middleware class name in camel case format.
      *
-     * @default yourMiddlewareClassName
+     * @default 'yourMiddlewareClassName'
      */
     name?: string;
 };