@athenna/http 3.0.11 → 3.1.0

package/build/Router/RouteGroup.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @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 '#src/Router/Route';
+import { RouteResource } from '#src/Router/RouteResource';
+import { MiddlewareRouteType } from '#src/Types/Middlewares/MiddlewareRouteType';
+import { TerminatorRouteType } from '#src/Types/Middlewares/TerminatorRouteType';
+import { InterceptorRouteType } from '#src/Types/Middlewares/InterceptorRouteType';
+export declare class RouteGroup {
+    /**
+     * All routes registered in the group.
+     */
+    routes: (Route | RouteGroup | RouteResource)[];
+    constructor(routes: (Route | RouteGroup | RouteResource)[]);
+    /**
+     * Define prefix all the routes in the group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).prefix('/api/v1')
+     * ```
+     */
+    prefix(prefix: string): RouteGroup;
+    /**
+     * Add a middleware to all routes in the group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).middleware('auth')
+     * ```
+     */
+    middleware(middleware: MiddlewareRouteType): RouteGroup;
+    /**
+     * Add an interceptor to all routes in the group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).interceptor('response')
+     * ```
+     */
+    interceptor(interceptor: InterceptorRouteType): RouteGroup;
+    /**
+     * Add a terminator to all routes in the group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).terminator('log')
+     * ```
+     */
+    terminator(terminator: TerminatorRouteType): RouteGroup;
+    /**
+     * Set up helmet options for route group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).helmet({
+     *  dnsPrefetchControl: { allow: true }
+     * })
+     * ```
+     */
+    helmet(options: Omit<import('@fastify/helmet').FastifyHelmetOptions, 'global'>): RouteGroup;
+    /**
+     * Set up rate limit options for route group method.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).rateLimit({
+     *  max: 3,
+     *  timeWindow: '1 minute'
+     * })
+     * ```
+     */
+    rateLimit(options: import('@fastify/rate-limit').RateLimitOptions): RouteGroup;
+    /**
+     * Invokes a given method with params on the route instance or route
+     * resource instance.
+     */
+    private invoke;
+}

package/build/Router/RouteGroup.js

@@ -0,0 +1,123 @@
+/**
+ * @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 { RouteResource } from '#src/Router/RouteResource';
+export class RouteGroup {
+    /**
+     * All routes registered in the group.
+     */
+    // eslint-disable-next-line no-use-before-define
+    routes;
+    constructor(routes) {
+        this.routes = routes;
+    }
+    /**
+     * Define prefix all the routes in the group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).prefix('/api/v1')
+     * ```
+     */
+    prefix(prefix) {
+        this.routes.forEach(route => this.invoke(route, 'prefix', [prefix]));
+        return this;
+    }
+    /**
+     * Add a middleware to all routes in the group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).middleware('auth')
+     * ```
+     */
+    middleware(middleware) {
+        this.routes.forEach(route => this.invoke(route, 'middleware', [middleware, true]));
+        return this;
+    }
+    /**
+     * Add an interceptor to all routes in the group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).interceptor('response')
+     * ```
+     */
+    interceptor(interceptor) {
+        this.routes.forEach(route => this.invoke(route, 'interceptor', [interceptor, true]));
+        return this;
+    }
+    /**
+     * Add a terminator to all routes in the group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).terminator('log')
+     * ```
+     */
+    terminator(terminator) {
+        this.routes.forEach(route => this.invoke(route, 'terminator', [terminator, true]));
+        return this;
+    }
+    /**
+     * Set up helmet options for route group.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).helmet({
+     *  dnsPrefetchControl: { allow: true }
+     * })
+     * ```
+     */
+    helmet(options) {
+        this.routes.forEach(route => this.invoke(route, 'helmet', [options]));
+        return this;
+    }
+    /**
+     * Set up rate limit options for route group method.
+     *
+     * @example
+     * ```ts
+     * Route.group(() => {
+     *
+     * }).rateLimit({
+     *  max: 3,
+     *  timeWindow: '1 minute'
+     * })
+     * ```
+     */
+    rateLimit(options) {
+        this.routes.forEach(route => this.invoke(route, 'rateLimit', [options]));
+        return this;
+    }
+    /**
+     * Invokes a given method with params on the route instance or route
+     * resource instance.
+     */
+    invoke(route, method, params) {
+        if (route instanceof 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;
+        }
+        route[method](...params);
+    }
+}

