@athenna/http 1.0.0

package/src/Router/Route.js

@@ -0,0 +1,99 @@
+"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.Route = void 0;
+require("@athenna/ioc");
+const utils_1 = require("@secjs/utils");
+const removeSlash_1 = require("../Utils/removeSlash");
+const isMiddlewareContract_1 = require("../Utils/isMiddlewareContract");
+const MiddlewareNotFoundException_1 = require("../Exceptions/MiddlewareNotFoundException");
+class Route {
+    constructor(url, methods, handler) {
+        this.url = url;
+        this.deleted = false;
+        this.methods = methods;
+        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;
+    }
+    as(name, prepend = false) {
+        this.name = prepend ? `${name}.${this.name}` : name;
+        return this;
+    }
+    namespace(namespace, overwrite = false) {
+        if (!this.routeNamespace || overwrite) {
+            this.routeNamespace = namespace;
+        }
+        return this;
+    }
+    middleware(middleware, type = 'handle', prepend = false) {
+        const dictionary = {
+            handle: 'handlers',
+            terminate: 'terminators',
+            intercept: 'interceptors',
+        };
+        const insertionType = prepend ? 'unshift' : 'push';
+        if (utils_1.Is.String(middleware)) {
+            const mid = ioc.use(`App/Middlewares/${middleware}`);
+            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);
+            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);
+            return this;
+        }
+        this.routeMiddlewares[dictionary[type]][insertionType](middleware);
+        return this;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            url: this.getUrl(),
+            handler: this.handler,
+            methods: this.methods,
+            middlewares: this.routeMiddlewares,
+            meta: {
+                namespace: this.routeNamespace,
+            },
+        };
+    }
+}
+exports.Route = Route;

package/src/Router/RouteGroup.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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 { Route } from './Route';
+import { RouteResource } from './RouteResource';
+import { MiddlewareTypes } from '../Contracts/MiddlewareTypes';
+import { MiddlewareContract } from '../Contracts/MiddlewareContract';
+import { HandlerContract } from '../Contracts/Context/HandlerContract';
+import { InterceptHandlerContract } from '../Contracts/Context/Middlewares/Intercept/InterceptHandlerContract';
+import { TerminateHandlerContract } from '../Contracts/Context/Middlewares/Terminate/TerminateHandlerContract';
+export declare class RouteGroup {
+    routes: (Route | RouteResource | RouteGroup)[];
+    constructor(routes: (Route | RouteResource | RouteGroup)[]);
+    private invoke;
+    prefix(prefix: string): this;
+    as(name: string): this;
+    namespace(namespace: string): this;
+    middleware(middleware: HandlerContract | MiddlewareContract | InterceptHandlerContract | TerminateHandlerContract | string, type?: MiddlewareTypes, prepend?: boolean): this;
+}

package/src/Router/RouteGroup.js

@@ -0,0 +1,51 @@
+"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.RouteGroup = void 0;
+const RouteResource_1 = require("./RouteResource");
+const CannotDefineGroupException_1 = require("../Exceptions/CannotDefineGroupException");
+class RouteGroup {
+    constructor(routes) {
+        this.routes = routes;
+    }
+    invoke(route, method, params) {
+        if (route instanceof RouteResource_1.RouteResource) {
+            route.routes.forEach(child => this.invoke(child, method, params));
+            return;
+        }
+        if (route instanceof RouteGroup) {
+            route.routes.forEach(child => this.invoke(child, method, params));
+            return;
+        }
+        if (method === 'as' && !route.name) {
+            throw new CannotDefineGroupException_1.CannotDefineGroupException();
+        }
+        route[method](...params);
+    }
+    prefix(prefix) {
+        this.routes.forEach(route => this.invoke(route, 'prefix', [prefix]));
+        return this;
+    }
+    as(name) {
+        this.routes.forEach(route => this.invoke(route, 'as', [name, true]));
+        return this;
+    }
+    namespace(namespace) {
+        this.routes.forEach(route => this.invoke(route, 'namespace', [namespace]));
+        return this;
+    }
+    middleware(middleware, type = 'handle', prepend = false) {
+        this.routes.forEach(route => {
+            this.invoke(route, 'middleware', [middleware, type, prepend]);
+        });
+        return this;
+    }
+}
+exports.RouteGroup = RouteGroup;

package/src/Router/RouteResource.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @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 { Route } from './Route';
+import { MiddlewareTypes } from '../Contracts/MiddlewareTypes';
+import { HandlerContract } from '../Contracts/Context/HandlerContract';
+import { InterceptHandlerContract } from '../Contracts/Context/Middlewares/Intercept/InterceptHandlerContract';
+import { TerminateHandlerContract } from '../Contracts/Context/Middlewares/Terminate/TerminateHandlerContract';
+import { MiddlewareContract } from '../Contracts/MiddlewareContract';
+export declare class RouteResource {
+    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;
+}

