@adonisjs/http-server 8.0.0-next.0 → 8.0.0-next.10

package/build/client.d.ts

@@ -1,258 +0,0 @@
-import { Prettify } from '@poppinss/utils/types';
-
-/**
- * Types shared with the client. These should never import other types
- */
-
-/**
- * Options accepted by "url" and "route" helper methods
- */
-type URLOptions = {
-    qs?: Record<string, any>;
-    prefixUrl?: string;
-};
-/**
- * Options accepted by "signedUrl" and "signedRoute" helper methods
- */
-type SignedURLOptions = URLOptions & {
-    expiresIn?: string | number;
-    purpose?: string;
-};
-/**
- * Returns params for a route identifier
- */
-type RouteBuilderArguments<Routes, Method extends keyof Routes, Identifier extends keyof Routes[Method], Options extends any = URLOptions> = Routes extends LookupList ? Prettify<undefined extends Routes[Method][Identifier]['params'] ? [identifier: Identifier, params?: undefined, options?: Options] : [undefined] extends [Routes[Method][Identifier]['params']] ? [
-    identifier: Identifier,
-    params?: Routes[Method][Identifier]['params'] | Routes[Method][Identifier]['paramsTuple'],
-    options?: Options
-] : [
-    identifier: Identifier,
-    params: Routes[Method][Identifier]['params'] | Routes[Method][Identifier]['paramsTuple'],
-    options?: Options
-]> : never;
-/**
- * Shape of a route param matcher
- */
-type RouteMatcher = {
-    match?: RegExp;
-    cast?: (value: string) => any;
-};
-/**
- * Route token stored by matchit library
- */
-type MatchItRouteToken = RouteMatcher & {
-    old: string;
-    type: 0 | 1 | 2 | 3;
-    val: string;
-    end: string;
-};
-/**
- * Representation of route shared with the client
- */
-type ClientRouteJSON = {
-    /**
-     * A unique name for the route
-     */
-    name?: string;
-    /**
-     * Route URI pattern
-     */
-    pattern: string;
-    /**
-     * HTTP methods, the route responds to.
-     */
-    methods: string[];
-    /**
-     * Route domain
-     */
-    domain: string;
-    /**
-     * Reference to the route handler
-     */
-    handler: {
-        reference?: any;
-    } | Function;
-    /**
-     * Tokens to be used to construct the route URL
-     */
-    tokens: MatchItRouteToken[];
-};
-/**
- * LookupList type is used by the URLBuilder to provide
- * type-safety when creating URLs.
- *
- * There is no runtime property that matches this type. Its
- * purely for type-inference.
- */
-type LookupList = {
-    [method: string]: {
-        [identifier: string]: {
-            paramsTuple?: [...any[]];
-            params?: {
-                [name: string]: any;
-            };
-        };
-    };
-};
-/**
- * The urlFor helper is used to make URLs for pre-existing known routes. You can
- * make a URL using the route name, route pattern, or the route controller
- * reference (depends upon enabled lookupStrategies)
- *
- * ```ts
- * urlFor('users.show', [1]) // /users/1
- *
- * // Lookup inside a specific domain
- * urlFor('blog.adonisjs.com@posts.show', [1]) // /posts/1
- * ```
- */
-type UrlFor<Routes extends LookupList, Options extends any = URLOptions> = (<Identifier extends keyof Routes['ALL'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'ALL', Identifier, Options>) => string) & {
-    /**
-     * Make URL for a GET route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.get('users.show', [1]) // { method: 'get', url: '/users/1' }
-     * urlFor.get('users.store', [1]) // Error: Route not found GET@users/store
-     * ```
-     */
-    get<RouteIdentifier extends keyof Routes['GET'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'GET', RouteIdentifier, Options>): {
-        method: 'get';
-        url: string;
-    };
-    /**
-     * Make URL for a POST route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.post('users.store') // { method: 'post', url: '/users' }
-     * urlFor.post('users.show', [1]) // Error: Route not found POST@users.show
-     * ```
-     */
-    post<RouteIdentifier extends keyof Routes['POST'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'POST', RouteIdentifier, Options>): {
-        method: 'post';
-        url: string;
-    };
-    /**
-     * Make URL for a PUT route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.put('users.update', [1]) // { method: 'put', url: '/users/1' }
-     * urlFor.put('users.show', [1]) // Error: Route not found PUT@users.show
-     * ```
-     */
-    put<RouteIdentifier extends keyof Routes['PUT'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'PUT', RouteIdentifier, Options>): {
-        method: 'put';
-        url: string;
-    };
-    /**
-     * Make URL for a PATCH route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.put('users.update', [1]) // { method: 'patch', url: '/users/1' }
-     * urlFor.put('users.show', [1]) // Error: Route not found PATCH@users.show
-     * ```
-     */
-    patch<RouteIdentifier extends keyof Routes['PATCH'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'PATCH', RouteIdentifier, Options>): {
-        method: 'patch';
-        url: string;
-    };
-    /**
-     * Make URL for a DELETE route. An error will be raised if the route doesn't
-     * exist.
-     *
-     * ```ts
-     * urlFor.delete('users.destroy', [1]) // { method: 'delete', url: '/users/1' }
-     * urlFor.delete('users.show', [1]) // Error: Route not found DELETE@users.show
-     * ```
-     */
-    delete<RouteIdentifier extends keyof Routes['DELETE'] & string>(...[identifier, params, options]: RouteBuilderArguments<Routes, 'DELETE', RouteIdentifier, Options>): {
-        method: 'delete';
-        url: string;
-    };
-    /**
-     * Make URL for a custom route method. An error will be raised if the route doesn't
-     * exist for the same method.
-     */
-    method<Method extends keyof Routes & string, RouteIdentifier extends keyof Routes[Method] & string>(method: Method, ...[identifier, params, options]: RouteBuilderArguments<Routes, Method, RouteIdentifier, Options>): {
-        method: Method;
-        url: string;
-    };
-};
-
-/**
- * The router client contains the shared logic for finding routes
- * used by the server and the client.
- */
-declare class RouterClient<T extends ClientRouteJSON> {
-    /**
-     * List of route references kept for lookup.
-     */
-    protected routes: {
-        [domain: string]: T[];
-    };
-    /**
-     * The lookup strategies to follow when generating URL builder
-     * types and client
-     */
-    lookupStrategies: ('name' | 'pattern' | 'controller')[];
-    constructor(routes?: {
-        [domain: string]: T[];
-    });
-    /**
-     * Register route JSON payload
-     */
-    protected register(route: T): void;
-    /**
-     * Define the lookup strategies to follow when generating URL builder
-     * types and client.
-     */
-    updateLookupStrategies(strategies: ('name' | 'pattern' | 'controller')[]): this;
-    /**
-     * Finds a route by its identifier. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     *
-     * When "followLookupStrategy" is enabled, the lookup will be performed
-     * on the basis of the lookup strategy enabled via the "lookupStrategies"
-     * method. The default lookupStrategy is "name" and "pattern".
-     */
-    find(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): T | 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.
-     *
-     * When "followLookupStrategy" is enabled, the lookup will be performed
-     * on the basis of the lookup strategy enabled via the "lookupStrategies"
-     * method. The default lookupStrategy is "name" and "pattern".
-     */
-    findOrFail(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): T;
-    /**
-     * Check if a route exists. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     *
-     * When "followLookupStrategy" is enabled, the lookup will be performed
-     * on the basis of the lookup strategy enabled via the "lookupStrategies"
-     * method. The default lookupStrategy is "name" and "pattern".
-     */
-    has(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): boolean;
-    /**
-     * Returns a list of routes grouped by their domain names
-     */
-    toJSON(): {
-        [domain: string]: T[];
-    };
-}
-
-/**
- * Creates the URLBuilder helper
- */
-declare function createUrlBuilder<Routes extends LookupList>(router: RouterClient<ClientRouteJSON>, searchParamsStringifier: (qs: Record<string, any>) => string): UrlFor<Routes>;
-
-export { type ClientRouteJSON, type LookupList, type MatchItRouteToken, type RouteBuilderArguments, type RouteMatcher, RouterClient, type SignedURLOptions, type URLOptions, type UrlFor, createUrlBuilder };

