@tuyau/core 0.4.2 → 1.0.0-beta.1

package/build/backend/generate_registry.d.ts

@@ -0,0 +1,27 @@
+interface GenerateRegistryConfig {
+    /**
+     * Path to write the generated registry file
+     * @default ./.adonisjs/client/registry.ts
+     */
+    output?: string;
+    /**
+     * Routes filtering configuration
+     */
+    routes?: {
+        /**
+         * Only include routes matching these patterns (route names)
+         * Can be strings, regex patterns, or functions
+         */
+        only?: Array<string | RegExp | ((routeName: string) => boolean)>;
+        /**
+         * Exclude routes matching these patterns (route names)
+         * Can be strings, regex patterns, or functions
+         */
+        except?: Array<string | RegExp | ((routeName: string) => boolean)>;
+    };
+}
+declare function generateRegistry(options?: GenerateRegistryConfig): {
+    run(devServer: any, routesScanner: any): Promise<void>;
+};
+
+export { generateRegistry };

package/build/backend/generate_registry.js

@@ -0,0 +1,88 @@
+// src/backend/generate_registry.ts
+import { dirname } from "path";
+import string from "@adonisjs/core/helpers/string";
+import { writeFile, mkdir } from "fs/promises";
+async function writeOutputFile(filePath, content) {
+  const dir = dirname(filePath);
+  await mkdir(dir, { recursive: true });
+  await writeFile(filePath, content);
+}
+function matchesPattern(routeName, pattern) {
+  if (typeof pattern === "string") return routeName.includes(pattern);
+  if (pattern instanceof RegExp) return pattern.test(routeName);
+  if (typeof pattern === "function") return pattern(routeName);
+  return false;
+}
+function filterRoutes(routes, filters) {
+  if (!filters) return routes;
+  const { only, except } = filters;
+  if (only && except)
+    throw new Error('Cannot use both "only" and "except" filters at the same time');
+  if (only) {
+    return routes.filter((route) => only.some((pattern) => matchesPattern(route.name, pattern)));
+  }
+  if (except) {
+    return routes.filter((route) => !except.some((pattern) => matchesPattern(route.name, pattern)));
+  }
+  return routes;
+}
+function generateRouteParams(route) {
+  const dynamicParams = route.tokens.filter((token) => token.type === 1);
+  const paramsType = dynamicParams.map((token) => `${token.val}: string`).join("; ");
+  const paramsTuple = dynamicParams.map(() => "string").join(", ");
+  return { paramsType, paramsTuple };
+}
+function generateRegistryEntry(route) {
+  const requestType = route.request?.type || "{}";
+  const responseType = route.response?.type || "unknown";
+  const { paramsType, paramsTuple } = generateRouteParams(route);
+  const routeName = route.name.split(".").map((segment) => string.camelCase(segment)).join(".");
+  return `  '${routeName}': {
+    methods: ${JSON.stringify(route.methods)},
+    pattern: '${route.pattern}',
+    tokens: ${JSON.stringify(route.tokens)},
+    types: placeholder as {
+      body: ${requestType}
+      paramsTuple: [${paramsTuple}]
+      params: ${paramsType ? `{ ${paramsType} }` : "{}"}
+      query: {}
+      response: ${responseType}
+    },
+  }`;
+}
+function generateRegistryContent(routes) {
+  const registryEntries = routes.map(generateRegistryEntry).join(",\n");
+  return `/* eslint-disable prettier/prettier */
+import type { AdonisEndpoint } from '@tuyau/core/types'
+import type { Infer } from '@vinejs/vine/types'
+
+const placeholder: any = {}
+export const registry = {
+${registryEntries}
+} as const satisfies Record<string, AdonisEndpoint>
+
+declare module '@tuyau/core/types' {
+  type Registry = typeof registry
+  export interface UserRegistry extends Registry {}
+}
+`;
+}
+function generateRegistry(options) {
+  const config = {
+    output: "./.adonisjs/client/registry.ts",
+    ...options
+  };
+  return {
+    async run(devServer, routesScanner) {
+      const startTime = process.hrtime();
+      const scannedRoutes = routesScanner.getScannedRoutes();
+      const filteredRoutes = filterRoutes(scannedRoutes, config.routes);
+      const registryContent = generateRegistryContent(filteredRoutes);
+      await writeOutputFile(config.output, registryContent);
+      devServer.ui.logger.info(`created ${config.output}`, { startTime });
+    }
+  };
+}
+export {
+  generateRegistry
+};

