@adonisjs/http-server 6.8.2-9 → 7.0.0-0

package/build/src/cookies/serializer.js

@@ -1,79 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import cookie from 'cookie';
-import string from '@poppinss/utils/string';
-import { CookieClient } from './client.js';
-/**
- * Cookies serializer is used to serialize a value to be set on the `Set-Cookie`
- * header. You can `encode`, `sign` on `encrypt` cookies using the serializer
- * and then set them individually using the `set-cookie` header.
- */
-export class CookieSerializer {
-    #client;
-    constructor(encryption) {
-        this.#client = new CookieClient(encryption);
-    }
-    /**
-     * Serializes the key-value pair to a string, that can be set on the
-     * `Set-Cookie` header.
-     */
-    #serializeAsCookie(key, value, options) {
-        /**
-         * Invoked expires method to get the date
-         */
-        let expires = options?.expires;
-        if (typeof expires === 'function') {
-            expires = expires();
-        }
-        /**
-         * Parse string based max age to seconds
-         */
-        let maxAge = options?.maxAge ? string.seconds.parse(options?.maxAge) : undefined;
-        const parsedOptions = Object.assign({}, options, { maxAge, expires });
-        return cookie.serialize(key, value, parsedOptions);
-    }
-    /**
-     * Encodes value as a plain cookie. By default, the plain value will be converted
-     * to a string using "JSON.stringify" method and then encoded as a base64 string.
-     *
-     * You can disable encoding of the cookie by setting `options.encoded = false`.
-     *
-     * ```ts
-     *  serializer.encode('name', 'virk')
-     * ```
-     */
-    encode(key, value, options) {
-        const packedValue = options?.encode === false ? value : this.#client.encode(key, value);
-        if (packedValue === null || packedValue === undefined) {
-            return null;
-        }
-        return this.#serializeAsCookie(key, packedValue, options);
-    }
-    /**
-     * Sign a key-value pair to a signed cookie. The signed value has a
-     * verification hash attached to it to detect data tampering.
-     */
-    sign(key, value, options) {
-        const packedValue = this.#client.sign(key, value);
-        if (packedValue === null) {
-            return null;
-        }
-        return this.#serializeAsCookie(key, packedValue, options);
-    }
-    /**
-     * Encrypts a key-value pair to an encrypted cookie.
-     */
-    encrypt(key, value, options) {
-        const packedValue = this.#client.encrypt(key, value);
-        if (packedValue === null) {
-            return null;
-        }
-        return this.#serializeAsCookie(key, packedValue, options);
-    }
-}

package/build/src/debug.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-declare const _default: import("util").DebugLogger;
-export default _default;

package/build/src/debug.js

@@ -1,10 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { debuglog } from 'node:util';
-export default debuglog('adonisjs:http');

package/build/src/define_config.d.ts

@@ -1,5 +0,0 @@
-import type { ServerConfig } from './types/server.js';
-/**
- * Define configuration for the HTTP server
- */
-export declare function defineConfig(config: Partial<ServerConfig>): ServerConfig;

package/build/src/define_config.js

@@ -1,51 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import proxyAddr from 'proxy-addr';
-import string from '@poppinss/utils/string';
-/**
- * Define configuration for the HTTP server
- */
-export function defineConfig(config) {
-    const normalizedConfig = {
-        allowMethodSpoofing: false,
-        trustProxy: proxyAddr.compile('loopback'),
-        subdomainOffset: 2,
-        generateRequestId: false,
-        useAsyncLocalStorage: false,
-        etag: false,
-        jsonpCallbackName: 'callback',
-        cookie: {
-            maxAge: '2h',
-            path: '/',
-            httpOnly: true,
-            secure: false,
-            sameSite: false,
-        },
-        qs: {
-            parse: {
-                depth: 5,
-                parameterLimit: 1000,
-                allowSparse: false,
-                arrayLimit: 20,
-                comma: true,
-            },
-            stringify: {
-                encode: true,
-                encodeValuesOnly: false,
-                arrayFormat: 'indices',
-                skipNulls: false,
-            },
-        },
-        ...config,
-    };
-    if (normalizedConfig.cookie.maxAge) {
-        normalizedConfig.cookie.maxAge = string.seconds.parse(normalizedConfig.cookie.maxAge);
-    }
-    return normalizedConfig;
-}

