@adonisjs/core 5.9.0 → 6.0.0-0

package/build/src/Hooks/Cors/index.js

@@ -1,314 +0,0 @@
-"use strict";
-/*
- * @adonisjs/core
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cors = void 0;
-/**
- * List of default exposed headers.
- */
-const SIMPLE_EXPOSE_HEADERS = [
-    'cache-control',
-    'content-language',
-    'content-type',
-    'expires',
-    'last-modified',
-    'pragma',
-];
-/**
- * The Cors middleware class to handle preflight request as per the CORS
- * RFC https://www.w3.org/TR/cors/.
- *
- * This is a functional middleware and shared among all requests. So make
- * sure not to set request specific instance properties.
- */
-class Cors {
-    constructor(options) {
-        this.options = options;
-        this.normalizeOptions();
-    }
-    /**
-     * Normalize config options
-     */
-    normalizeOptions() {
-        /**
-         * Convert all headers to lowercase
-         */
-        this.options.exposeHeaders = this.options.exposeHeaders.map((header) => header.toLowerCase());
-        const hasExtraHeaders = this.options.exposeHeaders.find((header) => {
-            return SIMPLE_EXPOSE_HEADERS.indexOf(header) === -1;
-        });
-        /**
-         * If expose headers doesn't have extra headers, then empty the list
-         */
-        if (!hasExtraHeaders) {
-            this.options.exposeHeaders = [];
-        }
-        /**
-         * A pre-computed function to know if CORS is enabled for current request or not
-         */
-        if (typeof this.options.enabled === 'function') {
-            this.isEnabled = this.options.enabled;
-        }
-        else {
-            this.isEnabled = () => this.options.enabled;
-        }
-    }
-    /**
-     * Computes the origin for the current request based upon the
-     * user config.
-     *
-     * Origin match is always case sensitive
-     */
-    computeResponseOrigin(origin, ctx) {
-        let allowedOrigins = this.options.origin;
-        /**
-         * If the `origin` value inside user config is a function, we
-         * call that function and use the return value as the
-         * new config value.
-         */
-        if (typeof allowedOrigins === 'function') {
-            allowedOrigins = allowedOrigins(origin, ctx);
-        }
-        /**
-         * If true, then allow the current origin
-         */
-        if (allowedOrigins === true) {
-            return origin;
-        }
-        /**
-         * False, disallows all origins
-         */
-        if (allowedOrigins === false) {
-            return null;
-        }
-        /**
-         * Wildcard allows the current origin. However, it also indicates
-         * the browser that all origins are allowed.
-         *
-         * Fundamentaly `*` and `true` are not same, though they both allows
-         * the same origin.
-         */
-        if (allowedOrigins === '*') {
-            /**
-             * Setting `Access-Control-Allow-Origin=*` along with `Access-Control-Allow-Credentials=true`
-             * isn't allowed. So in that case, we return the value of the current origin and not the
-             * wildcard identifier.
-             */
-            return this.options.credentials === true ? origin : '*';
-        }
-        /**
-         * Find the matching origin, if value is an array
-         */
-        if (Array.isArray(allowedOrigins)) {
-            if (allowedOrigins.find((allowedOrigin) => allowedOrigin === origin)) {
-                return origin;
-            }
-            return null;
-        }
-        /**
-         * Find the matching origin, if value is a comma seperated string
-         */
-        if (allowedOrigins.split(',').find((allowedOrigin) => allowedOrigin === origin)) {
-            return origin;
-        }
-        /**
-         * Nothing is allowed
-         */
-        return null;
-    }
-    /**
-     * Returns an array of headers allowed based upon user config
-     * and request headers.
-     *
-     * The array items are casted to lowercase for case insensitive
-     * match.
-     */
-    computedAllowedHeaders(headers, ctx) {
-        let allowedHeaders = this.options.headers;
-        /**
-         * Compute allowed headers by calling the config function.
-         */
-        if (typeof allowedHeaders === 'function') {
-            allowedHeaders = allowedHeaders(headers, ctx);
-        }
-        /**
-         * Allow current set of headers, when `allowedHeaders = true`
-         */
-        if (allowedHeaders === true) {
-            return headers.map((header) => header.toLowerCase());
-        }
-        /**
-         * Disallow all headers
-         */
-        if (allowedHeaders === false) {
-            return [];
-        }
-        /**
-         * Allow explicitly define headers as an array of comma seperated
-         * string literal.
-         */
-        if (Array.isArray(allowedHeaders)) {
-            return allowedHeaders.map((header) => header.toLowerCase());
-        }
-        return allowedHeaders.split(',').map((header) => header.toLowerCase());
-    }
-    /**
-     * Sets the `Access-Control-Allow-Origin` header
-     */
-    setOrigin(response, allowedOrigin) {
-        response.header('Access-Control-Allow-Origin', allowedOrigin);
-    }
-    /**
-     * Setting `Access-Control-Expose-Headers` headers, when custom headers
-     * are defined. If no custom headers are defined, then simple response
-     * headers are used instead.
-     */
-    setExposedHeaders(response) {
-        if (this.options.exposeHeaders.length) {
-            response.header('Access-Control-Expose-Headers', this.options.exposeHeaders.join(','));
-        }
-    }
-    /**
-     * Allows `Access-Control-Allow-Credentials` when enabled inside the user
-     * config.
-     */
-    setCredentials(response) {
-        if (this.options.credentials === true) {
-            response.header('Access-Control-Allow-Credentials', 'true');
-        }
-    }
-    /**
-     * Set `Access-Control-Allow-Methods` header.
-     */
-    setAllowMethods(response) {
-        response.header('Access-Control-Allow-Methods', this.options.methods.join(','));
-    }
-    /**
-     * Set `Access-Control-Allow-Headers` header.
-     */
-    setAllowHeaders(response, allowedHeaders) {
-        response.header('Access-Control-Allow-Headers', allowedHeaders.join(','));
-    }
-    /**
-     * Set `Access-Control-Max-Age` header.
-     */
-    setMaxAge(response) {
-        if (this.options.maxAge) {
-            response.header('Access-Control-Max-Age', this.options.maxAge);
-        }
-    }
-    /**
-     * Ends the preflight request with 204 status code
-     */
-    endPreFlight(response) {
-        response.status(204).send(null);
-    }
-    /**
-     * Handle HTTP request for CORS. This method is binded as a before hook
-     * to the HTTP server.
-     */
-    async handle(ctx) {
-        /**
-         * Return early when CORS is not enabled for the current request
-         */
-        if (!this.isEnabled(ctx.request, ctx)) {
-            return;
-        }
-        const origin = ctx.request.header('origin');
-        const isOptions = ctx.request.method() === 'OPTIONS';
-        /**
-         * If their is no Origin header present, then let the user-agent handle
-         * this situation, since the request is outside the scope of CORS.
-         */
-        if (!origin) {
-            return;
-        }
-        const allowedOrigin = this.computeResponseOrigin(origin, ctx);
-        /**
-         * If origin is not allowed, then we don't set any of the cors headers
-         */
-        if (!allowedOrigin) {
-            /**
-             * Also end the OPTIONS request right away
-             */
-            if (isOptions) {
-                this.endPreFlight(ctx.response);
-            }
-            return;
-        }
-        /**
-         * Set required headers for non options request.
-         */
-        if (!isOptions) {
-            this.setOrigin(ctx.response, allowedOrigin);
-            this.setCredentials(ctx.response);
-            this.setExposedHeaders(ctx.response);
-            return;
-        }
-        /**
-         * Everything below is for pre-flight (aka OPTIONS) request
-         */
-        const requestMethod = ctx.request.header('Access-Control-Request-Method');
-        /**
-         * End the request, when `Access-Control-Request-Method` is missing or isn't
-         * part of allowed methods.
-         * https://www.w3.org/TR/cors/#http-access-control-request-method
-         */
-        if (!requestMethod || this.options.methods.indexOf(requestMethod) === -1) {
-            this.endPreFlight(ctx.response);
-            return;
-        }
-        /**
-         * When `Access-Control-Request-Headers` header is missing or is empty, then
-         * we subsitute that with an empty list.
-         * https://www.w3.org/TR/cors/#http-access-control-request-headers
-         */
-        let requestHeaders = ctx.request.header('Access-Control-Request-Headers');
-        if (requestHeaders && requestHeaders !== '') {
-            requestHeaders = requestHeaders.split(',');
-        }
-        else {
-            requestHeaders = [];
-        }
-        /**
-         * Computing allowed headers array from the user config
-         */
-        const allowedHeaders = this.computedAllowedHeaders(requestHeaders, ctx);
-        /**
-         * Finding if all request `Access-Control-Request-Headers` falls under the
-         * list of allowed headers inside user config
-         */
-        const headersMatches = requestHeaders.every((header) => {
-            if (header === 'origin') {
-                return true;
-            }
-            /**
-             * Doing case insenstive match
-             */
-            return allowedHeaders.indexOf(header.toLowerCase()) > -1;
-        });
-        /**
-         * If headers test fails, then we need to end the request without setting
-         * any headers (part of spec).
-         * https://www.w3.org/TR/cors/#http-access-control-request-headers
-         */
-        if (headersMatches === false) {
-            this.endPreFlight(ctx.response);
-            return;
-        }
-        this.setOrigin(ctx.response, allowedOrigin);
-        this.setCredentials(ctx.response);
-        this.setExposedHeaders(ctx.response);
-        this.setAllowMethods(ctx.response);
-        this.setAllowHeaders(ctx.response, allowedHeaders);
-        this.setMaxAge(ctx.response);
-        this.endPreFlight(ctx.response);
-    }
-}
-exports.Cors = Cors;

