@tuyau/core 1.0.0 → 1.2.0

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

@@ -1,265 +1,3 @@
-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';
-/**
- * Base endpoint types structure
- */
-interface EndpointTypes {
-    paramsTuple: [...any[]];
-    params: Record<string, string | number | boolean | bigint>;
-    query: Record<string, any>;
-    body: unknown;
-    response: unknown;
-}
-/**
- * Schema endpoint, used in generated registry.schema.d.ts
- * Does not include tokens (only present in runtime routes)
- */
-interface SchemaEndpoint {
-    methods: Method[];
-    pattern: string;
-    types: EndpointTypes;
-}
-/**
- * Definition of an AdonisJS endpoint with types and metadata
- * Includes tokens for runtime route building
- */
-interface AdonisEndpoint extends SchemaEndpoint {
-    tokens: ClientRouteMatchItTokens[];
-}
-/**
- * Extract query params from a validator type if it has a 'query' property.
- * Used in generated registry to separate query params from body for POST/PUT/PATCH/DELETE.
- * For GET/HEAD, use ExtractQueryForGet instead.
- */
-type ExtractQuery<T> = 'query' extends keyof T ? T extends {
-    query?: infer Q;
-} ? Q : {} : {};
-/**
- * Extract query params for GET/HEAD requests.
- * Excludes headers, cookies, and params from the validator type since these are not query params.
- */
-type ExtractQueryForGet<T> = Omit<T, 'headers' | 'cookies' | 'params'>;
-/**
- * Extract body from a validator type, excluding reserved properties.
- * Excludes 'query', 'params', 'headers', and 'cookies' as these are handled separately by AdonisJS.
- */
-type ExtractBody<T> = Omit<T, 'query' | 'params' | 'headers' | 'cookies'>;
-/**
- * Success status codes (2xx)
- */
-type SuccessStatus = 200 | 201 | 202 | 203 | 204 | 205 | 206;
-/**
- * Extract the actual response type from a controller return type.
- * - Success responses (2xx): extracts `__response`
- * - Error responses (non-2xx with __response/__status): returns `never` to filter from unions
- * - Plain types (no __status): returns as-is
- */
-type ExtractResponse<T> = T extends {
-    __response: infer R;
-    __status: SuccessStatus;
-} ? R : T extends {
-    __response: unknown;
-    __status: number;
-} ? never : T;
-/**
- * Registry mapping endpoint names to their definitions
- */
-interface AdonisRegistry extends Record<string, AdonisEndpoint> {
-}
-type ValueOf<T> = T[keyof T];
-/**
- * Split a string by a delimiter
- */
-type Split<S extends string, D extends string = '.'> = S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
-/**
- * Convert a union type to an intersection type
- */
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-/**
- * Structure of a Tuyau registry containing routes and optional tree
- */
-interface TuyauRegistry<Routes extends Record<string, AdonisEndpoint> = Record<string, AdonisEndpoint>, Tree = unknown> {
-    routes: Routes;
-    $tree?: Tree;
-}
-/**
- * Extracts the $tree type from a registry
- * Uses direct access instead of conditional type for performance
- */
-type InferTree<R extends TuyauRegistry> = R['$tree'];
-/**
- * Extracts the routes from a registry
- */
-type InferRoutes<R extends TuyauRegistry> = R['routes'];
-type Endpoints = ValueOf<AdonisRegistry>;
-type EndpointByName<Name extends keyof AdonisRegistry & string> = AdonisRegistry[Name];
-/**
- * Pre-computed base Ky options to avoid recomputing Omit on every request
- */
-type BaseRequestOptions = Omit<Options, 'body' | 'params' | 'searchParams' | 'method' | 'json' | 'prefixUrl'>;
-/**
- * Helper types for optional/required fields - using literal types instead of mapped types
- */
-type ParamsArg<T> = keyof T extends never ? {} : {} extends T ? {
-    params?: T;
-} : {
-    params: T;
-};
-type QueryArg<T> = keyof T extends never ? {} : {} extends T ? {
-    query?: T;
-} : {
-    query: T;
-};
-type BodyArg<T> = keyof T extends never ? {} : {} extends T ? {
-    body?: T;
-} : {
-    body: T;
-};
-/**
- * Request args without ky options
- */
-type RawRequestArgs<E extends SchemaEndpoint> = ParamsArg<E['types']['params']> & QueryArg<E['types']['query']> & BodyArg<E['types']['body']>;
-/**
- * Constructs the request arguments type for an endpoint
- */
-type RequestArgs<E extends SchemaEndpoint> = RawRequestArgs<E> & BaseRequestOptions;
-/**
- * Extracts response type from an endpoint
- */
-type ResponseOf<E extends SchemaEndpoint> = E['types']['response'];
-/**
- * Function type for calling an endpoint
- */
-type EndpointFn<E extends SchemaEndpoint> = (args: RequestArgs<E>) => Promise<E['types']['response']>;
-/**
- * Function type for an endpoint with inlined args
- */
-type EndpointFnInline<E extends AdonisEndpoint> = (args: ParamsArg<E['types']['params']> & QueryArg<E['types']['query']> & BodyArg<E['types']['body']> & BaseRequestOptions) => Promise<E['types']['response']>;
-/**
- * Transforms a pre-computed ApiDefinition tree into callable endpoint functions
- * This recursively converts each endpoint in the tree to a callable function
- * Handles intersection types where a node is both an endpoint AND has children
- */
-type TransformApiDefinition<T> = {
-    [K in keyof T]: T[K] extends AdonisEndpoint ? EndpointFnInline<T[K]> & TransformApiDefinition<Omit<T[K], keyof AdonisEndpoint>> : TransformApiDefinition<T[K]>;
-};
-/**
- * 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
- */
-interface TuyauPlugin {
-    (params: {
-        options: TuyauConfiguration<any>;
-    }): void;
-}
-type MaybeArray<T> = T | T[];
-/**
- * Type for URL query parameters
- */
-interface QueryParameters extends Record<string, MaybeArray<string | number | boolean | null | undefined> | QueryParameters> {
-}
-/**
- * Configuration options for creating a Tuyau client
- */
-interface TuyauConfiguration<T extends TuyauRegistry> extends Omit<Options, 'prefixUrl' | 'body' | 'json' | 'method' | 'searchParams'> {
-    registry: T;
-    baseUrl: string;
-    plugins?: TuyauPlugin[];
-}
-/**
- * Should be augmented by the user to provide their endpoint registry
- * Structure: { routes: Record<string, AdonisEndpoint>, $tree: ApiDefinition }
- */
-interface UserRegistry {
-}
-type UserAdonisRegistry = UserRegistry extends {
-    routes: infer R;
-} ? R extends Record<string, AdonisEndpoint> ? R : Record<string, AdonisEndpoint> : 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'] extends P ? M extends Reg[K]['methods'][number] ? Reg[K] : never : 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;
-    };
-} ? (PT extends [] ? {
-    paramsTuple?: PT;
-} : {
-    paramsTuple: PT;
-}) & (keyof P extends never ? {} : {
-    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 BaseRequestOptions, type EndpointByMethodPattern, type EndpointByName, type EndpointFn, type EndpointTypes, type Endpoints, type EndpointsByMethod, type ExtractBody, type ExtractQuery, type ExtractQueryForGet, type ExtractResponse, type InferRoutes, type InferTree, type MaybeArray, type Method, Path, PathWithRegistry, type PatternsByMethod, type QueryParameters, type RawRequestArgs, type RegValues, type RegistryGroupedByMethod, type RequestArgs, type ResponseOf, Route, RouteWithRegistry, type SchemaEndpoint, type Split, type StrKeys, type TransformApiDefinition, type TuyauConfiguration, type TuyauPlugin, type TuyauRegistry, type UnionToIntersection, type UserRegistry, type ValueOf };
+export { A as AdonisEndpoint, q as AdonisRegistry, B as BaseRequestOptions, C as CurrentRouteOptions, E as EndpointByMethodPattern, s as EndpointByName, x as EndpointFn, j as EndpointTypes, r as Endpoints, y as EndpointsByMethod, f as ErrorResponseOf, n as ExtractBody, p as ExtractErrorResponse, l as ExtractQuery, m as ExtractQueryForGet, o as ExtractResponse, I as InferRoutes, c as InferTree, N as KnownStatuses, F as MaybeArray, M as Method, K as Path, H as PathWithRegistry, P as PatternsByMethod, Q as QueryParameters, v as RawRequestArgs, z as RegValues, R as RegistryGroupedByMethod, d as RequestArgs, w as ResponseOf, t as ResponseType, L as Route, J as RouteWithRegistry, k as SchemaEndpoint, S as StrKeys, b as TransformApiDefinition, a as TuyauConfiguration, D as TuyauPlugin, T as TuyauRegistry, u as TuyauRequestOptions, U as UnionToIntersection, G as UserRegistry, V as ValueOf } from '../../index-SVztBh2W.js';
+import 'ky';
+import '@adonisjs/http-server/client/url_builder';