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

package/build/index.d.ts

@@ -1,23 +1,24 @@
-import { AdonisEndpoint, RawRequestArgs, Method, UnionToIntersection, StrKeys, Split } from '@tuyau/core/types';
+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 { SkipToken, DataTag, QueryFilters, WithRequired as WithRequired$1, UseMutationOptions, InfiniteData, InfiniteQueryObserverOptions, DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions } from '@tanstack/react-query';
 import { Tuyau } from '@tuyau/core/client';
 
+type Response$2<E extends SchemaEndpoint> = E['types']['response'];
 /**
  * Decorate query endpoints with Tanstack queries abilities
  */
-interface DecorateQueryFn<EDef extends AdonisEndpoint> extends TypeHelper<EDef> {
+interface DecorateQueryFn<EDef extends SchemaEndpoint> {
     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'>;
+    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'>;
 }
 /**
  * Type definition for query options with overloads for different scenarios
  */
-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 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>;
 }
 
 /**
@@ -30,18 +31,19 @@ type DistributiveOmit<TObj, TKey extends keyof any> = TObj extends any ? Omit<TO
 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 AdonisEndpoint> {
-    <TContext = unknown>(opts?: TuyauMutationOptionsIn<RawRequestArgs<TDef>, any, TDef['types']['response'], TContext>): TuyauMutationOptionsOut<RawRequestArgs<TDef>, any, TDef['types']['response'], TContext>;
+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 AdonisEndpoint> extends TypeHelper<EDef> {
+interface DecorateMutationFn<EDef extends SchemaEndpoint> {
     mutationOptions: TuyauReactMutationOptions<EDef>;
     mutationKey: () => TuyauMutationKey;
 }
@@ -52,6 +54,7 @@ interface TuyauMutationOptionsOptions {
 }
 declare function tuyauMutationOptions(options: TuyauMutationOptionsOptions): _tanstack_react_query.WithRequired<UseMutationOptions<unknown, any, any, any>, "mutationKey">;
 
+type Response<E extends SchemaEndpoint> = E['types']['response'];
 /**
  * Infinite query options input type
  */
@@ -72,17 +75,17 @@ interface TuyauInfiniteQueryOptionsOut<TQueryFnData, TError, TData> extends Omit
 /**
  * Type definition for infinite query options
  */
-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>;
+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>;
 }
 /**
  * Decorate query endpoints with infinite query capabilities
  */
-interface DecorateInfiniteQueryFn<EDef extends AdonisEndpoint> extends TypeHelper<EDef> {
+interface DecorateInfiniteQueryFn<EDef extends SchemaEndpoint> {
     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'>;
+    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'>;
 }
 
 /**
@@ -155,34 +158,33 @@ interface DecorateRouterKeyable {
     pathKey: () => TuyauQueryKey;
     pathFilter: (filters?: QueryFilters<TuyauQueryKey>) => WithRequired<QueryFilters<TuyauQueryKey>, 'queryKey'>;
 }
-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 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>;
+/**
+ * Keys that identify an endpoint-like structure
+ */
+type EndpointKeys = 'methods' | 'pattern' | 'types';
+/**
+ * Determines if endpoint is a query (GET/HEAD) or mutation
+ */
+type IsQueryMethod<E extends SchemaEndpoint> = E['methods'][number] extends infer M ? M extends 'GET' | 'HEAD' ? true : false : false;
+/**
+ * Endpoint node with query or mutation decorators
+ * Optimized: uses direct conditional instead of nested extends
+ */
+type EndpointNode<E extends SchemaEndpoint> = (IsQueryMethod<E> extends true ? DecorateQueryFn<E> & DecorateInfiniteQueryFn<E> : DecorateMutationFn<E>) & DecorateRouterKeyable;
+/**
+ * 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
+ */
+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>;
 
-declare function createTuyauReactQueryClient<D extends Record<string, AdonisEndpoint>>(options: {
-    client: Tuyau<D>;
-    queryClient: QueryClient | (() => QueryClient);
+declare function createTuyauReactQueryClient<Reg extends TuyauRegistry, Tree = InferTree<Reg>, Routes extends Record<string, AdonisEndpoint> = InferRoutes<Reg>>(options: {
+    client: Tuyau<Reg, Routes>;
     globalOptions?: TuyauReactRequestOptions;
-}): TuyauReactQuery<D> & DecorateRouterKeyable;
+}): TransformToReactQuery<Tree>;
 
 interface TuyauQueryOptionsOptions {
     request: RawRequestArgs<any> | SkipToken;
@@ -201,4 +203,4 @@ declare function tuyauQueryOptions(options: TuyauQueryOptionsOptions): _tanstack
     };
 };
 