package/build/src/Hooks/Static/index.d.ts

@@ -1,18 +0,0 @@
-/// <reference types="@adonisjs/http-server/build/adonis-typings" />
-import { AssetsConfig } from '@ioc:Adonis/Core/Static';
-import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-/**
- * A simple server hook to serve static files from the public directory.
- * The public directory must be configured within the `.adonisrc.json`
- * file.
- */
-export declare class ServeStatic {
-    private publicPath;
-    private config;
-    private serve;
-    constructor(publicPath: string, config: AssetsConfig);
-    /**
-     * Handle the request to serve static files.
-     */
-    handle({ request, response }: HttpContextContract): Promise<void>;
-}

package/build/src/Hooks/Static/index.js

@@ -1,66 +0,0 @@
-"use strict";
-/*
- * @adonisjs/core
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServeStatic = void 0;
-const serve_static_1 = __importDefault(require("serve-static"));
-/**
- * A simple server hook to serve static files from the public directory.
- * The public directory must be configured within the `.adonisrc.json`
- * file.
- */
-class ServeStatic {
-    constructor(publicPath, config) {
-        this.publicPath = publicPath;
-        this.config = config;
-        this.serve = (0, serve_static_1.default)(this.publicPath, Object.assign({}, this.config, {
-            setHeaders: (res, path, stats) => {
-                const headers = res.parent.getHeaders();
-                Object.keys(headers).forEach((key) => {
-                    res.setHeader(key, headers[key]);
-                });
-                /**
-                 * Set user defined custom headers
-                 */
-                if (typeof this.config.headers === 'function') {
-                    const customHeaders = this.config.headers(path, stats);
-                    Object.keys(customHeaders).forEach((key) => {
-                        res.setHeader(key, customHeaders[key]);
-                    });
-                }
-            },
-        }));
-    }
-    /**
-     * Handle the request to serve static files.
-     */
-    async handle({ request, response }) {
-        return new Promise((resolve) => {
-            function next() {
-                response.response.removeListener('finish', next);
-                resolve();
-            }
-            response.response['parent'] = response;
-            /**
-             * Whether or not the file has been served by serve static, we
-             * will cleanup the finish event listener.
-             *
-             * 1. If file has been served, then the `finish` callback get invoked.
-             * 2. If file has not been served, then callback (3rd argument) will
-             *    get invoked.
-             */
-            response.response.addListener('finish', next);
-            this.serve(request.request, response.response, next);
-        });
-    }
-}
-exports.ServeStatic = ServeStatic;

