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

package/build/src/router/route.js

@@ -1,293 +0,0 @@
-/*
- * @adonisjs/http-server
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-import is from '@sindresorhus/is';
-import Macroable from '@poppinss/macroable';
-import Middleware from '@poppinss/middleware';
-import { RuntimeException } from '@poppinss/utils';
-import { moduleCaller, moduleExpression, moduleImporter } from '@adonisjs/fold';
-import { execute } from './executor.js';
-import { dropSlash } from '../helpers.js';
-import debug from '../debug.js';
-/**
- * The route class exposes the APIs for constructing a route using the
- * fluent API.
- */
-export class Route extends Macroable {
-    /**
-     * Route pattern
-     */
-    #pattern;
-    /**
-     * HTTP Methods for the route
-     */
-    #methods;
-    /**
-     * A unique name for the route
-     */
-    #name;
-    /**
-     * A boolean to prevent route from getting registered within
-     * the store.
-     *
-     * This flag must be set before "Router.commit" method
-     */
-    #isDeleted = false;
-    /**
-     * Route handler
-     */
-    #handler;
-    /**
-     * Matchers inherited from the router
-     */
-    #globalMatchers;
-    /**
-     * Reference to the AdonisJS application
-     */
-    #app;
-    /**
-     * Middleware registered on the router
-     */
-    #routerMiddleware;
-    /**
-     * By default the route is part of the `root` domain. Root domain is used
-     * when no domain is defined
-     */
-    #routeDomain = 'root';
-    /**
-     * An object of matchers to be forwarded to the store. The matchers
-     * list is populated by calling `where` method
-     */
-    #matchers = {};
-    /**
-     * Custom prefixes defined on the route or the route parent
-     * groups
-     */
-    #prefixes = [];
-    /**
-     * Middleware defined directly on the route or the route parent
-     * routes. We mantain an array for each layer of the stack
-     */
-    #middleware = [];
-    constructor(app, routerMiddleware, options) {
-        super();
-        this.#app = app;
-        this.#routerMiddleware = routerMiddleware;
-        this.#pattern = options.pattern;
-        this.#methods = options.methods;
-        this.#handler = this.#resolveRouteHandle(options.handler);
-        this.#globalMatchers = options.globalMatchers;
-    }
-    /**
-     * Resolves the route handler string expression to a
-     * handler method object
-     */
-    #resolveRouteHandle(handler) {
-        if (typeof handler === 'string') {
-            return {
-                reference: handler,
-                ...moduleExpression(handler, this.#app.appRoot).toHandleMethod(),
-            };
-        }
-        /**
-         * Using a lazily imported controller
-         */
-        if (Array.isArray(handler)) {
-            /**
-             * The first item of the tuple is a class constructor
-             */
-            if (is.class_(handler[0])) {
-                return {
-                    reference: handler,
-                    ...moduleCaller(handler[0], (handler[1] || 'handle')).toHandleMethod(),
-                };
-            }
-            /**
-             * The first item of the tuple is a function that lazily
-             * loads the controller
-             */
-            return {
-                reference: handler,
-                ...moduleImporter(handler[0], (handler[1] || 'handle')).toHandleMethod(),
-            };
-        }
-        return handler;
-    }
-    /**
-     * 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 { ...this.#globalMatchers, ...this.#matchers };
-    }
-    /**
-     * Returns a normalized pattern string by prefixing the `prefix` (if defined).
-     */
-    #computePattern() {
-        const pattern = dropSlash(this.#pattern);
-        const prefix = this.#prefixes
-            .slice()
-            .reverse()
-            .map((one) => dropSlash(one))
-            .join('');
-        return prefix ? `${prefix}${pattern === '/' ? '' : pattern}` : pattern;
-    }
-    /**
-     * Define 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 group
-     * matchers.
-     *
-     * ```ts
-     * Route.group(() => {
-     *   Route.get('/:id', 'handler').where('id', /^[0-9]$/)
-     * }).where('id', /[^a-z$]/)
-     * ```
-     *
-     * The `/^[0-9]$/` will 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 (is.regExp(matcher)) {
-            this.#matchers[param] = { match: matcher };
-        }
-        else {
-            this.#matchers[param] = matcher;
-        }
-        return this;
-    }
-    /**
-     * Define prefix for the route. Calling this method multiple times
-     * applies multiple prefixes in the reverse order.
-     */
-    prefix(prefix) {
-        this.#prefixes.push(prefix);
-        return this;
-    }
-    /**
-     * Define a custom domain for the route. We do not overwrite the domain
-     * unless `overwrite` flag is set to true.
-     */
-    domain(domain, overwrite = false) {
-        if (this.#routeDomain === 'root' || overwrite) {
-            this.#routeDomain = domain;
-        }
-        return this;
-    }
-    /**
-     * Define one or more middleware to be executed before the route
-     * handler.
-     *
-     * Named middleware can be referenced using the name registered with
-     * the router middleware store.
-     */
-    use(middleware) {
-        this.#middleware.push(Array.isArray(middleware) ? middleware : [middleware]);
-        return this;
-    }
-    /**
-     * @alias use
-     */
-    middleware(middleware) {
-        return this.use(middleware);
-    }
-    /**
-     * Give a unique name to the route. Assinging a new unique removes the
-     * existing name of the route.
-     *
-     * Setting prepends to true prefixes the name to the existing name.
-     */
-    as(name, prepend = false) {
-        if (prepend) {
-            if (!this.#name) {
-                throw new RuntimeException(`Routes inside a group must have names before calling "router.group.as"`);
-            }
-            this.#name = `${name}.${this.#name}`;
-            return this;
-        }
-        this.#name = name;
-        return this;
-    }
-    /**
-     * Check if the route was marked to be deleted
-     */
-    isDeleted() {
-        return this.#isDeleted;
-    }
-    /**
-     * Mark route as deleted. Deleted routes are not registered
-     * with the route store
-     */
-    markAsDeleted() {
-        this.#isDeleted = true;
-    }
-    /**
-     * Get the route name
-     */
-    getName() {
-        return this.#name;
-    }
-    /**
-     * Get the route pattern
-     */
-    getPattern() {
-        return this.#pattern;
-    }
-    /**
-     * Set the route pattern
-     */
-    setPattern(pattern) {
-        this.#pattern = pattern;
-        return this;
-    }
-    /**
-     * Returns the stack of middleware registered on the route.
-     * The value is shared by reference.
-     */
-    getMiddleware() {
-        return this.#middleware;
-    }
-    /**
-     * Returns the middleware instance for persistence inside the
-     * store
-     */
-    #getMiddlewareForStore() {
-        const middleware = new Middleware();
-        this.#routerMiddleware.forEach((one) => {
-            debug('adding global middleware to route %s, %O', this.#pattern, one);
-            middleware.add(one);
-        });
-        this.#middleware.flat().forEach((one) => {
-            debug('adding named middleware to route %s, %O', this.#pattern, one);
-            middleware.add(one);
-        });
-        return middleware;
-    }
-    /**
-     * Returns JSON representation of the route
-     */
-    toJSON() {
-        return {
-            domain: this.#routeDomain,
-            pattern: this.#computePattern(),
-            matchers: this.#getMatchers(),
-            meta: {},
-            name: this.#name,
-            handler: this.#handler,
-            methods: this.#methods,
-            middleware: this.#getMiddlewareForStore(),
-            execute: execute,
-        };
-    }
-}

