@adonisjs/http-server 5.11.0 → 6.0.0-0

package/build/src/router/group.js

@@ -0,0 +1,117 @@
+import { Macroable } from '@poppinss/macroable';
+import { BriskRoute } from './brisk.js';
+import { RouteResource } from './resource.js';
+export class RouteGroup extends Macroable {
+    routes;
+    #middleware = [];
+    #middlewareStore;
+    constructor(routes, middlewareStore) {
+        super();
+        this.routes = routes;
+        this.#middlewareStore = middlewareStore;
+    }
+    #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);
+    }
+    #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);
+    }
+    #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);
+    }
+    #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);
+    }
+    #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);
+    }
+    where(param, matcher) {
+        this.routes.forEach((route) => this.#updateRouteMatchers(route, param, matcher));
+        return this;
+    }
+    prefix(prefix) {
+        this.routes.forEach((route) => this.#setRoutePrefix(route, prefix));
+        return this;
+    }
+    domain(domain) {
+        this.routes.forEach((route) => this.#updateRouteDomain(route, domain));
+        return this;
+    }
+    as(name) {
+        this.routes.forEach((route) => this.#updateRouteName(route, name));
+        return this;
+    }
+    middleware(middleware, args) {
+        if (!this.#middleware.length) {
+            this.routes.forEach((route) => this.#shareMiddlewareStackWithRoutes(route));
+        }
+        if (typeof middleware === 'string') {
+            this.#middleware.push(this.#middlewareStore.get(middleware, args));
+            return this;
+        }
+        if (typeof middleware === 'function') {
+            this.#middleware.push(middleware);
+        }
+        return this;
+    }
+}

package/build/src/router/lookup_store/main.d.ts

@@ -0,0 +1,17 @@
+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';
+export declare class LookupStore {
+    #private;
+    constructor(encryption: Encryption, qsParser: Qs);
+    register(route: RouteJSON): void;
+    builder(): UrlBuilder;
+    builderForDomain(domain: string): UrlBuilder;
+    find(routeIdentifier: string, domain?: string): RouteJSON | null;
+    findOrFail(routeIdentifier: string, domain?: string): RouteJSON;
+    has(routeIdentifier: string, domain?: string): boolean;
+    toJSON(): {
+        [domain: string]: RouteJSON[];
+    };
+}

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

@@ -0,0 +1,37 @@
+import { UrlBuilder } from './url_builder.js';
+import { RouteFinder } from './route_finder.js';
+export class LookupStore {
+    #routes = {};
+    #encryption;
+    #qsParser;
+    constructor(encryption, qsParser) {
+        this.#encryption = encryption;
+        this.#qsParser = qsParser;
+    }
+    register(route) {
+        this.#routes[route.domain] = this.#routes[route.domain] || [];
+        this.#routes[route.domain].push(route);
+    }
+    builder() {
+        return this.builderForDomain('root');
+    }
+    builderForDomain(domain) {
+        const routes = this.#routes[domain];
+        return new UrlBuilder(this.#encryption, new RouteFinder(routes || []), this.#qsParser);
+    }
+    find(routeIdentifier, domain) {
+        const routes = this.#routes[domain || 'root'] || [];
+        return new RouteFinder(routes).find(routeIdentifier);
+    }
+    findOrFail(routeIdentifier, domain) {
+        const routes = this.#routes[domain || 'root'] || [];
+        return new RouteFinder(routes).findOrFail(routeIdentifier);
+    }
+    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,8 @@
+import type { RouteJSON } from '../../types/route.js';
+export declare class RouteFinder {
+    #private;
+    constructor(routes: RouteJSON[]);
+    find(routeIdentifier: string): RouteJSON | null;
+    findOrFail(routeIdentifier: string): RouteJSON;
+    has(routeIdentifier: string): boolean;
+}

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

@@ -0,0 +1,28 @@
+import { CannotLookupRouteException } from '../../exceptions/cannot_lookup_route.js';
+export class RouteFinder {
+    #routes;
+    constructor(routes) {
+        this.#routes = routes;
+    }
+    find(routeIdentifier) {
+        return (this.#routes.find(({ name, pattern, handler }) => {
+            if (name === routeIdentifier || pattern === routeIdentifier) {
+                return true;
+            }
+            if (typeof handler === 'function') {
+                return false;
+            }
+            return handler.name === routeIdentifier;
+        }) || null);
+    }
+    findOrFail(routeIdentifier) {
+        const route = this.find(routeIdentifier);
+        if (!route) {
+            throw new CannotLookupRouteException(`Cannot lookup route "${routeIdentifier}"`);
+        }
+        return route;
+    }
+    has(routeIdentifier) {
+        return !!this.find(routeIdentifier);
+    }
+}

package/build/src/router/lookup_store/url_builder.d.ts

@@ -0,0 +1,16 @@
+import type Encryption from '@adonisjs/encryption';
+import type { Qs } from '../../qs.js';
+import type { RouteFinder } from './route_finder.js';
+export declare class UrlBuilder {
+    #private;
+    constructor(encryption: Encryption, routeFinder: RouteFinder, qsParser: Qs);
+    prefixUrl(url: string): this;
+    disableRouteLookup(): this;
+    qs(queryString?: Record<string, any>): this;
+    params(params?: any[] | Record<string, any>): this;
+    make(identifier: string): string;
+    makeSigned(identifier: string, options?: {
+        expiresIn?: string | number;
+        purpose?: string;
+    }): string;
+}

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

@@ -0,0 +1,111 @@
+import { RuntimeException } from '@poppinss/utils';
+export class UrlBuilder {
+    #qsParser;
+    #params = {};
+    #qs = {};
+    #shouldPerformLookup = true;
+    #baseUrl;
+    #encryption;
+    #routeFinder;
+    constructor(encryption, routeFinder, qsParser) {
+        this.#qsParser = qsParser;
+        this.#encryption = encryption;
+        this.#routeFinder = routeFinder;
+    }
+    #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`);
+        }
+    }
+    #ensureHasParamValue(pattern, param, value) {
+        if (value === undefined || value === null) {
+            throw new RuntimeException(`Cannot make URL for "${pattern}" route. Missing value for "${param}" param`);
+        }
+    }
+    #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 = pattern.split('/');
+        for (const token of tokens) {
+            if (token === '*') {
+                const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject['*'];
+                this.#ensureHasWildCardValues(pattern, values);
+                values.forEach((value) => uriSegments.push(value));
+                break;
+            }
+            else if (!token.startsWith(':')) {
+                uriSegments.push(token);
+            }
+            else {
+                const paramName = token.replace(/^:/, '').replace(/\?$/, '');
+                const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
+                if (!token.endsWith('?')) {
+                    this.#ensureHasParamValue(pattern, paramName, value);
+                }
+                paramsIndex++;
+                if (value !== undefined && value !== null) {
+                    uriSegments.push(value);
+                }
+            }
+        }
+        return uriSegments.join('/');
+    }
+    #suffixQueryString(url, qs) {
+        if (qs) {
+            const queryString = this.#qsParser.stringify(qs);
+            url = queryString ? `${url}?${queryString}` : url;
+        }
+        return url;
+    }
+    #prefixBaseUrl(uri) {
+        return this.#baseUrl ? `${this.#baseUrl}${uri}` : uri;
+    }
+    prefixUrl(url) {
+        this.#baseUrl = url;
+        return this;
+    }
+    disableRouteLookup() {
+        this.#shouldPerformLookup = false;
+        return this;
+    }
+    qs(queryString) {
+        if (!queryString) {
+            return this;
+        }
+        this.#qs = queryString;
+        return this;
+    }
+    params(params) {
+        if (!params) {
+            return this;
+        }
+        this.#params = params;
+        return this;
+    }
+    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);
+    }
+    makeSigned(identifier, options) {
+        let url;
+        if (this.#shouldPerformLookup) {
+            const route = this.#routeFinder.findOrFail(identifier);
+            url = this.#processPattern(route.pattern);
+        }
+        else {
+            url = this.#processPattern(identifier);
+        }
+        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);
+    }
+}

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