-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 };
+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

@@ -12,9 +12,23 @@ function buildKey(opts) {
   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" }];
+  if (type === "infinite" && isObject(request)) {
+    const query = request.query;
+    const body = request.body;
+    const hasCursorInQuery = isObject(query) && ("direction" in query || "cursor" in query);
+    const hasCursorInBody = isObject(body) && ("direction" in body || "cursor" in body);
+    if (hasCursorInQuery || hasCursorInBody) {
+      const cleanedRequest = { ...request };
+      if (hasCursorInQuery && isObject(query)) {
+        const { cursor: _, direction: __, ...cleanQuery } = query;
+        cleanedRequest.query = cleanQuery;
+      }
+      if (hasCursorInBody && isObject(body)) {
+        const { cursor: _, direction: __, ...cleanBody } = body;
+        cleanedRequest.body = cleanBody;
+      }
+      return [splitPath, { request: cleanedRequest, type: "infinite" }];
+    }
   }
   return [
     splitPath,
@@ -35,6 +49,7 @@ function tuyauQueryOptions(options) {
       const effectiveAbortOnUnmount = opts?.tuyau?.abortOnUnmount ?? globalOptions?.abortOnUnmount ?? false;
       return await client.request(routeName, {
         ...request,
+        retry: 0,
         ...effectiveAbortOnUnmount ? { signal: queryFnContext.signal } : {}
       });
     };
@@ -43,10 +58,7 @@ function tuyauQueryOptions(options) {
 }
 
 // src/infinite_query.ts
-import {
-  infiniteQueryOptions,
-  skipToken as skipToken3
-} from "@tanstack/react-query";
+import { infiniteQueryOptions, skipToken as skipToken3 } from "@tanstack/react-query";
 function tuyauInfiniteQueryOptions(options) {
   const { request, routeName, opts, queryKey, client, globalOptions } = options;
   const queryFn = invoke(() => {
@@ -70,6 +82,7 @@ function tuyauInfiniteQueryOptions(options) {
       }
       return await client.request(routeName, {
         ...requestArgs,
+        retry: 0,
         ...effectiveAbortOnUnmount ? { signal: queryFnContext.signal } : {}
       });
     };
@@ -95,14 +108,17 @@ function tuyauMutationOptions(options) {
   const mutationKey = getMutationKeyInternal({ segments: routeName.split(".") });
   const mutationFn = async (request) => {
     const requestArgs = request || {};
-    return await client.request(routeName, requestArgs);
+    return await client.request(routeName, { ...requestArgs, retry: 0 });
   };
   return mutationOptions({ ...opts, mutationKey, mutationFn });
 }
 
 // src/main.ts
+function toSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
 function segmentsToRouteName(segments) {
-  return segments.join(".");
+  return segments.map(toSnakeCase).join(".");
 }
 function createTuyauReactQueryClient(options) {
   const { client, globalOptions } = options;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuyau/react-query",
   "type": "module",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.2",
   "description": "React Query plugin for Tuyau",
   "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "ISC",
@@ -13,19 +13,23 @@
   "files": [
     "build"
   ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "peerDependencies": {
     "@tanstack/react-query": "^5.74.7",
     "@tuyau/core": "1.0.0-beta.2"
   },
   "devDependencies": {
-    "@adonisjs/core": "^7.0.0-next.10",
-    "@happy-dom/global-registrator": "^20.0.10",
-    "@tanstack/react-query": "^5.90.7",
+    "@adonisjs/core": "^7.0.0-next.13",
+    "@faker-js/faker": "^10.1.0",
+    "@happy-dom/global-registrator": "^20.0.11",
+    "@tanstack/react-query": "^5.90.12",
     "@testing-library/react": "^16.3.0",
-    "@types/react": "^19.2.2",
+    "@types/react": "^19.2.7",
     "@vinejs/vine": "^4.1.0",
-    "react": "^19.2.0",
-    "@tuyau/core": "1.0.0-beta.2"
+    "react": "^19.2.1",
+    "@tuyau/core": "1.0.0-beta.6"
   },
   "tsup": {
     "entry": [