@zenstackhq/tanstack-query 3.0.0-beta.17 → 3.0.0-beta.19

package/src/react.ts

@@ -36,7 +36,9 @@ import type {
     GroupByArgs,
     GroupByResult,
     ModelResult,
+    SelectIncludeOmit,
     SelectSubset,
+    Subset,
     UpdateArgs,
     UpdateManyAndReturnArgs,
     UpdateManyArgs,
@@ -55,6 +57,7 @@ import {
     type ExtraMutationOptions,
     type ExtraQueryOptions,
 } from './utils/common';
+import type { TrimDelegateModelOperations, WithOptimistic } from './utils/types';
 
 export type { FetchFn } from './utils/common';
 
@@ -79,7 +82,7 @@ export const QuerySettingsProvider = QuerySettingsContext.Provider;
 /**
  * React context provider for configuring query settings.
  *
- * @deprecated Use `QuerySettingsProvider` instead.
+ * @deprecated Use {@link QuerySettingsProvider} instead.
  */
 export const Provider = QuerySettingsProvider;
 
@@ -90,12 +93,14 @@ function useHooksContext() {
 
 export type ModelQueryOptions<T> = Omit<UseQueryOptions<T, DefaultError>, 'queryKey'> & ExtraQueryOptions;
 
-export type ModelQueryResult<T> = UseQueryResult<T, DefaultError> & { queryKey: QueryKey };
+export type ModelQueryResult<T> = UseQueryResult<WithOptimistic<T>, DefaultError> & { queryKey: QueryKey };
 
 export type ModelSuspenseQueryOptions<T> = Omit<UseSuspenseQueryOptions<T, DefaultError>, 'queryKey'> &
     ExtraQueryOptions;
 
-export type ModelSuspenseQueryResult<T> = UseSuspenseQueryResult<T, DefaultError> & { queryKey: QueryKey };
+export type ModelSuspenseQueryResult<T> = UseSuspenseQueryResult<WithOptimistic<T>, DefaultError> & {
+    queryKey: QueryKey;
+};
 
 export type ModelInfiniteQueryOptions<T> = Omit<
     UseInfiniteQueryOptions<T, DefaultError, InfiniteData<T>>,
@@ -118,120 +123,144 @@ export type ModelMutationOptions<T, TArgs> = Omit<UseMutationOptions<T, DefaultE
 
 export type ModelMutationResult<T, TArgs> = UseMutationResult<T, DefaultError, TArgs>;
 
-export type SchemaHooks<Schema extends SchemaDef> = {
-    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
-};
-
-export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = {
-    useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-        args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(
-        args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
-        options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useFindFirst<T extends FindArgs<Schema, Model, false>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useSuspenseFindFirst<T extends FindArgs<Schema, Model, false>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
-        options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>,
-    ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
-
-    useFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
-
-    useSuspenseFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T>[]>;
-
-    useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
-
-    useSuspenseInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
-        args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
-        options?: ModelSuspenseInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
-    ): ModelSuspenseInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
-
-    useCreate<T extends CreateArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useCreateMany<T extends CreateManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
-
-    useUpdate<T extends UpdateArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>[], T>;
-
-    useUpsert<T extends UpsertArgs<Schema, Model>>(
-        options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useDelete<T extends DeleteArgs<Schema, Model>>(
+export type ModelMutationModelResult<
+    Schema extends SchemaDef,
+    Model extends GetModels<Schema>,
+    TArgs extends SelectIncludeOmit<Schema, Model, boolean>,
+    Array extends boolean = false,
+> = Omit<ModelMutationResult<ModelResult<Schema, Model, TArgs>, TArgs>, 'mutateAsync'> & {
+    mutateAsync<T extends TArgs>(
+        args: T,
         options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
-    ): ModelMutationResult<ModelResult<Schema, Model, T>, T>;
-
-    useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
-        options?: ModelMutationOptions<BatchResult, T>,
-    ): ModelMutationResult<BatchResult, T>;
-
-    useCount<T extends CountArgs<Schema, Model>>(
-        options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
-    ): ModelQueryResult<CountResult<Schema, Model, T>>;
-
-    useSuspenseCount<T extends CountArgs<Schema, Model>>(
-        options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
-    ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
-
-    useAggregate<T extends AggregateArgs<Schema, Model>>(
-        options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
-    ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
-
-    useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
-        options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
-    ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
-
-    useGroupBy<T extends GroupByArgs<Schema, Model>>(
-        options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
-    ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
+    ): Promise<Array extends true ? ModelResult<Schema, Model, T>[] : ModelResult<Schema, Model, T>>;
+};
 
-    useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
-        options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
-    ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
+export type ClientHooks<Schema extends SchemaDef> = {
+    [Model in GetModels<Schema> as `${Uncapitalize<Model>}`]: ModelQueryHooks<Schema, Model>;
 };
 
+// Note that we can potentially use TypeScript's mapped type to directly map from ORM contract, but that seems
+// to significantly slow down tsc performance ...
+export type ModelQueryHooks<Schema extends SchemaDef, Model extends GetModels<Schema>> = TrimDelegateModelOperations<
+    Schema,
+    Model,
+    {
+        useFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useSuspenseFindUnique<T extends FindUniqueArgs<Schema, Model>>(
+            args: SelectSubset<T, FindUniqueArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindFirst<T extends FindArgs<Schema, Model, false>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useSuspenseFindFirst<T extends FindArgs<Schema, Model, false>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, false>>,
+            options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T> | null>,
+        ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T> | null>;
+
+        useFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelQueryResult<ModelResult<Schema, Model, T>[]>;
+
+        useSuspenseFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelSuspenseQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelSuspenseQueryResult<ModelResult<Schema, Model, T>[]>;
+
+        useInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+
+        useSuspenseInfiniteFindMany<T extends FindArgs<Schema, Model, true>>(
+            args?: SelectSubset<T, FindArgs<Schema, Model, true>>,
+            options?: ModelSuspenseInfiniteQueryOptions<ModelResult<Schema, Model, T>[]>,
+        ): ModelSuspenseInfiniteQueryResult<InfiniteData<ModelResult<Schema, Model, T>[]>>;
+
+        useCreate<T extends CreateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useCreateMany<T extends CreateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCreateManyAndReturn<T extends CreateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpdate<T extends UpdateArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useUpdateMany<T extends UpdateManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useUpdateManyAndReturn<T extends UpdateManyAndReturnArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>[], T>,
+        ): ModelMutationModelResult<Schema, Model, T, true>;
+
+        useUpsert<T extends UpsertArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDelete<T extends DeleteArgs<Schema, Model>>(
+            options?: ModelMutationOptions<ModelResult<Schema, Model, T>, T>,
+        ): ModelMutationModelResult<Schema, Model, T>;
+
+        useDeleteMany<T extends DeleteManyArgs<Schema, Model>>(
+            options?: ModelMutationOptions<BatchResult, T>,
+        ): ModelMutationResult<BatchResult, T>;
+
+        useCount<T extends CountArgs<Schema, Model>>(
+            args?: Subset<T, CountArgs<Schema, Model>>,
+            options?: ModelQueryOptions<CountResult<Schema, Model, T>>,
+        ): ModelQueryResult<CountResult<Schema, Model, T>>;
+
+        useSuspenseCount<T extends CountArgs<Schema, Model>>(
+            args?: Subset<T, CountArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<CountResult<Schema, Model, T>>,
+        ): ModelSuspenseQueryResult<CountResult<Schema, Model, T>>;
+
+        useAggregate<T extends AggregateArgs<Schema, Model>>(
+            args: Subset<T, AggregateArgs<Schema, Model>>,
+            options?: ModelQueryOptions<AggregateResult<Schema, Model, T>>,
+        ): ModelQueryResult<AggregateResult<Schema, Model, T>>;
+
+        useSuspenseAggregate<T extends AggregateArgs<Schema, Model>>(
+            args: Subset<T, AggregateArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<AggregateResult<Schema, Model, T>>,
+        ): ModelSuspenseQueryResult<AggregateResult<Schema, Model, T>>;
+
+        useGroupBy<T extends GroupByArgs<Schema, Model>>(
+            args: Subset<T, GroupByArgs<Schema, Model>>,
+            options?: ModelQueryOptions<GroupByResult<Schema, Model, T>>,
+        ): ModelQueryResult<GroupByResult<Schema, Model, T>>;
+
+        useSuspenseGroupBy<T extends GroupByArgs<Schema, Model>>(
+            args: Subset<T, GroupByArgs<Schema, Model>>,
+            options?: ModelSuspenseQueryOptions<GroupByResult<Schema, Model, T>>,
+        ): ModelSuspenseQueryResult<GroupByResult<Schema, Model, T>>;
+    }
+>;
+
 /**
  * Gets data query hooks for all models in the schema.
  */
-export function useClientQueries<Schema extends SchemaDef>(schema: Schema): SchemaHooks<Schema> {
+export function useClientQueries<Schema extends SchemaDef>(schema: Schema): ClientHooks<Schema> {
     return Object.keys(schema.models).reduce((acc, model) => {
         (acc as any)[lowerCaseFirst(model)] = useModelQueries(schema, model as GetModels<Schema>);
         return acc;
-    }, {} as SchemaHooks<Schema>);
+    }, {} as ClientHooks<Schema>);
 }
 
 /**
@@ -282,63 +311,63 @@ export function useModelQueries<Schema extends SchemaDef, Model extends GetModel
         },
 
         useCreate: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'create', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'create', options);
         },
 
         useCreateMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'createMany', options, false);
+            return useInternalMutation(schema, modelName, 'POST', 'createMany', options);
         },
 
         useCreateManyAndReturn: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'createManyAndReturn', options);
         },
 
         useUpdate: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'update', options, true);
+            return useInternalMutation(schema, modelName, 'PUT', 'update', options);
         },
 
         useUpdateMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options, false);
+            return useInternalMutation(schema, modelName, 'PUT', 'updateMany', options);
         },
 
         useUpdateManyAndReturn: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options, true);
+            return useInternalMutation(schema, modelName, 'PUT', 'updateManyAndReturn', options);
         },
 
         useUpsert: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'POST', 'upsert', options, true);
+            return useInternalMutation(schema, modelName, 'POST', 'upsert', options);
         },
 
         useDelete: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options, true);
+            return useInternalMutation(schema, modelName, 'DELETE', 'delete', options);
         },
 
         useDeleteMany: (options?: any) => {
-            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options, false);
+            return useInternalMutation(schema, modelName, 'DELETE', 'deleteMany', options);
         },
 
-        useCount: (options?: any) => {
-            return useInternalQuery(schema, modelName, 'count', undefined, options);
+        useCount: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'count', args, options);
         },
 
-        useSuspenseCount: (options?: any) => {
-            return useInternalSuspenseQuery(schema, modelName, 'count', undefined, options);
+        useSuspenseCount: (args: any, options?: any) => {
+            return useInternalSuspenseQuery(schema, modelName, 'count', args, options);
         },
 
-        useAggregate: (options?: any) => {
-            return useInternalQuery(schema, modelName, 'aggregate', undefined, options);
+        useAggregate: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'aggregate', args, options);
         },
 
-        useSuspenseAggregate: (options?: any) => {
-            return useInternalSuspenseQuery(schema, modelName, 'aggregate', undefined, options);
+        useSuspenseAggregate: (args: any, options?: any) => {
+            return useInternalSuspenseQuery(schema, modelName, 'aggregate', args, options);
         },
 
-        useGroupBy: (options?: any) => {
-            return useInternalQuery(schema, modelName, 'groupBy', undefined, options);
+        useGroupBy: (args: any, options?: any) => {
+            return useInternalQuery(schema, modelName, 'groupBy', args, options);
         },
 
-        useSuspenseGroupBy: (options?: any) => {
-            return useInternalSuspenseQuery(schema, modelName, 'groupBy', undefined, options);
+        useSuspenseGroupBy: (args: any, options?: any) => {
+            return useInternalSuspenseQuery(schema, modelName, 'groupBy', args, options);
         },
     } as ModelQueryHooks<Schema, Model>;
 }
@@ -360,7 +389,7 @@ export function useInternalQuery<TQueryFnData, TData>(
         queryKey,
         ...useQuery({
             queryKey,
-            queryFn: ({ signal }) => fetcher<TQueryFnData, false>(reqUrl, { signal }, fetch, false),
+            queryFn: ({ signal }) => fetcher<TQueryFnData>(reqUrl, { signal }, fetch),
             ...options,
         }),
     };
@@ -383,7 +412,7 @@ export function useInternalSuspenseQuery<TQueryFnData, TData>(
         queryKey,
         ...useSuspenseQuery({
             queryKey,
-            queryFn: ({ signal }) => fetcher<TQueryFnData, false>(reqUrl, { signal }, fetch, false),
+            queryFn: ({ signal }) => fetcher<TQueryFnData>(reqUrl, { signal }, fetch),
             ...options,
         }),
     };
@@ -394,11 +423,14 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
     model: string,
     operation: string,
     args: unknown,
-    options: Omit<
-        UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>,
-        'queryKey' | 'initialPageParam'
-    >,
+    options:
+        | Omit<
+              UseInfiniteQueryOptions<TQueryFnData, DefaultError, InfiniteData<TData>>,
+              'queryKey' | 'initialPageParam'
+          >
+        | undefined,
 ) {
+    options = options ?? { getNextPageParam: () => undefined };
     const { endpoint, fetch } = useHooksContext();
     const queryKey = getQueryKey(model, operation, args, { infinite: true, optimisticUpdate: false });
     return {
@@ -406,12 +438,7 @@ export function useInternalInfiniteQuery<TQueryFnData, TData>(
         ...useInfiniteQuery({
             queryKey,
             queryFn: ({ pageParam, signal }) => {
-                return fetcher<TQueryFnData, false>(
-                    makeUrl(endpoint, model, operation, pageParam ?? args),
-                    { signal },
-                    fetch,
-                    false,
-                );
+                return fetcher<TQueryFnData>(makeUrl(endpoint, model, operation, pageParam ?? args), { signal }, fetch);
             },
             initialPageParam: args,
             ...options,
@@ -436,12 +463,7 @@ export function useInternalSuspenseInfiniteQuery<TQueryFnData, TData>(
         ...useSuspenseInfiniteQuery({
             queryKey,
             queryFn: ({ pageParam, signal }) => {
-                return fetcher<TQueryFnData, false>(
-                    makeUrl(endpoint, model, operation, pageParam ?? args),
-                    { signal },
-                    fetch,
-                    false,
-                );
+                return fetcher<TQueryFnData>(makeUrl(endpoint, model, operation, pageParam ?? args), { signal }, fetch);
             },
             initialPageParam: args,
             ...options,
@@ -460,20 +482,14 @@ export function useInternalSuspenseInfiniteQuery<TQueryFnData, TData>(
  * @param options The react-query options.
  * @param checkReadBack Whether to check for read back errors and return undefined if found.
  */
-export function useInternalMutation<
-    TArgs,
-    R = any,
-    C extends boolean = boolean,
-    Result = C extends true ? R | undefined : R,
->(
+export function useInternalMutation<TArgs, R = any>(
     schema: SchemaDef,
     model: string,
     method: 'POST' | 'PUT' | 'DELETE',
     operation: string,
-    options?: Omit<UseMutationOptions<Result, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions,
-    checkReadBack?: C,
+    options?: Omit<UseMutationOptions<R, DefaultError, TArgs>, 'mutationFn'> & ExtraMutationOptions,
 ) {
-    const { endpoint, fetch } = useHooksContext();
+    const { endpoint, fetch, logging } = useHooksContext();
     const queryClient = useQueryClient();
     const mutationFn = (data: any) => {
         const reqUrl =
@@ -487,13 +503,12 @@ export function useInternalMutation<
                 body: marshal(data),
             }),
         };
-        return fetcher<R, C>(reqUrl, fetchInit, fetch, checkReadBack) as Promise<Result>;
+        return fetcher<R>(reqUrl, fetchInit, fetch) as Promise<R>;
     };
 
     const finalOptions = { ...options, mutationFn };
     const invalidateQueries = options?.invalidateQueries !== false;
     const optimisticUpdate = !!options?.optimisticUpdate;
-    const { logging } = useContext(QuerySettingsContext);
 
     if (operation) {
         if (invalidateQueries) {