@tuyau/react-query 1.0.0 → 1.1.1

package/build/index.d.ts

@@ -1,62 +1,72 @@
-import { SchemaEndpoint, RawRequestArgs, BaseRequestOptions, TuyauRegistry, InferTree, AdonisEndpoint, InferRoutes } from '@tuyau/core/types';
+import { SchemaEndpoint, ResponseOf, RawRequestArgs, ErrorOf, 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, UnusedSkipTokenInfiniteOptions, DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, DefinedInitialDataOptions, UndefinedInitialDataOptions, UnusedSkipTokenOptions } from '@tanstack/react-query';
+import { SkipToken, DataTag, QueryFilters, UseMutationOptions, InfiniteData, UnusedSkipTokenInfiniteOptions, DefinedInitialDataInfiniteOptions, UndefinedInitialDataInfiniteOptions, DefinedInitialDataOptions, UnusedSkipTokenOptions, UndefinedInitialDataOptions } from '@tanstack/react-query';
+import { TuyauQueryKey, WithRequired, DistributiveOmit, TuyauQueryBaseOptions, TuyauMutationKey, TuyauRequestOptions, DecorateRouterKeyable, CreateQueryFnOptions } from '@tuyau/query-core';
+export { DecorateRouterKeyable, DistributiveOmit, QueryType, TuyauMutationKey, TuyauQueryBaseOptions, TuyauQueryKey, WithRequired } from '@tuyau/query-core';
 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 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'>;
+    queryKey: (args?: RawRequestArgs<EDef>) => DataTag<TuyauQueryKey, ResponseOf<EDef>>;
+    queryFilter: (args?: RawRequestArgs<EDef>, filters?: QueryFilters<DataTag<TuyauQueryKey, ResponseOf<EDef>>>) => WithRequired<QueryFilters<DataTag<TuyauQueryKey, ResponseOf<EDef>>>, 'queryKey'>;
 }
 /**
  * Type definition for query options with overloads for different scenarios
  */
 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>;
-    (): UnusedSkipTokenTuyauQueryOptionsOut<Response$2<EDef>, Response$2<EDef>, unknown>;
-    (input: SkipToken): UndefinedTuyauQueryOptionsOut<Response$2<EDef>, Response$2<EDef>, unknown>;
-    <TData = Response$2<EDef>>(input: RawRequestArgs<EDef> | SkipToken, opts?: UndefinedTuyauQueryOptionsIn<Response$2<EDef>, TData, unknown>): UndefinedTuyauQueryOptionsOut<Response$2<EDef>, TData, unknown>;
+    <TData = ResponseOf<EDef>>(input: RawRequestArgs<EDef> | SkipToken, opts: DefinedTuyauQueryOptionsIn<ResponseOf<EDef>, TData, ErrorOf<EDef>>): DefinedTuyauQueryOptionsOut<ResponseOf<EDef>, TData, ErrorOf<EDef>>;
+    <TData = ResponseOf<EDef>>(input: RawRequestArgs<EDef>, opts?: UnusedSkipTokenTuyauQueryOptionsIn<ResponseOf<EDef>, TData, ErrorOf<EDef>>): UnusedSkipTokenTuyauQueryOptionsOut<ResponseOf<EDef>, TData, ErrorOf<EDef>>;
+    (): UnusedSkipTokenTuyauQueryOptionsOut<ResponseOf<EDef>, ResponseOf<EDef>, ErrorOf<EDef>>;
+    (input: SkipToken): UndefinedTuyauQueryOptionsOut<ResponseOf<EDef>, ResponseOf<EDef>, ErrorOf<EDef>>;
+    <TData = ResponseOf<EDef>>(input: RawRequestArgs<EDef> | SkipToken, opts?: UndefinedTuyauQueryOptionsIn<ResponseOf<EDef>, TData, ErrorOf<EDef>>): UndefinedTuyauQueryOptionsOut<ResponseOf<EDef>, TData, ErrorOf<EDef>>;
 }
 
+type ReservedOptions = 'mutationKey' | 'mutationFn';
 /**
- * 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
+ * User-facing mutation options input. Extends TanStack's mutation observer
+ * options but omits `mutationKey` and `mutationFn` which are auto-generated
  */
-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 {
 }