package/build/client/index.d.ts

@@ -0,0 +1,82 @@
+import { UrlFor } from '@adonisjs/http-server/client/url_builder';
+import { AdonisEndpoint, TuyauConfiguration, BuildNamed, RegistryGroupedByMethod, PatternsByMethod, RequestArgs, EndpointByMethodPattern, StrKeys, Method } from './types/index.js';
+import { KyResponse, KyRequest, HTTPError } from 'ky';
+
+/**
+ * Main client class for making HTTP requests to AdonisJS endpoints
+ * Provides both fluent API and direct method calling capabilities
+ */
+declare class Tuyau<R extends Record<string, AdonisEndpoint>> {
+    #private;
+    private config;
+    readonly api: BuildNamed<R>;
+    readonly urlFor: UrlFor<RegistryGroupedByMethod<R>>;
+    /**
+     * Initializes the Tuyau client with provided configuration
+     */
+    constructor(config: TuyauConfiguration<R>);
+    /**
+     * Makes a GET request to the specified pattern
+     */
+    get<P extends PatternsByMethod<R, 'GET'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'GET', P>>): Promise<EndpointByMethodPattern<R, 'GET', P>['types']['response']>;
+    /**
+     * Makes a POST request to the specified pattern
+     */
+    post<P extends PatternsByMethod<R, 'POST'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'POST', P>>): Promise<EndpointByMethodPattern<R, 'POST', P>['types']['response']>;
+    /**
+     * Makes a PUT request to the specified pattern
+     */
+    put<P extends PatternsByMethod<R, 'PUT'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'PUT', P>>): Promise<EndpointByMethodPattern<R, 'PUT', P>['types']['response']>;
+    /**
+     * Makes a PATCH request to the specified pattern
+     */
+    patch<P extends PatternsByMethod<R, 'PATCH'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'PATCH', P>>): Promise<EndpointByMethodPattern<R, 'PATCH', P>['types']['response']>;
+    /**
+     * Makes a DELETE request to the specified pattern
+     */
+    delete<P extends PatternsByMethod<R, 'DELETE'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'DELETE', P>>): Promise<EndpointByMethodPattern<R, 'DELETE', P>['types']['response']>;
+    /**
+     * Makes a HEAD request to the specified pattern
+     */
+    head<P extends PatternsByMethod<R, 'HEAD'>>(pattern: P, args: RequestArgs<EndpointByMethodPattern<R, 'HEAD', P>>): Promise<EndpointByMethodPattern<R, 'HEAD', P>['types']['response']>;
+    /**
+     * Makes a request to a named endpoint
+     */
+    request<Name extends StrKeys<R>>(name: Name, args: RequestArgs<R[Name]>): Promise<R[Name]['types']['response']>;
+    /**
+     * Gets route information by name including URL and HTTP method
+     */
+    getRoute<Name extends StrKeys<R>>(name: Name, args: RequestArgs<R[Name]>): {
+        url: string;
+        methods: Method[];
+    };
+    /**
+     * Creates a proxy-based fluent API for accessing endpoints by name
+     */
+    private makeNamed;
+}
+/**
+ * Factory function to create a new Tuyau client instance
+ */
+declare function createTuyau<R extends Record<string, AdonisEndpoint>>(config: TuyauConfiguration<R>): Tuyau<R>;
+
+declare function parseResponse(response?: KyResponse): Promise<unknown>;
+declare class TuyauHTTPError extends Error {
+    status: number | undefined;
+    rawResponse: KyResponse | undefined;
+    rawRequest: KyRequest | undefined;
+    response: any;
+    constructor(kyError: HTTPError, response: any);
+}
+/**
+ * Network error that occurs when the server is unreachable or the client is offline
+ */
+declare class TuyauNetworkError extends Error {
+    cause: Error;
+    constructor(cause: Error, request?: {
+        url: string;
+        method: string;
+    });
+}
+
+export { Tuyau, TuyauHTTPError, TuyauNetworkError, createTuyau, parseResponse };

