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

package/build/src/router/main.js

@@ -1,316 +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 { moduleImporter } from '@adonisjs/fold';
-import { RuntimeException } from '@poppinss/utils';
-import { Route } from './route.js';
-import { RouteGroup } from './group.js';
-import { BriskRoute } from './brisk.js';
-import { RoutesStore } from './store.js';
-import { toRoutesJSON } from '../helpers.js';
-import { RouteResource } from './resource.js';
-import { LookupStore } from './lookup_store/main.js';
-import { RouteMatchers as Matchers } from './matchers.js';
-import { defineNamedMiddleware } from '../define_middleware.js';
-import { parseRoutePattern } from './parser.js';
-/**
- * Router class exposes a unified API to register new routes, group them or
- * create route resources.
- *
- * ```ts
- * const router = new Router()
- *
- * router.get('/', async function () {
- *   // handle request
- * })
- * ```
- */
-export class Router extends LookupStore {
-    /**
-     * Application is needed to resolve string based controller expressions
-     */
-    #app;
-    /**
-     * Store with tokenized routes
-     */
-    #store = new RoutesStore();
-    /**
-     * Global matchers to test route params against regular expressions.
-     */
-    #globalMatchers = {};
-    /**
-     * Middleware store to be shared with the routes
-     */
-    #middleware = [];
-    /**
-     * A boolean to tell the router that a group is in
-     * open state right now
-     */
-    #openedGroups = [];
-    /**
-     * Collection of routes, including route resource and route
-     * group. To get a flat list of routes, call `router.toJSON()`
-     */
-    routes = [];
-    /**
-     * A flag to know if routes for explicit domains have been registered.
-     * The boolean is computed after calling the "commit" method.
-     */
-    usingDomains = false;
-    /**
-     * Shortcut methods for commonly used route matchers
-     */
-    matchers = new Matchers();
-    constructor(app, encryption, qsParser) {
-        super(encryption, qsParser);
-        this.#app = app;
-    }
-    /**
-     * Push a give router entity to the list of routes or the
-     * recently opened group.
-     */
-    #pushToRoutes(entity) {
-        const openedGroup = this.#openedGroups[this.#openedGroups.length - 1];
-        if (openedGroup) {
-            openedGroup.routes.push(entity);
-            return;
-        }
-        this.routes.push(entity);
-    }
-    /**
-     * Parses the route pattern
-     */
-    parsePattern(pattern, matchers) {
-        return parseRoutePattern(pattern, matchers);
-    }
-    /**
-     * Define an array of middleware to use on all the routes.
-     * Calling this method multiple times pushes to the
-     * existing list of middleware
-     */
-    use(middleware) {
-        middleware.forEach((one) => this.#middleware.push(moduleImporter(one, 'handle').toHandleMethod()));
-        return this;
-    }
-    /**
-     * Define a collection of named middleware. The defined collection is
-     * not registered anywhere, but instead converted in a new collection
-     * of functions you can apply on the routes, or router groups.
-     */
-    named(collection) {
-        return defineNamedMiddleware(collection);
-    }
-    /**
-     * Add route for a given pattern and methods
-     */
-    route(pattern, methods, handler) {
-        const route = new Route(this.#app, this.#middleware, {
-            pattern,
-            methods,
-            handler,
-            globalMatchers: this.#globalMatchers,
-        });
-        this.#pushToRoutes(route);
-        return route;
-    }
-    /**
-     * Define a route that handles all common HTTP methods
-     */
-    any(pattern, handler) {
-        return this.route(pattern, ['HEAD', 'OPTIONS', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE'], handler);
-    }
-    /**
-     * Define `GET` route
-     */
-    get(pattern, handler) {
-        return this.route(pattern, ['GET', 'HEAD'], handler);
-    }
-    /**
-     * Define `POST` route
-     */
-    post(pattern, handler) {
-        return this.route(pattern, ['POST'], handler);
-    }
-    /**
-     * Define `PUT` route
-     */
-    put(pattern, handler) {
-        return this.route(pattern, ['PUT'], handler);
-    }
-    /**
-     * Define `PATCH` route
-     */
-    patch(pattern, handler) {
-        return this.route(pattern, ['PATCH'], handler);
-    }
-    /**
-     * Define `DELETE` route
-     */
-    delete(pattern, handler) {
-        return this.route(pattern, ['DELETE'], handler);
-    }
-    /**
-     * Creates a group of routes. A route group can apply transforms
-     * to routes in bulk
-     */
-    group(callback) {
-        /*
-         * Create a new group with empty set of routes
-         */
-        const group = new RouteGroup([]);
-        /**
-         * Track group
-         */
-        this.#pushToRoutes(group);
-        /*
-         * Track the group, so that the upcoming calls inside the callback
-         * can use this group
-         */
-        this.#openedGroups.push(group);
-        /*
-         * Execute the callback. Now all registered routes will be
-         * collected seperately from the `routes` array
-         */
-        callback();
-        /*
-         * Now the callback is over, get rid of the opened group
-         */
-        this.#openedGroups.pop();
-        return group;
-    }
-    /**
-     * Registers a route resource with conventional set of routes
-     */
-    resource(resource, controller) {
-        const resourceInstance = new RouteResource(this.#app, this.#middleware, {
-            resource,
-            controller,
-            shallow: false,
-            globalMatchers: this.#globalMatchers,
-        });
-        this.#pushToRoutes(resourceInstance);
-        return resourceInstance;
-    }
-    /**
-     * Register a route resource with shallow nested routes.
-     */
-    shallowResource(resource, controller) {
-        const resourceInstance = new RouteResource(this.#app, this.#middleware, {
-            resource,
-            controller,
-            shallow: true,
-            globalMatchers: this.#globalMatchers,
-        });
-        this.#pushToRoutes(resourceInstance);
-        return resourceInstance;
-    }
-    /**
-     * Returns a brisk route instance for a given URL pattern
-     */
-    on(pattern) {
-        const briskRoute = new BriskRoute(this.#app, this.#middleware, {
-            pattern,
-            globalMatchers: this.#globalMatchers,
-        });
-        this.#pushToRoutes(briskRoute);
-        return briskRoute;
-    }
-    /**
-     * Define matcher for a given param. The global params are applied
-     * on all the routes (unless overridden at the route level).
-     */
-    where(param, matcher) {
-        if (typeof matcher === 'string') {
-            this.#globalMatchers[param] = { match: new RegExp(matcher) };
-        }
-        else if (is.regExp(matcher)) {
-            this.#globalMatchers[param] = { match: matcher };
-        }
-        else {
-            this.#globalMatchers[param] = matcher;
-        }
-        return this;
-    }
-    /**
-     * Commit routes to the store. The router is freezed after the
-     * commit method is called.
-     */
-    commit() {
-        const routeNamesByDomain = new Map();
-        toRoutesJSON(this.routes).forEach((route) => {
-            if (!routeNamesByDomain.has(route.domain)) {
-                routeNamesByDomain.set(route.domain, new Set());
-            }
-            const routeNames = routeNamesByDomain.get(route.domain);
-            /*
-             * Raise error when route name is already in use. Route names have to be unique
-             * to ensure that only one route is returned during lookup.
-             */
-            if (route.name && routeNames.has(route.name)) {
-                throw new RuntimeException(`Route with duplicate name found. A route with name "${route.name}" already exists`);
-            }
-            /*
-             * If route has a unique, then track the name for checking duplicates
-             */
-            if (route.name) {
-                routeNames.add(route.name);
-            }
-            /**
-             * Register the route with the lookup store
-             */
-            this.register(route);
-            this.#store.add(route);
-        });
-        routeNamesByDomain.clear();
-        this.usingDomains = this.#store.usingDomains;
-        this.routes = [];
-        this.#globalMatchers = {};
-        this.#middleware = [];
-    }
-    /**
-     * Find route for a given URL, method and optionally domain
-     */
-    match(url, method, hostname) {
-        const matchingDomain = this.#store.matchDomain(hostname);
-        return matchingDomain.length
-            ? this.#store.match(url, method, {
-                tokens: matchingDomain,
-                hostname: hostname,
-            })
-            : this.#store.match(url, method);
-    }
-    /**
-     * Make URL to a pre-registered route
-     */
-    makeUrl(routeIdentifier, params, options) {
-        const normalizedOptions = Object.assign({}, options);
-        const builder = normalizedOptions.domain
-            ? this.builderForDomain(normalizedOptions.domain)
-            : this.builder();
-        builder.params(params);
-        builder.qs(normalizedOptions.qs);
-        normalizedOptions.prefixUrl && builder.prefixUrl(normalizedOptions.prefixUrl);
-        normalizedOptions.disableRouteLookup && builder.disableRouteLookup();
-        return builder.make(routeIdentifier);
-    }
-    /**
-     * Makes a signed URL to a pre-registered route.
-     */
-    makeSignedUrl(routeIdentifier, params, options) {
-        const normalizedOptions = Object.assign({}, options);
-        const builder = normalizedOptions.domain
-            ? this.builderForDomain(normalizedOptions.domain)
-            : this.builder();
-        builder.params(params);
-        builder.qs(normalizedOptions.qs);
-        normalizedOptions.prefixUrl && builder.prefixUrl(normalizedOptions.prefixUrl);
-        normalizedOptions.disableRouteLookup && builder.disableRouteLookup();
-        return builder.makeSigned(routeIdentifier, normalizedOptions);
-    }
-}