+/**
+ * Fully resolved mutation options ready to be passed to `useMutation`.
+ * Includes the auto-generated `mutationKey` and `mutationFn`
+ */
 interface TuyauMutationOptionsOut<TInput, TError, TOutput, TContext> extends UseMutationOptions<TOutput, TError, TInput, TContext> {
     mutationKey: TuyauMutationKey;
 }
+/**
+ * Callable interface exposed on mutation endpoints.
+ * Returns fully resolved mutation options from user-provided options
+ */
 interface TuyauReactMutationOptions<TDef extends SchemaEndpoint> {
-    <TContext = unknown>(opts?: TuyauMutationOptionsIn<RawRequestArgs<TDef>, any, Response$1<TDef>, TContext>): TuyauMutationOptionsOut<RawRequestArgs<TDef>, any, Response$1<TDef>, TContext>;
+    <TContext = unknown>(opts?: TuyauMutationOptionsIn<RawRequestArgs<TDef>, ErrorOf<TDef>, ResponseOf<TDef>, TContext>): TuyauMutationOptionsOut<RawRequestArgs<TDef>, ErrorOf<TDef>, ResponseOf<TDef>, TContext>;
 }
-declare function getMutationKeyInternal(options: {
-    segments: string[];
-}): TuyauMutationKey;
+/**
+ * Decorates mutation endpoints with `mutationOptions` and `mutationKey` methods
+ */
 interface DecorateMutationFn<EDef extends SchemaEndpoint> {
     mutationOptions: TuyauReactMutationOptions<EDef>;
     mutationKey: () => TuyauMutationKey;
 }
+/**
+ * Internal options for building a mutation options object
+ */
 interface TuyauMutationOptionsOptions {
     opts?: TuyauMutationOptionsIn<any, any, any, any>;
     routeName: string;
     client: Tuyau<any>;
+    globalOptions?: TuyauRequestOptions;
 }
-declare function tuyauMutationOptions(options: TuyauMutationOptionsOptions): _tanstack_react_query.WithRequired<UseMutationOptions<unknown, any, any, any>, "mutationKey">;
+/**
+ * Builds a TanStack React Query `mutationOptions` object from Tuyau route information.
+ * Delegates mutationFn creation to the shared `createMutationFn` from `@tuyau/query-core`
+ */
+declare function tuyauMutationOptions(options: TuyauMutationOptionsOptions): _tanstack_react_query.WithRequired<UseMutationOptions<any, any, any, any>, "mutationKey">;
 
-type Response<E extends SchemaEndpoint> = E['types']['response'];
 type ReservedInfiniteQueryOptions = 'queryKey' | 'queryFn' | 'queryHashFn' | 'queryHash';
 /**
  * Base infinite query options with Tuyau-specific options
@@ -111,47 +121,29 @@ interface TuyauReactInfiniteQueryOptions<EDef extends SchemaEndpoint> {
     /**
      * Overload 1: When input is NOT SkipToken, return options compatible with useSuspenseInfiniteQuery
      */
-    <TData = InfiniteData<Response<EDef>>>(input: RawRequestArgs<EDef>, opts: UnusedSkipTokenTuyauInfiniteQueryOptionsIn<Response<EDef>, unknown, TData>): UnusedSkipTokenTuyauInfiniteQueryOptionsOut<Response<EDef>, unknown, TData>;
+    <TData = InfiniteData<ResponseOf<EDef>>>(input: RawRequestArgs<EDef>, opts: UnusedSkipTokenTuyauInfiniteQueryOptionsIn<ResponseOf<EDef>, ErrorOf<EDef>, TData>): UnusedSkipTokenTuyauInfiniteQueryOptionsOut<ResponseOf<EDef>, ErrorOf<EDef>, TData>;
     /**
      * Overload 2: When initialData is defined
      */
-    <TData = InfiniteData<Response<EDef>>>(input: RawRequestArgs<EDef> | SkipToken, opts: DefinedTuyauInfiniteQueryOptionsIn<Response<EDef>, unknown, TData>): DefinedTuyauInfiniteQueryOptionsOut<Response<EDef>, unknown, TData>;
+    <TData = InfiniteData<ResponseOf<EDef>>>(input: RawRequestArgs<EDef> | SkipToken, opts: DefinedTuyauInfiniteQueryOptionsIn<ResponseOf<EDef>, ErrorOf<EDef>, TData>): DefinedTuyauInfiniteQueryOptionsOut<ResponseOf<EDef>, ErrorOf<EDef>, TData>;
     /**
      * Overload 3: No arguments - no skipToken possible
      */
