@athenna/http 1.0.5 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@athenna/http",
-  "version": "1.0.5",
+  "version": "1.0.8",
   "description": "The Athenna Http server. Built on top of fastify",
   "license": "MIT",
   "author": "João Lenon <lenon@athenna.io>",
@@ -9,8 +9,8 @@
   "homepage": "https://github.com/AthennaIO/Http#readme",
   "scripts": {
     "build": "tsc --project tsconfig.json && tscpaths -p tsconfig.json -s . -o .",
-    "test": "npm run lint:fix && cross-env NODE_TS=true cross-env NODE_ENV=testing jest --verbose",
-    "test:debug": "npm run lint:fix && cross-env NODE_TS=true cross-env NODE_ENV=testing cross-env DEBUG=api:* jest --verbose",
+    "test": "npm run lint:fix && cross-env NODE_TS=true cross-env NODE_ENV=testing jest --verbose --runInBand",
+    "test:debug": "cross-env DEBUG=api:* && npm run test",
     "lint:fix": "eslint \"{src,tests}/**/*.ts\" --fix"
   },
   "keywords": [

package/src/Contracts/Context/Middlewares/Intercept/InterceptContextContract.d.ts

@@ -7,14 +7,11 @@
  * file that was distributed with this source code.
  */
 import { RequestContract } from '../../RequestContract';
-import { ResponseContract } from '../../ResponseContract';
-import { NextInterceptContract } from './NextInterceptContract';
 export interface InterceptContextContract {
     request: RequestContract;
-    response: ResponseContract;
     params: Record<string, string>;
     queries: Record<string, string>;
-    body: Record<string, any>;
+    body: any;
+    status: number;
     data: Record<string, any>;
-    next: NextInterceptContract;
 }

package/src/Contracts/MiddlewareContract.d.ts

@@ -11,6 +11,6 @@ import { InterceptContextContract } from './Context/Middlewares/Intercept/Interc
 import { TerminateContextContract } from './Context/Middlewares/Terminate/TerminateContextContract';
 export interface MiddlewareContract {
     handle?: (ctx: HandleContextContract) => void | Promise<void>;
-    intercept?: (ctx: InterceptContextContract) => void | Promise<void>;
+    intercept?: (ctx: InterceptContextContract) => any | Promise<any>;
     terminate?: (ctx: TerminateContextContract) => void | Promise<void>;
 }

package/src/{Contracts/Context/Middlewares/Intercept/NextInterceptContract.d.ts → Exceptions/UndefinedControllerMethodException.d.ts}

@@ -6,6 +6,7 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-export interface NextInterceptContract {
-    (body: Record<string, any>, error?: any): Promise<void> | void;
+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/Http.d.ts

@@ -6,7 +6,8 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { FastifyInstance, PrintRoutesOptions } from 'fastify';
+import LightMyRequest from 'light-my-request';
+import { FastifyInstance, InjectOptions, PrintRoutesOptions } from 'fastify';
 import { HttpMethodTypes } from './Contracts/HttpMethodTypes';
 import { HandlerContract } from './Contracts/Context/HandlerContract';
 import { MiddlewareTypesContract } from './Contracts/MiddlewareTypesContract';
@@ -21,6 +22,8 @@ export declare class Http {
     getServer(): FastifyInstance;
     getRoutes(options?: PrintRoutesOptions): string;
     use(handler: HandleHandlerContract | InterceptHandlerContract | TerminateHandlerContract, type?: 'handle' | 'intercept' | 'terminate'): void;
+    request(): LightMyRequest.Chain;
+    request(options: InjectOptions | string): Promise<LightMyRequest.Response>;
     listen(port?: string | number, host?: string): Promise<string>;
     close(cb?: any): Promise<void>;
     route(url: string, methods: HttpMethodTypes[], handler: HandlerContract, middlewares?: MiddlewareTypesContract): void;

package/src/Http.js

@@ -38,11 +38,18 @@ class Http {
                 break;
             case 'terminate':
                 hookName = 'onResponse';
-                handlerType = 'createDoneHandler';
+                handlerType = 'createResponseHandler';
                 break;
         }
         this.server.addHook(hookName, FastifyHandler_1.FastifyHandler[handlerType](handler));
     }
+    request(options) {
+        const server = this.getServer();
+        if (!options) {
+            return server.inject();
+        }
+        return server.inject(options);
+    }
     async listen(port, host) {
         return this.server.listen(port || 1335, host || 'localhost');
     }
@@ -60,7 +67,7 @@ class Http {
             method: methods,
             handler: FastifyHandler_1.FastifyHandler.createRequestHandler(handler),
             preHandler: handlers.map(m => FastifyHandler_1.FastifyHandler.createDoneHandler(m)),
-            onResponse: terminators.map(m => FastifyHandler_1.FastifyHandler.createDoneHandler(m)),
+            onResponse: terminators.map(m => FastifyHandler_1.FastifyHandler.createResponseHandler(m)),
             onSend: interceptors.map(m => FastifyHandler_1.FastifyHandler.createOnSendHandler(m)),
         });
     }

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;

