@adonisjs/http-server 5.12.0 → 6.0.1-0

package/build/src/Router/Route.d.ts

@@ -1,138 +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 { Macroable } from 'macroable';
-import { RouteJSON, RouteContract, RouteHandler, RouteMatchersNode, RouteParamMatcher, RouteMiddlewareHandler } from '@ioc:Adonis/Core/Route';
-/**
- * Route class is used to construct consistent [[RouteDefinition]] using
- * fluent API. An instance of route is usually obtained using the
- * [[Router]] class helper methods.
- *
- * @example
- * ```ts
- * const route = new Route('posts/:id', ['GET'], async function () {
- * })
- *
- * route
- *   .where('id', /^[0-9]+$/)
- *   .middleware(async function () {
- *   })
- * ```
- */
-export declare class Route extends Macroable implements RouteContract {
-    private pattern;
-    private methods;
-    private handler;
-    private globalMatchers;
-    protected static macros: {};
-    protected static getters: {};
-    /**
-     * By default the route is part of `root` domain. Root
-     * domain is used when no domain is defined
-     */
-    private routeDomain;
-    /**
-     * An object of matchers to be forwarded to the
-     * store. The matchers list is populated by
-     * calling `where` method
-     */
-    private matchers;
-    /**
-     * Custom prefixes. Usually added to a group of routes. We keep an array of them
-     * since nested groups will want all of them ot concat.
-     */
-    private prefixes;
-    /**
-     * An array of middleware. Added using `middleware` function
-     */
-    private routeMiddleware;
-    /**
-     * Storing the namespace explicitly set using `route.namespace` method
-     */
-    private routeNamespace;
-    /**
-     * A boolean to prevent route from getting registered within
-     * the [[Store]].
-     *
-     * This flag must be set before [[Router.commit]] method
-     */
-    deleted: boolean;
-    /**
-     * A unique name to lookup the route
-     */
-    name: string;
-    constructor(pattern: string, methods: string[], handler: RouteHandler, globalMatchers: RouteMatchersNode);
-    /**
-     * Returns an object of param matchers by merging global and local
-     * matchers. The local copy is given preference over the global
-     * one's
-     */
-    private getMatchers;
-    /**
-     * Returns a normalized pattern string by prefixing the `prefix` (if defined).
-     */
-    private computePattern;
-    /**
-     * Define Regex matcher for a given param. If a matcher exists, then we do not
-     * override that, since the routes inside a group will set matchers before
-     * the group, so they should have priority over the route matchers.
-     *
-     * ```
-     * Route.group(() => {
-     *   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
-     * }).where('id', /[^a-z$]/)
-     * ```
-     *
-     * The `/^[0-9]$/` should win over the matcher defined by the group
-     */
-    where(param: string, matcher: RouteParamMatcher): this;
-    /**
-     * Define prefix for the route. Prefixes will be concated
-     * This method is mainly exposed for the [[RouteGroup]]
-     */
-    prefix(prefix: string): this;
-    /**
-     * Define a custom domain for the route. Again we do not overwrite the domain
-     * unless `overwrite` flag is set to true.
-     *
-     * This is again done to make route.domain win over route.group.domain
-     */
-    domain(domain: string, overwrite?: boolean): this;
-    /**
-     * Define an array of middleware to be executed on the route. If `prepend`
-     * is true, then middleware will be added to start of the existing
-     * middleware. The option is exposed for [[RouteGroup]]
-     */
-    middleware(middleware: RouteMiddlewareHandler | RouteMiddlewareHandler[], prepend?: boolean): this;
-    /**
-     * Give memorizable name to the route. This is helpful, when you
-     * want to lookup route defination by it's name.
-     *
-     * If `prepend` is true, then it will keep on prepending to the existing
-     * name. This option is exposed for [[RouteGroup]]
-     */
-    as(name: string, prepend?: boolean): this;
-    /**
-     * Define controller namespace for a given route
-     */
-    namespace(namespace: string, overwrite?: boolean): this;
-    /**
-     * Get the route pattern
-     */
-    getPattern(): string;
-    /**
-     * Set the route pattern
-     */
-    setPattern(pattern: string): this;
-    /**
-     * Returns [[RouteDefinition]] that can be passed to the [[Store]] for
-     * registering the route
-     */
-    toJSON(): RouteJSON;
-}