package/build/client/index.js

@@ -0,0 +1,291 @@
+// src/client/tuyau.ts
+import ky, { HTTPError } from "ky";
+import { serialize } from "object-to-formdata";
+import { createUrlBuilder } from "@adonisjs/http-server/client/url_builder";
+
+// src/client/errors.ts
+async function parseResponse(response) {
+  if (!response) return;
+  const responseType = response.headers.get("Content-Type")?.split(";")[0];
+  if (responseType === "application/json") {
+    return await response.json();
+  } else if (responseType === "application/octet-stream") {
+    return await response.arrayBuffer();
+  }
+  return await response.text();
+}
+var TuyauHTTPError = class extends Error {
+  status;
+  rawResponse;
+  rawRequest;
+  response;
+  constructor(kyError, response) {
+    const status = kyError.response?.status;
+    const reason = status ? `status code ${status}` : "an unknown error";
+    const url = kyError.request?.url.replace(kyError.options.prefixUrl || "", "");
+    const message = kyError.response ? `Request failed with ${reason}: ${kyError.request?.method.toUpperCase()} /${url}` : `Request failed with ${reason}`;
+    super(message, { cause: kyError });
+    this.rawResponse = kyError.response;
+    this.response = response;
+    this.status = kyError.response?.status;
+    this.rawRequest = kyError.request;
+    this.name = "TuyauHTTPError";
+  }
+};
+var TuyauNetworkError = class extends Error {
+  constructor(cause, request) {
+    const message = request ? `Network error: ${request.method.toUpperCase()} ${request.url}` : "Network error occurred";
+    super(message, { cause });
+    this.cause = cause;
+    this.name = "TuyauNetworkError";
+  }
+};
+
+// src/client/utils.ts
+function buildSearchParams(query) {
+  if (!query) return;
+  let stringified = "";
+  const append = (key, value, isArray = false) => {
+    if (value === void 0 || value === null) return;
+    const encodedKey = encodeURIComponent(key);
+    const encodedValue = encodeURIComponent(value);
+    const keyValuePair = `${encodedKey}${isArray ? "[]" : ""}=${encodedValue}`;
+    stringified += (stringified ? "&" : "?") + keyValuePair;
+  };
+  for (const [key, value] of Object.entries(query)) {
+    if (!value) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) append(key, v, true);
+    } else {
+      append(key, `${value}`);
+    }
+  }
+  return stringified;
+}
+function removeSlash(value) {
+  return value.replace(/^\//, "");
+}
+function isObject(value) {
+  return typeof value === "object" && !Array.isArray(value) && value !== null;
+}
+var isServer = typeof FileList === "undefined";
+var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+
+// src/client/tuyau.ts
+var Tuyau = class {
+  /**
+   * Initializes the Tuyau client with provided configuration
+   */
+  constructor(config) {
+    this.config = config;
+    this.api = this.makeNamed([]);
+    this.#entries = Object.entries(this.config.registry);
+    this.urlFor = this.#createUrlBuilder();
+    this.#applyPlugins();
+    this.#client = ky.create(this.#mergeKyConfiguration());
+  }
+  api;
+  urlFor;
+  #entries;
+  #client;
+  /**
+   * Merges the default Ky configuration with user-provided config
+   */
+  #mergeKyConfiguration() {
+    return {
+      prefixUrl: this.config.baseUrl,
+      ...this.config,
+      hooks: {
+        ...this.config.hooks,
+        beforeRequest: [
+          ...this.config.hooks?.beforeRequest || [],
+          this.#appendCsrfToken.bind(this)
+        ]
+      }
+    };
+  }
+  /**
+   * Applies registered plugins to the client configuration
+   */
+  #applyPlugins() {
+    this.config.plugins?.forEach((plugin) => plugin({ options: this.config }));
+  }
+  /**
+   * Creates a URL builder instance for generating URLs based on the route registry
+   */
+  #createUrlBuilder() {
+    const rootEntries = this.#entries.map(([name, entry]) => ({ name, domain: "root", ...entry }));
+    return createUrlBuilder({ root: rootEntries }, buildSearchParams);
+  }
+  /**
+   * Automatically appends CSRF token from cookies to requests
+   */
+  #appendCsrfToken(request) {
+    const xCsrfToken = globalThis.document?.cookie.split("; ").find((row) => row.startsWith("XSRF-TOKEN="));
+    if (!xCsrfToken) return;
+    request.headers.set("X-XSRF-TOKEN", decodeURIComponent(xCsrfToken.split("=")[1]));
+  }
+  /**
+   * Checks if a value represents a file for upload
+   */
+  #isFile(v) {
+    if (isReactNative && isObject(v) && v.uri) return true;
+    if (isServer) return v instanceof Blob;
+    return v instanceof FileList || v instanceof File;
+  }
+  /**
+   * Checks if an object contains any file uploads
+   */
+  #hasFile(obj) {
+    if (!obj) return false;
+    return Object.values(obj).some((val) => {
+      if (Array.isArray(val)) return val.some(this.#isFile);
+      return this.#isFile(val);
+    });
+  }
+  #getLowercaseMethod(method) {
+    return method.toLowerCase();
+  }
+  #buildUrl(name, method, args) {
+    const lowercaseMethod = this.#getLowercaseMethod(method);
+    const usedMethod = lowercaseMethod === "head" || lowercaseMethod === "options" ? "get" : lowercaseMethod;
+    return this.urlFor[usedMethod](name, args?.params || {}).url;
+  }
+  /**
+   * Performs the actual HTTP request with proper body formatting
+   */
+  async #doFetch(name, method, args) {
+    const url = this.#buildUrl(name, method, args);
+    let key = "json";
+    let body = args.body;
+    if (!(body instanceof FormData) && this.#hasFile(body)) {
+      body = serialize(body, { indices: true });
+      key = "body";
+    } else if (body instanceof FormData) {
+      key = "body";
+    }
+    const isGetOrHead = ["GET", "HEAD"].includes(method);
+    const { body: _, ...restArgs } = args;
+    const requestOptions = {
+      searchParams: buildSearchParams(args?.query || {}),
+      [key]: !isGetOrHead ? body : void 0,
+      ...restArgs
+    };
+    try {
+      const res = await this.#client[this.#getLowercaseMethod(method)](
+        removeSlash(url),
+        requestOptions
+      );
+      let data;
+      const responseType = res.headers.get("Content-Type")?.split(";")[0];
+      if (responseType === "application/json") {
+        data = await res.json();
+      } else if (responseType === "application/octet-stream") {
+        data = await res.arrayBuffer();
+      } else {
+        data = await res.text();
+      }
+      return data;
+    } catch (originalError) {
+      if (originalError instanceof HTTPError) {
+        const parsedResponse = await parseResponse(originalError.response);
+        throw new TuyauHTTPError(originalError, parsedResponse);
+      }
+      throw new TuyauNetworkError(originalError, { url, method });
+    }
+  }
+  /**
+   * Finds an endpoint definition by HTTP method and pattern
+   */
+  #byMethodPath(method, pattern) {
+    const [name, endpoint] = this.#entries.find(
+      ([, e]) => e.methods[0] === method && e.pattern === pattern
+    ) || [null, null];
+    if (!name || !endpoint) throw new Error(`No ${method} ${pattern}`);
+    return { name, endpoint };
+  }
+  /**
+   * Makes a request to a specific endpoint using method and pattern
+   */
+  #request(method, pattern, args) {
+    const { name, endpoint } = this.#byMethodPath(method, pattern);
+    return this.#doFetch(name, endpoint.methods[0], args);
+  }
+  /**
+   * Makes a GET request to the specified pattern
+   */
+  get(pattern, args) {
+    return this.#request("GET", pattern, args);
+  }
+  /**
+   * Makes a POST request to the specified pattern
+   */
+  post(pattern, args) {
+    return this.#request("POST", pattern, args);
+  }
+  /**
+   * Makes a PUT request to the specified pattern
+   */
+  put(pattern, args) {
+    return this.#request("PUT", pattern, args);
+  }
+  /**
+   * Makes a PATCH request to the specified pattern
+   */
+  patch(pattern, args) {
+    return this.#request("PATCH", pattern, args);
+  }
+  /**
+   * Makes a DELETE request to the specified pattern
+   */
+  delete(pattern, args) {
+    return this.#request("DELETE", pattern, args);
+  }
+  /**
+   * Makes a HEAD request to the specified pattern
+   */
+  head(pattern, args) {
+    return this.#request("HEAD", pattern, args);
+  }
+  /**
+   * Makes a request to a named endpoint
+   */
+  request(name, args) {
+    const def = this.config.registry[name];
+    return this.#doFetch(name, def.methods[0], args);
+  }
+  /**
+   * Gets route information by name including URL and HTTP method
+   */
+  getRoute(name, args) {
+    const def = this.config.registry[name];
+    if (!def) throw new Error(`Route ${String(name)} not found`);
+    const url = this.#buildUrl(name, def.methods[0], args);
+    return { url, methods: def.methods };
+  }
+  /**
+   * Creates a proxy-based fluent API for accessing endpoints by name
+   */
+  makeNamed(segments) {
+    const dot = segments.join(".");
+    const def = this.config.registry[dot];
+    if (def) {
+      const fn = (args) => this.#doFetch(dot, def.methods[0], args);
+      return new Proxy(fn, {
+        get: (_t, prop) => this.makeNamed([...segments, String(prop)]),
+        apply: (_t, _this, argArray) => fn(...argArray)
+      });
+    }
+    return new Proxy({}, { get: (_t, prop) => this.makeNamed([...segments, String(prop)]) });
+  }
+};
+function createTuyau(config) {
+  return new Tuyau(config);
+}
+export {
+  Tuyau,
+  TuyauHTTPError,
+  TuyauNetworkError,
+  createTuyau,
+  parseResponse
+};

