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

package/build/index.d.ts

@@ -1,100 +1,108 @@
-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 { AdonisEndpoint, RawRequestArgs, Method, UnionToIntersection, StrKeys, Split } 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 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 AdonisEndpoint> extends TypeHelper<EDef> {
+    queryOptions: TuyauReactQueryOptions<EDef>;
+    queryKey: (args?: RawRequestArgs<EDef>) => DataTag<TuyauQueryKey, EDef['types']['response']>;
+    queryFilter: (args?: RawRequestArgs<EDef>, filters?: QueryFilters<DataTag<TuyauQueryKey, EDef['types']['response']>>) => WithRequired$1<QueryFilters<DataTag<TuyauQueryKey, EDef['types']['response']>>, '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 AdonisEndpoint> {
+    <TData = EDef['types']['response']>(input: RawRequestArgs<EDef> | SkipToken, opts: DefinedTuyauQueryOptionsIn<EDef['types']['response'], TData, unknown>): DefinedTuyauQueryOptionsOut<EDef['types']['response'], TData, unknown>;
+    <TData = EDef['types']['response']>(input: RawRequestArgs<EDef>, opts?: UnusedSkipTokenTuyauQueryOptionsIn<EDef['types']['response'], TData, unknown>): UnusedSkipTokenTuyauQueryOptionsOut<EDef['types']['response'], TData, unknown>;
+    <TData = EDef['types']['response']>(input?: RawRequestArgs<EDef> | SkipToken, opts?: UndefinedTuyauQueryOptionsIn<EDef['types']['response'], TData, unknown>): UndefinedTuyauQueryOptionsOut<EDef['types']['response'], 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';
+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 AdonisEndpoint> {
+    <TContext = unknown>(opts?: TuyauMutationOptionsIn<RawRequestArgs<TDef>, any, TDef['types']['response'], TContext>): TuyauMutationOptionsOut<RawRequestArgs<TDef>, any, TDef['types']['response'], TContext>;
+}
+declare function getMutationKeyInternal(options: {
+    segments: string[];
+}): TuyauMutationKey;
+interface DecorateMutationFn<EDef extends AdonisEndpoint> extends TypeHelper<EDef> {
+    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">;
+
 /**
- * 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 AdonisEndpoint> {
+    <TData = InfiniteData<EDef['types']['response']>>(input: RawRequestArgs<EDef> | SkipToken, opts: TuyauInfiniteQueryOptionsIn<EDef['types']['response'], unknown, TData>): TuyauInfiniteQueryOptionsOut<EDef['types']['response'], unknown, TData>;
+    <TData = InfiniteData<EDef['types']['response']>>(input?: RawRequestArgs<EDef> | SkipToken, opts?: TuyauInfiniteQueryOptionsIn<EDef['types']['response'], unknown, TData>): TuyauInfiniteQueryOptionsOut<EDef['types']['response'], 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 AdonisEndpoint> extends TypeHelper<EDef> {
+    infiniteQueryOptions: TuyauReactInfiniteQueryOptions<EDef>;
+    infiniteQueryKey: (args?: RawRequestArgs<EDef>) => DataTag<TuyauQueryKey, InfiniteData<EDef['types']['response']>>;
+    infiniteQueryFilter: (args?: RawRequestArgs<EDef>, filters?: QueryFilters<DataTag<TuyauQueryKey, InfiniteData<EDef['types']['response']>>>) => WithRequired$1<QueryFilters<DataTag<TuyauQueryKey, InfiniteData<EDef['types']['response']>>>, '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 +121,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 +149,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';
-    };
-}
-/**
- * Output type for infinite query options with defined initial data
- */
-interface DefinedTuyauInfiniteQueryOptionsOut<TQueryFnData, TData, TError> extends DefinedInitialDataInfiniteOptions<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 unused skip token
- */
-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 EndpointNode<E extends AdonisEndpoint> = E extends {
+    methods: readonly (infer M extends Method)[];
+} ? M extends 'GET' | 'HEAD' ? DecorateQueryFn<E> & DecorateInfiniteQueryFn<E> & DecorateRouterKeyable : DecorateMutationFn<E> & DecorateRouterKeyable : DecorateRouterKeyable;
+interface TypeHelper<EDef extends AdonisEndpoint> {
+    /**
+     * @internal
+     */
+    '~types': {
+        request: EDef['types']['body'];
+        response: EDef['types']['response'];
     };
 }
-/**
- * Type definition for infinite query options with overloads for different scenarios
- */
-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>;
-}
-/**
- * Interface for infinite query function decorators
- */
-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 SetAtPathWithKeyable<Path extends string[], V> = Path extends [
+    infer H extends string,
+    ...infer T extends string[]
+] ? {
+    [K in H]: T['length'] extends 0 ? V : SetAtPathWithKeyable<T, V> & DecorateRouterKeyable;
+} : {};
+type BuildNamespaces<R extends Record<string, AdonisEndpoint>> = UnionToIntersection<{
+    [K in StrKeys<R>]: SetAtPathWithKeyable<Split<K>, EndpointNode<R[K]>>;
+}[StrKeys<R>]> & DecorateRouterKeyable;
+type TuyauReactQuery<R extends Record<string, AdonisEndpoint>> = BuildNamespaces<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<D extends Record<string, AdonisEndpoint>>(options: {
+    client: Tuyau<D>;
     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;
+}): TuyauReactQuery<D> & DecorateRouterKeyable;
 
-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 TuyauMutationKey, type TuyauMutationOptionsIn, type TuyauMutationOptionsOptions, type TuyauMutationOptionsOut, type TuyauQueryBaseOptions, type TuyauQueryKey, type TuyauQueryOptionsOptions, type TuyauReactMutationOptions, type TuyauReactQuery, type TuyauReactRequestOptions, type TypeHelper, 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
+  skipToken as skipToken3
 } 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 };
-}
 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 segmentsToRouteName(segments) {
+  return segments.join(".");
 }
-
-// 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 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.0",
   "description": "React Query plugin for Tuyau",
   "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "ISC",
@@ -15,21 +15,17 @@
   ],
   "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",
+    "@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.2"
   },
   "tsup": {
     "entry": [
@@ -43,14 +39,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"
   }
 }