package/build/src/HttpExceptionHandler/index.d.ts

@@ -1,82 +0,0 @@
-/// <reference types="@adonisjs/logger/build/adonis-typings/logger" />
-/// <reference types="@adonisjs/http-server/build/adonis-typings" />
-import { LoggerContract } from '@ioc:Adonis/Core/Logger';
-import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-/**
- * Http exception handler serves as the base exception handler
- * to handle all exceptions occured during the HTTP request
- * lifecycle and makes appropriate response for them.
- */
-export declare abstract class HttpExceptionHandler {
-    protected logger: LoggerContract;
-    /**
-     * An array of error codes that must not be reported
-     */
-    protected ignoreCodes: string[];
-    /**
-     * An array of http statuses that must not be reported. The first
-     * level of filteration is on the basis of statuses and then
-     * the error codes.
-     */
-    protected ignoreStatuses: number[];
-    /**
-     * An array of internal error codes to ignore
-     * from the reporting list
-     */
-    protected internalIgnoreCodes: string[];
-    /**
-     * Map of status pages to render, instead of making the
-     * regular response
-     */
-    protected statusPages: {
-        [key: string]: string;
-    };
-    /**
-     * Map of status pages for after expanding the expressions
-     * defined inside statusPages.
-     *
-     * This property is initialized using the getter defined at
-     * the end of this file
-     */
-    expandedStatusPages: {
-        [key: string]: string;
-    };
-    /**
-     * A flag to disable status pages during development
-     */
-    protected disableStatusPagesInDevelopment: boolean;
-    constructor(logger: LoggerContract);
-    /**
-     * A custom context to send to the logger when reporting
-     * errors.
-     */
-    protected context(ctx: HttpContextContract): any;
-    /**
-     * Returns a boolean telling if a given error is supposed
-     * to be logged or not
-     */
-    protected shouldReport(error: any): boolean;
-    /**
-     * Makes the JSON response, based upon the environment in
-     * which the app is runing
-     */
-    protected makeJSONResponse(error: any, ctx: HttpContextContract): Promise<void>;
-    /**
-     * Makes the JSON API response, based upon the environment in
-     * which the app is runing
-     */
-    protected makeJSONAPIResponse(error: any, ctx: HttpContextContract): Promise<void>;
-    /**
-     * Makes the HTML response, based upon the environment in
-     * which the app is runing
-     */
-    protected makeHtmlResponse(error: any, ctx: HttpContextContract): Promise<void>;
-    /**
-     * Report a given error
-     */
-    report(error: any, ctx: HttpContextContract): void;
-    /**
-     * Handle exception and make response
-     */
-    handle(error: any, ctx: HttpContextContract): Promise<any>;
-}

