@athenna/http 4.25.0 → 4.27.0

package/src/context/Request.js

@@ -7,82 +7,319 @@
  * file that was distributed with this source code.
  */
 import { Is, Json } from '@athenna/common';
-export function request(req) {
-    const request = {
-        request: req,
-        id: req.id,
-        ip: req.ip,
-        hostname: req.hostname,
-        get port() {
-            return request.getAddressInfo().port;
-        },
-        version: req.raw.httpVersion,
-        protocol: req.protocol,
-        method: req.method,
-        baseUrl: req.url.split('?')[0],
-        get baseHostUrl() {
-            return request.getHostUrlFor(request.baseUrl);
-        },
-        routeUrl: req.routeOptions.url,
-        get routeHostUrl() {
-            return request.getHostUrlFor(request.routeUrl);
-        },
-        originalUrl: req.url,
-        get originalHostUrl() {
-            return request.getHostUrlFor(request.originalUrl);
-        },
-        body: req.body || {},
-        params: req.params || {},
-        queries: req.query || {},
-        headers: req.headers || {},
-        param(param, defaultValue) {
-            return Json.get(request.params, param, defaultValue);
-        },
-        query(query, defaultValue) {
-            return Json.get(request.queries, query, defaultValue);
-        },
-        header(header, defaultValue) {
-            return Json.get(request.headers, header, defaultValue);
-        },
-        input(key, defaultValue) {
-            return request.payload(key, defaultValue);
-        },
-        payload(key, defaultValue) {
-            return Json.get(request.body, key, defaultValue);
-        },
-        only(keys) {
-            const body = {};
-            Object.keys(request.body).forEach(key => {
-                if (!keys.includes(key)) {
-                    return;
-                }
-                body[key] = request.body[key];
-            });
-            return body;
-        },
-        except(keys) {
-            const body = {};
-            Object.keys(request.body).forEach(key => {
-                if (keys.includes(key)) {
-                    return;
-                }
-                body[key] = request.body[key];
-            });
-            return body;
-        },
-        getHostUrlFor(url) {
-            let { address, port } = request.getAddressInfo();
-            if (address === '::1') {
-                address = '127.0.0.1';
+export class Request {
+    constructor(request) {
+        this.request = request;
+    }
+    /**
+     * Get the request id.
+     *
+     * @example
+     * ```ts
+     * console.log(request.id) // '12345'
+     * ```
+     */
+    get id() {
+        return this.request.id;
+    }
+    /**
+     * Get the request ip.
+     *
+     * @example
+     * ```ts
+     * console.log(request.ip) // '192.168.0.1'
+     * ```
+     */
+    get ip() {
+        return this.request.ip;
+    }
+    /**
+     * Get the request hostname.
+     *
+     * @example
+     * ```ts
+     * console.log(request.hostname) // 'localhost'
+     * ```
+     */
+    get hostname() {
+        return this.request.hostname;
+    }
+    /**
+     * Get the server port.
+     *
+     * @example
+     * ```ts
+     * console.log(request.port) // 3000
+     * ```
+     */
+    get port() {
+        return this.getAddressInfo().port;
+    }
+    /**
+     * Get the http version.
+     *
+     * @example
+     * ```ts
+     * console.log(request.version) // 1
+     * ```
+     */
+    get version() {
+        return this.request.raw.httpVersion;
+    }
+    /**
+     * Get the request protocol.
+     *
+     * @example
+     * ```ts
+     * console.log(request.protocol) // 'http'
+     * ```
+     */
+    get protocol() {
+        return this.request.protocol;
+    }
+    /**
+     * Get the request method.
+     *
+     * @example
+     * ```ts
+     * console.log(request.method) // 'GET'
+     * ```
+     */
+    get method() {
+        return this.request.method;
+    }
+    /**
+     * Get the base url from request.
+     *
+     * @example
+     * ```ts
+     * console.log(request.baseUrl) // '/users/1'
+     * ```
+     */
+    get baseUrl() {
+        return this.request.url.split('?')[0];
+    }
+    /**
+     * Get the base url with host and port info from request.
+     *
+     * @example
+     * ```ts
+     * console.log(request.baseHostUrl) // 'http://localhost:3030/users/1'
+     * ```
+     */
+    get baseHostUrl() {
+        return this.getHostUrlFor(this.baseUrl);
+    }
+    /**
+     * Get the route url from request.
+     *
+     * @example
+     * ```ts
+     * console.log(request.routeUrl) // '/users/:id'
+     * ```
+     */
+    get routeUrl() {
+        return this.request.routeOptions.url;
+    }
+    /**
+     * Get the route url with host and port info from request.
+     *
+     * @example
+     * ```ts
+     * console.log(request.routeHostUrl) // 'http://localhost:3030/users/:id'
+     * ```
+     */
+    get routeHostUrl() {
+        return this.getHostUrlFor(this.routeUrl);
+    }
+    /**
+     * Get the original url from request.
+     *
+     * @example
+     * ```ts
+     * console.log(request.originalUrl) // '/users/1?query=true'
+     * ```
+     */
+    get originalUrl() {
+        return this.request.url;
+    }
+    /**
+     * Get the original url with host and port info from request.
+     *
+     * @example
+     * ```ts
+     * console.log(request.originalHostUrl) // 'http://localhost:3000/users/1?query=true'
+     * ```
+     */
+    get originalHostUrl() {
+        return this.getHostUrlFor(this.originalUrl);
+    }
+    /**
+     * Get all body from request.
+     *
+     * @example
+     * ```ts
+     * const { name, email } = request.body
+     * ```
+     */
+    get body() {
+        return this.request.body || {};
+    }
+    /**
+     * Get all params from request.
+     *
+     * @example
+     * ```ts
+     * const { id } = request.params
+     * ```
+     */
+    get params() {
+        return this.request.params || {};
+    }
+    /**
+     * Get all queries from request.
+     *
+     * @example
+     * ```ts
+     * const { page, limit } = request.queries
+     * ```
+     */
+    get queries() {
+        return this.request.query || {};
+    }
+    /**
+     * Get all headers from request.
+     *
+     * @example
+     * ```ts
+     * const { accept } = request.headers
+     * ```
+     */
+    get headers() {
+        return this.request.headers || {};
+    }
+    /**
+     * Get a value from the request params or return
+     * the default value.
+     *
+     * @example
+     * ```ts
+     * const id = request.param('id', '1')
+     * ```
+     */
+    param(param, defaultValue) {
+        return Json.get(this.params, param, defaultValue);
+    }
+    /**
+     * Get a value from the request query param or return
+     * the default value.
+     *
+     * @example
+     * ```ts
+     * const page = request.query('page', '1')
+     * ```
+     */
+    query(query, defaultValue) {
+        return Json.get(this.queries, query, defaultValue);
+    }
+    /**
+     * Get a value from the request header or return
+     * the default value.
+     *
+     * @example
+     * ```ts
+     * const accept = request.header('accept', 'application/json')
+     * ```
+     */
+    header(header, defaultValue) {
+        return Json.get(this.headers, header, defaultValue);
+    }
+    /**
+     * Get a value from the request body or return
+     * the default value.
+     *
+     * @example
+     * ```ts
+     * const name = request.input('name', 'lenon')
+     * ```
+     */
+    input(key, defaultValue) {
+        return this.payload(key, defaultValue);
+    }
+    /**
+     * Get a value from the request body or return
+     * the default value.
+     *
+     * @example
+     * ```ts
+     * const name = request.payload('name', 'lenon')
+     * ```
+     */
+    payload(key, defaultValue) {
+        return Json.get(this.body, key, defaultValue);
+    }
+    /**
+     * Get only the selected values from the request body.
+     *
+     * @example
+     * ```ts
+     * const body = request.only(['name', 'email'])
+     * ```
+     */
+    only(keys) {
+        const body = {};
+        Object.keys(this.body).forEach(key => {
+            if (!keys.includes(key)) {
+                return;
             }
-            if (!Is.Ip(address) && address !== 'localhost') {
-                return `${request.protocol}://${address}${url}`;
+            body[key] = this.body[key];
+        });
+        return body;
+    }
+    /**
+     * Get all the values from the request body except the
+     * selected ones.
+     *
+     * @example
+     * ```ts
+     * const body = request.except(['name'])
+     * ```
+     */
+    except(keys) {
+        const body = {};
+        Object.keys(this.body).forEach(key => {
+            if (keys.includes(key)) {
+                return;
             }
-            return `${request.protocol}://${address}:${port}${url}`;
-        },
-        getAddressInfo() {
-            return req.server.server.address();
+            body[key] = this.body[key];
+        });
+        return body;
+    }
+    /**
+     * Get the original fastify request.
+     */
+    getFastifyRequest() {
+        return this.request;
+    }
+    /**
+     * Add the hostname and port to the url.
+     */
+    getHostUrlFor(url) {
+        let { address, port } = this.getAddressInfo();
+        if (address === '::1') {
+            address = '127.0.0.1';
         }
-    };
-    return request;
+        if (!Is.Ip(address) && address !== 'localhost') {
+            return `${this.protocol}://${address}${url}`;
+        }
+        return `${this.protocol}://${address}:${port}${url}`;
+    }
+    /**
+     * 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.request.server.server.address();
+    }
 }

package/src/context/Response.d.ts

@@ -7,8 +7,213 @@
  * file that was distributed with this source code.
  */
 import type { FastifyReply } from 'fastify';
-import type { Request, Response } from '#src/types';
-/**
- * Create the Athenna response object
- */
-export declare function response(reply: FastifyReply, request?: Request): Response;
+import type { SendOptions } from '@fastify/static';
+import type { FastifyHelmetOptions } from '@fastify/helmet';
+export declare class Response {
+    /**
+     * The fastify response object.
+     */
+    private response;
+    /**
+     * The request object from request context.
+     */
+    private request;
+    constructor(response: FastifyReply, request?: Request);
+    /**
+     * Verify if the response has been already sent. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * if (response.sent) {
+     *  // do something
+     * }
+     * ```
+     */
+    get sent(): boolean;
+    /**
+     * Get the response body sent in response. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * const { createdAt, updatedAt } = response.body
+     * ```
+     */
+    get body(): any | any[];
+    /**
+     * Get the status code sent in response. Keep
+     * in mind that this method will only return `true`
+     * after `response.send()`, `response.view()`,
+     * `response.sendFile()` or `response.download()` methods
+     * call.
+     *
+     * @example
+     * ```ts
+     * if (response.statusCode !== 200) {
+     *  // do something
+     * }
+     * ```
+     */
+    get statusCode(): number;
+    /**
+     * Get the headers set in the response.
+     *
+     * @example
+     * ```ts
+     * const headers = response.headers
+     * ```
+     */
+    get headers(): any;
+    /**
+     * Get the time in MS of how much the request has
+     * taken to response. Keep in mind that this method
+     * will only return `true` after `response.send()`,
+     * `response.view()`, `response.sendFile()` or
+     * `response.download()` methods call.
+     *
+     * @example
+     * ```ts
+     * console.log(response.responseTime) // 1000
+     * ```
+     */
+    get responseTime(): number;
+    /**
+     * Terminate the request sending a view to be rendered.
+     *
+     * @example
+     * ```ts
+     * return response.view('welcome', { name: 'lenon' })
+     * ```
+     */
+    view(view: string, data?: any): Promise<Response>;
+    /**
+     * Terminate the request sending the response body or not.
+     *
+     * @example
+     * ```ts
+     * return response.send({ name: 'lenon' })
+     * ```
+     */
+    send(data?: any): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.sendFile('img.png')
+     * ```
+     */
+    sendFile(filename: string, filepath?: string): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.sendFile('img.png', { cacheControl: false })
+     * ```
+     */
+    sendFile(filename: string, options?: string | SendOptions): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.sendFile('img.png', Path.tmp(), {
+     *  cacheControl: false
+     * })
+     * ```
+     */
+    sendFile(filename: string, filepath?: string, options?: SendOptions): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.download('img.png', 'custom-img.png')
+     * ```
+     */
+    download(filepath: string, filename: string): Promise<Response>;
+    /**
+     * @example
+     * ```ts
+     * return response.download('img.png', 'custom-img.png', {
+     *  cacheControl: false
+     * })
+     * ```
+     */
+    download(filepath: string, filename: string, options?: SendOptions): Promise<Response>;
+    /**
+     * Set the response status code.
+     *
+     * @example
+     * ```ts
+     * return response.status(200).send()
+     * ```
+     */
+    status(code: number): Response;
+    /**
+     * Add some header to the response.
+     *
+     * @example
+     * ```ts
+     * response.header('content-type', 'application/json')
+     *
+     * return response.header('accept-encoding', 'gzip').send(user)
+     * ```
+     */
+    header(header: string, value: any): Response;
+    /**
+     * Verify if response has some header.
+     *
+     * @example
+     * ```ts
+     * if (response.hasHeader('content-type')) {
+     *   // do something
+     * }
+     * ```
+     */
+    hasHeader(header: string): boolean;
+    /**
+     * Add some header safely to the response. This means that
+     * the header is not going to be added if is already set.
+     *
+     * @example
+     * ```ts
+     * response.safeHeader('content-type', 'application/json')
+     * ```
+     */
+    safeHeader(header: string, value: any): Response;
+    /**
+     * Remove some header from the response.
+     *
+     * @example
+     * ```ts
+     * response.removeHeader('content-type')
+     * ```
+     */
+    removeHeader(header: string): Response;
+    /**
+     * Redirect the response to other url. You can also set a
+     * different status code for the redirect.
+     *
+     * @example
+     * ```ts
+     * return response.redirect('users', 304)
+     * ```
+     */
+    redirectTo(url: string, status?: number): Promise<Response>;
+    /**
+     * Apply helmet in response.
+     *
+     * @example
+     * ```ts
+     * return response
+     *  .helmet({ enableCSPNonces: false })
+     *  .view('profile', user)
+     * ```
+     */
+    helmet(options: FastifyHelmetOptions): Response;
+    /**
+     * Get the original fastify response.
+     */
+    getFastifyResponse(): FastifyReply;
+}