package/build/src/Router/Route.js

@@ -1,204 +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.Route = void 0;
-/// <reference path="../../adonis-typings/index.ts" />
-const macroable_1 = require("macroable");
-const helpers_1 = require("@poppinss/utils/build/helpers");
-const helpers_2 = require("../helpers");
-/**
- * Route class is used to construct consistent [[RouteDefinition]] using
- * fluent API. An instance of route is usually obtained using the
- * [[Router]] class helper methods.
- *
- * @example
- * ```ts
- * const route = new Route('posts/:id', ['GET'], async function () {
- * })
- *
- * route
- *   .where('id', /^[0-9]+$/)
- *   .middleware(async function () {
- *   })
- * ```
- */
-class Route extends macroable_1.Macroable {
-    constructor(pattern, methods, handler, globalMatchers) {
-        super();
-        this.pattern = pattern;
-        this.methods = methods;
-        this.handler = handler;
-        this.globalMatchers = globalMatchers;
-        /**
-         * By default the route is part of `root` domain. Root
-         * domain is used when no domain is defined
-         */
-        this.routeDomain = 'root';
-        /**
-         * An object of matchers to be forwarded to the
-         * store. The matchers list is populated by
-         * calling `where` method
-         */
-        this.matchers = {};
-        /**
-         * Custom prefixes. Usually added to a group of routes. We keep an array of them
-         * since nested groups will want all of them ot concat.
-         */
-        this.prefixes = [];
-        /**
-         * An array of middleware. Added using `middleware` function
-         */
-        this.routeMiddleware = [];
-        /**
-         * A boolean to prevent route from getting registered within
-         * the [[Store]].
-         *
-         * This flag must be set before [[Router.commit]] method
-         */
-        this.deleted = false;
-    }
-    /**
-     * Returns an object of param matchers by merging global and local
-     * matchers. The local copy is given preference over the global
-     * one's
-     */
-    getMatchers() {
-        return Object.assign({}, this.globalMatchers, this.matchers);
-    }
-    /**
-     * Returns a normalized pattern string by prefixing the `prefix` (if defined).
-     */
-    computePattern() {
-        const pattern = (0, helpers_2.dropSlash)(this.pattern);
-        const prefix = this.prefixes
-            .slice()
-            .reverse()
-            .map((one) => (0, helpers_2.dropSlash)(one))
-            .join('');
-        return prefix ? `${prefix}${pattern === '/' ? '' : pattern}` : pattern;
-    }
-    /**
-     * Define Regex matcher for a given param. If a matcher exists, then we do not
-     * override that, since the routes inside a group will set matchers before
-     * the group, so they should have priority over the route matchers.
-     *
-     * ```
-     * Route.group(() => {
-     *   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
-     * }).where('id', /[^a-z$]/)
-     * ```
-     *
-     * The `/^[0-9]$/` should win over the matcher defined by the group
-     */
-    where(param, matcher) {
-        if (this.matchers[param]) {
-            return this;
-        }
-        if (typeof matcher === 'string') {
-            this.matchers[param] = { match: new RegExp(matcher) };
-        }
-        else if (helpers_1.types.isRegexp(matcher)) {
-            this.matchers[param] = { match: matcher };
-        }
-        else {
-            this.matchers[param] = matcher;
-        }
-        return this;
-    }
-    /**
-     * Define prefix for the route. Prefixes will be concated
-     * This method is mainly exposed for the [[RouteGroup]]
-     */
-    prefix(prefix) {
-        this.prefixes.push(prefix);
-        return this;
-    }
-    /**
-     * Define a custom domain for the route. Again we do not overwrite the domain
-     * unless `overwrite` flag is set to true.
-     *
-     * This is again done to make route.domain win over route.group.domain
-     */
-    domain(domain, overwrite = false) {
-        if (this.routeDomain === 'root' || overwrite) {
-            this.routeDomain = domain;
-        }
-        return this;
-    }
-    /**
-     * Define an array of middleware to be executed on the route. If `prepend`
-     * is true, then middleware will be added to start of the existing
-     * middleware. The option is exposed for [[RouteGroup]]
-     */
-    middleware(middleware, prepend = false) {
-        middleware = Array.isArray(middleware) ? middleware : [middleware];
-        if (prepend) {
-            this.routeMiddleware.unshift(middleware);
-        }
-        else {
-            this.routeMiddleware.push(middleware);
-        }
-        return this;
-    }
-    /**
-     * Give memorizable name to the route. This is helpful, when you
-     * want to lookup route defination by it's name.
-     *
-     * If `prepend` is true, then it will keep on prepending to the existing
-     * name. This option is exposed for [[RouteGroup]]
-     */
-    as(name, prepend = false) {
-        this.name = prepend ? `${name}.${this.name}` : name;
-        return this;
-    }
-    /**
-     * Define controller namespace for a given route
-     */
-    namespace(namespace, overwrite = false) {
-        if (!this.routeNamespace || overwrite) {
-            this.routeNamespace = namespace;
-        }
-        return this;
-    }
-    /**
-     * Get the route pattern
-     */
-    getPattern() {
-        return this.pattern;
-    }
-    /**
-     * Set the route pattern
-     */
-    setPattern(pattern) {
-        this.pattern = pattern;
-        return this;
-    }
-    /**
-     * Returns [[RouteDefinition]] that can be passed to the [[Store]] for
-     * registering the route
-     */
-    toJSON() {
-        return {
-            domain: this.routeDomain,
-            pattern: this.computePattern(),
-            matchers: this.getMatchers(),
-            meta: {
-                namespace: this.routeNamespace,
-            },
-            name: this.name,
-            handler: this.handler,
-            methods: this.methods,
-            middleware: this.routeMiddleware.flat(),
-        };
-    }
-}
-exports.Route = Route;
-Route.macros = {};
-Route.getters = {};