@@ -0,0 +1,36 @@
+import type Encryption from '@adonisjs/encryption';
+import type { Application } from '@adonisjs/application';
+import type { Qs } from '../qs.js';
+import { Route } from './route.js';
+import { RouteGroup } from './group.js';
+import { BriskRoute } from './brisk.js';
+import { RouteResource } from './resource.js';
+import { LookupStore } from './lookup_store/main.js';
+import { RouteMatchers as Matchers } from './matchers.js';
+import type { LazyImport } from '../types/base.js';
+import { MiddlewareStore } from '../middleware/store.js';
+import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { RouteFn, MatchedRoute, RouteMatcher, MakeUrlOptions, MakeSignedUrlOptions } from '../types/route.js';
+export declare class Router<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends LookupStore {
+    #private;
+    routes: (Route<NamedMiddleware> | RouteResource<NamedMiddleware> | RouteGroup<NamedMiddleware> | BriskRoute<NamedMiddleware>)[];
+    usingDomains: boolean;
+    matchers: Matchers;
+    constructor(app: Application, encryption: Encryption, middlewareStore: MiddlewareStore<NamedMiddleware>, qsParser: Qs);
+    route(pattern: string, methods: string[], handler: string | RouteFn): Route<NamedMiddleware>;
+    any(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
+    get(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
+    post(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
+    put(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
+    patch(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
+    delete(pattern: string, handler: string | RouteFn): Route<NamedMiddleware>;
+    group(callback: () => void): RouteGroup<NamedMiddleware>;
+    resource(resource: string, controller: string): RouteResource<NamedMiddleware>;
+    shallowResource(resource: string, controller: string): RouteResource<NamedMiddleware>;
+    on(pattern: string): BriskRoute<NamedMiddleware>;
+    where(param: string, matcher: RouteMatcher | string | RegExp): this;
+    commit(): void;
+    match(url: string, method: string, hostname?: string | null): null | MatchedRoute;
+    makeUrl(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeUrlOptions): string;
+    makeSignedUrl(routeIdentifier: string, params?: any[] | Record<string, any>, options?: MakeSignedUrlOptions): string;
+}

package/build/src/router/main.js

@@ -0,0 +1,161 @@
+import is from '@sindresorhus/is';
+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';
+export class Router extends LookupStore {
+    #app;
+    #store = new RoutesStore();
+    #globalMatchers = {};
+    #middlewareStore;
+    #openedGroups = [];
+    routes = [];
+    usingDomains = false;
+    matchers = new Matchers();
+    constructor(app, encryption, middlewareStore, qsParser) {
+        super(encryption, qsParser);
+        this.#app = app;
+        this.#middlewareStore = middlewareStore;
+    }
+    #pushToRoutes(entity) {
+        const openedGroup = this.#openedGroups[this.#openedGroups.length - 1];
+        if (openedGroup) {
+            openedGroup.routes.push(entity);
+            return;
+        }
+        this.routes.push(entity);
+    }
+    route(pattern, methods, handler) {
+        const route = new Route(this.#app, this.#middlewareStore, {
+            pattern,
+            methods,
+            handler,
+            globalMatchers: this.#globalMatchers,
+        });
+        this.#pushToRoutes(route);
+        return route;
+    }
+    any(pattern, handler) {
+        return this.route(pattern, ['HEAD', 'OPTIONS', 'GET', 'POST', 'PUT', 'PATCH', 'DELETE'], handler);
+    }
+    get(pattern, handler) {
+        return this.route(pattern, ['GET', 'HEAD'], handler);
+    }
+    post(pattern, handler) {
+        return this.route(pattern, ['POST'], handler);
+    }
+    put(pattern, handler) {
+        return this.route(pattern, ['PUT'], handler);
+    }
+    patch(pattern, handler) {
+        return this.route(pattern, ['PATCH'], handler);
+    }
+    delete(pattern, handler) {
+        return this.route(pattern, ['DELETE'], handler);
+    }
+    group(callback) {
+        const group = new RouteGroup([], this.#middlewareStore);
+        this.#pushToRoutes(group);
+        this.#openedGroups.push(group);
+        callback();
+        this.#openedGroups.pop();
+        return group;
+    }
+    resource(resource, controller) {
+        const resourceInstance = new RouteResource(this.#app, this.#middlewareStore, {
+            resource,
+            controller,
+            shallow: false,
+            globalMatchers: this.#globalMatchers,
+        });
+        this.#pushToRoutes(resourceInstance);
+        return resourceInstance;
+    }
+    shallowResource(resource, controller) {
+        const resourceInstance = new RouteResource(this.#app, this.#middlewareStore, {
+            resource,
+            controller,
+            shallow: true,
+            globalMatchers: this.#globalMatchers,
+        });
+        this.#pushToRoutes(resourceInstance);
+        return resourceInstance;
+    }
+    on(pattern) {
+        const briskRoute = new BriskRoute(this.#app, this.#middlewareStore, {
+            pattern,
+            globalMatchers: this.#globalMatchers,
+        });
+        this.#pushToRoutes(briskRoute);
+        return briskRoute;
+    }
+    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() {
+        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);
+            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.name) {
+                routeNames.add(route.name);
+            }
+            this.register(route);
+            this.#store.add(route);
+        });
+        routeNamesByDomain.clear();
+        this.usingDomains = this.#store.usingDomains;
+        this.routes = [];
+        this.#globalMatchers = {};
+    }
+    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);
+    }
+    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);
+    }
+    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.d.ts