package/build/src/HttpExceptionHandler/index.js

@@ -1,213 +0,0 @@
-"use strict";
-/*
- * @adonisjs/core
- *
- * (c) Harminder Virk <virk@adonisjs.com>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpExceptionHandler = void 0;
-/**
- * Http exception handler serves as the base exception handler
- * to handle all exceptions occured during the HTTP request
- * lifecycle and makes appropriate response for them.
- */
-class HttpExceptionHandler {
-    constructor(logger) {
-        this.logger = logger;
-        /**
-         * An array of error codes that must not be reported
-         */
-        this.ignoreCodes = [];
-        /**
-         * An array of http statuses that must not be reported. The first
-         * level of filteration is on the basis of statuses and then
-         * the error codes.
-         */
-        this.ignoreStatuses = [400, 422, 401];
-        /**
-         * An array of internal error codes to ignore
-         * from the reporting list
-         */
-        this.internalIgnoreCodes = ['E_ROUTE_NOT_FOUND'];
-        /**
-         * Map of status pages to render, instead of making the
-         * regular response
-         */
-        this.statusPages = {};
-        /**
-         * A flag to disable status pages during development
-         */
-        this.disableStatusPagesInDevelopment = true;
-    }
-    /**
-     * A custom context to send to the logger when reporting
-     * errors.
-     */
-    context(ctx) {
-        const requestId = ctx.request.id();
-        return requestId
-            ? {
-                'x-request-id': requestId,
-            }
-            : {};
-    }
-    /**
-     * Returns a boolean telling if a given error is supposed
-     * to be logged or not
-     */
-    shouldReport(error) {
-        /**
-         * Do not report the error when it's status is mentioned inside
-         * the `ignoreStatuses` array.
-         */
-        if (error.status && this.ignoreStatuses.indexOf(error.status) > -1) {
-            return false;
-        }
-        /**
-         * Don't report when error has a code and it's in the ignore list.
-         */
-        if (error.code && this.ignoreCodes.concat(this.internalIgnoreCodes).indexOf(error.code) > -1) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Makes the JSON response, based upon the environment in
-     * which the app is runing
-     */
-    async makeJSONResponse(error, ctx) {
-        if (process.env.NODE_ENV === 'development') {
-            ctx.response.status(error.status).send({
-                message: error.message,
-                stack: error.stack,
-                code: error.code,
-            });
-            return;
-        }
-        ctx.response.status(error.status).send({ message: error.message });
-    }
-    /**
-     * Makes the JSON API response, based upon the environment in
-     * which the app is runing
-     */
-    async makeJSONAPIResponse(error, ctx) {
-        ctx.response.status(error.status).send({
-            errors: [
-                {
-                    title: error.message,
-                    ...(process.env.NODE_ENV === 'development' ? { detail: error.stack } : {}),
-                    code: error.code,
-                    status: error.status,
-                },
-            ],
-        });
-    }
-    /**
-     * Makes the HTML response, based upon the environment in
-     * which the app is runing
-     */
-    async makeHtmlResponse(error, ctx) {
-        if (process.env.NODE_ENV === 'development' &&
-            (!this.expandedStatusPages[error.status] || this.disableStatusPagesInDevelopment)) {
-            const Youch = require('youch');
-            const html = await new Youch(error, ctx.request.request).toHTML();
-            ctx.response.status(error.status).send(html);
-            return;
-        }
-        /**
-         * Render status pages
-         */
-        if (ctx['view'] && this.expandedStatusPages[error.status]) {
-            const html = await ctx['view'].render(this.expandedStatusPages[error.status], { error });
-            ctx.response.status(error.status).send(html);
-            return;
-        }
-        ctx.response.status(error.status).send(`<h1> ${error.message} </h1>`);
-    }
-    /**
-     * Report a given error
-     */
-    report(error, ctx) {
-        error.status = error.status || 500;
-        if (!this.shouldReport(error)) {
-            return;
-        }
-        if (typeof error.report === 'function') {
-            error.report(error, ctx);
-            return;
-        }
-        /**
-         * - Using `error` for `500 and above`
-         * - `warn` for `400 and above`
-         * - `info` for rest. This should not happen, but technically it's possible for someone
-         *    to raise with 200
-         */
-        if (!error.status || error.status >= 500) {
-            if (process.env.NODE_ENV !== 'test') {
-                ctx.logger.error({ err: error, ...this.context(ctx) }, error.message);
-            }
-        }
-        else if (error.status >= 400) {
-            ctx.logger.warn(this.context(ctx), error.message);
-        }
-        else {
-            ctx.logger.info(this.context(ctx), error.message);
-        }
-    }
-    /**
-     * Handle exception and make response
-     */
-    async handle(error, ctx) {
-        error.status = error.status || 500;
-        if (typeof error.handle === 'function') {
-            return error.handle(error, ctx);
-        }
-        /**
-         * Send stack in the response when in test environment and
-         * there is a fatal error.
-         */
-        if (error.status >= 500 && error.stack && process.env.NODE_ENV === 'test') {
-            return ctx.response.status(error.status).send(error.stack);
-        }
-        /**
-         * Attempt to find the best error reporter for validation
-         */
-        switch (ctx.request.accepts(['html', 'application/vnd.api+json', 'json'])) {
-            case 'html':
-            case null:
-                return this.makeHtmlResponse(error, ctx);
-            case 'json':
-                return this.makeJSONResponse(error, ctx);
-            case 'application/vnd.api+json':
-                return this.makeJSONAPIResponse(error, ctx);
-        }
-    }
-}
-exports.HttpExceptionHandler = HttpExceptionHandler;
-/**
- * Single getter to pull status pages after expanding the range expression
- */
-Object.defineProperty(HttpExceptionHandler.prototype, 'expandedStatusPages', {
-    get() {
-        const value = Object.keys(this.statusPages).reduce((result, codeRange) => {
-            const parts = codeRange.split('.');
-            const min = Number(parts[0]);
-            const max = Number(parts[parts.length - 1]);
-            if (isNaN(min) || isNaN(max)) {
-                return result;
-            }
-            if (min === max) {
-                result[codeRange] = this.statusPages[codeRange];
-            }
-            Array.apply(null, new Array(max - min + 1)).forEach((_, step) => {
-                result[min + step] = this.statusPages[codeRange];
-            });
-            return result;
-        }, {});
-        Object.defineProperty(this, 'expandedStatusPages', { value });
-        return value;
-    },
-});