package/build/src/router/store.js

@@ -1,195 +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.
- */
-// @ts-expect-error
-import matchit from '@poppinss/matchit';
-import lodash from '@poppinss/utils/lodash';
-import { RuntimeException } from '@poppinss/utils';
-import { parseRoutePattern } from './parser.js';
-import debug from '../debug.js';
-/**
- * Store class is used to store a list of routes, along side with their tokens
- * to match the URLs.
- *
- * ```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 class RoutesStore {
-    /**
-     * A flag to know if routes for explicit domains
-     * have been registered
-     */
-    usingDomains = false;
-    /**
-     * Tree of registered routes and their matchit tokens
-     */
-    tree = { tokens: [], domains: {} };
-    /**
-     * Returns the domain node for a given domain.
-     */
-    #getDomainNode(domain) {
-        if (!this.tree.domains[domain]) {
-            this.tree.tokens.push(parseRoutePattern(domain));
-            this.tree.domains[domain] = {};
-        }
-        return this.tree.domains[domain];
-    }
-    /**
-     * Returns the method node for a given domain and method.
-     */
-    #getMethodNode(domain, method) {
-        const domainNode = this.#getDomainNode(domain);
-        if (!domainNode[method]) {
-            domainNode[method] = { tokens: [], routes: {}, routeKeys: {} };
-        }
-        return domainNode[method];
-    }
-    /**
-     * Collects route params
-     */
-    #collectRouteParams(route, tokens) {
-        const collectedParams = new Set();
-        for (let token of tokens) {
-            if ([1, 3].includes(token.type)) {
-                if (collectedParams.has(token.val)) {
-                    throw new RuntimeException(`Duplicate param "${token.val}" found in "${route.pattern}"`);
-                }
-                else {
-                    collectedParams.add(token.val);
-                }
-            }
-        }
-        const params = [...collectedParams];
-        collectedParams.clear();
-        return params;
-    }
-    /**
-     * Register route for a given domain and method
-     */
-    #registerRoute(domain, method, tokens, route) {
-        const methodRoutes = this.#getMethodNode(domain, method);
-        /*
-         * Check for duplicate route for the same domain and method
-         */
-        if (methodRoutes.routes[route.pattern]) {
-            throw new RuntimeException(`Duplicate route found. "${method}: ${route.pattern}" route already exists`);
-        }
-        if (debug.enabled) {
-            debug('registering route to the store %O', route);
-            debug('route middleware %O', route.middleware.all().entries());
-        }
-        methodRoutes.tokens.push(tokens);
-        methodRoutes.routes[route.pattern] = route;
-        methodRoutes.routeKeys[route.pattern] =
-            domain !== 'root' ? `${domain}-${method}-${route.pattern}` : `${method}-${route.pattern}`;
-    }
-    /**
-     * Add a route to the store
-     *
-     * ```ts
-     * store.add({
-     *   pattern: 'post/:id',
-     *   methods: ['GET'],
-     *   matchers: {},
-     *   meta: {},
-     *   handler: function handler () {
-     *   }
-     * })
-     * ```
-     */
-    add(route) {
-        /**
-         * Set flag when a custom domain is used
-         */
-        if (route.domain !== 'root') {
-            this.usingDomains = true;
-        }
-        /**
-         * Generate tokens for the route
-         */
-        const tokens = parseRoutePattern(route.pattern, route.matchers);
-        /**
-         * Create route node object for persistence
-         */
-        const routeNode = lodash.merge({ meta: {} }, lodash.pick(route, ['pattern', 'handler', 'meta', 'middleware', 'name', 'execute']));
-        /**
-         * Set route params
-         */
-        routeNode.meta.params = this.#collectRouteParams(routeNode, tokens);
-        /**
-         * Register route for every method
-         */
-        route.methods.forEach((method) => {
-            this.#registerRoute(route.domain, method, tokens, routeNode);
-        });
-        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 domainName = domain?.tokens[0]?.old || '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.match(url, matchedMethod.tokens);
-        if (!matchedRoute.length) {
-            return null;
-        }
-        const route = matchedMethod.routes[matchedRoute[0].old];
-        return {
-            route: route,
-            routeKey: matchedMethod.routeKeys[route.pattern],
-            params: matchit.exec(url, matchedRoute),
-            subdomains: domain?.hostname ? matchit.exec(domain.hostname, domain.tokens) : {},
-        };
-    }
-    /**
-     * Match hostname against registered domains.
-     */
-    matchDomain(hostname) {
-        if (!hostname || !this.usingDomains) {
-            return [];
-        }
-        return matchit.match(hostname, this.tree.tokens);
-    }
-}