package/build/src/router/matchers.js

@@ -1,36 +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';
-/**
- * Shortcut methods for commonly used route matchers
- */
-export class RouteMatchers extends Macroable {
-    /**
-     * Enforce value to be a number and also casts it to number data
-     * type
-     */
-    number() {
-        return { match: /^[0-9]+$/, cast: (value) => Number(value) };
-    }
-    /**
-     * Enforce value to be formatted as uuid
-     */
-    uuid() {
-        return {
-            match: /^[0-9a-zA-F]{8}-[0-9a-zA-F]{4}-[0-9a-zA-F]{4}-[0-9a-zA-F]{4}-[0-9a-zA-F]{12}$/,
-            cast: (value) => value.toLowerCase(),
-        };
-    }
-    /**
-     * Enforce value to be formatted as slug
-     */
-    slug() {
-        return { match: /^[^\s-_](?!.*?[-_]{2,})([a-z0-9-\\]{1,})[^\s]*[^-_\s]$/ };
-    }
-}

package/build/src/router/parser.js

@@ -1,17 +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';
-/**
- * Parses the route pattern
- */
-export function parseRoutePattern(pattern, matchers) {
-    const tokens = matchit.parse(pattern, matchers);
-    return tokens;
-}

package/build/src/router/resource.js

@@ -1,216 +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 string from '@poppinss/utils/string';
-import Macroable from '@poppinss/macroable';
-import { RuntimeException } from '@poppinss/utils';
-import { Route } from './route.js';
-/**
- * Route resource exposes the API to register multiple routes for a resource.
- */
-export class RouteResource extends Macroable {
-    /**
-     * Resource identifier. Nested resources are separated
-     * with a dot notation
-     */
-    #resource;
-    /**
-     * The controller to handle resource routing requests
-     */
-    #controller;
-    /**
-     * Is it a shallow resource? Shallow resources URLs do not have parent
-     * resource name and id once they can be identified with the id.
-     */
-    #shallow = false;
-    /**
-     * Matchers inherited from the router
-     */
-    #globalMatchers;
-    /**
-     * Reference to the AdonisJS application
-     */
-    #app;
-    /**
-     * Middleware registered on the router
-     */
-    #routerMiddleware;
-    /**
-     * Parameter names for the resources. Defaults to `id` for
-     * a singular resource and `resource_id` for nested
-     * resources.
-     */
-    #params = {};
-    /**
-     * Base name for the routes. We suffix action names
-     * on top of the base name
-     */
-    #routesBaseName;
-    /**
-     * A collection of routes instances that belongs to this resource
-     */
-    routes = [];
-    constructor(app, routerMiddleware, options) {
-        super();
-        this.#validateResourceName(options.resource);
-        this.#app = app;
-        this.#shallow = options.shallow;
-        this.#routerMiddleware = routerMiddleware;
-        this.#controller = options.controller;
-        this.#globalMatchers = options.globalMatchers;
-        this.#resource = this.#normalizeResourceName(options.resource);
-        this.#routesBaseName = this.#getRoutesBaseName();
-        this.#buildRoutes();
-    }
-    /**
-     * Normalizes the resource name to dropping leading and trailing
-     * slashes.
-     */
-    #normalizeResourceName(resource) {
-        return resource.replace(/^\//, '').replace(/\/$/, '');
-    }
-    /**
-     * Ensure resource name is not an empty string
-     */
-    #validateResourceName(resource) {
-        if (!resource || resource === '/') {
-            throw new RuntimeException(`Invalid resource name "${resource}"`);
-        }
-    }
-    /**
-     * Converting segments of a resource to snake case to
-     * make the route name.
-     */
-    #getRoutesBaseName() {
-        return this.#resource
-            .split('.')
-            .map((token) => string.snakeCase(token))
-            .join('.');
-    }
-    /**
-     * Create a new route for the given pattern, methods and controller action
-     */
-    #createRoute(pattern, methods, action) {
-        const route = new Route(this.#app, this.#routerMiddleware, {
-            pattern,
-            methods,
-            handler: typeof this.#controller === 'string'
-                ? `${this.#controller}.${action}`
-                : [this.#controller, action],
-            globalMatchers: this.#globalMatchers,
-        });
-        route.as(`${this.#routesBaseName}.${action}`);
-        this.routes.push(route);
-    }
-    /**
-     * Returns the `resource_id` name for a given resource. The
-     * resource name is converted to singular form and
-     * transformed to snake case.
-     *
-     * photos becomes photo_id
-     * users becomes user_id
-     */
-    #getResourceId(resource) {
-        return `${string.snakeCase(string.singular(resource))}_id`;
-    }
-    /**
-     * Build routes for the given resource
-     */
-    #buildRoutes() {
-        const resources = this.#resource.split('.');
-        const mainResource = resources.pop();
-        this.#params[mainResource] = ':id';
-        const baseURI = `${resources
-            .map((resource) => {
-            const paramName = `:${this.#getResourceId(resource)}`;
-            this.#params[resource] = paramName;
-            return `${resource}/${paramName}`;
-        })
-            .join('/')}/${mainResource}`;
-        this.#createRoute(baseURI, ['GET', 'HEAD'], 'index');
-        this.#createRoute(`${baseURI}/create`, ['GET', 'HEAD'], 'create');
-        this.#createRoute(baseURI, ['POST'], 'store');
-        this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ['GET', 'HEAD'], 'show');
-        this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id/edit`, ['GET', 'HEAD'], 'edit');
-        this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ['PUT', 'PATCH'], 'update');
-        this.#createRoute(`${this.#shallow ? mainResource : baseURI}/:id`, ['DELETE'], 'destroy');
-    }
-    /**
-     * Filter the routes based on their partial names
-     */
-    #filter(names, inverse) {
-        const actions = Array.isArray(names) ? names : [names];
-        return this.routes.filter((route) => {
-            const match = actions.find((name) => route.getName().endsWith(name));
-            return inverse ? !match : match;
-        });
-    }
-    /**
-     * Register only given routes and remove others
-     */
-    only(names) {
-        this.#filter(names, true).forEach((route) => route.markAsDeleted());
-        return this;
-    }
-    /**
-     * Register all routes, except the one's defined
-     */
-    except(names) {
-        this.#filter(names, false).forEach((route) => route.markAsDeleted());
-        return this;
-    }
-    /**
-     * Register api only routes. The `create` and `edit` routes, which
-     * are meant to show forms will not be registered
-     */
-    apiOnly() {
-        return this.except(['create', 'edit']);
-    }
-    /**
-     * Define matcher for params inside the resource
-     */
-    where(key, matcher) {
-        this.routes.forEach((route) => {
-            route.where(key, matcher);
-        });
-        return this;
-    }
-    tap(actions, callback) {
-        if (typeof actions === 'function') {
-            this.routes.forEach((route) => actions(route));
-            return this;
-        }
-        this.#filter(actions, false).forEach((route) => callback(route));
-        return this;
-    }
-    /**
-     * Set the param name for a given resource
-     */
-    params(resources) {
-        Object.keys(resources).forEach((resource) => {
-            const param = resources[resource];
-            const existingParam = this.#params[resource];
-            this.#params[resource] = `:${param}`;
-            this.routes.forEach((route) => {
-                route.setPattern(route.getPattern().replace(`${resource}/${existingParam}`, `${resource}/:${param}`));
-            });
-        });
-        return this;
-    }
-    /**
-     * Prepend name to all the routes
-     */
-    as(name, normalizeName = true) {
-        name = normalizeName ? string.snakeCase(name) : name;
-        this.routes.forEach((route) => {
-            route.as(route.getName().replace(this.#routesBaseName, name), false);
-        });
-        this.#routesBaseName = name;
-        return this;
-    }
-}