-    (): UnusedSkipTokenTuyauInfiniteQueryOptionsOut<Response<EDef>, unknown, InfiniteData<Response<EDef>>>;
+    (): UnusedSkipTokenTuyauInfiniteQueryOptionsOut<ResponseOf<EDef>, ErrorOf<EDef>, InfiniteData<ResponseOf<EDef>>>;
     /**
      * Overload 4: With skipToken or conditional (request | skipToken) and options
      */
-    <TData = InfiniteData<Response<EDef>>>(input: RawRequestArgs<EDef> | SkipToken, opts: UndefinedTuyauInfiniteQueryOptionsIn<Response<EDef>, unknown, TData>): UndefinedTuyauInfiniteQueryOptionsOut<Response<EDef>, unknown, TData>;
+    <TData = InfiniteData<ResponseOf<EDef>>>(input: RawRequestArgs<EDef> | SkipToken, opts: UndefinedTuyauInfiniteQueryOptionsIn<ResponseOf<EDef>, ErrorOf<EDef>, TData>): UndefinedTuyauInfiniteQueryOptionsOut<ResponseOf<EDef>, ErrorOf<EDef>, TData>;
 }
 /**
  * Decorate query endpoints with infinite query capabilities
  */
 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'>;
+    infiniteQueryKey: (args?: RawRequestArgs<EDef>) => DataTag<TuyauQueryKey, InfiniteData<ResponseOf<EDef>>>;
+    infiniteQueryFilter: (args?: RawRequestArgs<EDef>, filters?: QueryFilters<DataTag<TuyauQueryKey, InfiniteData<ResponseOf<EDef>>>>) => WithRequired<QueryFilters<DataTag<TuyauQueryKey, InfiniteData<ResponseOf<EDef>>>>, 'queryKey'>;
 }
 
-/**
- * Query type identifier
- */
-type QueryType = 'any' | 'infinite' | 'query';
-/**
- * Tuyau-specific query key structure
- */
-type TuyauQueryKey = [
-    readonly string[],
-    {
-        request?: RawRequestArgs<any>;
-        type?: Exclude<QueryType, 'any'>;
-    }?
-];
-/**
- * Tuyau-specific mutation key structure
- */
-type TuyauMutationKey = [readonly string[]];
 /**
  * Query options with defined initial data
  */
@@ -186,30 +178,9 @@ interface UnusedSkipTokenTuyauQueryOptionsOut<TQueryFnData, TData, TError> exten
     queryKey: DataTag<TuyauQueryKey, TData, TError>;
 }
 /**
- * Tuyau-specific request options for React Query integration
- */
-interface TuyauReactRequestOptions extends BaseRequestOptions {
-    /**
-     * Opt out or into aborting request on unmount
-     */
-    abortOnUnmount?: boolean;
-}
-/**
- * Base options for Tuyau queries and mutations
- */
-interface TuyauQueryBaseOptions {
-    /**
-     * Tuyau-specific options including Ky request options (timeout, retry, headers, etc.)
-     */
-    tuyau?: TuyauReactRequestOptions;
-}
-interface DecorateRouterKeyable {
-    pathKey: () => TuyauQueryKey;
-    pathFilter: (filters?: QueryFilters<TuyauQueryKey>) => WithRequired<QueryFilters<TuyauQueryKey>, 'queryKey'>;
-}
-/**
- * Keys that identify an endpoint-like structure
+ * Alias for backward compatibility with existing consumers
  */
+type TuyauReactRequestOptions = TuyauRequestOptions;
 type EndpointKeys = 'methods' | 'pattern' | 'types';
 /**
  * Determines if endpoint is a query (GET/HEAD) or mutation
@@ -230,26 +201,30 @@ type TransformToReactQuery<T> = {
 } & DecorateRouterKeyable;
 type TuyauReactQuery<R extends Record<string, SchemaEndpoint>> = TransformToReactQuery<R>;
 
+/**
+ * Creates a type-safe TanStack React Query client from a Tuyau client instance.
+ * Returns a Proxy-based object that mirrors the API route tree and exposes
+ * `queryOptions`, `mutationOptions`, `infiniteQueryOptions`, and key/filter
+ * helpers on each endpoint node
+ */
 declare function createTuyauReactQueryClient<Reg extends TuyauRegistry, Tree = InferTree<Reg>, Routes extends Record<string, AdonisEndpoint> = InferRoutes<Reg>>(options: {
     client: Tuyau<Reg, Routes>;
     globalOptions?: TuyauReactRequestOptions;
 }): TransformToReactQuery<Tree>;
 
