@tuyau/react-query 0.0.1-next.2 → 1.0.0-beta.1

package/build/index.d.ts

@@ -1,100 +1,111 @@
-import { IsNever } from '@tuyau/utils/types';
-import { SkipToken, DataTag, QueryFilters, UseMutationOptions, DefinedInitialDataOptions, UnusedSkipTokenOptions, UndefinedInitialDataOptions, DefinedInitialDataInfiniteOptions, UnusedSkipTokenInfiniteOptions, UndefinedInitialDataInfiniteOptions, QueryClient } from '@tanstack/react-query';
-import { GeneratedRoutes, TuyauClient, QueryParameters, ApiDefinition } from '@tuyau/client';
-import * as React from 'react';
+import { SchemaEndpoint, RawRequestArgs, TuyauRegistry, InferTree, AdonisEndpoint, InferRoutes } from '@tuyau/core/types';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { SkipToken, DataTag, QueryFilters, WithRequired as WithRequired$1, UseMutationOptions, InfiniteData, InfiniteQueryObserverOptions, DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions, QueryClient } from '@tanstack/react-query';
+import { Tuyau } from '@tuyau/core/client';
 
+type Response$2<E extends SchemaEndpoint> = E['types']['response'];
 /**
- * Type definition for query options with overloads for different scenarios
+ * Decorate query endpoints with Tanstack queries abilities
  */
