@athenna/http 4.6.0 → 4.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@athenna/http",
-    "version": "4.6.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.9.0",
+        "@athenna/artisan": "^4.10.0",
         "@athenna/common": "^4.10.1",
         "@athenna/config": "^4.4.0",
-        "@athenna/ioc": "^4.2.0",
-        "@athenna/logger": "^4.3.0",
-        "@athenna/test": "^4.5.0",
-        "@athenna/view": "^4.2.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",
@@ -209,30 +209,27 @@
         "providers": [],
         "controllers": [
             "#tests/fixtures/controllers/HelloController",
-            "#tests/fixtures/controllers/DecoratedController"
+            "#tests/fixtures/controllers/AnnotatedController"
         ],
         "middlewares": [
-            "#tests/fixtures/middlewares/Middleware",
-            "#tests/fixtures/middlewares/ImportedMiddleware",
-            "#tests/fixtures/middlewares/DecoratedMiddleware",
-            "#tests/fixtures/middlewares/DecoratedInterceptor",
-            "#tests/fixtures/middlewares/DecoratedTerminator"
+            "#tests/fixtures/middlewares/MyMiddleware",
+            "#tests/fixtures/middlewares/ImportedMiddleware"
         ],
         "namedMiddlewares": {
-            "middleware": "#tests/fixtures/middlewares/Middleware",
-            "interceptor": "#tests/fixtures/middlewares/Interceptor",
-            "terminator": "#tests/fixtures/middlewares/Terminator",
-            "not-found-middleware": "#tests/fixtures/middlewares/DecoratedMiddleware",
-            "not-found-interceptor": "#tests/fixtures/middlewares/DecoratedInterceptor",
-            "not-found-terminator": "#tests/fixtures/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/fixtures/middlewares/Middleware",
-            "#tests/fixtures/middlewares/Interceptor",
-            "#tests/fixtures/middlewares/Terminator",
-            "#tests/fixtures/middlewares/DecoratedGlobalMiddleware",
-            "#tests/fixtures/middlewares/DecoratedGlobalInterceptor",
-            "#tests/fixtures/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": {

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.
  */
@@ -18,13 +19,14 @@ export function Controller(options) {
             alias: `App/Http/Controllers/${target.name}`,
             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),
+            type: 'transient',
             alias: `App/Http/Interceptors/${target.name}`,
-            type: 'transient'
+            name: String.toCamelCase(target.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);
+        options.name = `App/Http/Interceptors/Names/${options.name}`;
+        debug('Registering interceptor metadata for the service container %o', {
+            ...options,
+            name: target.name,
+            namedAlias: options.name
+        });
+        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),
+            type: 'transient',
             alias: `App/Http/Middlewares/${target.name}`,
-            type: 'transient'
+            name: String.toCamelCase(target.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);
+        options.name = `App/Http/Middlewares/Names/${options.name}`;
+        debug('Registering middleware metadata for the service container %o', {
+            ...options,
+            name: target.name,
+            namedAlias: options.name
+        });
+        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),
+            type: 'transient',
             alias: `App/Http/Terminators/${target.name}`,
-            type: 'transient'
+            name: String.toCamelCase(target.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);
+        options.name = `App/Http/Terminators/Names/${options.name}`;
+        debug('Registering terminator metadata for the service container %o', {
+            ...options,
+            name: target.name,
+            namedAlias: options.name
+        });
+        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/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/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);
+            });
         });
     }
     /**
@@ -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 = {
@@ -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;
@@ -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)) {

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;
 };