package/src/Router/Router.d.ts

@@ -16,7 +16,6 @@ import { HandlerContract } from '../Contracts/Context/HandlerContract';
 export declare class Router {
     routes: (Route | RouteResource | RouteGroup)[];
     private readonly openedGroups;
-    private getRecentGroup;
     private readonly http;
     private controllerInstance;
     constructor(http: Http);
@@ -35,4 +34,5 @@ export declare class Router {
     any(url: string, handler: HandlerContract | string): Route;
     register(): void;
     toRoutesJSON(routes?: any): any;
+    private getRecentGroup;
 }

package/src/Router/Router.js

@@ -20,9 +20,6 @@ class Router {
         this.routes = [];
         this.openedGroups = [];
     }
-    getRecentGroup() {
-        return this.openedGroups[this.openedGroups.length - 1];
-    }
     listRoutes() {
         return this.toRoutesJSON(this.routes);
     }
@@ -118,5 +115,8 @@ class Router {
             return list;
         }, []);
     }
+    getRecentGroup() {
+        return this.openedGroups[this.openedGroups.length - 1];
+    }
 }
 exports.Router = Router;

package/src/Utils/FastifyHandler.d.ts

@@ -11,14 +11,16 @@ import { HandlerContract } from '../Contracts/Context/HandlerContract';
 import { ErrorHandlerContract } from '../Contracts/Context/Error/ErrorHandlerContract';
 import { HandleHandlerContract } from '../Contracts/Context/Middlewares/Handle/HandleHandlerContract';
 import { InterceptHandlerContract } from '../Contracts/Context/Middlewares/Intercept/InterceptHandlerContract';
+import { TerminateHandlerContract } from '../Contracts/Context/Middlewares/Terminate/TerminateHandlerContract';
 declare module 'fastify' {
     interface FastifyRequest {
         data: Record<string, any>;
     }
 }
 export declare class FastifyHandler {
-    static createOnSendHandler(handler: InterceptHandlerContract): (req: any, res: any, payload: any, done: any) => any;
+    static createOnSendHandler(handler: InterceptHandlerContract): (req: any, _res: any, payload: any) => Promise<any>;
     static createDoneHandler(handler: HandleHandlerContract): (req: any, res: any, done: any) => any;
+    static createResponseHandler(handler: TerminateHandlerContract): (req: any, res: any, done: any) => any;
     static createErrorHandler(handler: ErrorHandlerContract): (error: any, req: FastifyRequest, res: FastifyReply) => any;
     static createRequestHandler(handler: HandlerContract): (req: FastifyRequest, res: FastifyReply) => Promise<any>;
 }

package/src/Utils/FastifyHandler.js

@@ -15,9 +15,8 @@ const Request_1 = require("../Context/Request");
 const Response_1 = require("../Context/Response");
 class FastifyHandler {
     static createOnSendHandler(handler) {
-        return (req, res, payload, done) => {
+        return async (req, _res, payload) => {
             const request = new Request_1.Request(req);
-            const response = new Response_1.Response(res);
             if (!req.data)
                 req.data = {};
             if (!req.query)
@@ -28,19 +27,17 @@ class FastifyHandler {
             if (utils_1.Is.Json(payload)) {
                 body = JSON.parse(body);
             }
-            return handler({
+            body = await handler({
                 request,
-                response,
                 body,
+                status: _res.statusCode,
                 params: req.params,
                 queries: req.query,
                 data: req.data,
-                next: (body, error = null) => {
-                    if (utils_1.Is.Object(body))
-                        body = JSON.stringify(body);
-                    done(error, body);
-                },
             });
+            if (utils_1.Is.Object(body))
+                body = JSON.stringify(body);
+            return body;
         };
     }
     static createDoneHandler(handler) {
@@ -63,6 +60,26 @@ class FastifyHandler {
             });
         };
     }
+    static createResponseHandler(handler) {
+        return (req, res, done) => {
+            const request = new Request_1.Request(req);
+            const response = new Response_1.Response(res);
+            if (!req.data)
+                req.data = {};
+            if (!req.query)
+                req.query = {};
+            if (!req.params)
+                req.params = {};
+            return handler({
+                request,
+                response,
+                params: req.params,
+                queries: req.query,
+                data: req.data,
+                next: done,
+            });
+        };
+    }
     static createErrorHandler(handler) {
         return (error, req, res) => {
             const request = new Request_1.Request(req);

package/src/Contracts/Context/Middlewares/Intercept/NextInterceptContract.js

@@ -1,10 +0,0 @@
-"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 });