@tuyau/react-query 0.0.1-next.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License
+
+Copyright (c) 2023
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/build/index.d.ts

@@ -0,0 +1,314 @@
+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';
+
+/**
+ * Type definition for query options with overloads for different scenarios
+ */
+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 for query function decorators (queryOptions, queryKey, queryFilter)
+ */
+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 for mutation function decorators
+ */
+interface DecorateMutationFn<EDef extends EndpointDef, TParams = Record<string, string | number>> extends TypeHelper<EDef> {
+    mutationOptions: TuyauReactMutationOptions<EDef, TParams>;
+    mutationKey: () => TuyauMutationKey;
+}
+/**
+ * Output type for mutation options
+ */
+interface TuyauMutationOptionsOut<TInput, TError, TOutput, TContext, TParams = Record<string, string | number>> extends UseMutationOptions<TOutput, TError, {
+    payload: TInput;
+    params?: TParams;
+}, TContext> {
+    mutationKey: TuyauMutationKey;
+}
+/**
+ * Type definition for mutation options with params and payload support
+ */
+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>;
+}
+
+/**
+ * Extract union type from successful HTTP status codes (200-299)
+ */
+type UnionFromSuccessStatuses<Res extends Record<number, unknown>> = Res[Extract<keyof Res, 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226>];
+/**
+ * Base endpoint definition structure
+ */
+type EndpointDef = {
+    request: Record<string, unknown>;
+    response: Record<number, unknown>;
+};
+/**
+ * Tuyau-specific query key structure
+ */
+type TuyauQueryKey = [
+    readonly string[],
+    {
+        payload?: unknown;
+        params?: unknown;
+        type?: 'infinite' | 'query';
+    }?
+];
+/**
+ * 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
+ */
+interface DefinedTuyauQueryOptionsIn<TQueryFnData, TData, TError> extends DistributiveOmit<DefinedInitialDataOptions<TQueryFnData, TError, TData, TuyauQueryKey>, 'queryKey' | 'queryFn' | 'queryHashFn' | 'queryHash'> {
+}
+/**
+ * Query options with undefined initial data
+ */
+interface UndefinedTuyauQueryOptionsIn<TQueryFnData, TData, TError> extends DistributiveOmit<UndefinedInitialDataOptions<TQueryFnData, TError, TData, TuyauQueryKey>, 'queryKey' | 'queryFn' | 'queryHashFn' | 'queryHash'> {
+}
+/**
+ * Query options with unused skip token
+ */
+interface UnusedSkipTokenTuyauQueryOptionsIn<TQueryFnData, TData, TError> extends DistributiveOmit<UnusedSkipTokenOptions<TQueryFnData, TError, TData, TuyauQueryKey>, 'queryKey' | 'queryFn' | 'queryHashFn' | 'queryHash'> {
+}
+/**
+ * Output type for query options with defined initial data
+ */
+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> {
+    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> {
+    queryKey: DataTag<TuyauQueryKey, TData, TError>;
+}
+/**
+ * Input type for mutation options with params and payload support
+ */
+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'];
+
+/**
+ * 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> extends DistributiveOmit<UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, unknown>, InfiniteQueryReservedOptions> {
+}
+/**
+ * Infinite query options with defined initial data
+ */
+interface DefinedTuyauInfiniteQueryOptionsIn<TQueryFnData, TData, TError> extends DistributiveOmit<DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, unknown>, InfiniteQueryReservedOptions> {
+}
+/**
+ * Infinite query options with unused skip token
+ */
+interface UnusedSkipTokenTuyauInfiniteQueryOptionsIn<TQueryFnData, TData, TError> extends DistributiveOmit<UnusedSkipTokenInfiniteOptions<TQueryFnData, TError, TuyauInfiniteData<TData>, TuyauQueryKey, unknown>, InfiniteQueryReservedOptions> {
+}
+/**
+ * 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';
+    };
+}
+/**
+ * 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 definition for infinite query options with overloads for different scenarios
+ */
+interface TuyauReactInfiniteQueryOptions<EDef extends EndpointDef, TParams = Record<string, string | number>> {
+    <TData = UnionFromSuccessStatuses<EDef['response']>>(input: {
+        payload?: EDef['request'];
+        params?: TParams;
+    } | SkipToken, opts: DefinedTuyauInfiniteQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any>): DefinedTuyauInfiniteQueryOptionsOut<UnionFromSuccessStatuses<EDef['response']>, TData, any>;
+    <TData = UnionFromSuccessStatuses<EDef['response']>>(input: {
+        payload?: EDef['request'];
+        params?: TParams;
+    }, opts: UnusedSkipTokenTuyauInfiniteQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any>): UnusedSkipTokenTuyauInfiniteQueryOptionsOut<UnionFromSuccessStatuses<EDef['response']>, TData, any>;
+    <TData = UnionFromSuccessStatuses<EDef['response']>>(input?: {
+        payload?: EDef['request'];
+        params?: TParams;
+    } | SkipToken, opts?: UndefinedTuyauInfiniteQueryOptionsIn<UnionFromSuccessStatuses<EDef['response']>, TData, any>): 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'>;
+}
+
+/**
+ * Create the Tuyau React Query client
+ */
+declare function createTuyauReactQueryClient<D extends Record<string, any>, R extends GeneratedRoutes>(options: {
+    client: TuyauClient<D, R>;
+    queryClient: QueryClient | (() => QueryClient);
+}): 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>>;
+};
+/**
+ * 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;
+
+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>;
+}
+/**
+ * Create a set of type-safe provider-consumers for Tuyau with React Query
+ */
+declare function createTuyauContext<API extends ApiDefinition>(): CreateTuyauContextResult<API>;
+
+export { type CreateTuyauContextResult, type InferRequestType, type InferResponseType, type TuyauReactInfiniteQueryOptions, type TuyauReactMutationOptions, type TuyauReactQuery, type TuyauReactQueryOptions, createTuyauContext, createTuyauReactQueryClient };

