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

package/build/src/router/brisk.js

@@ -1,85 +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 Macroable from '@poppinss/macroable';
-import { Route } from './route.js';
-/**
- * Brisk routes exposes the API to configure the route handler by chaining
- * one of the pre-defined methods.
- *
- * For example: Instead of defining the redirect logic as a callback, one can
- * chain the `.redirect` method.
- *
- * Brisk routes are always registered under the `GET` HTTP method.
- */
-export class BriskRoute extends Macroable {
-    /**
-     * Route pattern
-     */
-    #pattern;
-    /**
-     * Matchers inherited from the router
-     */
-    #globalMatchers;
-    /**
-     * Reference to the AdonisJS application
-     */
-    #app;
-    /**
-     * Middleware registered on the router
-     */
-    #routerMiddleware;
-    /**
-     * Reference to route instance. Set after `setHandler` is called
-     */
-    route = null;
-    constructor(app, routerMiddleware, options) {
-        super();
-        this.#app = app;
-        this.#routerMiddleware = routerMiddleware;
-        this.#pattern = options.pattern;
-        this.#globalMatchers = options.globalMatchers;
-    }
-    /**
-     * Set handler for the brisk route
-     */
-    setHandler(handler) {
-        this.route = new Route(this.#app, this.#routerMiddleware, {
-            pattern: this.#pattern,
-            globalMatchers: this.#globalMatchers,
-            methods: ['GET', 'HEAD'],
-            handler: handler,
-        });
-        return this.route;
-    }
-    /**
-     * Redirects to a given route. Params from the original request will
-     * be used when no custom params are defined.
-     */
-    redirect(identifier, params, options) {
-        return this.setHandler(async function redirectsToRoute(ctx) {
-            const redirector = ctx.response.redirect();
-            if (options?.status) {
-                redirector.status(options.status);
-            }
-            return redirector.toRoute(identifier, params || ctx.params, options);
-        });
-    }
-    /**
-     * Redirect request to a fixed URL
-     */
-    redirectToPath(url, options) {
-        return this.setHandler(async function redirectsToPath(ctx) {
-            const redirector = ctx.response.redirect();
-            if (options?.status) {
-                redirector.status(options.status);
-            }
-            return redirector.toPath(url);
-        });
-    }
-}

package/build/src/router/executor.js

@@ -1,30 +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 { useReturnValue } from './factories/use_return_value.js';
-/**
- * Executor to execute the route middleware pipeline the route
- * handler
- */
-export function execute(route, resolver, ctx, errorResponder) {
-    return route.middleware
-        .runner()
-        .errorHandler((error) => errorResponder(error, ctx))
-        .finalHandler(async () => {
-        if (typeof route.handler === 'function') {
-            return Promise.resolve(route.handler(ctx)).then(useReturnValue(ctx));
-        }
-        return route.handler.handle(resolver, ctx).then(useReturnValue(ctx));
-    })
-        .run(async (middleware, next) => {
-        if (typeof middleware === 'function') {
-            return middleware(ctx, next);
-        }
-        return middleware.handle(resolver, ctx, next, middleware.args);
-    });
-}

package/build/src/router/factories/use_return_value.js

@@ -1,22 +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.
- */
-/**
- * A factory function that uses the return value of the request
- * pipeline as the response
- */
-export function useReturnValue(ctx) {
-    return function (value) {
-        if (value !== undefined && // Return value is explicitly defined
-            !ctx.response.hasLazyBody && // Lazy body is not set
-            value !== ctx.response // Return value is not the instance of response object
-        ) {
-            ctx.response.send(value);
-        }
-    };
-}

package/build/src/router/group.js

