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

package/build/src/router/brisk.d.ts

@@ -0,0 +1,42 @@
+import Macroable from '@poppinss/macroable';
+import type { Application } from '@adonisjs/application';
+import { Route } from './route.js';
+import type { ParsedGlobalMiddleware } from '../types/middleware.js';
+import type { MakeUrlOptions, RouteFn, RouteMatchers } from '../types/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 declare class BriskRoute extends Macroable {
+    #private;
+    /**
+     * Reference to route instance. Set after `setHandler` is called
+     */
+    route: null | Route;
+    constructor(app: Application<any>, routerMiddleware: ParsedGlobalMiddleware[], options: {
+        pattern: string;
+        globalMatchers: RouteMatchers;
+    });
+    /**
+     * Set handler for the brisk route
+     */
+    setHandler(handler: RouteFn): Route;
+    /**
+     * Redirects to a given route. Params from the original request will
+     * be used when no custom params are defined.
+     */
+    redirect(identifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions & {
+        status: number;
+    }): Route;
+    /**
+     * Redirect request to a fixed URL
+     */
+    redirectToPath(url: string, options?: {
+        status: number;
+    }): Route;
+}

package/build/src/router/brisk.js

@@ -0,0 +1,85 @@
+/*
+ * @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.d.ts

@@ -0,0 +1,9 @@
+import type { ContainerResolver } from '@adonisjs/fold';
+import type { StoreRouteNode } from '../types/route.js';
+import type { HttpContext } from '../http_context/main.js';
+import type { ServerErrorHandler } from '../types/server.js';
+/**
+ * Executor to execute the route middleware pipeline the route
+ * handler
+ */
+export declare function execute(route: StoreRouteNode, resolver: ContainerResolver<any>, ctx: HttpContext, errorResponder: ServerErrorHandler['handle']): Promise<void>;

package/build/src/router/executor.js

@@ -0,0 +1,30 @@
+/*
+ * @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.d.ts

@@ -0,0 +1,6 @@
+import type { HttpContext } from '../../http_context/main.js';
+/**
+ * A factory function that uses the return value of the request
+ * pipeline as the response
+ */
+export declare function useReturnValue(ctx: HttpContext): (value: any) => void;

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

@@ -0,0 +1,22 @@
+/*
+ * @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.d.ts

@@ -0,0 +1,65 @@
+import Macroable from '@poppinss/macroable';
+import type { RouteMatcher } from '../types/route.js';
+import type { MiddlewareFn, ParsedNamedMiddleware } from '../types/middleware.js';
+import { Route } from './route.js';
+import { BriskRoute } from './brisk.js';
+import { RouteResource } from './resource.js';
+import { OneOrMore } from '../types/base.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 declare class RouteGroup extends Macroable {
+    #private;
+    routes: (Route | RouteGroup | RouteResource | BriskRoute)[];
+    constructor(routes: (Route | RouteGroup | RouteResource | BriskRoute)[]);
+    /**
+     * Define route param matcher
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).where('id', /^[0-9]+/)
+     * ```
+     */
+    where(param: string, matcher: RouteMatcher | string | RegExp): this;
+    /**
+     * Define prefix all the routes in the group.
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).prefix('v1')
+     * ```
+     */
+    prefix(prefix: string): this;
+    /**
+     * Define domain for all the routes.
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).domain(':name.adonisjs.com')
+     * ```
+     */
+    domain(domain: string): this;
+    /**
+     * Prepend name to the routes name.
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).as('version1')
+     * ```
+     */
+    as(name: string): this;
+    /**
+     * Prepend an array of middleware to all routes middleware.
+     *
+     * ```ts
+     * Route.group(() => {
+     * }).use(middleware.auth())
+     * ```
+     */
+    use(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+    /**
+     * @alias use
+     */
+    middleware(middleware: OneOrMore<MiddlewareFn | ParsedNamedMiddleware>): this;
+}

package/build/src/router/group.js

@@ -0,0 +1,207 @@
+/*
+ * @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.d.ts

@@ -0,0 +1,49 @@
+import type { Encryption } from '@adonisjs/encryption';
+import type { Qs } from '../../qs.js';
+import { UrlBuilder } from './url_builder.js';
+import type { RouteJSON } from '../../types/route.js';
+/**
+ * Lookup store exposes the API to lookup routes and
+ * make URLs for registered routes.
+ */
+export declare class LookupStore {
+    #private;
+    constructor(encryption: Encryption, qsParser: Qs);
+    /**
+     * Register route JSON payload
+     */
+    register(route: RouteJSON): void;
+    /**
+     * Returns an instance of the URL builder for making
+     * route URIs
+     */
+    builder(): UrlBuilder;
+    /**
+     * Returns an instance of the URL builder for a specific
+     * domain.
+     */
+    builderForDomain(domain: string): UrlBuilder;
+    /**
+     * Finds a route by its identifier. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     */
+    find(routeIdentifier: string, domain?: string): RouteJSON | null;
+    /**
+     * 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: string, domain?: string): RouteJSON;
+    /**
+     * Check if a route exists. The identifier can be the
+     * route name, controller.method name or the route pattern
+     * itself.
+     */
+    has(routeIdentifier: string, domain?: string): boolean;
+    toJSON(): {
+        [domain: string]: RouteJSON[];
+    };
+}

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

@@ -0,0 +1,86 @@
+/*
+ * @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.d.ts

@@ -0,0 +1,21 @@
+import type { RouteJSON } from '../../types/route.js';
+/**
+ * Route finder is used to find a route by its name, route pattern
+ * or the controller.method name.
+ */
+export declare class RouteFinder {
+    #private;
+    constructor(routes: RouteJSON[]);
+    /**
+     * Find a route by indentifier
+     */
+    find(routeIdentifier: string): RouteJSON | null;
+    /**
+     * Find a route by indentifier or fail
+     */
+    findOrFail(routeIdentifier: string): RouteJSON;
+    /**
+     * Find if a route exists
+     */
+    has(routeIdentifier: string): boolean;
+}

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

@@ -0,0 +1,49 @@
+/*
+ * @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);
+    }
+}