package/build/client.js

@@ -1,229 +0,0 @@
-// src/client/router.ts
-var RouterClient = class {
-  /**
-   * List of route references kept for lookup.
-   */
-  routes;
-  /**
-   * The lookup strategies to follow when generating URL builder
-   * types and client
-   */
-  lookupStrategies = ["name", "pattern"];
-  constructor(routes) {
-    this.routes = routes ?? {};
-  }
-  /**
-   * Register route JSON payload
-   */
-  register(route) {
-    this.routes[route.domain] = this.routes[route.domain] || [];
-    this.routes[route.domain].push(route);
-  }
-  /**
-   * Define the lookup strategies to follow when generating URL builder
-   * types and client.
-   */
-  updateLookupStrategies(strategies) {
-    this.lookupStrategies = strategies;
-    return this;
-  }
-  /**
-   * Finds a route by its identifier. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   *
-   * When "followLookupStrategy" is enabled, the lookup will be performed
-   * on the basis of the lookup strategy enabled via the "lookupStrategies"
-   * method. The default lookupStrategy is "name" and "pattern".
-   */
-  find(routeIdentifier, domain, method, followLookupStrategy) {
-    if (!domain) {
-      let route = null;
-      for (const routeDomain of Object.keys(this.routes)) {
-        route = this.find(routeIdentifier, routeDomain, method, followLookupStrategy);
-        if (route) {
-          break;
-        }
-      }
-      return route;
-    }
-    const routes = this.routes[domain];
-    if (!routes) {
-      return null;
-    }
-    const lookupByName = !followLookupStrategy || this.lookupStrategies.includes("name");
-    const lookupByPattern = !followLookupStrategy || this.lookupStrategies.includes("pattern");
-    const lookupByController = !followLookupStrategy || this.lookupStrategies.includes("controller");
-    return routes.find((route) => {
-      if (method && !route.methods.includes(method)) {
-        return false;
-      }
-      if (route.name === routeIdentifier && lookupByName || route.pattern === routeIdentifier && lookupByPattern) {
-        return true;
-      }
-      if (typeof route.handler === "function" || !lookupByController) {
-        return false;
-      }
-      return route.handler.reference === routeIdentifier;
-    }) || 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.
-   *
-   * When "followLookupStrategy" is enabled, the lookup will be performed
-   * on the basis of the lookup strategy enabled via the "lookupStrategies"
-   * method. The default lookupStrategy is "name" and "pattern".
-   */
-  findOrFail(routeIdentifier, domain, method, followLookupStrategy) {
-    const route = this.find(routeIdentifier, domain, method, followLookupStrategy);
-    if (!route) {
-      throw new Error(`Cannot lookup route "${routeIdentifier}"`);
-    }
-    return route;
-  }
-  /**
-   * Check if a route exists. The identifier can be the
-   * route name, controller.method name or the route pattern
-   * itself.
-   *
-   * When "followLookupStrategy" is enabled, the lookup will be performed
-   * on the basis of the lookup strategy enabled via the "lookupStrategies"
-   * method. The default lookupStrategy is "name" and "pattern".
-   */
-  has(routeIdentifier, domain, method, followLookupStrategy) {
-    return !!this.find(routeIdentifier, domain, method, followLookupStrategy);
-  }
-  /**
-   * Returns a list of routes grouped by their domain names
-   */
-  toJSON() {
-    return this.routes;
-  }
-};
-
-// src/client/url_builder.ts
-function createURL(identifier, tokens, searchParamsStringifier, params, options) {
-  const uriSegments = [];
-  const paramsArray = Array.isArray(params) ? params : null;
-  const paramsObject = !Array.isArray(params) ? params ?? {} : {};
-  let paramsIndex = 0;
-  for (const token of tokens) {
-    if (token.type === 0) {
-      uriSegments.push(token.val === "/" ? "" : `${token.val}${token.end}`);
-      continue;
-    }
-    if (token.type === 2) {
-      const values = paramsArray ? paramsArray.slice(paramsIndex) : paramsObject["*"];
-      if (!Array.isArray(values) || !values.length) {
-        throw new Error(
-          `Cannot make URL for "${identifier}". Invalid value provided for the wildcard param`
-        );
-      }
-      uriSegments.push(`${values.join("/")}${token.end}`);
-      break;
-    }
-    const paramName = token.val;
-    const value = paramsArray ? paramsArray[paramsIndex] : paramsObject[paramName];
-    const isDefined = value !== void 0 && value !== null;
-    if (token.type === 1 && !isDefined) {
-      throw new Error(
-        `Cannot make URL for "${identifier}". Missing value for the "${paramName}" param`
-      );
-    }
-    if (isDefined) {
-      uriSegments.push(`${value}${token.end}`);
-    }
-    paramsIndex++;
-  }
-  let URI = `/${uriSegments.join("/")}`;
-  if (options?.prefixUrl) {
-    URI = `${options?.prefixUrl.replace(/\/$/, "")}${URI}`;
-  }
-  if (options?.qs) {
-    const queryString = searchParamsStringifier(options?.qs);
-    URI = queryString ? `${URI}?${queryString}` : URI;
-  }
-  return URI;
-}
-function createUrlBuilder(router, searchParamsStringifier) {
-  let domainsList;
-  function createUrlForRoute(identifier, params, options, method) {
-    if (!domainsList) {
-      domainsList = Object.keys(router.toJSON()).filter((domain2) => domain2 !== "root");
-    }
-    const domain = domainsList.find((name) => identifier.startsWith(`${name}@`));
-    const routeIdentifier = domain ? identifier.replace(new RegExp(`^${domain}@`), "") : identifier;
-    const route = router.findOrFail(routeIdentifier, domain, method, true);
-    return createURL(
-      route.name ?? route.pattern,
-      route.tokens,
-      searchParamsStringifier,
-      params,
-      options
-    );
-  }
-  const urlFor = function route(...[identifier, params, options]) {
-    return createUrlForRoute(identifier, params, options);
-  };
-  urlFor.get = function urlForMethodGet(...[identifier, params, options]) {
-    return {
-      url: createUrlForRoute(identifier, params, options, "GET"),
-      method: "get",
-      toString() {
-        return this.url;
-      }
-    };
-  };
-  urlFor.post = function urlForMethodPost(...[identifier, params, options]) {
-    return {
-      url: createUrlForRoute(identifier, params, options, "POST"),
-      method: "post",
-      toString() {
-        return this.url;
-      }
-    };
-  };
-  urlFor.put = function urlForMethodPut(...[identifier, params, options]) {
-    return {
-      url: createUrlForRoute(identifier, params, options, "PUT"),
-      method: "put",
-      toString() {
-        return this.url;
-      }
-    };
-  };
-  urlFor.patch = function urlForMethodPatch(...[identifier, params, options]) {
-    return {
-      url: createUrlForRoute(identifier, params, options, "PATCH"),
-      method: "patch",
-      toString() {
-        return this.url;
-      }
-    };
-  };
-  urlFor.delete = function urlForMethodDelete(...[identifier, params, options]) {
-    return {
-      url: createUrlForRoute(identifier, params, options, "DELETE"),
-      method: "delete",
-      toString() {
-        return this.url;
-      }
-    };
-  };
-  urlFor.method = function urlForCustomMethod(method, ...[identifier, params, options]) {
-    return {
-      url: createUrlForRoute(identifier, params, options, method),
-      method,
-      toString() {
-        return this.url;
-      }
-    };
-  };
-  return urlFor;
-}
-
-export { RouterClient, createUrlBuilder };

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

@@ -1,3 +0,0 @@
-export * from './types.ts';
-export { RouterClient } from './router.ts';
-export { createUrlBuilder } from './url_builder.ts';

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

@@ -1,68 +0,0 @@
-import { type ClientRouteJSON } from './types.ts';
-/**
- * The router client contains the shared logic for finding routes
- * used by the server and the client.
- */
-export declare class RouterClient<T extends ClientRouteJSON> {
-    /**
-     * List of route references kept for lookup.
-     */
-    protected routes: {
-        [domain: string]: T[];
-    };
-    /**
-     * The lookup strategies to follow when generating URL builder
-     * types and client
-     */
-    lookupStrategies: ('name' | 'pattern' | 'controller')[];
-    constructor(routes?: {
-        [domain: string]: T[];
-    });
-    /**
-     * Register route JSON payload
-     */
-    protected register(route: T): void;
-    /**
-     * Define the lookup strategies to follow when generating URL builder
-     * types and client.
-     */
-    updateLookupStrategies(strategies: ('name' | 'pattern' | 'controller')[]): this;
-    /**
-     * Finds a route by its identifier. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     *
-     * When "followLookupStrategy" is enabled, the lookup will be performed
-     * on the basis of the lookup strategy enabled via the "lookupStrategies"
-     * method. The default lookupStrategy is "name" and "pattern".
-     */
-    find(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): T | 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.
-     *
-     * When "followLookupStrategy" is enabled, the lookup will be performed
-     * on the basis of the lookup strategy enabled via the "lookupStrategies"
-     * method. The default lookupStrategy is "name" and "pattern".
-     */
-    findOrFail(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): T;
-    /**
-     * Check if a route exists. The identifier can be the
-     * route name, controller.method name or the route pattern
-     * itself.
-     *
-     * When "followLookupStrategy" is enabled, the lookup will be performed
-     * on the basis of the lookup strategy enabled via the "lookupStrategies"
-     * method. The default lookupStrategy is "name" and "pattern".
-     */
-    has(routeIdentifier: string, domain?: string, method?: string, followLookupStrategy?: boolean): boolean;
-    /**
-     * Returns a list of routes grouped by their domain names
-     */
-    toJSON(): {
-        [domain: string]: T[];
-    };
-}