@@ -1,207 +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 Macroable from '@poppinss/macroable';
-import { BriskRoute } from './brisk.js';
-import { RouteResource } from './resource.js';
-/**
- * Group class exposes the API to take action on a group of routes.
- * The group routes must be pre-defined using the constructor.
- */
-export class RouteGroup extends Macroable {
-    routes;
-    /**
-     * Array of middleware registered on the group.
-     */
-    #middleware = [];
-    constructor(routes) {
-        super();
-        this.routes = routes;
-    }
-    /**
-     * Shares midldeware stack with the routes. The method is invoked recursively
-     * to only register middleware with the route class and not with the
-     * resource or the child group
-     */
-    #shareMiddlewareStackWithRoutes(route) {
-        if (route instanceof RouteGroup) {
-            route.routes.forEach((child) => this.#shareMiddlewareStackWithRoutes(child));
-            return;
-        }
-        if (route instanceof RouteResource) {
-            route.routes.forEach((child) => child.getMiddleware().unshift(this.#middleware));
-            return;
-        }
-        if (route instanceof BriskRoute) {
-            route.route.getMiddleware().unshift(this.#middleware);
-            return;
-        }
-        route.getMiddleware().unshift(this.#middleware);
-    }
-    /**
-     * Updates the route name. The method is invoked recursively to only update
-     * the name with the route class and not with the resource or the child
-     * group.
-     */
-    #updateRouteName(route, name) {
-        if (route instanceof RouteGroup) {
-            route.routes.forEach((child) => this.#updateRouteName(child, name));
-            return;
-        }
-        if (route instanceof RouteResource) {
-            route.routes.forEach((child) => child.as(name, true));
-            return;
-        }
-        if (route instanceof BriskRoute) {
-            route.route.as(name, true);
-            return;
-        }
-        route.as(name, true);
-    }
-    /**
-     * Sets prefix on the route. The method is invoked recursively to only set
-     * the prefix with the route class and not with the resource or the
-     * child group.
-     */
-    #setRoutePrefix(route, prefix) {
-        if (route instanceof RouteGroup) {
-            route.routes.forEach((child) => this.#setRoutePrefix(child, prefix));
-            return;
-        }
-        if (route instanceof RouteResource) {
-            route.routes.forEach((child) => child.prefix(prefix));
-            return;
-        }
-        if (route instanceof BriskRoute) {
-            route.route.prefix(prefix);
-            return;
-        }
-        route.prefix(prefix);
-    }
-    /**
-     * Updates domain on the route. The method is invoked recursively to only update
-     * the domain with the route class and not with the resource or the child
-     * group.
-     */
-    #updateRouteDomain(route, domain) {
-        if (route instanceof RouteGroup) {
-            route.routes.forEach((child) => this.#updateRouteDomain(child, domain));
-            return;
-        }
-        if (route instanceof RouteResource) {
-            route.routes.forEach((child) => child.domain(domain));
-            return;
-        }
-        if (route instanceof BriskRoute) {
-            route.route.domain(domain, false);
-            return;
-        }
-        route.domain(domain, false);
-    }
-    /**
-     * Updates matchers on the route. The method is invoked recursively to only update
-     * the matchers with the route class and not with the resource or the child
-     * group.
-     */
-    #updateRouteMatchers(route, param, matcher) {
-        if (route instanceof RouteGroup) {
-            route.routes.forEach((child) => this.#updateRouteMatchers(child, param, matcher));
-            return;
-        }
-        if (route instanceof RouteResource) {
-            route.routes.forEach((child) => child.where(param, matcher));
-            return;
-        }
-        if (route instanceof BriskRoute) {
-            route.route.where(param, matcher);
-            return;
-        }
-        route.where(param, matcher);
-    }
-    /**
-     * Define route param matcher
-     *
-     * ```ts
-     * Route.group(() => {
-     * }).where('id', /^[0-9]+/)
-     * ```
-     */
-    where(param, matcher) {
-        this.routes.forEach((route) => this.#updateRouteMatchers(route, param, matcher));
-        return this;
-    }
-    /**
-     * Define prefix all the routes in the group.
-     *
-     * ```ts
-     * Route.group(() => {
-     * }).prefix('v1')
-     * ```
-     */
-    prefix(prefix) {
-        this.routes.forEach((route) => this.#setRoutePrefix(route, prefix));
-        return this;
-    }
-    /**
-     * Define domain for all the routes.
-     *
-     * ```ts
-     * Route.group(() => {
-     * }).domain(':name.adonisjs.com')
-     * ```
-     */
-    domain(domain) {
-        this.routes.forEach((route) => this.#updateRouteDomain(route, domain));
-        return this;
-    }
-    /**
-     * Prepend name to the routes name.
-     *
-     * ```ts
-     * Route.group(() => {
-     * }).as('version1')
-     * ```
-     */
-    as(name) {
-        this.routes.forEach((route) => this.#updateRouteName(route, name));
-        return this;
-    }
-    /**
-     * Prepend an array of middleware to all routes middleware.
-     *
-     * ```ts
-     * Route.group(() => {
-     * }).use(middleware.auth())
-     * ```
-     */
-    use(middleware) {
-        /**
-         * Register middleware with children. We share the group middleware
-         * array by reference, therefore have to register it only for the
-         * first time.
-         */
-        if (!this.#middleware.length) {
-            this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route));
-        }
-        if (Array.isArray(middleware)) {
-            for (let one of middleware) {
-                this.#middleware.push(one);
-            }
-        }
-        else {
-            this.#middleware.push(middleware);
-        }
-        return this;
-    }
-    /**
-     * @alias use
-     */
-    middleware(middleware) {
-        return this.use(middleware);
-    }
-}

package/build/src/router/lookup_store/main.js

@@ -1,86 +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 { UrlBuilder } from './url_builder.js';
-import { RouteFinder } from './route_finder.js';
-/**
- * Lookup store exposes the API to lookup routes and
- * make URLs for registered routes.
- */
-export class LookupStore {
-    /**
-     * List of routes grouped by domain
-     */
-    #routes = {};
-    /**
-     * Encryption for making URLs
-     */
-    #encryption;
-    /**
-     * Query string parser for making URLs
-     */
-    #qsParser;
-    constructor(encryption, qsParser) {
-        this.#encryption = encryption;
-        this.#qsParser = qsParser;
-    }
-    /**
-     * Register route JSON payload
-     */
-    register(route) {
-        this.#routes[route.domain] = this.#routes[route.domain] || [];
-        this.#routes[route.domain].push(route);
-    }
-    /**
-     * Returns an instance of the URL builder for making
-     * route URIs
-     */
-    builder() {
-        return this.builderForDomain('root');
-    }
-    /**
-     * Returns an instance of the URL builder for a specific
-     * domain.
-     */
-    builderForDomain(domain) {
-        const routes = this.#routes[domain];
-        return new UrlBuilder(this.#encryption, new RouteFinder(routes || []), this.#qsParser);
-    }
-    /**
-     * Finds a route by its identifier. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     */
-    find(routeIdentifier, domain) {
-        const routes = this.#routes[domain || 'root'] || [];
-        return new RouteFinder(routes).find(routeIdentifier);
-    }
-    /**
-     * Finds a route by its identifier. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     *
-     * An error is raised when unable to find the route.
-     */
-    findOrFail(routeIdentifier, domain) {
-        const routes = this.#routes[domain || 'root'] || [];
-        return new RouteFinder(routes).findOrFail(routeIdentifier);
-    }
-    /**
-     * Check if a route exists. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     */
-    has(routeIdentifier, domain) {
-        const routes = this.#routes[domain || 'root'] || [];
-        return new RouteFinder(routes).has(routeIdentifier);
-    }
-    toJSON() {
-        return this.#routes;
-    }
-}

package/build/src/router/lookup_store/route_finder.js

@@ -1,49 +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 * as errors from '../../exceptions.js';
-/**
- * Route finder is used to find a route by its name, route pattern
- * or the controller.method name.
- */
-export class RouteFinder {
-    #routes;
-    constructor(routes) {
-        this.#routes = routes;
-    }
-    /**
-     * Find a route by indentifier
-     */
-    find(routeIdentifier) {
-        return (this.#routes.find(({ name, pattern, handler }) => {
-            if (name === routeIdentifier || pattern === routeIdentifier) {
-                return true;
-            }
-            if (typeof handler === 'function') {
-                return false;
-            }
-            return handler.reference === routeIdentifier;
-        }) || null);
-    }
-    /**
-     * Find a route by indentifier or fail
-     */
-    findOrFail(routeIdentifier) {
-        const route = this.find(routeIdentifier);
-        if (!route) {
-            throw new errors.E_CANNOT_LOOKUP_ROUTE([routeIdentifier]);
-        }
-        return route;
-    }
-    /**
-     * Find if a route exists
-     */
-    has(routeIdentifier) {
-        return !!this.find(routeIdentifier);
-    }
-}

package/build/src/router/lookup_store/url_builder.js

@@ -1,209 +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 { RuntimeException } from '@poppinss/utils';
-import { parseRoutePattern } from '../parser.js';
-/**
- * URL builder class is used to create URIs for pre-registered
- * routes.
- *
- * ```ts
- * const builder = new UrlBuilder(encryption, routeFinder)
- *
- * builder
- *  .qs({ sort: 'id' })
- *  .params([category.id])
- *  .make('categories.posts.index')
- * ```
- */
-export class UrlBuilder {
-    /**
-     * Query string parser
-     */
-    #qsParser;
-    /**
-     * The parameters to apply on the route
-     */
-    #params = {};
-    /**
-     * Query string to append to the route
-     */
-    #qs = {};
-    /**
-     * Should we perform the route lookup or just build the
-     * given pattern as it is.
-     */
-    #shouldPerformLookup = true;
-    /**
-     * BaseURL to append to the constructored URL
-     */
-    #baseUrl;
-    /**
-     * Encryption class for making signed URLs
-     */
-    #encryption;
-    /**
-     * Route finder for finding route pattern
-     */
-    #routeFinder;
-    constructor(encryption, routeFinder, qsParser) {
-        this.#qsParser = qsParser;
-        this.#encryption = encryption;
-        this.#routeFinder = routeFinder;
-    }
-    /**
-     * Raises exception when wildcard values array is missing or
-     * has length of zero.
-     */
-    #ensureHasWildCardValues(pattern, values) {
-        if (!values || !Array.isArray(values) || !values.length) {
-            throw new RuntimeException(`Cannot make URL for "${pattern}" route. Invalid value provided for wildcard param`);
-        }
-    }
-    /*
-     * Raises exception when value is not defined
-     */
-    #ensureHasParamValue(pattern, param, value) {
-        if (value === undefined || value === null) {
-            throw new RuntimeException(`Cannot make URL for "${pattern}" route. Missing value for "${param}" param`);
-        }
-    }
-    /**
-     * Processes the pattern against the params
-     */
-    #processPattern(pattern) {
-        const uriSegments = [];
-        const paramsArray = Array.isArray(this.#params) ? this.#params : null;
-        const paramsObject = !Array.isArray(this.#params) ? this.#params : {};
-        let paramsIndex = 0;
-        const tokens = parseRoutePattern(pattern);
-        for (const token of tokens) {
-            /**
-             * Expected wildcard param to be at the end always and hence
-             * we must break out from the loop
-             */
-            if (token.type === 0) {
-                uriSegments.push(`${token.val}${token.end}`);
-            }
-            else if (token.type === 2) {
-                const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject['*'];
-                this.#ensureHasWildCardValues(pattern, values);
-                uriSegments.push(`${values.join('/')}${token.end}`);
-                break;
-            }
-            else {
-                const paramName = token.val;
-                const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
-                /**
-                 * Type = 1 means param is required
-                 */
-                if (token.type === 1) {
-                    this.#ensureHasParamValue(pattern, paramName, value);
-                }
-                paramsIndex++;
-                if (value !== undefined && value !== null) {
-                    uriSegments.push(`${value}${token.end}`);
-                }
-            }
-        }
-        return `/${uriSegments.join('/')}`;
-    }
-    /**
-     * Suffix the query string to the URL
-     */
-    #suffixQueryString(url, qs) {
-        if (qs) {
-            const queryString = this.#qsParser.stringify(qs);
-            url = queryString ? `${url}?${queryString}` : url;
-        }
-        return url;
-    }
-    /**
-     * Prefixes base URL to the uri string
-     */
-    #prefixBaseUrl(uri) {
-        return this.#baseUrl ? `${this.#baseUrl}${uri}` : uri;
-    }
-    /**
-     * Prefix a custom base URL to the final URI
-     */
-    prefixUrl(url) {
-        this.#baseUrl = url;
-        return this;
-    }
-    /**
-     * Disable route lookup. Calling this method considers
-     * the "identifier" as the route pattern
-     */
-    disableRouteLookup() {
-        this.#shouldPerformLookup = false;
-        return this;
-    }
-    /**
-     * Append query string to the final URI
-     */
-    qs(queryString) {
-        if (!queryString) {
-            return this;
-        }
-        this.#qs = queryString;
-        return this;
-    }
-    /**
-     * Specify params to apply to the route pattern
-     */
-    params(params) {
-        if (!params) {
-            return this;
-        }
-        this.#params = params;
-        return this;
-    }
-    /**
-     * Generate URL for the given route identifier. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     */
-    make(identifier) {
-        let url;
-        if (this.#shouldPerformLookup) {
-            const route = this.#routeFinder.findOrFail(identifier);
-            url = this.#processPattern(route.pattern);
-        }
-        else {
-            url = this.#processPattern(identifier);
-        }
-        return this.#suffixQueryString(this.#prefixBaseUrl(url), this.#qs);
-    }
-    /**
-     * Generate a signed URL for the given route identifier. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     */
-    makeSigned(identifier, options) {
-        let url;
-        if (this.#shouldPerformLookup) {
-            const route = this.#routeFinder.findOrFail(identifier);
-            url = this.#processPattern(route.pattern);
-        }
-        else {
-            url = this.#processPattern(identifier);
-        }
-        /*
-         * Making the signature from the qualified url. We do not prefix the domain when
-         * making signature, since it just makes the signature big.
-         *
-         * There might be a case, when someone wants to generate signature for the same route
-         * on their 2 different domains, but we ignore that case for now and can consider
-         * it later (when someone asks for it)
-         */
-        const signature = this.#encryption.verifier.sign(this.#suffixQueryString(url, this.#qs), options?.expiresIn, options?.purpose);
-        const qs = Object.assign({}, this.#qs, { signature });
-        return this.#suffixQueryString(this.#prefixBaseUrl(url), qs);
-    }
-}