package/build/src/define_middleware.d.ts

@@ -1,11 +0,0 @@
-import type { LazyImport, UnWrapLazyImport } from './types/base.js';
-import type { GetMiddlewareArgs, MiddlewareAsClass, ParsedGlobalMiddleware } from './types/middleware.js';
-/**
- * Define an collection of named middleware. The collection gets converted
- * into a collection of factory functions. Calling the function returns
- * a reference to the executable middleware.
- */
-export declare function defineNamedMiddleware<NamedMiddleware extends Record<string | number | symbol, LazyImport<MiddlewareAsClass>>>(collection: NamedMiddleware): { [K in keyof NamedMiddleware]: <Args extends GetMiddlewareArgs<UnWrapLazyImport<NamedMiddleware[K]>>>(...args: Args) => {
-    name: K;
-    args: Args[0];
-} & ParsedGlobalMiddleware; };

package/build/src/define_middleware.js

@@ -1,35 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import { moduleImporter } from '@adonisjs/fold';
-/**
- * Converts a middleware name and its lazy import to a factory function. The function
- * can than later be used to reference the middleware with different arguments
- * every time.
- */
-function middlewareReferenceBuilder(name, middleware) {
-    const handler = moduleImporter(middleware, 'handle').toHandleMethod();
-    return function (...args) {
-        return {
-            name,
-            args: args[0],
-            ...handler,
-        };
-    };
-}
-/**
- * Define an collection of named middleware. The collection gets converted
- * into a collection of factory functions. Calling the function returns
- * a reference to the executable middleware.
- */
-export function defineNamedMiddleware(collection) {
-    return Object.keys(collection).reduce((result, key) => {
-        result[key] = middlewareReferenceBuilder(key, collection[key]);
-        return result;
-    }, {});
-}

package/build/src/exception_handler.d.ts

