@athenna/http 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/http",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "The Athenna Http server. Built on top of fastify",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",

package/src/Exceptions/UndefinedControllerMethodException.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @athenna/http
+ *
+ * (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 declare class UndefinedControllerMethodException extends Exception {
+    constructor(method: string, controller: string);
+}

package/src/Exceptions/UndefinedControllerMethodException.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @athenna/http
+ *
+ * (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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UndefinedControllerMethodException = void 0;
+const utils_1 = require("@secjs/utils");
+class UndefinedControllerMethodException extends utils_1.Exception {
+    constructor(method, controller) {
+        const content = `The method ${method} is not defined inside your controller ${controller}`;
+        super(content, 500, 'UNDEFINED_METHOD_ERROR', `Remember defining the method ${method} inside your controller ${controller}`);
+    }
+}
+exports.UndefinedControllerMethodException = UndefinedControllerMethodException;

package/src/Router/Route.d.ts

@@ -11,32 +11,22 @@ import { MiddlewareTypes } from '../Contracts/MiddlewareTypes';
 import { HttpMethodTypes } from '../Contracts/HttpMethodTypes';
 import { MiddlewareContract } from '../Contracts/MiddlewareContract';
 import { HandlerContract } from '../Contracts/Context/HandlerContract';
-import { MiddlewareTypesContract } from '../Contracts/MiddlewareTypesContract';
 import { InterceptHandlerContract } from '../Contracts/Context/Middlewares/Intercept/InterceptHandlerContract';
 import { TerminateHandlerContract } from '../Contracts/Context/Middlewares/Terminate/TerminateHandlerContract';
 export declare class Route {
+    name: string;
+    deleted: boolean;
     private readonly url;
     private readonly handler;
     private readonly methods;
-    name: string;
-    deleted: boolean;
     private routeMiddlewares;
     private routeNamespace;
     private prefixes;
     constructor(url: string, methods: HttpMethodTypes[], handler: HandlerContract | string);
-    private getUrl;
     prefix(prefix: any): this;
     as(name: string, prepend?: boolean): this;
     namespace(namespace: string, overwrite?: boolean): this;
     middleware(middleware: HandlerContract | MiddlewareContract | InterceptHandlerContract | TerminateHandlerContract | string, type?: MiddlewareTypes, prepend?: boolean): this;
-    toJSON(): {
-        name: string;
-        url: string;
-        handler: HandlerContract;
-        methods: HttpMethodTypes[];
-        middlewares: MiddlewareTypesContract;
-        meta: {
-            namespace: string;
-        };
-    };
+    toJSON(): any;
+    private getUrl;
 }

package/src/Router/Route.js

@@ -14,6 +14,7 @@ const utils_1 = require("@secjs/utils");
 const removeSlash_1 = require("../Utils/removeSlash");
 const isMiddlewareContract_1 = require("../Utils/isMiddlewareContract");
 const MiddlewareNotFoundException_1 = require("../Exceptions/MiddlewareNotFoundException");
+const UndefinedControllerMethodException_1 = require("../Exceptions/UndefinedControllerMethodException");
 class Route {
     constructor(url, methods, handler) {
         this.url = url;
@@ -22,21 +23,8 @@ class Route {
         this.prefixes = [];
         this.deleted = false;
         this.routeMiddlewares = { handlers: [], terminators: [], interceptors: [] };
-        if (utils_1.Is.String(handler)) {
-            const [controller, method] = handler.split('.');
-            handler = ioc.use(`App/Controllers/${controller}`)[method];
-        }
         this.handler = handler;
     }
-    getUrl() {
-        const url = removeSlash_1.removeSlash(this.url);
-        const prefix = this.prefixes
-            .slice()
-            .reverse()
-            .map(p => removeSlash_1.removeSlash(p))
-            .join('');
-        return prefix ? `${prefix}${url === '/' ? '' : url}` : url;
-    }
     prefix(prefix) {
         this.prefixes.push(prefix);
         return this;
@@ -63,37 +51,63 @@ class Route {
             if (!mid) {
                 throw new MiddlewareNotFoundException_1.MiddlewareNotFoundException(middleware);
             }
-            if (mid.handle)
-                this.routeMiddlewares.handlers[insertionType](mid.handle);
-            if (mid.intercept)
-                this.routeMiddlewares.interceptors[insertionType](mid.intercept);
-            if (mid.terminate)
-                this.routeMiddlewares.terminators[insertionType](mid.terminate);
+            if (mid.handle) {
+                this.routeMiddlewares.handlers[insertionType](mid.handle.bind(mid));
+            }
+            if (mid.intercept) {
+                this.routeMiddlewares.interceptors[insertionType](mid.intercept.bind(mid));
+            }
+            if (mid.terminate) {
+                this.routeMiddlewares.terminators[insertionType](mid.terminate.bind(mid));
+            }
             return this;
         }
         if (isMiddlewareContract_1.isMiddlewareContract(middleware)) {
-            if (middleware.handle)
-                this.routeMiddlewares.handlers[insertionType](middleware.handle);
-            if (middleware.intercept)
-                this.routeMiddlewares.interceptors[insertionType](middleware.intercept);
-            if (middleware.terminate)
-                this.routeMiddlewares.terminators[insertionType](middleware.terminate);
+            if (middleware.handle) {
+                this.routeMiddlewares.handlers[insertionType](middleware.handle.bind(middleware));
+            }
+            if (middleware.intercept) {
+                this.routeMiddlewares.interceptors[insertionType](middleware.intercept.bind(middleware));
+            }
+            if (middleware.terminate) {
+                this.routeMiddlewares.terminators[insertionType](middleware.terminate.bind(middleware));
+            }
             return this;
         }
         this.routeMiddlewares[dictionary[type]][insertionType](middleware);
         return this;
     }
     toJSON() {
-        return {
+        const json = {
             name: this.name,
             url: this.getUrl(),
-            handler: this.handler,
             methods: this.methods,
             middlewares: this.routeMiddlewares,
             meta: {
                 namespace: this.routeNamespace,
             },
         };
+        if (utils_1.Is.String(this.handler)) {
+            const [controller, method] = this.handler.split('.');
+            const dependency = ioc.use(`App/Controllers/${controller}`);
+            if (!dependency[method]) {
+                throw new UndefinedControllerMethodException_1.UndefinedControllerMethodException(method, controller);
+            }
+            json.handler = dependency[method].bind(dependency);
+        }
+        else {
+            json.handler = this.handler;
+        }
+        return json;
+    }
+    getUrl() {
+        const url = removeSlash_1.removeSlash(this.url);
+        const prefix = this.prefixes
+            .slice()
+            .reverse()
+            .map(p => removeSlash_1.removeSlash(p))
+            .join('');
+        return prefix ? `${prefix}${url === '/' ? '' : url}` : url;
     }
 }
 exports.Route = Route;

package/src/Router/RouteResource.d.ts

@@ -13,17 +13,17 @@ import { InterceptHandlerContract } from '../Contracts/Context/Middlewares/Inter
 import { TerminateHandlerContract } from '../Contracts/Context/Middlewares/Terminate/TerminateHandlerContract';
 import { MiddlewareContract } from '../Contracts/MiddlewareContract';
 export declare class RouteResource {
+    routes: Route[];
     private resource;
     private readonly controller;
     private resourceName;
-    routes: Route[];
     constructor(resource: string, controller: any);
-    private makeRoute;
-    private buildRoutes;
-    private filter;
     middleware(middleware: HandlerContract | MiddlewareContract | InterceptHandlerContract | TerminateHandlerContract | string, type?: MiddlewareTypes): this;
     only(names: string[]): this;
     except(names: string[]): this;
     namespace(namespace: string): this;
     as(name: string): this;
+    private makeRoute;
+    private buildRoutes;
+    private filter;
 }

package/src/Router/RouteResource.js

@@ -22,6 +22,32 @@ class RouteResource {
             .join('.');
         this.buildRoutes();
     }
+    middleware(middleware, type = 'handle') {
+        this.routes.forEach(route => route.middleware(middleware, type));
+        return this;
+    }
+    only(names) {
+        this.filter(names, true).forEach(route => (route.deleted = true));
+        return this;
+    }
+    except(names) {
+        this.filter(names, false).forEach(route => (route.deleted = true));
+        return this;
+    }
+    namespace(namespace) {
+        this.routes.forEach(route => {
+            route.namespace(namespace);
+        });
+        return this;
+    }
+    as(name) {
+        name = utils_1.String.toSnakeCase(name);
+        this.routes.forEach(route => {
+            route.as(route.name.replace(this.resourceName, name), false);
+        });
+        this.resourceName = name;
+        return this;
+    }
     makeRoute(url, methods, action) {
         let handler = '';
         if (utils_1.Is.String(this.controller)) {
@@ -54,31 +80,5 @@ class RouteResource {
             return inverse ? !match : match;
         });
     }
-    middleware(middleware, type = 'handle') {
-        this.routes.forEach(route => route.middleware(middleware, type));
-        return this;
-    }
-    only(names) {
-        this.filter(names, true).forEach(route => (route.deleted = true));
-        return this;
-    }
-    except(names) {
-        this.filter(names, false).forEach(route => (route.deleted = true));
-        return this;
-    }
-    namespace(namespace) {
-        this.routes.forEach(route => {
-            route.namespace(namespace);
-        });
-        return this;
-    }
-    as(name) {
-        name = utils_1.String.toSnakeCase(name);
-        this.routes.forEach(route => {
-            route.as(route.name.replace(this.resourceName, name), false);
-        });
-        this.resourceName = name;
-        return this;
-    }
 }
 exports.RouteResource = RouteResource;