-interface TuyauQueryOptionsOptions {
-    request: RawRequestArgs<any> | SkipToken;
-    opts?: TuyauQueryBaseOptions;
+/**
+ * Internal options for building a TanStack Query options object
+ */
+type TuyauQueryOptionsOptions = CreateQueryFnOptions & {
     queryKey: TuyauQueryKey;
-    routeName: string;
-    client: Tuyau<any>;
-    globalOptions?: TuyauReactRequestOptions;
-}
+};
+/**
+ * Builds a TanStack React Query `queryOptions` object from Tuyau route information.
+ * Delegates queryFn creation to the shared `createQueryFn` from `@tuyau/query-core`
+ */
 declare function tuyauQueryOptions(options: TuyauQueryOptionsOptions): _tanstack_react_query.UseQueryOptions<any, Error, any, readonly unknown[]> & {
     initialData?: any;
-} & {
-    queryKey: readonly unknown[] & {
-        [dataTagSymbol]: any;
-        [dataTagErrorSymbol]: Error;
-    };
-};
+} & _tanstack_react_query.QueryKeyWithDataTag<readonly unknown[], any, Error>;
 
-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 };
+export { createTuyauReactQueryClient, tuyauMutationOptions, tuyauQueryOptions };
+export type { DecorateMutationFn, DefinedTuyauQueryOptionsIn, DefinedTuyauQueryOptionsOut, EndpointNode, TransformToReactQuery, TuyauMutationOptionsIn, TuyauMutationOptionsOptions, TuyauMutationOptionsOut, TuyauQueryOptionsOptions, TuyauReactMutationOptions, TuyauReactQuery, TuyauReactRequestOptions, UndefinedTuyauQueryOptionsIn, UndefinedTuyauQueryOptionsOut, UnusedSkipTokenTuyauQueryOptionsIn, UnusedSkipTokenTuyauQueryOptionsOut };

package/build/index.js

@@ -1,101 +1,21 @@
-// src/utils.ts
-import { skipToken } from "@tanstack/react-query";
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function invoke(fn) {
-  return fn?.();
-}
-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)) {
-    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,
-    {
-      ...typeof request !== "undefined" && request !== skipToken && { request },
-      ...type && type !== "any" && { type }
-    }
-  ];
-}
-function extractKyOptions(tuyauOpts) {
-  if (!tuyauOpts) return {};
-  const { abortOnUnmount, ...kyOptions } = tuyauOpts;
-  return kyOptions;
-}
+// src/main.ts
+import { buildKey, segmentsToRouteName, getMutationKeyInternal as getMutationKeyInternal2 } from "@tuyau/query-core";
 
 // src/query.ts
-import { queryOptions, skipToken as skipToken2 } from "@tanstack/react-query";
+import { queryOptions } from "@tanstack/react-query";
+import { createQueryFn } from "@tuyau/query-core";
 function tuyauQueryOptions(options) {
-  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;
-      const kyOptions = extractKyOptions(opts?.tuyau);
-      return await client.request(routeName, {
-        ...request,
-        ...kyOptions,
-        retry: 0,
-        ...effectiveAbortOnUnmount ? { signal: queryFnContext.signal } : {}
-      });
-    };
-  });
-  return queryOptions({ ...opts, queryKey, queryFn });
+  const { queryKey, ...fnOptions } = options;
+  const queryFn = createQueryFn(fnOptions);
+  return queryOptions({ ...options.opts, queryKey, queryFn });
 }
 
 // src/infinite_query.ts