package/build/src/Router/Store.d.ts

@@ -1,93 +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 { RouteJSON, RoutesTree, MatchedRoute, RouteStoreMatch } from '@ioc:Adonis/Core/Route';
-/**
- * Store class is used to store a list of routes, along side with their tokens
- * to match the URL's. The used data structures to store information is tailored
- * for quick lookups.
- *
- * @example
- * ```ts
- * const store = new Store()
- *
- * store.add({
- *  pattern: 'posts/:id',
- *  handler: function onRoute () {},
- *  middleware: [],
- *  matchers: {
- *    id: '^[0-9]$+'
- *  },
- *  meta: {},
- *  methods: ['GET']
- * })
- *
- * store.match('posts/1', 'GET')
- * ```
- */
-export declare class Store {
-    tree: RoutesTree;
-    /**
-     * The [[matchDomainReal]] and [[matchDomainNoop]] functions are two
-     * implementation of matching a domain. We use noop implementation
-     * by default and once an explicit domain is registered, we
-     * pivot to [[matchDomainReal]].
-     *
-     * This all is done for performance, since we have noticed around 8-10%
-     * improvement.
-     */
-    private matchDomainReal;
-    private matchDomainNoop;
-    /**
-     * The implementation used for matching domain. Will pivot to `matchDomainReal`
-     * when one or more domains will be defined
-     */
-    matchDomain: any;
-    /**
-     * Returns the domain node for a given domain. If domain node is missing,
-     * it will added to the routes object and tokens are also generated
-     */
-    private getDomainNode;
-    /**
-     * Returns the method node for a given domain and method. If method is
-     * missing, it will be added to the domain node
-     */
-    private getMethodRoutes;
-    /**
-     * Adds a route to the store for all the given HTTP methods. Also an array
-     * of tokens is generated for the route pattern. The tokens are then
-     * matched against the URL to find the appropriate route.
-     *
-     * @example
-     * ```ts
-     * store.add({
-     *   pattern: 'post/:id',
-     *   methods: ['GET'],
-     *   matchers: {},
-     *   meta: {},
-     *   handler: function handler () {
-     *   }
-     * })
-     * ```
-     */
-    add(route: RouteJSON): this;
-    /**
-     * Matches the url, method and optionally domain to pull the matching
-     * route. `null` is returned when unable to match the URL against
-     * registered routes.
-     *
-     * The domain parameter has to be a registered pattern and not the fully
-     * qualified runtime domain. You must call `matchDomain` first to fetch
-     * the pattern for qualified domain
-     */
-    match(url: string, method: string, domain?: {
-        storeMatch: RouteStoreMatch[];
-        value: string;
-    }): null | MatchedRoute;
-}