-interface TuyauReactQueryOptions<EDef extends EndpointDef, TParams = Record<string, string | number>> {
-    <TData = UnionFromSuccessStatuses<EDef['response']>>(input: {
-        payload?: EDef['request'];
-        params?: TParams;
-    } | SkipToken, opts: DefinedTuyauQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any>): DefinedTuyauQueryOptionsOut<UnionFromSuccessStatuses<EDef['response']>, TData, any>;
-    <TData = UnionFromSuccessStatuses<EDef['response']>>(input: {
-        payload?: EDef['request'];
-        params?: TParams;
-    }, opts?: UnusedSkipTokenTuyauQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any>): UnusedSkipTokenTuyauQueryOptionsOut<UnionFromSuccessStatuses<EDef['response']>, TData, any>;
-    <TData = UnionFromSuccessStatuses<EDef['response']>>(input?: {
-        payload?: EDef['request'];
-        params?: TParams;
-    } | SkipToken, opts?: UndefinedTuyauQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any>): UndefinedTuyauQueryOptionsOut<UnionFromSuccessStatuses<EDef['response']>, TData, any>;
+interface DecorateQueryFn<EDef extends SchemaEndpoint> {
+    queryOptions: TuyauReactQueryOptions<EDef>;
+    queryKey: (args?: RawRequestArgs<EDef>) => DataTag<TuyauQueryKey, Response$2<EDef>>;
+    queryFilter: (args?: RawRequestArgs<EDef>, filters?: QueryFilters<DataTag<TuyauQueryKey, Response$2<EDef>>>) => WithRequired$1<QueryFilters<DataTag<TuyauQueryKey, Response$2<EDef>>>, 'queryKey'>;
 }
 /**
- * Interface for query function decorators
+ * Type definition for query options with overloads for different scenarios
  */
-interface DecorateQueryFn<EDef extends EndpointDef, TParams = Record<string, string | number>> extends TypeHelper<EDef> {
-    queryOptions: TuyauReactQueryOptions<EDef, TParams>;
-    queryKey: (input?: {
-        payload?: Partial<EDef['request']>;
-        params?: TParams;
-    }) => DataTag<TuyauQueryKey, UnionFromSuccessStatuses<EDef['response']>, any>;
-    queryFilter: (input?: {
-        payload?: Partial<EDef['request']>;
-        params?: TParams;
-    }, filters?: QueryFilters<DataTag<TuyauQueryKey, UnionFromSuccessStatuses<EDef['response']>, any>>) => WithRequired<QueryFilters<DataTag<TuyauQueryKey, UnionFromSuccessStatuses<EDef['response']>, any>>, 'queryKey'>;
+interface TuyauReactQueryOptions<EDef extends SchemaEndpoint> {
+    <TData = Response$2<EDef>>(input: RawRequestArgs<EDef> | SkipToken, opts: DefinedTuyauQueryOptionsIn<Response$2<EDef>, TData, unknown>): DefinedTuyauQueryOptionsOut<Response$2<EDef>, TData, unknown>;
+    <TData = Response$2<EDef>>(input: RawRequestArgs<EDef>, opts?: UnusedSkipTokenTuyauQueryOptionsIn<Response$2<EDef>, TData, unknown>): UnusedSkipTokenTuyauQueryOptionsOut<Response$2<EDef>, TData, unknown>;
+    <TData = Response$2<EDef>>(input?: RawRequestArgs<EDef> | SkipToken, opts?: UndefinedTuyauQueryOptionsIn<Response$2<EDef>, TData, unknown>): UndefinedTuyauQueryOptionsOut<Response$2<EDef>, TData, unknown>;
 }
 
 /**
- * Interface for mutation function decorators
+ * Omits the key without removing a potential union
+ */
+type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any ? Omit<TObj, TKey> : never;
+/**
+ * Make certain keys required in a type
  */
-interface DecorateMutationFn<EDef extends EndpointDef, TParams = Record<string, string | number>> extends TypeHelper<EDef> {
-    mutationOptions: TuyauReactMutationOptions<EDef, TParams>;
+type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;
+
+type ReservedOptions = 'mutationKey' | 'mutationFn';
+type Response$1<E extends SchemaEndpoint> = E['types']['response'];
+interface TuyauMutationOptionsIn<TInput, TError, TOutput, TContext> extends DistributiveOmit<UseMutationOptions<TOutput, TError, TInput, TContext>, ReservedOptions>, TuyauQueryBaseOptions {
+}
+interface TuyauMutationOptionsOut<TInput, TError, TOutput, TContext> extends UseMutationOptions<TOutput, TError, TInput, TContext> {
+    mutationKey: TuyauMutationKey;
+}
+interface TuyauReactMutationOptions<TDef extends SchemaEndpoint> {
+    <TContext = unknown>(opts?: TuyauMutationOptionsIn<RawRequestArgs<TDef>, any, Response$1<TDef>, TContext>): TuyauMutationOptionsOut<RawRequestArgs<TDef>, any, Response$1<TDef>, TContext>;
+}
+declare function getMutationKeyInternal(options: {
+    segments: string[];
+}): TuyauMutationKey;
+interface DecorateMutationFn<EDef extends SchemaEndpoint> {
+    mutationOptions: TuyauReactMutationOptions<EDef>;
     mutationKey: () => TuyauMutationKey;
 }
+interface TuyauMutationOptionsOptions {
+    opts?: TuyauMutationOptionsIn<any, any, any, any>;
+    routeName: string;
+    client: Tuyau<any>;
+}
+declare function tuyauMutationOptions(options: TuyauMutationOptionsOptions): _tanstack_react_query.WithRequired<UseMutationOptions<unknown, any, any, any>, "mutationKey">;
+
+type Response<E extends SchemaEndpoint> = E['types']['response'];
 /**
- * Output type for mutation options
+ * Infinite query options input type
  */
-interface TuyauMutationOptionsOut<TInput, TError, TOutput, TContext, TParams = Record<string, string | number>> extends UseMutationOptions<TOutput, TError, TInput extends undefined | {} | Record<string, never> | unknown ? {
-    payload?: TInput;
-    params?: TParams;
-} : {
-    payload: TInput;
-    params?: TParams;
-}, TContext> {
-    mutationKey: TuyauMutationKey;
+interface TuyauInfiniteQueryOptionsIn<TQueryFnData, TError, TData> extends DistributiveOmit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData>, 'queryKey' | 'queryFn' | 'queryHashFn' | 'queryHash'>, TuyauQueryBaseOptions {
+    /**
+     * The key that will be used for the page parameter in the request.
+     * For example, if your API expects ?page=1, set this to 'page'.
+     * If your API expects ?cursor=abc, set this to 'cursor'.
+     */
+    pageParamKey?: string;
 }
 /**
- * Type definition for mutation options
+ * Infinite query options output type
  */
-interface TuyauReactMutationOptions<TDef extends EndpointDef, TParams = Record<string, string | number>> {
-    <TContext = unknown>(opts?: TuyauMutationOptionsIn<TDef['request'], any, UnionFromSuccessStatuses<TDef['response']>, TContext, TParams>): TuyauMutationOptionsOut<TDef['request'], any, UnionFromSuccessStatuses<TDef['response']>, TContext, TParams>;
+interface TuyauInfiniteQueryOptionsOut<TQueryFnData, TError, TData> extends Omit<InfiniteQueryObserverOptions<TQueryFnData, TError, TData>, 'queryKey'> {
+    queryKey: DataTag<TuyauQueryKey, TData>;
 }
-
 /**
- * Extract union type from successful HTTP status codes (200-299)
+ * Type definition for infinite query options
  */
-type UnionFromSuccessStatuses<Res extends Record<number, unknown>> = Res[Extract<keyof Res, 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226>];
+interface TuyauReactInfiniteQueryOptions<EDef extends SchemaEndpoint> {
+    <TData = InfiniteData<Response<EDef>>>(input: RawRequestArgs<EDef> | SkipToken, opts: TuyauInfiniteQueryOptionsIn<Response<EDef>, unknown, TData>): TuyauInfiniteQueryOptionsOut<Response<EDef>, unknown, TData>;
+    <TData = InfiniteData<Response<EDef>>>(input?: RawRequestArgs<EDef> | SkipToken, opts?: TuyauInfiniteQueryOptionsIn<Response<EDef>, unknown, TData>): TuyauInfiniteQueryOptionsOut<Response<EDef>, unknown, TData>;
+}
 /**
- * Base endpoint definition structure
+ * Decorate query endpoints with infinite query capabilities
  */
-type EndpointDef = {
-    request: Record<string, unknown>;
-    response: Record<number, unknown>;
-};
+interface DecorateInfiniteQueryFn<EDef extends SchemaEndpoint> {
+    infiniteQueryOptions: TuyauReactInfiniteQueryOptions<EDef>;
+    infiniteQueryKey: (args?: RawRequestArgs<EDef>) => DataTag<TuyauQueryKey, InfiniteData<Response<EDef>>>;
+    infiniteQueryFilter: (args?: RawRequestArgs<EDef>, filters?: QueryFilters<DataTag<TuyauQueryKey, InfiniteData<Response<EDef>>>>) => WithRequired$1<QueryFilters<DataTag<TuyauQueryKey, InfiniteData<Response<EDef>>>>, 'queryKey'>;
+}
+
+/**
+ * Query type identifier
+ */
+type QueryType = 'any' | 'infinite' | 'query';
 /**
  * Tuyau-specific query key structure
  */
 type TuyauQueryKey = [
     readonly string[],
     {
-        payload?: unknown;
-        params?: unknown;
-        type?: 'infinite' | 'query';
+        request?: RawRequestArgs<any>;
+        type?: Exclude<QueryType, 'any'>;
     }?
 ];
 /**
  * Tuyau-specific mutation key structure
  */
 type TuyauMutationKey = [readonly string[]];
-/**
- * Omits the key without removing a potential union
- */
-type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any ? Omit<TObj, TKey> : never;
-/**
- * Make certain keys required in a type
- */
-type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>;
 /**
  * Query options with defined initial data
  */
@@ -113,57 +124,21 @@ interface UnusedSkipTokenTuyauQueryOptionsIn<TQueryFnData, TData, TError> extend
 /**
  * Output type for query options with defined initial data
  */
-interface DefinedTuyauQueryOptionsOut<TQueryFnData, TData, TError> extends DefinedInitialDataOptions<TQueryFnData, TError, TData, TuyauQueryKey>, TuyauQueryOptionsResult {
+interface DefinedTuyauQueryOptionsOut<TQueryFnData, TData, TError> extends DefinedInitialDataOptions<TQueryFnData, TError, TData, TuyauQueryKey> {
     queryKey: DataTag<TuyauQueryKey, TData, TError>;
 }
 /**
  * Output type for query options with undefined initial data
  */
-interface UndefinedTuyauQueryOptionsOut<TQueryFnData, TData, TError> extends UndefinedInitialDataOptions<TQueryFnData, TError, TData, TuyauQueryKey>, TuyauQueryOptionsResult {
+interface UndefinedTuyauQueryOptionsOut<TQueryFnData, TData, TError> extends UndefinedInitialDataOptions<TQueryFnData, TError, TData, TuyauQueryKey> {
     queryKey: DataTag<TuyauQueryKey, TData, TError>;
 }
 /**
  * Output type for query options with unused skip token
  */
-interface UnusedSkipTokenTuyauQueryOptionsOut<TQueryFnData, TData, TError> extends UnusedSkipTokenOptions<TQueryFnData, TError, TData, TuyauQueryKey>, TuyauQueryOptionsResult {
+interface UnusedSkipTokenTuyauQueryOptionsOut<TQueryFnData, TData, TError> extends UnusedSkipTokenOptions<TQueryFnData, TError, TData, TuyauQueryKey> {
     queryKey: DataTag<TuyauQueryKey, TData, TError>;
 }
-/**
- * Input type for mutation options
- */
-interface TuyauMutationOptionsIn<TInput, TError, TOutput, TContext, TParams = Record<string, string | number>> extends DistributiveOmit<UseMutationOptions<TOutput, TError, {
-    payload: TInput;
-    params?: TParams;
-}, TContext>, 'mutationKey' | 'mutationFn'> {
-    /**
-     * Route parameters to be passed to the mutation
-     */
-    params?: TParams;
-}
-/**
- * Interface for router keyable decorators (pathKey, pathFilter)
- */
-interface DecorateRouterKeyable {
-    pathKey: () => TuyauQueryKey;
-    pathFilter: (filters?: QueryFilters<TuyauQueryKey>) => WithRequired<QueryFilters<TuyauQueryKey>, 'queryKey'>;
-}
-interface TypeHelper<EDef extends EndpointDef> {
-    /**
-     * @internal
-     */
-    '~types': {
-        request: EDef['request'];
-        response: EDef['response'];
-    };
-}
-/**
- * Infer request type from an endpoint
- */
-type InferRequestType<Endpoint extends DecorateQueryFn<any> | DecorateMutationFn<any>> = Endpoint['~types']['request'];
-/**
- * Infer response type from an endpoint
- */
-type InferResponseType<Endpoint extends DecorateQueryFn<any> | DecorateMutationFn<any>> = Endpoint['~types']['response']['200'];
 /**
  * Tuyau-specific request options for React Query integration
  */
@@ -177,180 +152,56 @@ interface TuyauReactRequestOptions {
  * Base options for Tuyau queries
  */
 interface TuyauQueryBaseOptions {
-    /**
-     * Tuyau-related options
-     */
     tuyau?: TuyauReactRequestOptions;
 }
-/**
- * Result interface for Tuyau query options
- */
-interface TuyauQueryOptionsResult {
-    tuyau: {
-        path: string[];
-        type: 'query';
-    };
-}
-
-/**
- * Reserved infinite query options that should not be overridden
- */
-type InfiniteQueryReservedOptions = 'queryKey' | 'queryFn' | 'queryHashFn' | 'queryHash';
-/**
- * Tuyau infinite data structure
- */
-type TuyauInfiniteData<TData> = {
-    pages: TData[];
-    pageParams: unknown[];
-};
-/**
- * Infinite query options with undefined initial data
- */
-interface UndefinedTuyauInfiniteQueryOptionsIn<TQueryFnData, TData, TError, TRequest, TPageParamKey extends keyof TRequest> extends DistributiveOmit<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, ExtractPageParamType<TRequest, TPageParamKey> | null>, InfiniteQueryReservedOptions>, TuyauQueryBaseOptions {
-    pageParamKey: TPageParamKey;
-}
-/**
- * Infinite query options with defined initial data
- */
-interface DefinedTuyauInfiniteQueryOptionsIn<TQueryFnData, TData, TError, TRequest, TPageParamKey extends keyof TRequest> extends DistributiveOmit<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, ExtractPageParamType<TRequest, TPageParamKey> | null>, InfiniteQueryReservedOptions>, TuyauQueryBaseOptions {
-    pageParamKey: TPageParamKey;
-}
-type ExtractPageParamType<TRequest, TPageParamKey extends keyof TRequest> = TRequest[TPageParamKey];
-/**
- * Infinite query options with unused skip token
- */
-interface UnusedSkipTokenTuyauInfiniteQueryOptionsIn<TQueryFnData, TData, TError, TRequest, TPageParamKey extends keyof TRequest> extends DistributiveOmit<UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, ExtractPageParamType<TRequest, TPageParamKey>>, InfiniteQueryReservedOptions>, TuyauQueryBaseOptions {
-    pageParamKey: TPageParamKey;
-}
-/**
- * Output type for infinite query options with undefined initial data
- */
-interface UndefinedTuyauInfiniteQueryOptionsOut<TQueryFnData, TData, TError> extends UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, unknown> {
-    queryKey: DataTag<TuyauQueryKey, TuyauInfiniteData<TData>, TError>;
-    tuyau: {
-        path: string[];
-        type: 'infinite';
-    };
+interface DecorateRouterKeyable {
+    pathKey: () => TuyauQueryKey;
+    pathFilter: (filters?: QueryFilters<TuyauQueryKey>) => WithRequired<QueryFilters<TuyauQueryKey>, 'queryKey'>;
 }
 /**
- * Output type for infinite query options with defined initial data
+ * Keys that identify an endpoint-like structure
  */
-interface DefinedTuyauInfiniteQueryOptionsOut<TQueryFnData, TData, TError> extends DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, unknown> {
-    queryKey: DataTag<TuyauQueryKey, TuyauInfiniteData<TData>, TError>;
-    tuyau: {
-        path: string[];
-        type: 'infinite';
-    };
-}
+type EndpointKeys = 'methods' | 'pattern' | 'types';
 /**
- * Output type for infinite query options with unused skip token
+ * Determines if endpoint is a query (GET/HEAD) or mutation
  */
-interface UnusedSkipTokenTuyauInfiniteQueryOptionsOut<TQueryFnData, TData, TError> extends UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, unknown> {
-    queryKey: DataTag<TuyauQueryKey, TuyauInfiniteData<TData>, TError>;
-    tuyau: {
-        path: string[];
-        type: 'infinite';
-    };
-}
+type IsQueryMethod<E extends SchemaEndpoint> = E['methods'][number] extends infer M ? M extends 'GET' | 'HEAD' ? true : false : false;
 /**
- * Type definition for infinite query options with overloads for different scenarios
+ * Endpoint node with query or mutation decorators
+ * Optimized: uses direct conditional instead of nested extends
  */
-interface TuyauReactInfiniteQueryOptions<EDef extends EndpointDef, TParams = Record<string, string | number>> {
-    <TData = UnionFromSuccessStatuses<EDef['response']>, TPageParamKey extends keyof EDef['request'] = string>(input: {
-        payload?: Omit<EDef['request'], TPageParamKey>;
-        params?: TParams;
-    } | SkipToken, opts: DefinedTuyauInfiniteQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any, EDef['request'], TPageParamKey>): DefinedTuyauInfiniteQueryOptionsOut<UnionFromSuccessStatuses<EDef['response']>, TData, any>;
-    <TData = UnionFromSuccessStatuses<EDef['response']>, TPageParamKey extends keyof EDef['request'] = string>(input: {
-        payload?: Omit<EDef['request'], TPageParamKey>;
-        params?: TParams;
-    }, opts: UnusedSkipTokenTuyauInfiniteQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any, EDef['request'], TPageParamKey>): UnusedSkipTokenTuyauInfiniteQueryOptionsOut<UnionFromSuccessStatuses<EDef['response']>, TData, any>;
-    <TData = UnionFromSuccessStatuses<EDef['response']>, TPageParamKey extends keyof EDef['request'] = string>(input?: {
-        payload?: Omit<EDef['request'], TPageParamKey>;
-        params?: TParams;
-    } | SkipToken, opts?: UndefinedTuyauInfiniteQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any, EDef['request'], TPageParamKey>): UndefinedTuyauInfiniteQueryOptionsOut<UnionFromSuccessStatuses<EDef['response']>, TData, any>;
-}
+type EndpointNode<E extends SchemaEndpoint> = (IsQueryMethod<E> extends true ? DecorateQueryFn<E> & DecorateInfiniteQueryFn<E> : DecorateMutationFn<E>) & DecorateRouterKeyable;
 /**
- * Interface for infinite query function decorators
+ * Transform a pre-computed tree structure into react-query decorated endpoints
+ * Uses the $tree from the registry to avoid recomputing the structure
+ * Handles the case where a node is both an endpoint AND has children
  */
-interface DecorateInfiniteQueryFn<EDef extends EndpointDef, TParams = Record<string, string | number>> {
-    infiniteQueryOptions: TuyauReactInfiniteQueryOptions<EDef, TParams>;
-    infiniteQueryKey: (input?: {
-        payload?: Partial<EDef['request']>;
-        params?: TParams;
-    }) => DataTag<TuyauQueryKey, TuyauInfiniteData<UnionFromSuccessStatuses<EDef['response']>>, any>;
-    infiniteQueryFilter: (input?: {
-        payload?: Partial<EDef['request']>;
-        params?: TParams;
-    }, filters?: QueryFilters<DataTag<TuyauQueryKey, TuyauInfiniteData<UnionFromSuccessStatuses<EDef['response']>>, any>>) => WithRequired<QueryFilters<DataTag<TuyauQueryKey, TuyauInfiniteData<UnionFromSuccessStatuses<EDef['response']>>, any>>, 'queryKey'>;
-}
+type TransformToReactQuery<T> = {
+    [K in keyof T]: T[K] extends SchemaEndpoint ? EndpointNode<T[K]> & TransformToReactQuery<Omit<T[K], EndpointKeys>> : TransformToReactQuery<T[K]>;
+} & DecorateRouterKeyable;
+type TuyauReactQuery<R extends Record<string, SchemaEndpoint>> = TransformToReactQuery<R>;
 
-/**
- * Options for configuring the Tuyau React Query client
- */
-interface TuyauReactQueryClientOptions<D extends Record<string, any>, R extends GeneratedRoutes> {
-    client: TuyauClient<D, R>;
+declare function createTuyauReactQueryClient<Reg extends TuyauRegistry, Tree = InferTree<Reg>, Routes extends Record<string, AdonisEndpoint> = InferRoutes<Reg>>(options: {
+    client: Tuyau<Reg, Routes>;
     queryClient: QueryClient | (() => QueryClient);
-    /**
-     * Global Tuyau-specific request options
-     */
     globalOptions?: TuyauReactRequestOptions;
-}
-/**
- * Create the Tuyau React Query client
- */
-declare function createTuyauReactQueryClient<D extends Record<string, any>, R extends GeneratedRoutes>(options: TuyauReactQueryClientOptions<D, R>): TuyauReactQuery<D> & DecorateRouterKeyable;
-/**
- * Main type for the Tuyau React Query client
- * Maps route definitions to appropriate query or mutation decorators
- */
-type TuyauReactQuery<in out Route extends Record<string, any>, NotProvidedParams = {}> = {
-    [K in keyof Route as K extends `:${string}` ? never : K]: Route[K] extends {
-        response: infer _Res extends Record<number, unknown>;
-        request: infer _Request;
-    } ? K extends '$get' | '$head' ? DecorateQueryFn<Route[K], NotProvidedParams> & DecorateInfiniteQueryFn<Route[K], NotProvidedParams> & DecorateRouterKeyable : // POST, PUT, PATCH, DELETE methods become mutations
-    DecorateMutationFn<Route[K], NotProvidedParams> & DecorateRouterKeyable : K extends '$url' ? (options?: {
-        query?: QueryParameters;
-    }) => string : CreateParams<Route[K], NotProvidedParams> & DecorateRouterKeyable;
-};
-/**
- * Extract path parameters from route keys
- */
-type ExtractPathParams<Route> = Extract<keyof Route, `:${string}`>;
-/**
- * Convert path parameter to object type
- */
-type PathParamToObject<Path extends string> = Path extends `:${infer Param}` ? {
-    [K in Param]: string | number;
-} : never;
-/**
- * Create the route parameter function signature
- */
-type CreateParamFunction<Route extends Record<string, any>, Path extends string, NotProvidedParams> = (params: PathParamToObject<Path>) => TuyauReactQuery<Route[Path], NotProvidedParams> & CreateParams<Route[Path], NotProvidedParams & PathParamToObject<Path>>;
-/**
- * Create the parameter property mappings
- */
-type CreateParamProperties<Route extends Record<string, any>, Path extends string, NotProvidedParams> = {
-    [K in keyof Route as K extends `:${string}` ? K : never]: TuyauReactQuery<Route[K], NotProvidedParams & PathParamToObject<Path>> & DecorateRouterKeyable;
-};
-/**
- * Type for handling route parameters
- */
-type CreateParams<Route extends Record<string, any>, NotProvidedParams = {}> = ExtractPathParams<Route> extends infer Path extends string ? IsNever<Path> extends true ? TuyauReactQuery<Route, NotProvidedParams> & DecorateRouterKeyable : CreateParamFunction<Route, Path, NotProvidedParams> & TuyauReactQuery<Route, NotProvidedParams> & CreateParamProperties<Route, Path, NotProvidedParams> & DecorateRouterKeyable : never;
+}): TransformToReactQuery<Tree>;
 
-type InferTuyauClient<API extends ApiDefinition> = TuyauClient<API['definition'], API['routes'] extends GeneratedRoutes ? API['routes'] : any>;
-type InferTuyauReactQuery<API extends ApiDefinition> = TuyauReactQuery<API['definition']>;
-interface CreateTuyauContextResult<API extends ApiDefinition> {
-    TuyauProvider: React.FC<{
-        children: React.ReactNode;
-        queryClient: QueryClient;
-        client: InferTuyauClient<API>;
-    }>;
-    useTuyau: () => InferTuyauReactQuery<API>;
-    useTuyauClient: () => InferTuyauClient<API>;
+interface TuyauQueryOptionsOptions {
+    request: RawRequestArgs<any> | SkipToken;
+    opts?: TuyauQueryBaseOptions;
+    queryKey: TuyauQueryKey;
+    routeName: string;
+    client: Tuyau<any>;
+    globalOptions?: TuyauReactRequestOptions;
 }
-/**
- * Create a set of type-safe provider-consumers for Tuyau with React Query
- */
-declare function createTuyauContext<API extends ApiDefinition>(): CreateTuyauContextResult<API>;
+declare function tuyauQueryOptions(options: TuyauQueryOptionsOptions): _tanstack_react_query.UseQueryOptions<any, Error, any, readonly unknown[]> & {
+    initialData?: any;
+} & {
+    queryKey: readonly unknown[] & {
+        [dataTagSymbol]: any;
+        [dataTagErrorSymbol]: Error;
+    };
+};
 
-export { type CreateTuyauContextResult, type InferRequestType, type InferResponseType, type TuyauReactInfiniteQueryOptions, type TuyauReactMutationOptions, type TuyauReactQuery, type TuyauReactQueryOptions, createTuyauContext, createTuyauReactQueryClient };
+export { type DecorateMutationFn, type DecorateRouterKeyable, type DefinedTuyauQueryOptionsIn, type DefinedTuyauQueryOptionsOut, type EndpointNode, type QueryType, type TransformToReactQuery, type TuyauMutationKey, type TuyauMutationOptionsIn, type TuyauMutationOptionsOptions, type TuyauMutationOptionsOut, type TuyauQueryBaseOptions, type TuyauQueryKey, type TuyauQueryOptionsOptions, type TuyauReactMutationOptions, type TuyauReactQuery, type TuyauReactRequestOptions, type UndefinedTuyauQueryOptionsIn, type UndefinedTuyauQueryOptionsOut, type UnusedSkipTokenTuyauQueryOptionsIn, type UnusedSkipTokenTuyauQueryOptionsOut, createTuyauReactQueryClient, getMutationKeyInternal, tuyauMutationOptions, tuyauQueryOptions };

package/build/index.js

@@ -1,273 +1,176 @@
-// src/main.ts
-import {
-  createTuyauRecursiveProxy
-} from "@tuyau/client";
-
 // src/utils.ts
-function unwrapLazyArg(arg) {
-  return typeof arg === "function" ? arg() : arg;
-}
+import { skipToken } from "@tanstack/react-query";
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function buildRequestPath(path, params) {
-  if (!params) return path.map(String);
-  const result = [];
-  for (const segment of path) {
-    const segmentStr = String(segment);
-    if (segmentStr.includes("/")) {
-      const parts = segmentStr.split("/");
-      for (const part of parts) {
-        if (part.startsWith(":")) {
-          const paramName = part.slice(1);
-          result.push(params[paramName]?.toString() || part);
-        } else {
-          result.push(part);
-        }
-      }
-    } else if (segmentStr.startsWith(":")) {
-      const paramName = segmentStr.slice(1);
-      result.push(params[paramName]?.toString() || segmentStr);
-    } else {
-      result.push(segmentStr);
-    }
-  }
-  return result;
+function invoke(fn) {
+  return fn?.();
 }
-
-// src/query.ts
-import {
-  queryOptions,
-  skipToken
-} from "@tanstack/react-query";
-function getQueryKeyInternal(path, input, type) {
-  let params;
-  let payload;
-  if (isObject(input)) {
-    if ("params" in input && input.params && typeof input.params === "object") {
-      params = input.params;
-    }
-    if ("payload" in input) {
-      payload = input.payload;
-    } else if (!("params" in input)) {
-      payload = input;
-    }
-  } else {
-    payload = input;
-  }
-  const splitPath = path.flatMap((part) => part.toString().split("/"));
-  if (!input && (!type || type === "any")) {
+function buildKey(opts) {
+  const { segments, request, type } = opts;
+  const splitPath = segments.flatMap((part) => part.split("."));
+  if (!request && type === "any") {
     return splitPath.length ? [splitPath] : [];
   }
+  if (type === "infinite" && isObject(request) && ("direction" in request || "cursor" in request)) {
+    const { cursor: _, direction: __, ...inputWithoutCursorAndDirection } = request;
+    return [splitPath, { request: inputWithoutCursorAndDirection, type: "infinite" }];
+  }
   return [
     splitPath,
     {
-      ...typeof payload !== "undefined" && payload !== skipToken && { payload },
-      ...typeof params !== "undefined" && { params },
+      ...typeof request !== "undefined" && request !== skipToken && { request },
       ...type && type !== "any" && { type }
     }
   ];
 }
+
+// src/query.ts
+import { queryOptions, skipToken as skipToken2 } from "@tanstack/react-query";
 function tuyauQueryOptions(options) {
-  const { input, opts, queryKey, path, client, globalOptions } = options;
-  const inputIsSkipToken = input === skipToken;
-  const queryFn = inputIsSkipToken ? skipToken : async (queryFnContext) => {
-    const { payload, requestPath } = extractInputAndPath(input, path);
-    const effectiveAbortOnUnmount = opts?.tuyau?.abortOnUnmount ?? globalOptions?.abortOnUnmount ?? false;
-    const actualOpts = {
-      ...opts,
-      tuyau: {
-        ...globalOptions,
-        ...opts?.tuyau,
-        ...effectiveAbortOnUnmount ? { signal: queryFnContext.signal } : { signal: null }
-      }
+  const { request, routeName, opts, queryKey, client, globalOptions } = options;
+  const queryFn = invoke(() => {
+    if (request === skipToken2) return skipToken2;
+    return async (queryFnContext) => {
+      const effectiveAbortOnUnmount = opts?.tuyau?.abortOnUnmount ?? globalOptions?.abortOnUnmount ?? false;
+      return await client.request(routeName, {
+        ...request,
+        ...effectiveAbortOnUnmount ? { signal: queryFnContext.signal } : {}
+      });
     };
-    return await client.$fetch({ paths: requestPath, input: payload, queryOptions: actualOpts });
-  };
-  return Object.assign(queryOptions({ ...opts, queryKey, queryFn }), {
-    tuyau: { path, type: "query" }
   });
-}
-function extractInputAndPath(input, path) {
-  if (typeof input !== "object" || input === null || !("payload" in input) && !("params" in input)) {
-    return { payload: input, requestPath: path };
-  }
-  const { payload, params } = input;
-  const requestPath = buildRequestPath(path, params);
-  return { payload, requestPath };
+  return queryOptions({ ...opts, queryKey, queryFn });
 }
 
 // src/infinite_query.ts
-import {
-  infiniteQueryOptions,
-  skipToken as skipToken2
-} from "@tanstack/react-query";
-function extractInfiniteInputAndPath(input, path, pageParamKey, pageParam) {
-  if (typeof input !== "object" || input === null || !("payload" in input) && !("params" in input)) {
-    const payload2 = typeof input === "object" && input !== null ? input : {};
-    const enhancedPayload2 = { ...payload2, [pageParamKey]: pageParam };
-    return { payload: enhancedPayload2, requestPath: path };
-  }
-  const { payload, params } = input;
-  const requestPath = buildRequestPath(path, params);
-  const enhancedPayload = { ...payload, [pageParamKey]: pageParam };
-  return { payload: enhancedPayload, requestPath };
-}
+import { infiniteQueryOptions, skipToken as skipToken3 } from "@tanstack/react-query";
 function tuyauInfiniteQueryOptions(options) {
-  const { input, opts, queryKey, path, client, globalOptions } = options;
-  const inputIsSkipToken = input === skipToken2;
-  if (!opts?.pageParamKey) {
-    throw new Error("pageParamKey is required for infinite queries");
-  }
-  const queryFn = inputIsSkipToken ? skipToken2 : async (queryFnContext) => {
-    const { payload, requestPath } = extractInfiniteInputAndPath(
-      input,
-      path,
-      opts.pageParamKey,
-      queryFnContext.pageParam
-    );
-    const effectiveAbortOnUnmount = opts?.tuyau?.abortOnUnmount ?? globalOptions?.abortOnUnmount ?? false;
-    const actualOpts = {
-      ...opts,
-      tuyau: {
-        ...globalOptions,
-        ...opts?.tuyau,
-        ...effectiveAbortOnUnmount ? { signal: queryFnContext.signal } : { signal: null }
+  const { request, routeName, opts, queryKey, client, globalOptions } = options;
+  const queryFn = invoke(() => {
+    if (request === skipToken3) return skipToken3;
+    return async (queryFnContext) => {
+      const { pageParam } = queryFnContext;
+      const effectiveAbortOnUnmount = opts?.tuyau?.abortOnUnmount ?? globalOptions?.abortOnUnmount ?? false;
+      const pageParamKey = opts?.pageParamKey || "page";
+      let requestArgs;
+      if (typeof request === "object" && request !== null) {
+        if (pageParam !== void 0) {
+          requestArgs = {
+            ...request,
+            query: { ...request.query, [pageParamKey]: pageParam }
+          };
+        } else {
+          requestArgs = request;
+        }
+      } else {
+        requestArgs = { query: pageParam !== void 0 ? { [pageParamKey]: pageParam } : {} };
       }
+      return await client.request(routeName, {
+        ...requestArgs,
+        ...effectiveAbortOnUnmount ? { signal: queryFnContext.signal } : {}
+      });
     };
-    return await client.$fetch({ paths: requestPath, input: payload, queryOptions: actualOpts });
-  };
-  return Object.assign(
-    infiniteQueryOptions({
-      ...opts,
-      queryKey,
-      queryFn,
-      initialPageParam: opts?.initialPageParam ?? null
-    }),
-    { tuyau: { path, type: "infinite" } }
-  );
+  });
+  return infiniteQueryOptions({
+    ...opts,
+    queryKey,
+    queryFn,
+    initialPageParam: opts?.initialPageParam ?? 1,
+    getNextPageParam: opts?.getNextPageParam ?? (() => null),
+    getPreviousPageParam: opts?.getPreviousPageParam
+  });
 }
 
 // src/mutation.ts
-import {
-  mutationOptions
-} from "@tanstack/react-query";
-function getMutationKeyInternal(path) {
-  const splitPath = path.flatMap((part) => part.toString().split("."));
-  return splitPath.length ? [splitPath] : [];
+import { mutationOptions } from "@tanstack/react-query";
+function getMutationKeyInternal(options) {
+  const key = [options.segments.flatMap((part) => part.split("."))];
+  return key;
 }
-function tuyauMutationOptions(args) {
-  const { opts, path, client, overrides } = args;
-  const queryClient = unwrapLazyArg(args.queryClient);
-  const mutationKey = getMutationKeyInternal(path);
-  const defaultOpts = queryClient.defaultMutationOptions(
-    queryClient.getMutationDefaults(mutationKey)
-  );
-  const mutationSuccessOverride = overrides?.onSuccess ?? ((options) => options.originalFn());
-  const mutationFn = async (input) => {
-    const requestPath = buildRequestPath(path, input.params);
-    return await client.$fetch({ paths: requestPath, input: input.payload });
+function tuyauMutationOptions(options) {
+  const { opts, routeName, client } = options;
+  const mutationKey = getMutationKeyInternal({ segments: routeName.split(".") });
+  const mutationFn = async (request) => {
+    const requestArgs = request || {};
+    return await client.request(routeName, requestArgs);
   };
-  const onSuccess = (data, variables, context) => {
-    const originalFn = () => {
-      if (opts?.onSuccess) return opts.onSuccess(data, variables, context);
-      if (defaultOpts?.onSuccess) return defaultOpts.onSuccess(data, variables, context);
-    };
-    return mutationSuccessOverride({
-      originalFn,
-      queryClient,
-      meta: opts?.meta ?? defaultOpts?.meta ?? {}
-    });
-  };
-  return Object.assign(mutationOptions({ ...opts, mutationKey, mutationFn, onSuccess }), {
-    tuyau: { path, type: "mutation" }
-  });
+  return mutationOptions({ ...opts, mutationKey, mutationFn });
 }
 
 // src/main.ts
-function createTuyauReactQueryClient(options) {
-  return createTuyauRecursiveProxy(({ args, executeIfRouteParamCall, paths, patternPaths }) => {
-    const fnName = paths.at(-1);
-    const path = paths.slice(0, -1);
-    const patternPath = patternPaths ? patternPaths.slice(0, -1) : path;
-    const [arg1, arg2] = args;
-    if (fnName === "queryOptions") {
-      return tuyauQueryOptions({
-        input: arg1,
-        opts: arg2 || {},
-        queryKey: getQueryKeyInternal(patternPath, arg1, "query"),
-        queryClient: unwrapLazyArg(options.queryClient),
-        client: options.client,
-        path,
-        globalOptions: options.globalOptions
-      });
-    }
-    if (fnName === "infiniteQueryOptions") {
-      return tuyauInfiniteQueryOptions({
-        input: arg1,
-        opts: arg2 || {},
-        queryKey: getQueryKeyInternal(patternPath, arg1, "infinite"),
-        queryClient: unwrapLazyArg(options.queryClient),
-        client: options.client,
-        path,
-        globalOptions: options.globalOptions
-      });
-    }
-    if (fnName === "queryKey") return getQueryKeyInternal(patternPath, arg1, "query");
-    if (fnName === "infiniteQueryKey") return getQueryKeyInternal(patternPath, arg1, "infinite");
-    if (fnName === "pathKey") return getQueryKeyInternal(patternPath);
-    if (fnName === "queryFilter") {
-      return { ...arg2, queryKey: getQueryKeyInternal(patternPath, arg1, "query") };
-    }
-    if (fnName === "infiniteQueryFilter") {
-      return { ...arg2, queryKey: getQueryKeyInternal(patternPath, arg1, "infinite") };
-    }
-    if (fnName === "pathFilter") {
-      return { ...arg1, queryKey: getQueryKeyInternal(patternPath) };
-    }
-    if (fnName === "mutationOptions") {
-      return tuyauMutationOptions({
-        path,
-        opts: arg1,
-        queryClient: unwrapLazyArg(options.queryClient),
-        client: options.client
-      });
-    }
-    if (fnName === "mutationKey") return getMutationKeyInternal(path);
-    const newProxy = executeIfRouteParamCall({ fnName, body: args[0] });
-    if (newProxy) return newProxy;
-    throw new Error(`Method ${fnName} not found on Tuyau client`);
-  });
+function toSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
 }
-
-// src/context.tsx
-import * as React from "react";
-function createTuyauContext() {
-  const TuyauClientContext = React.createContext(null);
-  const TuyauContext = React.createContext(null);
-  function TuyauProvider(props) {
-    const value = React.useMemo(
-      () => createTuyauReactQueryClient({
-        client: props.client,
-        queryClient: props.queryClient
+function segmentsToRouteName(segments) {
+  return segments.map(toSnakeCase).join(".");
+}
+function createTuyauReactQueryClient(options) {
+  const { client, globalOptions } = options;
+  function makeReactQueryNamed(segments) {
+    const routeName = segmentsToRouteName(segments);
+    const decoratedEndpoint = {
+      /**
+       * Queries
+       */
+      queryOptions: (request, opts) => {
+        return tuyauQueryOptions({
+          opts,
+          client,
+          request,
+          routeName,
+          globalOptions,
+          queryKey: buildKey({ segments, request, type: "query" })
+        });
+      },
+      queryKey: (request) => buildKey({ segments, request, type: "query" }),
+      queryFilter: (request, filters) => ({
+        queryKey: buildKey({ segments, request, type: "query" }),
+        ...filters
       }),
-      [props.client, props.queryClient]
-    );
-    return /* @__PURE__ */ React.createElement(TuyauClientContext.Provider, { value: props.client }, /* @__PURE__ */ React.createElement(TuyauContext.Provider, { value }, props.children));
-  }
-  function useTuyau() {
-    const utils = React.useContext(TuyauContext);
-    if (!utils) throw new Error("useTuyau() can only be used inside of a <TuyauProvider>");
-    return utils;
-  }
-  function useTuyauClient() {
-    const client = React.useContext(TuyauClientContext);
-    if (!client) throw new Error("useTuyauClient() can only be used inside of a <TuyauProvider>");
-    return client;
+      /**
+       * Infinite Queries
+       */
+      infiniteQueryOptions: (request, opts) => {
+        return tuyauInfiniteQueryOptions({
+          opts,
+          client,
+          request,
+          routeName,
+          globalOptions,
+          queryKey: buildKey({ segments, request, type: "infinite" })
+        });
+      },
+      infiniteQueryKey: (request) => buildKey({ segments, request, type: "infinite" }),
+      infiniteQueryFilter: (request, filters) => ({
+        queryKey: buildKey({ segments, request, type: "infinite" }),
+        ...filters
+      }),
+      /**
+       * Mutations
+       */
+      mutationOptions: (opts) => tuyauMutationOptions({ opts, client, routeName }),
+      mutationKey: () => getMutationKeyInternal({ segments }),
+      /**
+       * Paths
+       */
+      pathKey: () => buildKey({ segments, type: "any" }),
+      pathFilter: (filters) => ({
+        queryKey: buildKey({ segments, type: "any" }),
+        ...filters
+      })
+    };
+    return new Proxy(decoratedEndpoint, {
+      get: (target, prop) => {
+        if (prop in target) return target[prop];
+        return makeReactQueryNamed([...segments, String(prop)]);
+      }
+    });
   }
-  return { TuyauProvider, useTuyau, useTuyauClient };
+  return makeReactQueryNamed([]);
 }
 export {
-  createTuyauContext,
-  createTuyauReactQueryClient
+  createTuyauReactQueryClient,
+  getMutationKeyInternal,
+  tuyauMutationOptions,
+  tuyauQueryOptions
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuyau/react-query",
   "type": "module",
-  "version": "0.0.1-next.2",
+  "version": "1.0.0-beta.1",
   "description": "React Query plugin for Tuyau",
   "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "ISC",
@@ -13,23 +13,23 @@
   "files": [
     "build"
   ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "peerDependencies": {
     "@tanstack/react-query": "^5.74.7",
-    "@tuyau/client": "^0.2.11-next.0"
-  },
-  "dependencies": {
-    "@tuyau/utils": "0.0.9"
+    "@tuyau/core": "1.0.0-beta.2"
   },
   "devDependencies": {
-    "@adonisjs/core": "^6.19.0",
-    "@happy-dom/global-registrator": "^17.6.3",
-    "@tanstack/react-query": "^5.83.0",
+    "@adonisjs/core": "^7.0.0-next.10",
+    "@faker-js/faker": "^10.1.0",
+    "@happy-dom/global-registrator": "^20.0.10",
+    "@tanstack/react-query": "^5.90.7",
     "@testing-library/react": "^16.3.0",
-    "@types/react": "^19.1.8",
-    "@vinejs/vine": "^3.0.1",
-    "nock": "^14.0.6",
-    "react": "^19.1.0",
-    "@tuyau/client": "0.2.11-next.2"
+    "@types/react": "^19.2.2",
+    "@vinejs/vine": "^4.1.0",
+    "react": "^19.2.0",
+    "@tuyau/core": "1.0.0-beta.4"
   },
   "tsup": {
     "entry": [
@@ -43,14 +43,14 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "latest"
+    "tag": "beta"
   },
   "scripts": {
     "lint": "eslint .",
     "typecheck": "tsc --noEmit",
     "build": "tsup-node",
-    "test": "c8 node --enable-source-maps --loader ts-node/esm bin/test.ts",
-    "quick:test": "node --enable-source-maps --loader ts-node/esm bin/test.ts",
+    "test": "pnpm quick:test",
+    "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts --force-exit",
     "checks": "pnpm lint && pnpm typecheck"
   }
 }