-import { infiniteQueryOptions, skipToken as skipToken3 } from "@tanstack/react-query";
+import { infiniteQueryOptions } from "@tanstack/react-query";
+import { createInfiniteQueryFn } from "@tuyau/query-core";
 function tuyauInfiniteQueryOptions(options) {
   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 kyOptions = extractKyOptions(opts?.tuyau);
-      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,
-        ...kyOptions,
-        retry: 0,
-        ...effectiveAbortOnUnmount ? { signal: queryFnContext.signal } : {}
-      });
-    };
-  });
+  const queryFn = createInfiniteQueryFn({ request, routeName, opts, client, globalOptions });
   return infiniteQueryOptions({
     ...opts,
     queryKey,
@@ -108,28 +28,15 @@ function tuyauInfiniteQueryOptions(options) {
 
 // src/mutation.ts
 import { mutationOptions } from "@tanstack/react-query";
-function getMutationKeyInternal(options) {
-  const key = [options.segments.flatMap((part) => part.split("."))];
-  return key;
-}
+import { getMutationKeyInternal, createMutationFn } from "@tuyau/query-core";
 function tuyauMutationOptions(options) {
-  const { opts, routeName, client } = options;
+  const { opts, routeName, client, globalOptions } = options;
   const mutationKey = getMutationKeyInternal({ segments: routeName.split(".") });
-  const kyOptions = extractKyOptions(opts?.tuyau);
-  const mutationFn = async (request) => {
-    const requestArgs = request || {};
-    return await client.request(routeName, { ...requestArgs, ...kyOptions, retry: 0 });
-  };
+  const mutationFn = createMutationFn({ opts, routeName, client, globalOptions });
   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.map(toSnakeCase).join(".");
-}
 function createTuyauReactQueryClient(options) {
   const { client, globalOptions } = options;
   function makeReactQueryNamed(segments) {
@@ -174,8 +81,8 @@ function createTuyauReactQueryClient(options) {
       /**
        * Mutations
        */
-      mutationOptions: (opts) => tuyauMutationOptions({ opts, client, routeName }),
-      mutationKey: () => getMutationKeyInternal({ segments }),
+      mutationOptions: (opts) => tuyauMutationOptions({ opts, client, routeName, globalOptions }),
+      mutationKey: () => getMutationKeyInternal2({ segments }),
       /**
        * Paths
        */
@@ -187,6 +94,7 @@ function createTuyauReactQueryClient(options) {
     };
     return new Proxy(decoratedEndpoint, {
       get: (target, prop) => {
+        if (typeof prop === "symbol") return void 0;
         if (prop in target) return target[prop];
         return makeReactQueryNamed([...segments, String(prop)]);
       }
@@ -196,7 +104,6 @@ function createTuyauReactQueryClient(options) {
 }
 export {
   createTuyauReactQueryClient,
-  getMutationKeyInternal,
   tuyauMutationOptions,
   tuyauQueryOptions
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuyau/react-query",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Tanstack Query integration for Tuyau",
   "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "MIT",
@@ -32,20 +32,24 @@
   "engines": {
     "node": ">=24.0.0"
   },
+  "dependencies": {
+    "@tuyau/query-core": "1.1.1"
+  },
   "peerDependencies": {
     "@tanstack/react-query": "^5.74.7",
     "@tuyau/core": "^1.0.0-beta.9"
   },
   "devDependencies": {
-    "@adonisjs/core": "^7.0.0-next.16",
-    "@faker-js/faker": "^10.1.0",
-    "@happy-dom/global-registrator": "^20.0.11",
-    "@tanstack/react-query": "^5.90.14",
-    "@testing-library/react": "^16.3.1",
-    "@types/react": "^19.2.7",
-    "@vinejs/vine": "^4.2.0",
-    "react": "^19.2.3",
-    "@tuyau/core": "1.0.0"
+    "@adonisjs/core": "^7.6.0",
+    "@faker-js/faker": "^10.6.0",
+    "@happy-dom/global-registrator": "^21.0.1",
+    "@tanstack/react-query": "^5.104.3",
+    "@testing-library/react": "^16.3.3",
+    "@types/react": "^19.3.0",
+    "@vinejs/vine": "^4.4.0",
+    "nock": "^15.0.1",
+    "react": "^19.3.1",
+    "@tuyau/core": "1.2.3"
   },
   "tsup": {
     "entry": [
@@ -59,10 +63,10 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "beta"
+    "tag": "latest"
   },
   "scripts": {
-    "lint": "eslint .",
+    "lint": "oxlint .",
     "typecheck": "tsc --noEmit",
     "build": "tsup-node",
     "test": "pnpm quick:test",