@adonisjs/http-server 5.12.0 → 6.0.1-0

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

@@ -1,77 +0,0 @@
-"use strict";
-/**
- * @adonisjs/http-server
- *
- * (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.Hooks = void 0;
-/**
- * Exposes to API to register and execute before and after hooks
- */
-class Hooks {
-    constructor() {
-        /**
-         * Registered before and after hooks
-         */
-        this.hooks = {
-            before: [],
-            after: [],
-        };
-    }
-    /**
-     * Register before hook
-     */
-    before(cb) {
-        this.hooks.before.push(cb);
-        return this;
-    }
-    /**
-     * Register after hook
-     */
-    after(cb) {
-        this.hooks.after.push(cb);
-        return this;
-    }
-    /**
-     * Executing before hooks in series. If this method returns `true`,
-     * it means that one of the before hooks wants to end the request
-     * without further processing it.
-     */
-    async executeBefore(ctx) {
-        for (let hook of this.hooks.before) {
-            await hook(ctx);
-            /*
-             * We must break the loop when one of the hooks set the response
-             */
-            if (ctx.response.hasLazyBody || !ctx.response.isPending) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Executes after hooks in series.
-     */
-    async executeAfter(ctx) {
-        for (let hook of this.hooks.after) {
-            await hook(ctx);
-        }
-    }
-    /**
-     * The commit action enables us to optimize the hook handlers
-     * for runtime peformance
-     */
-    commit() {
-        if (this.hooks.before.length === 0) {
-            this.executeBefore = async () => false;
-        }
-        if (this.hooks.after.length === 0) {
-            this.executeAfter = async () => { };
-        }
-    }
-}
-exports.Hooks = Hooks;

package/build/src/Server/PreCompiler/index.d.ts

@@ -1,60 +0,0 @@
-/**
- * @adonisjs/http-server
- *
- * (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.
- */
-/// <reference path="../../../adonis-typings/index.d.ts" />
-import { RouteNode } from '@ioc:Adonis/Core/Route';
-import { IocContract } from '@adonisjs/fold';
-import { MiddlewareStoreContract } from '@ioc:Adonis/Core/Middleware';
-/**
- * Precompiler is used to pre compiler the route handler and middleware. We
- * lookup the middleware and controllers upfront in the IoC container
- * and cache the lookup to boost the runtime performance.
- *
- * Also each route gets a `finalHandler` property, which is used to invoke the
- * route middleware and the route actual handler
- */
-export declare class PreCompiler {
-    private middlewareStore;
-    /**
-     * This function is used by reference to execute the route handler
-     */
-    private runRouteHandler;
-    /**
-     * Method to execute middleware using the middleware store
-     */
-    private executeMiddleware;
-    /**
-     * This function is used by reference to execute the route middleware + route handler
-     */
-    private runRouteMiddleware;
-    /**
-     * The resolver used to resolve the controllers from IoC container
-     */
-    private resolver;
-    constructor(container: IocContract, middlewareStore: MiddlewareStoreContract);
-    /**
-     * Pre-compiling the handler to boost the runtime performance
-     */
-    private compileHandler;
-    /**
-     * Pre-compile the route middleware to boost runtime performance
-     */
-    private compileMiddleware;
-    /**
-     * Sets `finalHandler` property on the `route.meta`. This method
-     * can be invoked to execute route middleware stack + route
-     * controller/closure.
-     */
-    private setFinalHandler;
-    /**
-     * Pre-compile route handler and it's middleware to boost runtime performance. Since
-     * most of this work is repetitive, we pre-compile and avoid doing it on every
-     * request
-     */
-    compileRoute(route: RouteNode): void;
-}

package/build/src/Server/PreCompiler/index.js

@@ -1,143 +0,0 @@
-"use strict";
-/**
- * @adonisjs/http-server
- *
- * (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.PreCompiler = void 0;
-/// <reference path="../../../adonis-typings/index.ts" />
-const haye_1 = __importDefault(require("haye"));
-const co_compose_1 = require("co-compose");
-const utils_1 = require("@poppinss/utils");
-const helpers_1 = require("@poppinss/utils/build/helpers");
-const helpers_2 = require("../../helpers");
-const exceptions_json_1 = require("../../../exceptions.json");
-/**
- * Precompiler is used to pre compiler the route handler and middleware. We
- * lookup the middleware and controllers upfront in the IoC container
- * and cache the lookup to boost the runtime performance.
- *
- * Also each route gets a `finalHandler` property, which is used to invoke the
- * route middleware and the route actual handler
- */
-class PreCompiler {
-    constructor(container, middlewareStore) {
-        this.middlewareStore = middlewareStore;
-        /**
-         * This function is used by reference to execute the route handler
-         */
-        this.runRouteHandler = async (ctx) => {
-            const routeHandler = ctx.route.meta.resolvedHandler;
-            /*
-             * Passing a child to the route handler, so that all internal
-             * actions can have their own child row
-             */
-            let returnValue;
-            if (routeHandler.type === 'function') {
-                returnValue = await routeHandler.handler(ctx);
-            }
-            else {
-                returnValue = await this.resolver.call(routeHandler, undefined, (controller) => {
-                    /**
-                     * Allowing controller to provide the controller method argument
-                     */
-                    if (typeof controller['getHandlerArguments'] === 'function') {
-                        return controller['getHandlerArguments'](ctx);
-                    }
-                    return [ctx];
-                });
-            }
-            if ((0, helpers_2.useReturnValue)(returnValue, ctx)) {
-                ctx.response.send(returnValue);
-            }
-        };
-        /**
-         * Method to execute middleware using the middleware store
-         */
-        this.executeMiddleware = (middleware, params) => {
-            return this.middlewareStore.invokeMiddleware(middleware, params);
-        };
-        /**
-         * This function is used by reference to execute the route middleware + route handler
-         */
-        this.runRouteMiddleware = (ctx) => {
-            return new co_compose_1.Middleware()
-                .register(ctx.route.meta.resolvedMiddleware)
-                .runner()
-                .executor(this.executeMiddleware)
-                .finalHandler(this.runRouteHandler, [ctx])
-                .run([ctx]);
-        };
-        this.resolver = container.getResolver(undefined, 'httpControllers', 'App/Controllers/Http');
-    }
-    /**
-     * Pre-compiling the handler to boost the runtime performance
-     */
-    compileHandler(route) {
-        if (typeof route.handler === 'string') {
-            route.meta.resolvedHandler = this.resolver.resolve(route.handler, route.meta.namespace);
-        }
-        else {
-            route.meta.resolvedHandler = { type: 'function', handler: route.handler };
-        }
-    }
-    /**
-     * Pre-compile the route middleware to boost runtime performance
-     */
-    compileMiddleware(route) {
-        route.meta.resolvedMiddleware = route.middleware.map((item) => {
-            if (typeof item === 'function') {
-                return { type: 'function', value: item, args: [] };
-            }
-            /*
-             * Extract middleware name and args from the string
-             */
-            const [{ name, args }] = haye_1.default.fromPipe(item).toArray();
-            /*
-             * Get resolved node for the given name and raise exception when that
-             * name is missing
-             */
-            const resolvedMiddleware = this.middlewareStore.getNamed(name);
-            if (!resolvedMiddleware) {
-                const error = new utils_1.Exception((0, helpers_1.interpolate)(exceptions_json_1.E_MISSING_NAMED_MIDDLEWARE.message, { name }), exceptions_json_1.E_MISSING_NAMED_MIDDLEWARE.status, exceptions_json_1.E_MISSING_NAMED_MIDDLEWARE.code);
-                error.help = exceptions_json_1.E_MISSING_NAMED_MIDDLEWARE.help.join('\n');
-                throw error;
-            }
-            return {
-                ...resolvedMiddleware,
-                args,
-            };
-        });
-    }
-    /**
-     * Sets `finalHandler` property on the `route.meta`. This method
-     * can be invoked to execute route middleware stack + route
-     * controller/closure.
-     */
-    setFinalHandler(route) {
-        if (route.meta.resolvedMiddleware && route.meta.resolvedMiddleware.length) {
-            route.meta.finalHandler = this.runRouteMiddleware;
-        }
-        else {
-            route.meta.finalHandler = this.runRouteHandler;
-        }
-    }
-    /**
-     * Pre-compile route handler and it's middleware to boost runtime performance. Since
-     * most of this work is repetitive, we pre-compile and avoid doing it on every
-     * request
-     */
-    compileRoute(route) {
-        this.compileHandler(route);
-        this.compileMiddleware(route);
-        this.setFinalHandler(route);
-    }
-}
-exports.PreCompiler = PreCompiler;

package/build/src/Server/RequestHandler/index.d.ts

@@ -1,39 +0,0 @@
-/**
- * @adonisjs/http-server
- *
- * (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.
- */
-/// <reference path="../../../adonis-typings/index.d.ts" />
-import { RouterContract } from '@ioc:Adonis/Core/Route';
-import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
-import { MiddlewareStoreContract } from '@ioc:Adonis/Core/Middleware';
-/**
- * Handles the request by invoking it's middleware chain, along with the
- * route finalHandler
- */
-export declare class RequestHandler {
-    private middlewareStore;
-    private router;
-    private globalMiddleware;
-    private handleRequest;
-    constructor(middlewareStore: MiddlewareStoreContract, router: RouterContract);
-    /**
-     * Function to invoke global middleware
-     */
-    private executeMiddleware;
-    /**
-     * Finds the route for the request
-     */
-    private findRoute;
-    /**
-     * Handles the request and invokes required middleware/handlers
-     */
-    handle(ctx: HttpContextContract): Promise<void>;
-    /**
-     * Computing certain methods to optimize for runtime performance
-     */
-    commit(): void;
-}

package/build/src/Server/RequestHandler/index.js

@@ -1,87 +0,0 @@
-"use strict";
-/**
- * @adonisjs/http-server
- *
- * (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.RequestHandler = void 0;
-/// <reference path="../../../adonis-typings/index.ts" />
-const co_compose_1 = require("co-compose");
-const helpers_1 = require("@poppinss/utils/build/helpers");
-const HttpException_1 = require("../../Exceptions/HttpException");
-const exceptions_json_1 = require("../../../exceptions.json");
-/**
- * Handles the request by invoking it's middleware chain, along with the
- * route finalHandler
- */
-class RequestHandler {
-    constructor(middlewareStore, router) {
-        this.middlewareStore = middlewareStore;
-        this.router = router;
-        /**
-         * Function to invoke global middleware
-         */
-        this.executeMiddleware = (middleware, params) => {
-            return this.middlewareStore.invokeMiddleware(middleware, params);
-        };
-    }
-    /**
-     * Finds the route for the request
-     */
-    findRoute(ctx) {
-        const url = ctx.request.url();
-        const method = ctx.request.method();
-        const hostname = ctx.request.hostname();
-        /*
-         * Profiling `route.match` method
-         */
-        const matchRoute = ctx.profiler.profile('http:route:match');
-        const route = this.router.match(url, method, hostname || undefined);
-        matchRoute.end();
-        /*
-         * Raise error when route is missing
-         */
-        if (!route) {
-            throw HttpException_1.HttpException.invoke((0, helpers_1.interpolate)(exceptions_json_1.E_ROUTE_NOT_FOUND.message, { method, url }), exceptions_json_1.E_ROUTE_NOT_FOUND.status, exceptions_json_1.E_ROUTE_NOT_FOUND.code);
-        }
-        /*
-         * Attach `params`, `subdomains` and `route` when route is found. This
-         * information only exists on a given route
-         */
-        ctx.params = route.params;
-        ctx.subdomains = route.subdomains;
-        ctx.route = route.route;
-        ctx.routeKey = route.routeKey;
-        ctx.request.updateParams(ctx.params);
-    }
-    /**
-     * Handles the request and invokes required middleware/handlers
-     */
-    async handle(ctx) {
-        this.findRoute(ctx);
-        return this.handleRequest(ctx);
-    }
-    /**
-     * Computing certain methods to optimize for runtime performance
-     */
-    commit() {
-        const middleware = this.middlewareStore.get();
-        if (!middleware.length) {
-            this.handleRequest = (ctx) => ctx.route.meta.finalHandler(ctx);
-            return;
-        }
-        this.globalMiddleware = new co_compose_1.Middleware().register(middleware);
-        this.handleRequest = (ctx) => {
-            return this.globalMiddleware
-                .runner()
-                .executor(this.executeMiddleware)
-                .finalHandler(ctx.route.meta.finalHandler, [ctx])
-                .run([ctx]);
-        };
-    }
-}
-exports.RequestHandler = RequestHandler;

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

@@ -1,90 +0,0 @@
-/**
- * @adonisjs/http-server
- *
- * (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.
- */
-/// <reference path="../../adonis-typings/index.d.ts" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { Server as HttpsServer } from 'https';
-import { EncryptionContract } from '@ioc:Adonis/Core/Encryption';
-import { ApplicationContract } from '@ioc:Adonis/Core/Application';
-import { IncomingMessage, ServerResponse, Server as HttpServer } from 'http';
-import { ServerContract, ServerConfig, ErrorHandler } from '@ioc:Adonis/Core/Server';
-import { Hooks } from './Hooks';
-import { Router } from '../Router';
-import { MiddlewareStore } from '../MiddlewareStore';
-/**
- * Server class handles the HTTP requests by using all Adonis micro modules.
- */
-export declare class Server implements ServerContract {
-    private application;
-    private encryption;
-    private httpConfig;
-    /**
-     * The server itself doesn't create the http server instance. However, the consumer
-     * of this class can create one and set the instance for further reference. This
-     * is what ignitor does.
-     */
-    instance?: HttpServer | HttpsServer;
-    /**
-     * The middleware store to register global and named middleware
-     */
-    middleware: MiddlewareStore;
-    /**
-     * The route to register routes
-     */
-    router: Router;
-    /**
-     * Server before/after hooks
-     */
-    hooks: Hooks;
-    /**
-     * Precompiler to set the finalHandler for the route
-     */
-    private precompiler;
-    /**
-     * Exception manager to handle exceptions
-     */
-    private exception;
-    /**
-     * Request handler to handle request after route is found
-     */
-    private requestHandler;
-    constructor(application: ApplicationContract, encryption: EncryptionContract, httpConfig: ServerConfig);
-    /**
-     * Handles HTTP request
-     */
-    private runBeforeHooksAndHandler;
-    /**
-     * Returns the profiler row
-     */
-    private getProfilerRow;
-    /**
-     * Returns the context for the request
-     */
-    private getContext;
-    /**
-     * Handle the request
-     */
-    private handleRequest;
-    /**
-     * Define custom error handler to handler all errors
-     * occurred during HTTP request
-     */
-    errorHandler(handler: ErrorHandler): this;
-    /**
-     * Optimizes internal handlers, based upon the existence of
-     * before handlers and global middleware. This helps in
-     * increasing throughput by 10%
-     */
-    optimize(): void;
-    /**
-     * Handles a given HTTP request. This method can be attached to any HTTP
-     * server
-     */
-    handle(req: IncomingMessage, res: ServerResponse): Promise<void>;
-}

package/build/src/Server/index.js

@@ -1,175 +0,0 @@
-"use strict";
-/**
- * @adonisjs/http-server
- *
- * (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.Server = void 0;
-/// <reference path="../../adonis-typings/index.ts" />
-const ms_1 = __importDefault(require("ms"));
-const Hooks_1 = require("./Hooks");
-const Router_1 = require("../Router");
-const Request_1 = require("../Request");
-const Response_1 = require("../Response");
-const PreCompiler_1 = require("./PreCompiler");
-const HttpContext_1 = require("../HttpContext");
-const RequestHandler_1 = require("./RequestHandler");
-const MiddlewareStore_1 = require("../MiddlewareStore");
-const ExceptionManager_1 = require("./ExceptionManager");
-const LocalStorage_1 = require("../HttpContext/LocalStorage");
-/**
- * Server class handles the HTTP requests by using all Adonis micro modules.
- */
-class Server {
-    constructor(application, encryption, httpConfig) {
-        this.application = application;
-        this.encryption = encryption;
-        this.httpConfig = httpConfig;
-        /**
-         * The middleware store to register global and named middleware
-         */
-        this.middleware = new MiddlewareStore_1.MiddlewareStore(this.application.container);
-        /**
-         * The route to register routes
-         */
-        this.router = new Router_1.Router(this.encryption, (route) => this.precompiler.compileRoute(route));
-        /**
-         * Server before/after hooks
-         */
-        this.hooks = new Hooks_1.Hooks();
-        /**
-         * Precompiler to set the finalHandler for the route
-         */
-        this.precompiler = new PreCompiler_1.PreCompiler(this.application.container, this.middleware);
-        /**
-         * Exception manager to handle exceptions
-         */
-        this.exception = new ExceptionManager_1.ExceptionManager(this.application.container);
-        /**
-         * Request handler to handle request after route is found
-         */
-        this.requestHandler = new RequestHandler_1.RequestHandler(this.middleware, this.router);
-        /*
-         * Pre process config to convert max age string to seconds.
-         */
-        if (httpConfig.cookie.maxAge && typeof httpConfig.cookie.maxAge === 'string') {
-            httpConfig.cookie.maxAge = (0, ms_1.default)(httpConfig.cookie.maxAge) / 1000;
-        }
-        (0, LocalStorage_1.useAsyncLocalStorage)(httpConfig.useAsyncLocalStorage || false);
-    }
-    /**
-     * Handles HTTP request
-     */
-    async runBeforeHooksAndHandler(ctx) {
-        /*
-         * Start with before hooks upfront. If they raise error
-         * then execute error handler.
-         */
-        return this.hooks.executeBefore(ctx).then((shortcircuit) => {
-            if (!shortcircuit) {
-                return this.requestHandler.handle(ctx);
-            }
-        });
-    }
-    /**
-     * Returns the profiler row
-     */
-    getProfilerRow(request) {
-        return this.application.profiler.create('http:request', {
-            request_id: request.id(),
-            url: request.url(),
-            method: request.method(),
-        });
-    }
-    /**
-     * Returns the context for the request
-     */
-    getContext(request, response, profilerRow) {
-        return new HttpContext_1.HttpContext(request, response, this.application.logger.child({
-            request_id: request.id(),
-        }), profilerRow);
-    }
-    /**
-     * Handle the request
-     */
-    async handleRequest(ctx, requestAction, res) {
-        /*
-         * Handle request by executing hooks, request middleware stack
-         * and route handler
-         */
-        try {
-            await this.runBeforeHooksAndHandler(ctx);
-        }
-        catch (error) {
-            await this.exception.handle(error, ctx);
-        }
-        /*
-         * Excute hooks when there are one or more hooks. The `ctx.response.finish`
-         * is intentionally inside both the `try` and `catch` blocks as a defensive
-         * measure.
-         *
-         * When we call `response.finish`, it will serialize the response body and may
-         * encouter errors while doing so and hence will be catched by the catch
-         * block.
-         */
-        try {
-            await this.hooks.executeAfter(ctx);
-            requestAction.end({ status_code: res.statusCode });
-            ctx.response.finish();
-        }
-        catch (error) {
-            await this.exception.handle(error, ctx);
-            requestAction.end({ status_code: res.statusCode, error });
-            ctx.response.finish();
-        }
-    }
-    /**
-     * Define custom error handler to handler all errors
-     * occurred during HTTP request
-     */
-    errorHandler(handler) {
-        this.exception.registerHandler(handler);
-        return this;
-    }
-    /**
-     * Optimizes internal handlers, based upon the existence of
-     * before handlers and global middleware. This helps in
-     * increasing throughput by 10%
-     */
-    optimize() {
-        this.router.commit();
-        this.hooks.commit();
-        this.requestHandler.commit();
-    }
-    /**
-     * Handles a given HTTP request. This method can be attached to any HTTP
-     * server
-     */
-    async handle(req, res) {
-        const request = new Request_1.Request(req, res, this.encryption, this.httpConfig);
-        const response = new Response_1.Response(req, res, this.encryption, this.httpConfig, this.router);
-        const requestAction = this.getProfilerRow(request);
-        const ctx = this.getContext(request, response, requestAction);
-        /*
-         * Reset accept header when `forceContentNegotiationTo` is defined
-         */
-        const accept = this.httpConfig.forceContentNegotiationTo;
-        if (accept) {
-            req.headers['accept'] = typeof accept === 'function' ? accept(ctx) : accept;
-        }
-        if (LocalStorage_1.usingAsyncLocalStorage) {
-            return LocalStorage_1.httpContextLocalStorage.run(ctx, () => this.handleRequest(ctx, requestAction, res));
-        }
-        else {
-            return this.handleRequest(ctx, requestAction, res);
-        }
-    }
-}
-exports.Server = Server;

package/build/standalone.d.ts

@@ -1,14 +0,0 @@
-/**
- * @adonisjs/http-server
- *
- * (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.
- */
-export { Router } from './src/Router';
-export { Server } from './src/Server';
-export { Request } from './src/Request';
-export { Response } from './src/Response';
-export { HttpContext } from './src/HttpContext';
-export { MiddlewareStore } from './src/MiddlewareStore';