@adonisjs/http-server 7.0.0-1 → 7.0.0-2

package/build/src/cookies/parser.js

@@ -1,167 +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 { CookieClient } from './client.js';
-/**
- * Cookie parser parses the HTTP `cookie` header and collects all cookies
- * inside an object of `key-value` pair, but doesn't attempt to decrypt
- * or unsign or decode the individual values.
- *
- * The cookie values are lazily decrypted, or unsigned to avoid unncessary
- * processing, which infact can be used as a means to burden the server
- * by sending too many cookies which even doesn't belongs to the
- * server.
- */
-export class CookieParser {
-    #client;
-    /**
-     * A copy of cached cookies, they are cached during a request after
-     * initial decoding, unsigning or decrypting.
-     */
-    #cachedCookies = {
-        signedCookies: {},
-        plainCookies: {},
-        encryptedCookies: {},
-    };
-    /**
-     * An object of key-value pair collected by parsing
-     * the request cookie header.
-     */
-    #cookies;
-    constructor(cookieHeader, encryption) {
-        this.#client = new CookieClient(encryption);
-        this.#cookies = this.#parse(cookieHeader);
-    }
-    /**
-     * Parses the request `cookie` header
-     */
-    #parse(cookieHeader) {
-        /*
-         * Set to empty object when cookie header is empty string
-         */
-        if (!cookieHeader) {
-            return {};
-        }
-        /*
-         * Parse and store reference
-         */
-        return cookie.parse(cookieHeader);
-    }
-    /**
-     * Attempts to decode a cookie by the name. When calling this method,
-     * you are assuming that the cookie was just encoded in the first
-     * place and not signed or encrypted.
-     */
-    decode(key, encoded = true) {
-        /*
-         * Ignore when initial value is not defined or null
-         */
-        const value = this.#cookies[key];
-        if (value === null || value === undefined) {
-            return null;
-        }
-        /*
-         * Reference to the cache object. Mainly done to avoid typos,
-         * since this object is referenced a handful of times inside
-         * this method.
-         */
-        const cache = this.#cachedCookies.plainCookies;
-        /*
-         * Return from cache, when already parsed
-         */
-        if (cache[key] !== undefined) {
-            return cache[key];
-        }
-        /*
-         * Attempt to unpack and cache it for future. The value is only
-         * when value it is not null.
-         */
-        const parsed = encoded ? this.#client.decode(key, value) : value;
-        if (parsed !== null) {
-            cache[key] = parsed;
-        }
-        return parsed;
-    }
-    /**
-     * Attempts to unsign a cookie by the name. When calling this method,
-     * you are assuming that the cookie was signed in the first place.
-     */
-    unsign(key) {
-        /*
-         * Ignore when initial value is not defined or null
-         */
-        const value = this.#cookies[key];
-        if (value === null || value === undefined) {
-            return null;
-        }
-        /*
-         * Reference to the cache object. Mainly done to avoid typos,
-         * since this object is referenced a handful of times inside
-         * this method.
-         */
-        const cache = this.#cachedCookies.signedCookies;
-        /*
-         * Return from cache, when already parsed
-         */
-        if (cache[key] !== undefined) {
-            return cache[key];
-        }
-        /*
-         * Attempt to unpack and cache it for future. The value is only
-         * when value it is not null.
-         */
-        const parsed = this.#client.unsign(key, value);
-        if (parsed !== null) {
-            cache[key] = parsed;
-        }
-        return parsed;
-    }
-    /**
-     * Attempts to decrypt a cookie by the name. When calling this method,
-     * you are assuming that the cookie was encrypted in the first place.
-     */
-    decrypt(key) {
-        /*
-         * Ignore when initial value is not defined or null
-         */
-        const value = this.#cookies[key];
-        if (value === null || value === undefined) {
-            return null;
-        }
-        /*
-         * Reference to the cache object. Mainly done to avoid typos,
-         * since this object is referenced a handful of times inside
-         * this method.
-         */
-        const cache = this.#cachedCookies.encryptedCookies;
-        /*
-         * Return from cache, when already parsed
-         */
-        if (cache[key] !== undefined) {
-            return cache[key];
-        }
-        /*
-         * Attempt to unpack and cache it for future. The value is only
-         * when value it is not null.
-         */
-        const parsed = this.#client.decrypt(key, value);
-        if (parsed !== null) {
-            cache[key] = parsed;
-        }
-        return parsed;
-    }
-    /**
-     * Returns an object of cookies key-value pair. Do note, the
-     * cookies are not decoded, unsigned or decrypted inside this
-     * list.
-     */
-    list() {
-        return this.#cookies;
-    }
-}

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.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.js

@@ -1,68 +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 { trustProxy, ...rest } = 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,
-            },
-        },
-        ...rest,
-    };
-    /**
-     * Normalizing maxAge property on cookies to be a number in
-     * seconds
-     */
-    if (normalizedConfig.cookie.maxAge) {
-        normalizedConfig.cookie.maxAge = string.seconds.parse(normalizedConfig.cookie.maxAge);
-    }
-    /**
-     * Normalizing trust proxy setting to allow boolean and
-     * string values
-     */
-    if (typeof trustProxy === 'boolean') {
-        const tpValue = trustProxy;
-        normalizedConfig.trustProxy = (_, __) => tpValue;
-    }
-    else if (typeof trustProxy === 'string') {
-        const tpValue = trustProxy;
-        normalizedConfig.trustProxy = proxyAddr.compile(tpValue);
-    }
-    return normalizedConfig;
-}

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.js

@@ -1,306 +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 Macroable from '@poppinss/macroable';
-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 extends Macroable {
-    /**
-     * 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,
-            }
-            : {};
-    }
-    /**
-     * 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;
-    }
-    /**
-     * 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({
-                cspNonce: 'nonce' in ctx.response ? ctx.response.nonce : undefined,
-            });
-            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);
-        }
-    }
-    /**
-     * 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.js

@@ -1,38 +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 { createError, Exception } from '@poppinss/utils';
-export const E_ROUTE_NOT_FOUND = createError('Cannot %s:%s', 'E_ROUTE_NOT_FOUND', 404);
-export const E_CANNOT_LOOKUP_ROUTE = createError('Cannot lookup route "%s"', 'E_CANNOT_LOOKUP_ROUTE', 500);
-export const E_HTTP_EXCEPTION = class HttpException extends Exception {
-    body;
-    static code = 'E_HTTP_EXCEPTION';
-    /**
-     * This method returns an instance of the exception class
-     */
-    static invoke(body, status, code = 'E_HTTP_EXCEPTION') {
-        if (body === null || body === undefined) {
-            const error = new this('HTTP Exception', { status, code });
-            error.body = 'Internal server error';
-            return error;
-        }
-        if (typeof body === 'object') {
-            const error = new this(body.message || 'HTTP Exception', { status, code });
-            error.body = body;
-            return error;
-        }
-        const error = new this(body, { status, code });
-        error.body = body;
-        return error;
-    }
-};
-export const E_HTTP_REQUEST_ABORTED = class AbortException extends E_HTTP_EXCEPTION {
-    handle(error, ctx) {
-        ctx.response.status(error.status).send(error.body);
-    }
-};