@athenna/http 3.0.11 → 3.1.0

package/build/Router/Router.js

@@ -0,0 +1,188 @@
+/**
+ * @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 { Is } from '@athenna/common';
+import { Route } from '#src/Router/Route';
+import { Server } from '#src/Facades/Server';
+import { RouteGroup } from '#src/Router/RouteGroup';
+import { RouteResource } from '#src/Router/RouteResource';
+import { UndefinedMethodException } from '#src/Exceptions/UndefinedMethodException';
+export class Router {
+    /**
+     * All routes registered.
+     */
+    routes = [];
+    /**
+     * Route groups opened.
+     */
+    openedGroups = [];
+    /**
+     * The controller instance.
+     */
+    controllerInstance;
+    /**
+     * List the routes registered.
+     */
+    list() {
+        return this.toJSON(this.routes);
+    }
+    /**
+     * Set the controller instance.
+     */
+    controller(controller) {
+        if (Is.String(controller)) {
+            controller = ioc.safeUse(`App/Http/Controllers/${controller}`);
+        }
+        this.controllerInstance = controller;
+        return this;
+    }
+    /**
+     * Add route for a given pattern and methods
+     */
+    route(pattern, methods, handler) {
+        if (this.isValidControllerHandler(handler)) {
+            if (!this.controllerInstance[handler]) {
+                throw new UndefinedMethodException(handler, this.controllerInstance.name);
+            }
+            handler = this.controllerInstance[handler];
+        }
+        const route = new Route(pattern, methods, handler);
+        const openedGroup = this.getRecentGroup();
+        if (openedGroup) {
+            openedGroup.routes.push(route);
+        }
+        else {
+            this.routes.push(route);
+        }
+        return route;
+    }
+    /**
+     * Creates a vanilla fastify route without using Athenna router.
+     */
+    vanillaRoute(options) {
+        return Server.fastify.route(options);
+    }
+    /**
+     * Creates a new route resource.
+     */
+    resource(resource, controller) {
+        const resourceInstance = new RouteResource(resource, controller || this.controllerInstance);
+        const openedGroup = this.getRecentGroup();
+        if (openedGroup) {
+            openedGroup.routes.push(resourceInstance);
+        }
+        else {
+            this.routes.push(resourceInstance);
+        }
+        return resourceInstance;
+    }
+    /**
+     * Define a route that handles all common HTTP methods.
+     */
+    any(pattern, handler) {
+        return this.route(pattern, ['HEAD', 'OPTIONS', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE'], handler);
+    }
+    /**
+     * Define GET route.
+     */
+    get(pattern, handler) {
+        return this.route(pattern, ['GET', 'HEAD'], handler);
+    }
+    /**
+     * Define HEAD route.
+     */
+    head(pattern, handler) {
+        return this.route(pattern, ['HEAD'], handler);
+    }
+    /**
+     * Define POST route.
+     */
+    post(pattern, handler) {
+        return this.route(pattern, ['POST'], handler);
+    }
+    /**
+     * Define PUT route.
+     */
+    put(pattern, handler) {
+        return this.route(pattern, ['PUT'], handler);
+    }
+    /**
+     * Define PATCH route.
+     */
+    patch(pattern, handler) {
+        return this.route(pattern, ['PATCH'], handler);
+    }
+    /**
+     * Define DELETE route.
+     */
+    delete(pattern, handler) {
+        return this.route(pattern, ['DELETE'], handler);
+    }
+    /**
+     * Define OPTIONS route.
+     */
+    options(pattern, handler) {
+        return this.route(pattern, ['OPTIONS'], handler);
+    }
+    /**
+     * Creates a group of routes. Anything applied in route groups will be applied
+     * in the routes that are inside that group.
+     */
+    group(callback) {
+        const group = new 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;
+    }
+    /**
+     * Register all the routes inside the http server. After routes are registered,
+     * anyone could be registered anymore.
+     */
+    register() {
+        this.toJSON(this.routes).forEach(route => Server.route(route));
+    }
+    /**
+     * Transform some route array to a route json array.
+     */
+    toJSON(routes) {
+        return routes.reduce((list, route) => {
+            if (route instanceof RouteGroup) {
+                list = list.concat(this.toJSON(route.routes));
+                return list;
+            }
+            if (route instanceof RouteResource) {
+                list = list.concat(this.toJSON(route.routes));
+                return list;
+            }
+            if (!route.route.deleted) {
+                list.push(route.toJSON());
+            }
+            return list;
+        }, []);
+    }
+    /**
+     * Get the most recent route group created.
+     */
+    getRecentGroup() {
+        return this.openedGroups[this.openedGroups.length - 1];
+    }
+    /**
+     * Indicates if if a valid controller handler method.
+     */
+    isValidControllerHandler(handler) {
+        return (this.controllerInstance && Is.String(handler) && !handler.includes('.'));
+    }
+}

package/build/Server/ServerImpl.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @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.
+ */
+/// <reference types="node" resolution-mode="require"/>
+import { InjectOptions, FastifyInstance, PrintRoutesOptions, FastifyListenOptions, FastifyServerOptions, LightMyRequestChain, LightMyRequestResponse } from 'fastify';
+import { InterceptHandler, TerminateHandler } from '#src/Types/Middlewares/MiddlewareHandler';
+import { AddressInfo } from 'node:net';
+import { RouteJSON } from '#src/Types/Router/RouteJSON';
+import { RequestHandler } from '#src/Types/Contexts/Context';
+import { ErrorHandler } from '#src/Types/Contexts/ErrorContext';
+export declare class ServerImpl {
+    /**
+     * Holds the fastify server instance.
+     */
+    fastify: FastifyInstance;
+    /**
+     * Set if the Http server is listening for new requests.
+     */
+    isListening: boolean;
+    constructor(options?: FastifyServerOptions);
+    /**
+     * Get the representation of the internal radix tree used by the
+     * router.
+     */
+    getRoutes(options?: PrintRoutesOptions): string;
+    /**
+     * Get the address info of the server. This method will return the
+     * port used to listen the server, the family (IPv4, IPv6) and the
+     * server address (127.0.0.1).
+     */
+    getAddressInfo(): AddressInfo;
+    /**
+     * Get the port where the server is running.
+     */
+    getPort(): number;
+    /**
+     * Get the host where the server is running.
+     */
+    getHost(): string;
+    /**
+     * Get the fastify version that is running the server.
+     */
+    getFastifyVersion(): string;
+    getSwagger(): import('openapi-types').OpenAPI.Document;
+    getSwagger(options: {
+        yaml: true;
+    }): string;
+    getSwagger(options: {
+        yaml: false;
+    }): import('openapi-types').OpenAPI.Document;
+    /**
+     * Set the error handler to handle errors that happens inside the server.
+     */
+    setErrorHandler(handler: ErrorHandler): ServerImpl;
+    /**
+     * Register a plugin inside the fastify server.
+     */
+    plugin(plugin: any, options?: any): Promise<void>;
+    /**
+     * Create a middleware that will be executed before the request gets
+     * inside the route handler.
+     */
+    middleware(handler: RequestHandler): ServerImpl;
+    /**
+     * Create an interceptor that will be executed before the response
+     * is returned. At this point you can still make modifications in the
+     * response.
+     */
+    intercept(handler: InterceptHandler): ServerImpl;
+    /**
+     * Create and terminator that will be executed after the response
+     * is returned. At this point you cannot make modifications in the
+     * response.
+     */
+    terminate(handler: TerminateHandler): ServerImpl;
+    /**
+     * Return a request handler to make internal requests to the Http server.
+     */
+    request(): LightMyRequestChain;
+    /**
+     * Return a request handler to make internal requests to the Http server.
+     */
+    request(options: InjectOptions): Promise<LightMyRequestResponse>;
+    /**
+     * Make the server start listening for requests.
+     */
+    listen(options: FastifyListenOptions): Promise<any>;
+    /**
+     * Close the server,
+     */
+    close(): Promise<void>;
+    /**
+     * Add a new route to the http server.
+     */
+    route(options: RouteJSON): void;
+    /**
+     * Add a new GET route to the http server.
+     */
+    get(options: Omit<RouteJSON, 'methods'>): void;
+    /**
+     * Add a new HEAD route to the http server.
+     */
+    head(options: Omit<RouteJSON, 'methods'>): void;
+    /**
+     * Add a new POST route to the http server.
+     */
+    post(options: Omit<RouteJSON, 'methods'>): void;
+    /**
+     * Add a new PUT route to the http server.
+     */
+    put(options: Omit<RouteJSON, 'methods'>): void;
+    /**
+     * Add a new PATCH route to the http server.
+     */
+    patch(options: Omit<RouteJSON, 'methods'>): void;
+    /**
+     * Add a new DELETE route to the http server.
+     */
+    delete(options: Omit<RouteJSON, 'methods'>): void;
+    /**
+     * Add a new OPTIONS route to the http server.
+     */
+    options(options: Omit<RouteJSON, 'methods'>): void;
+}

package/build/Server/ServerImpl.js

@@ -0,0 +1,213 @@
+/**
+ * @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 fastify from 'fastify';
+import { Options } from '@athenna/common';
+import { FastifyHandler } from '#src/Handlers/FastifyHandler';
+export class ServerImpl {
+    /**
+     * Holds the fastify server instance.
+     */
+    fastify;
+    /**
+     * Set if the Http server is listening for new requests.
+     */
+    isListening;
+    constructor(options) {
+        this.fastify = fastify.fastify(options);
+        this.isListening = false;
+    }
+    /**
+     * Get the representation of the internal radix tree used by the
+     * router.
+     */
+    getRoutes(options) {
+        return this.fastify.printRoutes(options);
+    }
+    /**
+     * Get the address info of the server. This method will return the
+     * port used to listen the server, the family (IPv4, IPv6) and the
+     * server address (127.0.0.1).
+     */
+    getAddressInfo() {
+        return this.fastify.server.address();
+    }
+    /**
+     * Get the port where the server is running.
+     */
+    getPort() {
+        return this.getAddressInfo()?.port;
+    }
+    /**
+     * Get the host where the server is running.
+     */
+    getHost() {
+        return this.getAddressInfo()?.address;
+    }
+    /**
+     * Get the fastify version that is running the server.
+     */
+    getFastifyVersion() {
+        return this.fastify.version;
+    }
+    /**
+     * Return the swagger documentation generated by routes if using the
+     * @fastify/swagger plugin in the server. If the plugin is not installed
+     * will return null.
+     */
+    getSwagger(options) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const swagger = this.fastify.swagger;
+        if (!swagger) {
+            return null;
+        }
+        return swagger(options);
+    }
+    /**
+     * Set the error handler to handle errors that happens inside the server.
+     */
+    setErrorHandler(handler) {
+        this.fastify.setErrorHandler(FastifyHandler.error(handler));
+        return this;
+    }
+    /**
+     * Register a plugin inside the fastify server.
+     */
+    async plugin(plugin, options) {
+        await this.fastify.register(plugin, options);
+    }
+    /**
+     * Create a middleware that will be executed before the request gets
+     * inside the route handler.
+     */
+    middleware(handler) {
+        this.fastify.addHook('preHandler', FastifyHandler.handle(handler));
+        return this;
+    }
+    /**
+     * Create an interceptor that will be executed before the response
+     * is returned. At this point you can still make modifications in the
+     * response.
+     */
+    intercept(handler) {
+        this.fastify.addHook('onSend', FastifyHandler.intercept(handler));
+        return this;
+    }
+    /**
+     * Create and terminator that will be executed after the response
+     * is returned. At this point you cannot make modifications in the
+     * response.
+     */
+    terminate(handler) {
+        this.fastify.addHook('onResponse', FastifyHandler.terminate(handler));
+        return this;
+    }
+    /**
+     * Return a request handler to make internal requests to the Http server.
+     */
+    request(options) {
+        if (!options) {
+            return this.fastify.inject();
+        }
+        return this.fastify.inject(options);
+    }
+    /**
+     * Make the server start listening for requests.
+     */
+    async listen(options) {
+        return this.fastify.listen(options).then(() => (this.isListening = true));
+    }
+    /**
+     * Close the server,
+     */
+    async close() {
+        if (!this.isListening) {
+            return;
+        }
+        await this.fastify.close().then(() => (this.isListening = true));
+    }
+    /**
+     * Add a new route to the http server.
+     */
+    route(options) {
+        if (!options.middlewares) {
+            options.middlewares = {};
+        }
+        options.middlewares = Options.create(options.middlewares, {
+            middlewares: [],
+            terminators: [],
+            interceptors: [],
+        });
+        if (options.methods.length === 2 && options.methods.includes('HEAD')) {
+            this.route({ ...options, methods: ['GET'] });
+            this.route({
+                ...options,
+                methods: ['HEAD'],
+                fastify: {
+                    ...options.fastify,
+                    schema: { ...options.fastify.schema, hide: true },
+                },
+            });
+            return;
+        }
+        this.fastify.route({
+            url: options.url,
+            method: options.methods,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            handler: FastifyHandler.request(options.handler),
+            preHandler: options.middlewares.middlewares.map(m => FastifyHandler.handle(m)),
+            onSend: options.middlewares.interceptors.map(m => FastifyHandler.intercept(m)),
+            onResponse: options.middlewares.terminators.map(m => FastifyHandler.terminate(m)),
+            ...options.fastify,
+        });
+    }
+    /**
+     * Add a new GET route to the http server.
+     */
+    get(options) {
+        this.route({ ...options, methods: ['GET'] });
+    }
+    /**
+     * Add a new HEAD route to the http server.
+     */
+    head(options) {
+        this.route({ ...options, methods: ['HEAD'] });
+    }
+    /**
+     * Add a new POST route to the http server.
+     */
+    post(options) {
+        this.route({ ...options, methods: ['POST'] });
+    }
+    /**
+     * Add a new PUT route to the http server.
+     */
+    put(options) {
+        this.route({ ...options, methods: ['PUT'] });
+    }
+    /**
+     * Add a new PATCH route to the http server.
+     */
+    patch(options) {
+        this.route({ ...options, methods: ['PATCH'] });
+    }
+    /**
+     * Add a new DELETE route to the http server.
+     */
+    delete(options) {
+        this.route({ ...options, methods: ['DELETE'] });
+    }
+    /**
+     * Add a new OPTIONS route to the http server.
+     */
+    options(options) {
+        this.route({ ...options, methods: ['OPTIONS'] });
+    }
+}