package/src/Router/RouteResource.js

@@ -0,0 +1,84 @@
+"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.RouteResource = void 0;
+const Route_1 = require("./Route");
+const utils_1 = require("@secjs/utils");
+class RouteResource {
+    constructor(resource, controller) {
+        this.routes = [];
+        this.resource = resource;
+        this.controller = controller;
+        this.resourceName = this.resource
+            .split('.')
+            .map(string => utils_1.String.toSnakeCase(string))
+            .join('.');
+        this.buildRoutes();
+    }
+    makeRoute(url, methods, action) {
+        let handler = '';
+        if (utils_1.Is.String(this.controller)) {
+            handler = `${this.controller}.${action}`;
+        }
+        else {
+            handler = this.controller[action];
+        }
+        const route = new Route_1.Route(url, methods, handler);
+        route.as(`${this.resourceName}.${action}`);
+        this.routes.push(route);
+    }
+    buildRoutes() {
+        this.resource = this.resource.replace(/^\//, '').replace(/\/$/, '');
+        const resourceTokens = this.resource.split('.');
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const mainResource = resourceTokens.pop();
+        const fullUrl = `${resourceTokens
+            .map(string => `${string}/:${utils_1.String.toSnakeCase(utils_1.String.singularize(string))}_id`)
+            .join('/')}/${mainResource}`;
+        this.makeRoute(fullUrl, ['HEAD', 'GET'], 'index');
+        this.makeRoute(fullUrl, ['POST'], 'store');
+        this.makeRoute(`${fullUrl}/:id`, ['HEAD', 'GET'], 'show');
+        this.makeRoute(`${fullUrl}/:id`, ['PUT', 'PATCH'], 'update');
+        this.makeRoute(`${fullUrl}/:id`, ['DELETE'], 'delete');
+    }
+    filter(names, inverse) {
+        return this.routes.filter(route => {
+            const match = names.find(name => route.name.endsWith(name));
+            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

@@ -0,0 +1,36 @@
+/**
+ * @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 { Route } from './Route';
+import { RouteGroup } from './RouteGroup';
+import { RouteResource } from './RouteResource';
+import { HttpMethodTypes } from '../Contracts/HttpMethodTypes';
+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();
+    listRoutes(): any;
+    controller(controller: any): this;
+    route(url: string, methods: HttpMethodTypes[], handler: HandlerContract | string): Route;
+    group(callback: () => void): RouteGroup;
+    resource(resource: string, controller: any): RouteResource;
+    get(url: string, handler: HandlerContract | string): Route;
+    head(url: string, handler: HandlerContract | string): Route;
+    post(url: string, handler: HandlerContract | string): Route;
+    put(url: string, handler: HandlerContract | string): Route;
+    patch(url: string, handler: HandlerContract | string): Route;
+    delete(url: string, handler: HandlerContract | string): Route;
+    options(url: string, handler: HandlerContract | string): Route;
+    any(url: string, handler: HandlerContract | string): Route;
+    register(): void;
+    toRoutesJSON(routes?: any): any;
+}

package/src/Router/Router.js

@@ -0,0 +1,123 @@
+"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.Router = void 0;
+const Http_1 = require("../Http");
+const Route_1 = require("./Route");
+const utils_1 = require("@secjs/utils");
+const ioc_1 = require("@athenna/ioc");
+const RouteGroup_1 = require("./RouteGroup");
+const RouteResource_1 = require("./RouteResource");
+class Router {
+    constructor() {
+        this.http = new ioc_1.Ioc().use('App/HttpServer') || new Http_1.Http();
+        this.routes = [];
+        this.openedGroups = [];
+    }
+    getRecentGroup() {
+        return this.openedGroups[this.openedGroups.length - 1];
+    }
+    listRoutes() {
+        return this.toRoutesJSON(this.routes);
+    }
+    controller(controller) {
+        this.controllerInstance = controller;
+        return this;
+    }
+    route(url, methods, handler) {
+        if (this.controllerInstance &&
+            utils_1.Is.String(handler) &&
+            !handler.includes('.')) {
+            handler = this.controllerInstance[handler];
+        }
+        const route = new Route_1.Route(url, methods, handler);
+        const openedGroup = this.getRecentGroup();
+        if (openedGroup) {
+            openedGroup.routes.push(route);
+        }
+        else {
+            this.routes.push(route);
+        }
+        return route;
+    }
+    group(callback) {
+        const group = new RouteGroup_1.RouteGroup([]);
+        const openedGroup = this.getRecentGroup();
+        if (openedGroup) {
+            openedGroup.routes.push(group);
+        }
+        else {
+            this.routes.push(group);
+        }
+        this.openedGroups.push(group);
+        callback();
+        this.openedGroups.pop();
+        return group;
+    }
+    resource(resource, controller) {
+        const resourceInstance = new RouteResource_1.RouteResource(resource, controller);
+        const openedGroup = this.getRecentGroup();
+        if (openedGroup) {
+            openedGroup.routes.push(resourceInstance);
+        }
+        else {
+            this.routes.push(resourceInstance);
+        }
+        return resourceInstance;
+    }
+    get(url, handler) {
+        return this.route(url, ['GET', 'HEAD'], handler);
+    }
+    head(url, handler) {
+        return this.route(url, ['HEAD'], handler);
+    }
+    post(url, handler) {
+        return this.route(url, ['POST'], handler);
+    }
+    put(url, handler) {
+        return this.route(url, ['PUT'], handler);
+    }
+    patch(url, handler) {
+        return this.route(url, ['PATCH'], handler);
+    }
+    delete(url, handler) {
+        return this.route(url, ['DELETE'], handler);
+    }
+    options(url, handler) {
+        return this.route(url, ['OPTIONS'], handler);
+    }
+    any(url, handler) {
+        return this.route(url, ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'], handler);
+    }
+    register() {
+        this.toRoutesJSON(this.routes).forEach(route => {
+            route.methods.forEach(method => {
+                this.http[method.toLowerCase()](route.url, route.handler, route.middlewares);
+            });
+        });
+    }
+    toRoutesJSON(routes) {
+        return routes.reduce((list, route) => {
+            if (route instanceof RouteGroup_1.RouteGroup) {
+                list = list.concat(this.toRoutesJSON(route.routes));
+                return list;
+            }
+            if (route instanceof RouteResource_1.RouteResource) {
+                list = list.concat(this.toRoutesJSON(route.routes));
+                return list;
+            }
+            if (!route.deleted) {
+                list.push(route.toJSON());
+            }
+            return list;
+        }, []);
+    }
+}
+exports.Router = Router;

package/src/Utils/FastifyHandler.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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 { FastifyReply, FastifyRequest } from 'fastify';
+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';
+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 createDoneHandler(handler: HandleHandlerContract): (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

@@ -0,0 +1,106 @@
+"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.FastifyHandler = void 0;
+/* eslint-disable @typescript-eslint/no-empty-function */
+const utils_1 = require("@secjs/utils");
+const Request_1 = require("../Context/Request");
+const Response_1 = require("../Context/Response");
+class FastifyHandler {
+    static createOnSendHandler(handler) {
+        return (req, res, payload, 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 = {};
+            let body = payload;
+            if (utils_1.Is.Json(payload)) {
+                body = JSON.parse(body);
+            }
+            return handler({
+                request,
+                response,
+                body,
+                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);
+                },
+            });
+        };
+    }
+    static createDoneHandler(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);
+            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,
+                error,
+            });
+        };
+    }
+    static createRequestHandler(handler) {
+        return async (req, res) => {
+            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,
+            });
+        };
+    }
+}
+exports.FastifyHandler = FastifyHandler;