package/build/index.js

@@ -0,0 +1,249 @@
+// src/main.ts
+import {
+  createTuyauRecursiveProxy
+} from "@tuyau/client";
+
+// src/utils.ts
+function unwrapLazyArg(arg) {
+  return typeof arg === "function" ? arg() : arg;
+}
+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;
+}
+
+// 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")) {
+    return splitPath.length ? [splitPath] : [];
+  }
+  return [
+    splitPath,
+    {
+      ...typeof payload !== "undefined" && payload !== skipToken && { payload },
+      ...typeof params !== "undefined" && { params },
+      ...type && type !== "any" && { type }
+    }
+  ];
+}
+function tuyauQueryOptions(options) {
+  const { input, opts, queryKey, path, client } = options;
+  const inputIsSkipToken = input === skipToken;
+  const queryFn = inputIsSkipToken ? skipToken : async () => {
+    const { payload, requestPath } = extractInputAndPath(input, path);
+    return await client.$fetch({ paths: requestPath, input: payload });
+  };
+  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 };
+}
+
+// src/infinite_query.ts
+import {
+  infiniteQueryOptions,
+  skipToken as skipToken2
+} from "@tanstack/react-query";
+function extractInfiniteInputAndPath(input, path) {
+  if (typeof input !== "object" || input === null || !("payload" in input) && !("params" in input)) {
+    const payload2 = typeof input === "object" && input !== null ? input : {};
+    return { payload: payload2, requestPath: path };
+  }
+  const { payload, params } = input;
+  const requestPath = buildRequestPath(path, params);
+  return { payload, requestPath };
+}
+function tuyauInfiniteQueryOptions(options) {
+  const { input, opts, queryKey, path, client } = options;
+  const inputIsSkipToken = input === skipToken2;
+  const queryFn = inputIsSkipToken ? skipToken2 : async () => {
+    const { payload, requestPath } = extractInfiniteInputAndPath(input, path);
+    return await client.$fetch({ paths: requestPath, input: payload });
+  };
+  return Object.assign(
+    infiniteQueryOptions({
+      ...opts,
+      queryKey,
+      queryFn,
+      initialPageParam: opts?.initialPageParam ?? null
+    }),
+    { tuyau: { path, type: "infinite" } }
+  );
+}
+
+// src/mutation.ts
+function getMutationKeyInternal(path) {
+  const splitPath = path.flatMap((part) => part.toString().split("."));
+  return splitPath.length ? [splitPath] : [];
+}
+function createTuyauOptionsResult(opts) {
+  return {
+    path: opts.path,
+    type: "mutation"
+  };
+}
+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 });
+  };
+  return {
+    ...opts,
+    mutationKey,
+    mutationFn,
+    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 ?? {}
+      });
+    },
+    tuyau: createTuyauOptionsResult({ path })
+  };
+}
+
+// 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
+      });
+    }
+    if (fnName === "infiniteQueryOptions") {
+      return tuyauInfiniteQueryOptions({
+        input: arg1,
+        opts: arg2 || {},
+        queryKey: getQueryKeyInternal(patternPath, arg1, "infinite"),
+        queryClient: unwrapLazyArg(options.queryClient),
+        client: options.client,
+        path
+      });
+    }
+    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`);
+  });
+}
+
+// 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
+      }),
+      [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;
+  }
+  return { TuyauProvider, useTuyau, useTuyauClient };
+}
+export {
+  createTuyauContext,
+  createTuyauReactQueryClient
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@tuyau/react-query",
+  "type": "module",
+  "version": "0.0.1-next.0",
+  "description": "React Query plugin for Tuyau",
+  "author": "Julien Ripouteau <julien@ripouteau.com>",
+  "license": "ISC",
+  "keywords": [],
+  "exports": {
+    ".": "./build/index.js"
+  },
+  "main": "build/index.js",
+  "files": [
+    "build"
+  ],
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.74.7",
+    "@tuyau/client": "^0.2.11-next.0"
+  },
+  "dependencies": {
+    "@tuyau/utils": "0.0.9"
+  },
+  "devDependencies": {
+    "@adonisjs/core": "^6.18.0",
+    "@happy-dom/global-registrator": "^17.4.7",
+    "@tanstack/react-query": "^5.76.1",
+    "@testing-library/react": "^16.3.0",
+    "@types/react": "^19.1.4",
+    "@vinejs/vine": "^3.0.1",
+    "nock": "^14.0.4",
+    "react": "^19.1.0",
+    "@tuyau/client": "0.2.11-next.0"
+  },
+  "tsup": {
+    "entry": [
+      "./src/index.ts"
+    ],
+    "outDir": "./build",
+    "clean": true,
+    "format": "esm",
+    "dts": true,
+    "target": "esnext"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "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",
+    "checks": "pnpm lint && pnpm typecheck"
+  }
+}