package/build/Router/RouteResource.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @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 '#src/Router/Route';
+import { TerminatorRouteType } from '#src/Types/Middlewares/TerminatorRouteType';
+import { MiddlewareRouteType } from '#src/Types/Middlewares/MiddlewareRouteType';
+import { InterceptorRouteType } from '#src/Types/Middlewares/InterceptorRouteType';
+import { RouteResourceTypes } from '#src/Types/Router/RouteResourceTypes';
+export declare class RouteResource {
+    /**
+     * All routes registered in the resource.
+     */
+    routes: Route[];
+    /**
+     * The resource name.
+     */
+    resource: string;
+    /**
+     * The resource controller.
+     */
+    controller: any;
+    constructor(resource: string, controller: any);
+    /**
+     * Set a middleware for the route resource.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').middleware('auth')
+     * ```
+     */
+    middleware(middleware: MiddlewareRouteType, prepend?: boolean): RouteResource;
+    /**
+     * Set a interceptor for the route resource.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').interceptor('response')
+     * ```
+     */
+    interceptor(interceptor: InterceptorRouteType, prepend?: boolean): RouteResource;
+    /**
+     * Set a terminator for the route resource.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').terminator('response')
+     * ```
+     */
+    terminator(terminator: TerminatorRouteType, prepend?: boolean): RouteResource;
+    /**
+     * Register only the methods in the array.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').only(['index'])
+     * ```
+     */
+    only(names: RouteResourceTypes[]): RouteResource;
+    /**
+     * Register all methods except the methods in the array.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').except(['index'])
+     * ```
+     */
+    except(names: RouteResourceTypes[]): RouteResource;
+    /**
+     * Set up helmet options for route resource.
+     *
+     *@example
+     * ```ts
+     * Route.helmet({
+     *  dnsPrefetchControl: { allow: true }
+     * })
+     * ```
+     */
+    helmet(options: Omit<import('@fastify/helmet').FastifyHelmetOptions, 'global'>): RouteResource;
+    /**
+     * Set up rate limit options for route resource method.
+     *
+     * @example
+     * ```ts
+     * Route.rateLimit({
+     *  max: 3,
+     *  timeWindow: '1 minute'
+     * })
+     * ```
+     */
+    rateLimit(options: import('@fastify/rate-limit').RateLimitOptions): RouteResource;
+    /**
+     * Filter routes by name.
+     */
+    private filter;
+    /**
+     * Create the route.
+     */
+    private makeRoute;
+    /**
+     * Create all the routes.
+     */
+    private buildRoutes;
+}

package/build/Router/RouteResource.js

@@ -0,0 +1,158 @@
+/**
+ * @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 '#src/Router/Route';
+import { Is, String } from '@athenna/common';
+export class RouteResource {
+    /**
+     * All routes registered in the resource.
+     */
+    routes = [];
+    /**
+     * The resource name.
+     */
+    resource;
+    /**
+     * The resource controller.
+     */
+    controller;
+    constructor(resource, controller) {
+        this.resource = resource;
+        this.controller = controller;
+        this.buildRoutes();
+    }
+    /**
+     * Set a middleware for the route resource.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').middleware('auth')
+     * ```
+     */
+    middleware(middleware, prepend) {
+        this.routes.forEach(route => route.middleware(middleware, prepend));
+        return this;
+    }
+    /**
+     * Set a interceptor for the route resource.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').interceptor('response')
+     * ```
+     */
+    interceptor(interceptor, prepend) {
+        this.routes.forEach(route => route.interceptor(interceptor, prepend));
+        return this;
+    }
+    /**
+     * Set a terminator for the route resource.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').terminator('response')
+     * ```
+     */
+    terminator(terminator, prepend) {
+        this.routes.forEach(route => route.terminator(terminator, prepend));
+        return this;
+    }
+    /**
+     * Register only the methods in the array.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').only(['index'])
+     * ```
+     */
+    only(names) {
+        this.filter(names, true).forEach(route => (route.route.deleted = true));
+        return this;
+    }
+    /**
+     * Register all methods except the methods in the array.
+     *
+     * @example
+     * ```ts
+     * Route.resource('/test', 'TestController').except(['index'])
+     * ```
+     */
+    except(names) {
+        this.filter(names, false).forEach(route => (route.route.deleted = true));
+        return this;
+    }
+    /**
+     * Set up helmet options for route resource.
+     *
+     *@example
+     * ```ts
+     * Route.helmet({
+     *  dnsPrefetchControl: { allow: true }
+     * })
+     * ```
+     */
+    helmet(options) {
+        this.routes.forEach(route => route.helmet(options));
+        return this;
+    }
+    /**
+     * Set up rate limit options for route resource method.
+     *
+     * @example
+     * ```ts
+     * Route.rateLimit({
+     *  max: 3,
+     *  timeWindow: '1 minute'
+     * })
+     * ```
+     */
+    rateLimit(options) {
+        this.routes.forEach(route => route.rateLimit(options));
+        return this;
+    }
+    /**
+     * Filter routes by name.
+     */
+    filter(names, inverse = false) {
+        return this.routes.filter(route => {
+            const match = names.find(name => route.route.name.endsWith(name));
+            return inverse ? !match : match;
+        });
+    }
+    /**
+     * Create the route.
+     */
+    makeRoute(url, methods, action) {
+        let name = '';
+        let handler = '';
+        if (Is.String(this.controller)) {
+            name = `${this.controller}.${action}`;
+            handler = `${this.controller}.${action}`;
+        }
+        else {
+            name = `${this.controller.constructor.name}.${action}`;
+            handler = this.controller[action];
+        }
+        this.routes.push(new Route(url, methods, handler).name(name));
+    }
+    /**
+     * Create all the routes.
+     */
+    buildRoutes() {
+        const resourceTokens = this.resource.split('.');
+        const mainResource = resourceTokens.pop();
+        const fullUrl = `${resourceTokens
+            .map(string => `${string}/:${String.toSnakeCase(String.singularize(string))}_id`)
+            .join('/')}/${mainResource}`;
+        this.makeRoute(fullUrl, ['GET'], 'index');
+        this.makeRoute(fullUrl, ['POST'], 'store');
+        this.makeRoute(`${fullUrl}/:id`, ['GET'], 'show');
+        this.makeRoute(`${fullUrl}/:id`, ['PUT', 'PATCH'], 'update');
+        this.makeRoute(`${fullUrl}/:id`, ['DELETE'], 'delete');
+    }
+}