package/build/client/types/index.d.ts

@@ -0,0 +1,195 @@
+import { Options } from 'ky';
+import { ClientRouteMatchItTokens } from '@adonisjs/http-server/client/url_builder';
+
+/**
+ * Supported HTTP methods for API endpoints
+ */
+type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/**
+ * Definition of an AdonisJS endpoint with types and metadata
+ */
+interface AdonisEndpoint {
+    methods: Method[];
+    pattern: string;
+    tokens: ClientRouteMatchItTokens[];
+    types: {
+        paramsTuple: [...any[]];
+        params: Record<string, string | number | boolean>;
+        query: Record<string, any>;
+        body: unknown;
+        response: unknown;
+    };
+}
+/**
+ * Registry mapping endpoint names to their definitions
+ */
+type AdonisRegistry = Record<string, AdonisEndpoint>;
+type ValueOf<T> = T[keyof T];
+type IsEmptyObj<T> = keyof T extends never ? true : false;
+type IsEmptyTuple<T> = T extends [] ? true : false;
+type Endpoints = ValueOf<AdonisRegistry>;
+type EndpointByName<Name extends keyof AdonisRegistry & string> = AdonisRegistry[Name];
+/**
+ * Checks if a type has any keys
+ */
+type HasKeys<T> = keyof T extends never ? false : true;
+/**
+ * Checks if a type has required keys (non-optional properties)
+ */
+type HasRequiredKeys<T> = T extends Record<string, any> ? keyof T extends never ? false : {} extends Pick<T, keyof T> ? false : true : false;
+/**
+ * Constructs the request arguments type for an endpoint
+ */
+type RequestArgs<E extends AdonisEndpoint> = (HasKeys<E['types']['params']> extends true ? HasRequiredKeys<E['types']['params']> extends true ? {
+    params: E['types']['params'];
+} : {
+    params?: E['types']['params'];
+} : {}) & (E['types']['query'] extends object ? HasRequiredKeys<E['types']['query']> extends true ? {
+    query: E['types']['query'];
+} : {
+    query?: E['types']['query'];
+} : {}) & (E['types']['body'] extends never | undefined ? {} : HasRequiredKeys<E['types']['body']> extends true ? {
+    body: E['types']['body'];
+} : {
+    body?: E['types']['body'];
+}) & Omit<Options, 'body' | 'params' | 'searchParams' | 'method' | 'json' | 'prefixUrl'>;
+/**
+ * Extracts response type from an endpoint
+ */
+type ResponseOf<E extends AdonisEndpoint> = E['types']['response'];
+/**
+ * Splits a dot-separated string into an array of strings
+ */
+type Split<S extends string> = S extends `${infer H}.${infer T}` ? [H, ...Split<T>] : [S];
+/**
+ * Converts a union type to an intersection type
+ */
+type UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+/**
+ * Builds a nested object type for the fluent API based on endpoint names
+ */
+type BuildNamed<Reg extends Record<string, AdonisEndpoint>> = UnionToIntersection<{
+    [K in keyof Reg & string]: SetAtPath<Split<K>, EndpointFn<Reg[K]>>;
+}[keyof Reg & string]>;
+/**
+ * Sets a value at a specific path in a nested object type
+ */
+type SetAtPath<Path extends string[], V> = Path extends [
+    infer H extends string,
+    ...infer T extends string[]
+] ? {
+    [K in H]: T['length'] extends 0 ? V : SetAtPath<T, V>;
+} : {};
+/**
+ * Function type for calling an endpoint
+ */
+type EndpointFn<E extends AdonisEndpoint> = (args: RequestArgs<E>) => Promise<E['types']['response']>;
+/**
+ * Filters endpoints by HTTP method
+ */
+type EndpointsByMethod<Reg extends Record<string, AdonisEndpoint>, M extends Method> = {
+    [K in keyof Reg]: M extends Reg[K]['methods'][number] ? Reg[K] : never;
+}[keyof Reg];
+type StrKeys<R> = Extract<keyof R, string>;
+type RegValues<R> = R[StrKeys<R>];
+/**
+ * Gets URL patterns for endpoints matching a specific HTTP method
+ */
+type PatternsByMethod<Reg extends Record<string, AdonisEndpoint>, M extends Method> = EndpointsByMethod<Reg, M>['pattern'];
+/**
+ * Finds an endpoint by HTTP method and URL pattern
+ */
+type EndpointByMethodPattern<R extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<R, M>> = FilterByMethodPathForRegistry<R, M, P>;
+/**
+ * Plugin function type for extending Tuyau functionality
+ */
+type TuyauPlugin = (params: {
+    options: TuyauConfiguration<any>;
+}) => void;
+type MaybeArray<T> = T | T[];
+/**
+ * Type for URL query parameters
+ */
+type QueryParameters = Record<string, MaybeArray<string | number | boolean | null | undefined>>;
+/**
+ * Configuration options for creating a Tuyau client
+ */
+type TuyauConfiguration<T extends Record<string, AdonisEndpoint>> = Omit<Options, 'prefixUrl' | 'body' | 'json' | 'method' | 'searchParams'> & {
+    registry: T;
+    baseUrl: string;
+    plugins?: TuyauPlugin[];
+};
+/**
+ * Should be augmented by the user to provide their endpoint registry
+ */
+interface UserRegistry {
+}
+type UserAdonisRegistry = UserRegistry extends Record<string, AdonisEndpoint> ? UserRegistry : Record<string, AdonisEndpoint>;
+type UserEndpointByName<Name extends keyof UserAdonisRegistry> = UserAdonisRegistry[Name];
+type FilterByMethodPathForRegistry<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends ValueOf<Reg>['pattern'] & string> = {
+    [K in keyof Reg]: [Reg[K]['pattern'], M] extends [P, Reg[K]['methods'][number]] ? Reg[K] : never;
+}[keyof Reg];
+type EndpointByNameForRegistry<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = Reg[Name];
+/**
+ * Internal type utilities for working with endpoints by HTTP method and path pattern
+ * Accepts a registry as generic parameter
+ */
+declare namespace PathWithRegistry {
+    type Request<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = RequestArgs<FilterByMethodPathForRegistry<Reg, M, P>>;
+    type Response<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = ResponseOf<FilterByMethodPathForRegistry<Reg, M, P>>;
+    type Params<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = FilterByMethodPathForRegistry<Reg, M, P>['types']['params'];
+    type Body<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = FilterByMethodPathForRegistry<Reg, M, P>['types']['body'];
+    type Query<Reg extends Record<string, AdonisEndpoint>, M extends Method, P extends PatternsByMethod<Reg, M>> = FilterByMethodPathForRegistry<Reg, M, P>['types']['query'];
+}
+/**
+ * Internal type utilities for working with endpoints by route name
+ * Accepts a registry as generic parameter
+ */
+declare namespace RouteWithRegistry {
+    type Request<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = RequestArgs<EndpointByNameForRegistry<Reg, Name>>;
+    type Response<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = ResponseOf<EndpointByNameForRegistry<Reg, Name>>;
+    type Params<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = EndpointByNameForRegistry<Reg, Name>['types']['params'];
+    type Body<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = EndpointByNameForRegistry<Reg, Name>['types']['body'];
+    type Query<Reg extends Record<string, AdonisEndpoint>, Name extends keyof Reg> = EndpointByNameForRegistry<Reg, Name>['types']['query'];
+}
+/**
+ * Type utilities for working with endpoints by HTTP method and path pattern
+ * Uses the user-augmented registry
+ */
+declare namespace Path {
+    type Request<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = RequestArgs<FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>>;
+    type Response<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = ResponseOf<FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>>;
+    type Params<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>['types']['params'];
+    type Body<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>['types']['body'];
+    type Query<M extends Method, P extends PatternsByMethod<UserAdonisRegistry, M>> = FilterByMethodPathForRegistry<UserAdonisRegistry, M, P>['types']['query'];
+}
+/**
+ * Type utilities for working with endpoints by route name
+ * Uses the user-augmented registry
+ */
+declare namespace Route {
+    type Request<Name extends keyof UserAdonisRegistry> = RequestArgs<UserEndpointByName<Name>>;
+    type Response<Name extends keyof UserAdonisRegistry> = ResponseOf<UserEndpointByName<Name>>;
+    type Params<Name extends keyof UserAdonisRegistry> = UserEndpointByName<Name>['types']['params'];
+    type Body<Name extends keyof UserAdonisRegistry> = UserEndpointByName<Name>['types']['body'];
+    type Query<Name extends keyof UserAdonisRegistry> = UserEndpointByName<Name>['types']['query'];
+}
+type ParamsShape<E> = E extends {
+    types: {
+        paramsTuple: infer PT;
+        params: infer P;
+    };
+} ? (IsEmptyTuple<PT> extends true ? {
+    paramsTuple?: PT;
+} : {
+    paramsTuple: PT;
+}) & (IsEmptyObj<P> extends true ? {} : {
+    params: P;
+}) : never;
+type RegistryGroupedByMethod<R extends Record<string, AdonisEndpoint>, M extends Method = Method> = {
+    [K in M | 'ALL']: {
+        [Route in keyof R as K extends 'ALL' ? Route : K extends R[Route]['methods'][number] ? Route : never]: ParamsShape<R[Route]>;
+    };
+};
+
+export { type AdonisEndpoint, type AdonisRegistry, type BuildNamed, type EndpointByMethodPattern, type EndpointByName, type Endpoints, type EndpointsByMethod, type HasKeys, type HasRequiredKeys, type MaybeArray, type Method, Path, PathWithRegistry, type PatternsByMethod, type QueryParameters, type RegValues, type RegistryGroupedByMethod, type RequestArgs, type ResponseOf, Route, RouteWithRegistry, type SetAtPath, type Split, type StrKeys, type TuyauConfiguration, type TuyauPlugin, type UnionToIntersection, type UserRegistry, type ValueOf };

package/build/commands/commands.json

@@ -1 +1 @@
-{"commands":[{"commandName":"tuyau:generate","description":"Tuyau generator command","help":"","namespace":"tuyau","aliases":[],"flags":[{"name":"verbose","flagName":"verbose","required":false,"type":"boolean","description":"Verbose logs","default":false,"alias":"v"}],"args":[],"options":{"startApp":true},"filePath":"generate.js"}],"version":1}
+{"commands":[],"version":1}