package/build/Types/Contexts/Context.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 { Request } from '#src/Context/Request';
+import { Response } from '#src/Context/Response';
+export type Context = {
+    request: Request;
+    response: Response;
+    data: any;
+    body: any;
+    params: any;
+    queries: any;
+    headers: any;
+};
+export type RequestHandler = (ctx: Context) => any | Promise<any>;

package/build/Types/Contexts/Context.js

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

package/build/Types/Contexts/ErrorContext.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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 { Request } from '#src/Context/Request';
+import { Response } from '#src/Context/Response';
+export type ErrorContext = {
+    request: Request;
+    response: Response;
+    data: any;
+    body: any;
+    error: any;
+    params: any;
+    queries: any;
+    headers: any;
+};
+export type ErrorHandler = (ctx: ErrorContext) => Promise<void>;

package/build/Types/Contexts/ErrorContext.js

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

package/build/Types/Contexts/InterceptContext.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @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 { Request } from '#src/Context/Request';
+import { Response } from '#src/Context/Response';
+export type InterceptContext = {
+    request: Request;
+    response: Response;
+    data: any;
+    body: any;
+    params: any;
+    queries: any;
+    headers: any;
+    status: number;
+};

package/build/Types/Contexts/InterceptContext.js

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

package/build/Types/Contexts/TerminateContext.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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 { Request } from '#src/Context/Request';
+import { Response } from '#src/Context/Response';
+export type TerminateContext = {
+    request: Request;
+    response: Response;
+    data: any;
+    body: any;
+    params: any;
+    queries: any;
+    headers: any;
+    status: number;
+    responseTime: number;
+};

package/build/Types/Contexts/TerminateContext.js

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

package/build/Types/Controllers/ControllerOptions.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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 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.
+     *
+     * @default App/Http/Controllers/YourControllerClassName
+     */
+    alias?: string;
+    /**
+     * The registration type that will be used to register your controller
+     * inside the service provider.
+     *
+     * @default transient
+     */
+    type?: 'fake' | 'scoped' | 'singleton' | 'transient';
+};

package/build/Types/Controllers/ControllerOptions.js

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