package/build/Router/Router.d.ts

@@ -0,0 +1,103 @@
+/**
+ * @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 '#src/Router/Route';
+import { RouteGroup } from '#src/Router/RouteGroup';
+import { RouteJSON } from '#src/Types/Router/RouteJSON';
+import { RouteResource } from '#src/Router/RouteResource';
+import { RequestHandler } from '#src/Types/Contexts/Context';
+import { RouteHandler } from '#src/Types/Router/RouteHandler';
+import { HTTPMethods, FastifyInstance, RouteOptions } from 'fastify';
+export declare class Router {
+    /**
+     * All routes registered.
+     */
+    routes: (Route | RouteGroup | RouteResource)[];
+    /**
+     * Route groups opened.
+     */
+    private openedGroups;
+    /**
+     * The controller instance.
+     */
+    private controllerInstance;
+    /**
+     * List the routes registered.
+     */
+    list(): RouteJSON[];
+    /**
+     * Set the controller instance.
+     */
+    controller(controller: any): this;
+    /**
+     * Add route for a given pattern and methods
+     */
+    route(pattern: string, methods: HTTPMethods[], handler: RouteHandler): Route;
+    /**
+     * Creates a vanilla fastify route without using Athenna router.
+     */
+    vanillaRoute(options?: RouteOptions): FastifyInstance;
+    /**
+     * Creates a new route resource.
+     */
+    resource(resource: string, controller?: any): RouteResource;
+    /**
+     * Define a route that handles all common HTTP methods.
+     */
+    any(pattern: string, handler: RequestHandler): Route;
+    /**
+     * Define GET route.
+     */
+    get(pattern: string, handler: RouteHandler): Route;
+    /**
+     * Define HEAD route.
+     */
+    head(pattern: string, handler: RouteHandler): Route;
+    /**
+     * Define POST route.
+     */
+    post(pattern: string, handler: RouteHandler): Route;
+    /**
+     * Define PUT route.
+     */
+    put(pattern: string, handler: RouteHandler): Route;
+    /**
+     * Define PATCH route.
+     */
+    patch(pattern: string, handler: RouteHandler): Route;
+    /**
+     * Define DELETE route.
+     */
+    delete(pattern: string, handler: RouteHandler): Route;
+    /**
+     * Define OPTIONS route.
+     */
+    options(pattern: string, handler: RouteHandler): Route;
+    /**
+     * Creates a group of routes. Anything applied in route groups will be applied
+     * in the routes that are inside that group.
+     */
+    group(callback: () => void): RouteGroup;
+    /**
+     * Register all the routes inside the http server. After routes are registered,
+     * anyone could be registered anymore.
+     */
+    register(): void;
+    /**
+     * Transform some route array to a route json array.
+     */
+    toJSON(routes: (Route | RouteGroup | RouteResource)[]): RouteJSON[];
+    /**
+     * Get the most recent route group created.
+     */
+    private getRecentGroup;
+    /**
+     * Indicates if if a valid controller handler method.
+     */
+    private isValidControllerHandler;
+}