package/build/src/Router/Store.js

@@ -1,211 +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.Store = void 0;
-/// <reference path="../../adonis-typings/index.ts" />
-const matchit_1 = __importDefault(require("@poppinss/matchit"));
-const utils_1 = require("@poppinss/utils");
-const RouterException_1 = require("../Exceptions/RouterException");
-/**
- * Store class is used to store a list of routes, along side with their tokens
- * to match the URL's. The used data structures to store information is tailored
- * for quick lookups.
- *
- * @example
- * ```ts
- * const store = new Store()
- *
- * store.add({
- *  pattern: 'posts/:id',
- *  handler: function onRoute () {},
- *  middleware: [],
- *  matchers: {
- *    id: '^[0-9]$+'
- *  },
- *  meta: {},
- *  methods: ['GET']
- * })
- *
- * store.match('posts/1', 'GET')
- * ```
- */
-class Store {
-    constructor() {
-        this.tree = { tokens: [], domains: {} };
-        /**
-         * The [[matchDomainReal]] and [[matchDomainNoop]] functions are two
-         * implementation of matching a domain. We use noop implementation
-         * by default and once an explicit domain is registered, we
-         * pivot to [[matchDomainReal]].
-         *
-         * This all is done for performance, since we have noticed around 8-10%
-         * improvement.
-         */
-        this.matchDomainReal = function (domain) {
-            return matchit_1.default.match(domain || 'root', this.tree.tokens);
-        }.bind(this);
-        this.matchDomainNoop = function (_) {
-            return [];
-        }.bind(this);
-        /**
-         * The implementation used for matching domain. Will pivot to `matchDomainReal`
-         * when one or more domains will be defined
-         */
-        this.matchDomain = this.matchDomainNoop;
-    }
-    /**
-     * Returns the domain node for a given domain. If domain node is missing,
-     * it will added to the routes object and tokens are also generated
-     */
-    getDomainNode(domain) {
-        if (!this.tree.domains[domain]) {
-            /**
-             * The tokens are required to match dynamic domains
-             */
-            this.tree.tokens.push(matchit_1.default.parse(domain));
-            this.tree.domains[domain] = {};
-        }
-        return this.tree.domains[domain];
-    }
-    /**
-     * Returns the method node for a given domain and method. If method is
-     * missing, it will be added to the domain node
-     */
-    getMethodRoutes(domain, method) {
-        const domainNode = this.getDomainNode(domain);
-        if (!domainNode[method]) {
-            domainNode[method] = { tokens: [], routes: {} };
-        }
-        return domainNode[method];
-    }
-    /**
-     * Adds a route to the store for all the given HTTP methods. Also an array
-     * of tokens is generated for the route pattern. The tokens are then
-     * matched against the URL to find the appropriate route.
-     *
-     * @example
-     * ```ts
-     * store.add({
-     *   pattern: 'post/:id',
-     *   methods: ['GET'],
-     *   matchers: {},
-     *   meta: {},
-     *   handler: function handler () {
-     *   }
-     * })
-     * ```
-     */
-    add(route) {
-        /*
-         * Create a copy of route properties by cherry picking
-         * fields. We create the copy outside the forEach
-         * loop, so that the same object is shared across
-         * all the methods (saving memory).
-         *
-         * Also sharing a single route note among all the methods is fine,
-         * since we create sub-trees for each method to make the lookups
-         * fast.
-         */
-        const routeJSON = {};
-        utils_1.lodash.merge(routeJSON, utils_1.lodash.pick(route, ['pattern', 'handler', 'meta', 'middleware', 'name']));
-        /*
-         * An explicit domain is defined
-         */
-        if (route.domain && route.domain !== 'root' && this.matchDomain !== this.matchDomainReal) {
-            this.matchDomain = this.matchDomainReal;
-        }
-        /*
-         * Generate tokens for the given route and push to the list
-         * of tokens
-         */
-        const tokens = matchit_1.default.parse(route.pattern, route.matchers);
-        const collectedParams = new Set();
-        /**
-         * Avoiding duplicate route params
-         */
-        for (let token of tokens) {
-            if ([1, 3].includes(token.type)) {
-                if (collectedParams.has(token.val)) {
-                    throw RouterException_1.RouterException.duplicateRouteParam(token.val, route.pattern);
-                }
-                else {
-                    collectedParams.add(token.val);
-                }
-            }
-        }
-        routeJSON.params = new Array(...collectedParams);
-        collectedParams.clear();
-        route.methods.forEach((method) => {
-            const methodRoutes = this.getMethodRoutes(route.domain || 'root', method);
-            /*
-             * Ensure that route doesn't pre-exists. In that case, we need to throw
-             * the exception, since it's a programmer error to create multiple
-             * routes with the same pattern on the same method.
-             */
-            if (methodRoutes.routes[route.pattern]) {
-                throw RouterException_1.RouterException.duplicateRoute(method, route.pattern);
-            }
-            methodRoutes.tokens.push(tokens);
-            /*
-             * Store reference to the route, so that we can return it to the user, when
-             * they call `match`.
-             */
-            methodRoutes.routes[route.pattern] = routeJSON;
-        });
-        return this;
-    }
-    /**
-     * Matches the url, method and optionally domain to pull the matching
-     * route. `null` is returned when unable to match the URL against
-     * registered routes.
-     *
-     * The domain parameter has to be a registered pattern and not the fully
-     * qualified runtime domain. You must call `matchDomain` first to fetch
-     * the pattern for qualified domain
-     */
-    match(url, method, domain) {
-        const matchingDomain = domain && domain.storeMatch[0] && domain.storeMatch[0].old;
-        const domainName = matchingDomain || 'root';
-        const matchedDomain = this.tree.domains[domainName];
-        if (!matchedDomain) {
-            return null;
-        }
-        /*
-         * Next get the method node for the given method inside the domain. If
-         * method node is missing, means no routes ever got registered for that
-         * method
-         */
-        const matchedMethod = this.tree.domains[domainName][method];
-        if (!matchedMethod) {
-            return null;
-        }
-        /*
-         * Next, match route for the given url inside the tokens list for the
-         * matchedMethod
-         */
-        const matchedRoute = matchit_1.default.match(url, matchedMethod.tokens);
-        if (!matchedRoute.length) {
-            return null;
-        }
-        const route = matchedMethod.routes[matchedRoute[0].old];
-        return {
-            route: route,
-            routeKey: matchingDomain
-                ? `${matchingDomain}-${method}-${route.pattern}`
-                : `${method}-${route.pattern}`,
-            params: matchit_1.default.exec(url, matchedRoute),
-            subdomains: domain?.value ? matchit_1.default.exec(domain.value, domain.storeMatch) : {},
-        };
-    }
-}
-exports.Store = Store;