@@ -0,0 +1,14 @@
+import { Macroable } from '@poppinss/macroable';
+export declare class RouteMatchers extends Macroable {
+    number(): {
+        match: RegExp;
+        cast: (value: string) => number;
+    };
+    uuid(): {
+        match: RegExp;
+        cast: (value: string) => string;
+    };
+    slug(): {
+        match: RegExp;
+    };
+}

package/build/src/router/matchers.js

@@ -0,0 +1,15 @@
+import { Macroable } from '@poppinss/macroable';
+export class RouteMatchers extends Macroable {
+    number() {
+        return { match: /^[0-9]+$/, cast: (value) => Number(value) };
+    }
+    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(),
+        };
+    }
+    slug() {
+        return { match: /^[^\s-_](?!.*?[-_]{2,})([a-z0-9-\\]{1,})[^\s]*[^-_\s]$/ };
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Macroable } from '@poppinss/macroable';
+import type { Application } from '@adonisjs/application';
+import { Route } from './route.js';
+import type { LazyImport } from '../types/base.js';
+import type { MiddlewareStore } from '../middleware/store.js';
+import type { MiddlewareAsClass } from '../types/middleware.js';
+import type { ResourceActionNames, RouteMatcher, RouteMatchers } from '../types/route.js';
+export declare class RouteResource<NamedMiddleware extends Record<string, LazyImport<MiddlewareAsClass>> = any> extends Macroable {
+    #private;
+    routes: Route[];
+    constructor(app: Application, middlewareStore: MiddlewareStore<NamedMiddleware>, options: {
+        resource: string;
+        controller: string;
+        globalMatchers: RouteMatchers;
+        shallow: boolean;
+    });
+    only(names: ResourceActionNames[]): this;
+    except(names: ResourceActionNames[]): this;
+    apiOnly(): this;
+    where(key: string, matcher: RouteMatcher | string | RegExp): this;
+    tap(callback: (route: Route<NamedMiddleware>) => void): this;
+    tap(actions: ResourceActionNames | ResourceActionNames[], callback: (route: Route<NamedMiddleware>) => void): this;
+    params(resources: {
+        [resource: string]: string;
+    }): this;
+    as(name: string): this;
+}