@@ -1,112 +0,0 @@
-import type { Level } from '@adonisjs/logger/types';
-import type { HttpContext } from './http_context/main.js';
-import type { HttpError, StatusPageRange, StatusPageRenderer } from './types/server.js';
-/**
- * The base HTTP exception handler one can inherit from to handle
- * HTTP exceptions.
- *
- * The HTTP exception handler has support for
- *
- * - Ability to render exceptions by calling the render method on the exception.
- * - Rendering status pages
- * - Pretty printing errors during development
- * - Transforming errors to JSON or HTML using content negotiation
- * - Reporting errors
- */
-export declare class ExceptionHandler {
-    #private;
-    /**
-     * Whether or not to render debug info. When set to true, the errors
-     * will have the complete error stack.
-     */
-    protected debug: boolean;
-    /**
-     * Whether or not to render status pages. When set to true, the unhandled
-     * errors with matching status codes will be rendered using a status
-     * page.
-     */
-    protected renderStatusPages: boolean;
-    /**
-     * A collection of error status code range and the view to render.
-     */
-    protected statusPages: Record<StatusPageRange, StatusPageRenderer>;
-    /**
-     * Enable/disable errors reporting
-     */
-    protected reportErrors: boolean;
-    /**
-     * An array of exception classes to ignore when
-     * reporting an error
-     */
-    protected ignoreExceptions: any[];
-    /**
-     * An array of HTTP status codes to ignore when reporting
-     * an error
-     */
-    protected ignoreStatuses: number[];
-    /**
-     * An array of error codes to ignore when reporting
-     * an error
-     */
-    protected ignoreCodes: string[];
-    /**
-     * Error reporting context
-     */
-    protected context(ctx: HttpContext): any;
-    /**
-     * Renders an error to JSON response
-     */
-    protected renderErrorAsJSON(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders an error to JSON API response
-     */
-    protected renderErrorAsJSONAPI(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders an error to HTML response
-     */
-    protected renderErrorAsHTML(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the validation error message to a JSON
-     * response
-     */
-    protected renderValidationErrorAsJSON(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the validation error message as per JSON API
-     * spec
-     */
-    protected renderValidationErrorAsJSONAPI(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the validation error as an HTML string
-     */
-    protected renderValidationErrorAsHTML(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the error to response
-     */
-    protected renderError(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Renders the validation error to response
-     */
-    protected renderValidationError(error: HttpError, ctx: HttpContext): Promise<void>;
-    /**
-     * Returns the log level for an error based upon the error
-     * status code.
-     */
-    protected getErrorLogLevel(error: HttpError): Level;
-    /**
-     * A boolean to control if errors should be rendered with
-     * all the available debugging info.
-     */
-    protected isDebuggingEnabled(_: HttpContext): boolean;
-    /**
-     * Returns a boolean by checking if an error should be reported.
-     */
-    protected shouldReport(error: HttpError): boolean;
-    /**
-     * Reports an error during an HTTP request
-     */
-    report(error: unknown, ctx: HttpContext): Promise<void>;
-    /**
-     * Handles the error during the HTTP request.
-     */
-    handle(error: unknown, ctx: HttpContext): Promise<any>;
-}

package/build/src/exception_handler.js

@@ -1,303 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import is from '@sindresorhus/is';
-import { parseRange } from './helpers.js';
-import * as errors from './exceptions.js';
-/**
- * The base HTTP exception handler one can inherit from to handle
- * HTTP exceptions.
- *
- * The HTTP exception handler has support for
- *
- * - Ability to render exceptions by calling the render method on the exception.
- * - Rendering status pages
- * - Pretty printing errors during development
- * - Transforming errors to JSON or HTML using content negotiation
- * - Reporting errors
- */
-export class ExceptionHandler {
-    /**
-     * Computed from the status pages property
-     */
-    #expandedStatusPages;
-    /**
-     * Whether or not to render debug info. When set to true, the errors
-     * will have the complete error stack.
-     */
-    debug = process.env.NODE_ENV !== 'production';
-    /**
-     * Whether or not to render status pages. When set to true, the unhandled
-     * errors with matching status codes will be rendered using a status
-     * page.
-     */
-    renderStatusPages = process.env.NODE_ENV === 'production';
-    /**
-     * A collection of error status code range and the view to render.
-     */
-    statusPages = {};
-    /**
-     * Enable/disable errors reporting
-     */
-    reportErrors = true;
-    /**
-     * An array of exception classes to ignore when
-     * reporting an error
-     */
-    ignoreExceptions = [
-        errors.E_HTTP_EXCEPTION,
-        errors.E_ROUTE_NOT_FOUND,
-        errors.E_CANNOT_LOOKUP_ROUTE,
-        errors.E_HTTP_REQUEST_ABORTED,
-    ];
-    /**
-     * An array of HTTP status codes to ignore when reporting
-     * an error
-     */
-    ignoreStatuses = [400, 422, 401];
-    /**
-     * An array of error codes to ignore when reporting
-     * an error
-     */
-    ignoreCodes = [];
-    /**
-     * Expands status pages
-     */
-    #expandStatusPages() {
-        if (!this.#expandedStatusPages) {
-            this.#expandedStatusPages = Object.keys(this.statusPages).reduce((result, range) => {
-                const renderer = this.statusPages[range];
-                result = Object.assign(result, parseRange(range, renderer));
-                return result;
-            }, {});
-        }
-        return this.#expandedStatusPages;
-    }
-    /**
-     * Forcefully tweaking the type of the error object to
-     * have known properties.
-     */
-    #toHttpError(error) {
-        const httpError = is.object(error) ? error : new Error(String(error));
-        httpError.message = httpError.message || 'Internal server error';
-        httpError.status = httpError.status || 500;
-        return httpError;
-    }
-    /**
-     * Error reporting context
-     */
-    context(ctx) {
-        const requestId = ctx.request.id();
-        return requestId
-            ? {
-                'x-request-id': requestId,
-            }
-            : {};
-    }
-    /**
-     * Renders an error to JSON response
-     */
-    async renderErrorAsJSON(error, ctx) {
-        if (this.isDebuggingEnabled(ctx)) {
-            const { default: Youch } = await import('youch');
-            const json = await new Youch(error, ctx.request.request).toJSON();
-            ctx.response.status(error.status).send(json.error);
-            return;
-        }
-        ctx.response.status(error.status).send({ message: error.message });
-    }
-    /**
-     * Renders an error to JSON API response
-     */
-    async renderErrorAsJSONAPI(error, ctx) {
-        if (this.isDebuggingEnabled(ctx)) {
-            const { default: Youch } = await import('youch');
-            const json = await new Youch(error, ctx.request.request).toJSON();
-            ctx.response.status(error.status).send(json.error);
-            return;
-        }
-        ctx.response.status(error.status).send({
-            errors: [
-                {
-                    title: error.message,
-                    code: error.code,
-                    status: error.status,
-                },
-            ],
-        });
-    }
-    /**
-     * Renders an error to HTML response
-     */
-    async renderErrorAsHTML(error, ctx) {
-        if (this.isDebuggingEnabled(ctx)) {
-            const { default: Youch } = await import('youch');
-            const html = await new Youch(error, ctx.request.request).toHTML();
-            ctx.response.status(error.status).send(html);
-            return;
-        }
-        ctx.response.status(error.status).send(`<p> ${error.message} </p>`);
-    }
-    /**
-     * Renders the validation error message to a JSON
-     * response
-     */
-    async renderValidationErrorAsJSON(error, ctx) {
-        ctx.response.status(error.status).send({
-            errors: error.messages,
-        });
-    }
-    /**
-     * Renders the validation error message as per JSON API
-     * spec
-     */
-    async renderValidationErrorAsJSONAPI(error, ctx) {
-        ctx.response.status(error.status).send({
-            errors: error.messages.map((message) => {
-                return {
-                    title: message.message,
-                    code: message.rule,
-                    source: {
-                        pointer: message.field,
-                    },
-                    meta: message.meta,
-                };
-            }),
-        });
-    }
-    /**
-     * Renders the validation error as an HTML string
-     */
-    async renderValidationErrorAsHTML(error, ctx) {
-        ctx.response
-            .status(error.status)
-            .type('html')
-            .send(error.messages
-            .map((message) => {
-            return `${message.field} - ${message.message}`;
-        })
-            .join('<br />'));
-    }
-    /**
-     * Renders the error to response
-     */
-    renderError(error, ctx) {
-        switch (ctx.request.accepts(['html', 'application/vnd.api+json', 'json'])) {
-            case 'application/vnd.api+json':
-                return this.renderErrorAsJSONAPI(error, ctx);
-            case 'json':
-                return this.renderErrorAsJSON(error, ctx);
-            case 'html':
-            default:
-                return this.renderErrorAsHTML(error, ctx);
-        }
-    }
-    /**
-     * Renders the validation error to response
-     */
-    renderValidationError(error, ctx) {
-        switch (ctx.request.accepts(['html', 'application/vnd.api+json', 'json'])) {
-            case 'application/vnd.api+json':
-                return this.renderValidationErrorAsJSONAPI(error, ctx);
-            case 'json':
-                return this.renderValidationErrorAsJSON(error, ctx);
-            case 'html':
-            default:
-                return this.renderValidationErrorAsHTML(error, ctx);
-        }
-    }
-    /**
-     * Returns the log level for an error based upon the error
-     * status code.
-     */
-    getErrorLogLevel(error) {
-        if (error.status >= 500) {
-            return 'error';
-        }
-        if (error.status >= 400) {
-            return 'warn';
-        }
-        return 'info';
-    }
-    /**
-     * A boolean to control if errors should be rendered with
-     * all the available debugging info.
-     */
-    isDebuggingEnabled(_) {
-        return this.debug;
-    }
-    /**
-     * Returns a boolean by checking if an error should be reported.
-     */
-    shouldReport(error) {
-        if (this.reportErrors === false) {
-            return false;
-        }
-        if (this.ignoreStatuses.includes(error.status)) {
-            return false;
-        }
-        if (error.code && this.ignoreCodes.includes(error.code)) {
-            return false;
-        }
-        if (this.ignoreExceptions.find((exception) => error instanceof exception)) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Reports an error during an HTTP request
-     */
-    async report(error, ctx) {
-        const httpError = this.#toHttpError(error);
-        if (!this.shouldReport(httpError)) {
-            return;
-        }
-        if (typeof httpError.report === 'function') {
-            httpError.report(httpError, ctx);
-            return;
-        }
-        /**
-         * Log the error using the logger
-         */
-        const level = this.getErrorLogLevel(httpError);
-        ctx.logger.log(level, {
-            ...(level === 'error' || level === 'fatal' ? { err: httpError } : {}),
-            ...this.context(ctx),
-        }, httpError.message);
-    }
-    /**
-     * Handles the error during the HTTP request.
-     */
-    async handle(error, ctx) {
-        const httpError = this.#toHttpError(error);
-        /**
-         * Self handle exception
-         */
-        if (typeof httpError.handle === 'function') {
-            return httpError.handle(httpError, ctx);
-        }
-        /**
-         * Handle validation error using the validation error
-         * renderers
-         */
-        if (httpError.code === 'E_VALIDATION_ERROR' && 'messages' in httpError) {
-            return this.renderValidationError(httpError, ctx);
-        }
-        /**
-         * Render status page
-         */
-        const statusPages = this.#expandStatusPages();
-        if (this.renderStatusPages && statusPages[httpError.status]) {
-            return statusPages[httpError.status](httpError, ctx);
-        }
-        /**
-         * Use the format renderers.
-         */
-        return this.renderError(httpError, ctx);
-    }
-}

package/build/src/exceptions.d.ts

@@ -1,84 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Exception } from '@poppinss/utils';
-import type { HttpContext } from './http_context/main.js';
-export declare const E_ROUTE_NOT_FOUND: new (args: [method: string, url: string], options?: ErrorOptions | undefined) => Exception;
-export declare const E_CANNOT_LOOKUP_ROUTE: new (args: [routeIdentifier: string], options?: ErrorOptions | undefined) => Exception;
-export declare const E_HTTP_EXCEPTION: {
-    new (message?: string | undefined, options?: (ErrorOptions & {
-        code?: string | undefined;
-        status?: number | undefined;
-    }) | undefined): {
-        body: any;
-        name: string;
-        help?: string | undefined;
-        code?: string | undefined;
-        status: number;
-        toString(): string;
-        readonly [Symbol.toStringTag]: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    code: string;
-    /**
-     * This method returns an instance of the exception class
-     */
-    invoke(body: any, status: number, code?: string): {
-        body: any;
-        name: string;
-        help?: string | undefined;
-        code?: string | undefined;
-        status: number;
-        toString(): string;
-        readonly [Symbol.toStringTag]: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    help?: string | undefined;
-    status?: number | undefined;
-    message?: string | undefined;
-    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-export declare const E_HTTP_REQUEST_ABORTED: {
-    new (message?: string | undefined, options?: (ErrorOptions & {
-        code?: string | undefined;
-        status?: number | undefined;
-    }) | undefined): {
-        handle(error: any, ctx: HttpContext): void;
-        body: any;
-        name: string;
-        help?: string | undefined;
-        code?: string | undefined;
-        status: number;
-        toString(): string;
-        readonly [Symbol.toStringTag]: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    code: string;
-    /**
-     * This method returns an instance of the exception class
-     */
-    invoke(body: any, status: number, code?: string): {
-        body: any;
-        name: string;
-        help?: string | undefined;
-        code?: string | undefined;
-        status: number;
-        toString(): string;
-        readonly [Symbol.toStringTag]: string;
-        message: string;
-        stack?: string | undefined;
-        cause?: unknown;
-    };
-    help?: string | undefined;
-    status?: number | undefined;
-    message?: string | undefined;
-    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};