package/src/Utils/defaultErrorHandler.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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 { ErrorContextContract } from '../Contracts/Context/Error/ErrorContextContract';
+export declare function defaultErrorHandler({ error, request, response, }: ErrorContextContract): void;

package/src/Utils/defaultErrorHandler.js

@@ -0,0 +1,30 @@
+"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.defaultErrorHandler = void 0;
+const utils_1 = require("@secjs/utils");
+function defaultErrorHandler({ error, request, response, }) {
+    const code = error.code || error.name;
+    const statusCode = error.statusCode || error.status || 500;
+    const body = {
+        code: utils_1.String.toSnakeCase(code).toUpperCase(),
+        path: request.baseUrl,
+        method: request.method,
+        status: statusCode <= 399 ? 'SUCCESS' : 'ERROR',
+        statusCode: statusCode,
+        error: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        },
+    };
+    response.status(statusCode).send(body);
+}
+exports.defaultErrorHandler = defaultErrorHandler;

package/src/Utils/isMiddlewareContract.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @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 { MiddlewareContract } from '../Contracts/MiddlewareContract';
+export declare function isMiddlewareContract(object: any): object is MiddlewareContract;

package/src/Utils/isMiddlewareContract.js

@@ -0,0 +1,15 @@
+"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.isMiddlewareContract = void 0;
+function isMiddlewareContract(object) {
+    return 'handle' in object || 'intercept' in object || 'terminate' in object;
+}
+exports.isMiddlewareContract = isMiddlewareContract;

package/src/Utils/removeSlash.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @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.
+ */
+export declare function removeSlash(url: string | string[]): string | string[];