package/build/src/server/factories/final_handler.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 * as errors from '../../exceptions.js';
-/**
- * The final handler is executed after the server middleware stack.
- * It looks for a matching route and executes the route middleware
- * stack.
- */
-export function finalHandler(router, resolver, ctx, errorResponder) {
-    return function () {
-        const url = ctx.request.url();
-        const method = ctx.request.method();
-        const hostname = router.usingDomains ? ctx.request.hostname() : undefined;
-        const route = router.match(url, method, hostname);
-        if (route) {
-            ctx.params = route.params;
-            ctx.subdomains = route.subdomains;
-            ctx.route = route.route;
-            ctx.routeKey = route.routeKey;
-            return route.route.execute(route.route, resolver, ctx, errorResponder);
-        }
-        return Promise.reject(new errors.E_ROUTE_NOT_FOUND([method, url]));
-    };
-}

package/build/src/server/factories/middleware_handler.js

@@ -1,16 +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.
- */
-/**
- * The middleware handler invokes the middleware functions.
- */
-export function middlewareHandler(resolver, ctx) {
-    return function (fn, next) {
-        return fn.handle(resolver, ctx, next);
-    };
-}

package/build/src/server/factories/write_response.js

@@ -1,24 +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.
- */
-/**
- * Writes the response to the socket. The "finish" method can
- * raise error when unable to serialize the response.
- */
-export function writeResponse(ctx) {
-    return function () {
-        try {
-            ctx.response.finish();
-        }
-        catch (error) {
-            ctx.logger.fatal({ err: error }, 'Response serialization failed');
-            ctx.response.internalServerError(error.message);
-            ctx.response.finish();
-        }
-    };
-}