@umituz/react-native-tanstack 1.2.7 → 1.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-tanstack",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "TanStack Query configuration and utilities for React Native apps - Pre-configured QueryClient with AsyncStorage persistence",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/index.ts

@@ -98,6 +98,7 @@ export {
   type UseQueryResult,
   type UseMutationResult,
   type UseInfiniteQueryResult,
+  type InfiniteData,
   type QueryKey,
   type QueryClient,
 } from '@tanstack/react-query';

package/src/presentation/hooks/useOptimisticUpdate.ts

@@ -1,68 +1,42 @@
 /**
  * useOptimisticUpdate Hook
  * Presentation layer - Optimistic update helper
- *
- * General-purpose optimistic updates for any React Native app
  */
 
 import { useMutation, useQueryClient, type UseMutationOptions } from '@tanstack/react-query';
 
+/**
+ * Context type for optimistic updates
+ */
+interface OptimisticContext<TData> {
+  previousData: TData | undefined;
+}
+
 /**
  * Optimistic update configuration
  */
 export interface OptimisticUpdateConfig<TData, TVariables> {
-  /**
-   * Query key to update optimistically
-   */
   queryKey: readonly unknown[];
-
-  /**
-   * Function to update the cached data optimistically
-   */
   updater: (oldData: TData | undefined, variables: TVariables) => TData;
-
-  /**
-   * Whether to invalidate the query after successful mutation
-   * @default true
-   */
   invalidateOnSuccess?: boolean;
 }
 
 /**
  * Hook for mutations with optimistic updates and automatic rollback
- *
- * @example
- * ```typescript
- * const updatePost = useOptimisticUpdate<Post, UpdatePostVariables>({
- *   mutationFn: (variables) => api.updatePost(variables.id, variables.data),
- *   queryKey: ['posts', postId],
- *   updater: (oldPost, variables) => ({
- *     ...oldPost,
- *     ...variables.data,
- *   }),
- * });
- *
- * // Usage
- * updatePost.mutate({ id: 123, data: { title: 'New Title' } });
- * ```
  */
 export function useOptimisticUpdate<TData = unknown, TVariables = unknown, TError = Error>(
   config: OptimisticUpdateConfig<TData, TVariables> &
-    UseMutationOptions<TData, TError, TVariables>,
+    Omit<UseMutationOptions<TData, TError, TVariables, OptimisticContext<TData>>, 'onMutate'>,
 ) {
   const queryClient = useQueryClient();
   const { queryKey, updater, invalidateOnSuccess = true, onError, onSettled, ...mutationOptions } = config;
 
-  return useMutation({
+  return useMutation<TData, TError, TVariables, OptimisticContext<TData>>({
     ...mutationOptions,
     onMutate: async (variables) => {
-      // Cancel outgoing refetches to avoid overwriting optimistic update
       await queryClient.cancelQueries({ queryKey });
-
-      // Snapshot the previous value
       const previousData = queryClient.getQueryData<TData>(queryKey);
 
-      // Optimistically update to the new value
       if (previousData !== undefined) {
         const optimisticData = updater(previousData, variables);
         queryClient.setQueryData(queryKey, optimisticData);
@@ -73,11 +47,9 @@ export function useOptimisticUpdate<TData = unknown, TVariables = unknown, TErro
         }
       }
 
-      // Return context with previous data for rollback
       return { previousData };
     },
-    onError: (error, variables, context, ...rest) => {
-      // Rollback to previous data on error
+    onError: (error, variables, context) => {
       if (context?.previousData !== undefined) {
         queryClient.setQueryData(queryKey, context.previousData);
 
@@ -87,40 +59,28 @@ export function useOptimisticUpdate<TData = unknown, TVariables = unknown, TErro
         }
       }
 
-      // Call user-provided onError
       if (onError) {
-        onError(error, variables, context, ...rest);
+        onError(error, variables, context);
       }
     },
-    onSettled: (data, error, variables, context, ...rest) => {
-      // Invalidate query to refetch with real data
+    onSettled: (data, error, variables, context) => {
       if (invalidateOnSuccess && !error) {
         queryClient.invalidateQueries({ queryKey });
       }
 
-      // Call user-provided onSettled
       if (onSettled) {
-        onSettled(data, error, variables, context, ...rest);
+        onSettled(data, error, variables, context);
       }
     },
   });
 }
 
 /**
- * Hook for list mutations with optimistic updates (add/remove/update items)
- *
- * @example
- * ```typescript
- * const addPost = useOptimisticListUpdate<Post[], { title: string }>({
- *   mutationFn: (variables) => api.createPost(variables),
- *   queryKey: ['posts'],
- *   updater: (oldPosts, newPost) => [...(oldPosts ?? []), newPost],
- * });
- * ```
+ * Hook for list mutations with optimistic updates
  */
 export function useOptimisticListUpdate<TData extends unknown[], TVariables = unknown>(
   config: OptimisticUpdateConfig<TData, TVariables> &
-    UseMutationOptions<TData, Error, TVariables>,
+    Omit<UseMutationOptions<TData, Error, TVariables, OptimisticContext<TData>>, 'onMutate'>,
 ) {
   return useOptimisticUpdate<TData, TVariables>(config);
 }

package/src/presentation/hooks/usePaginatedQuery.ts

@@ -1,14 +1,11 @@
 /**
  * usePaginatedQuery Hook
  * Presentation layer - Pagination helper
- *
- * General-purpose pagination for any React Native app
  */
 
 import {
   useInfiniteQuery,
   type UseInfiniteQueryOptions,
-  type InfiniteData,
 } from '@tanstack/react-query';
 import { useMemo } from 'react';
 
@@ -49,18 +46,6 @@ export interface OffsetPaginatedResponse<TData> {
 
 /**
  * Hook for cursor-based infinite scroll
- *
- * @example
- * ```typescript
- * const { data, fetchNextPage, hasNextPage, isFetchingNextPage } = useCursorPagination({
- *   queryKey: ['posts'],
- *   queryFn: ({ pageParam }) => fetchPosts({ cursor: pageParam, limit: 20 }),
- *   limit: 20,
- * });
- *
- * // Flatten all pages into single array
- * const allPosts = data.pages.flatMap(page => page.items);
- * ```
  */
 export function useCursorPagination<TData>(
   options: Omit<
@@ -68,6 +53,7 @@ export function useCursorPagination<TData>(
       CursorPaginatedResponse<TData>,
       Error,
       CursorPaginatedResponse<TData>,
+      CursorPaginatedResponse<TData>,
       readonly unknown[],
       string | undefined
     >,
@@ -76,7 +62,7 @@ export function useCursorPagination<TData>(
     limit?: number;
   },
 ) {
-  const { limit = 20, ...queryOptions } = options;
+  const { limit: _limit = 20, ...queryOptions } = options;
 
   const result = useInfiniteQuery({
     ...queryOptions,
@@ -85,11 +71,9 @@ export function useCursorPagination<TData>(
       lastPage.hasMore ? lastPage.nextCursor : undefined,
   });
 
-  // Flatten pages into single array for easier consumption
   const flatData = useMemo(() => {
-    const infiniteData = result.data as InfiniteData<CursorPaginatedResponse<TData>> | undefined;
-    if (!infiniteData?.pages) return [];
-    return infiniteData.pages.flatMap((page) => page.items);
+    if (!result.data?.pages) return [];
+    return result.data.pages.flatMap((page) => page.items);
   }, [result.data]);
 
   return {
@@ -101,15 +85,6 @@ export function useCursorPagination<TData>(
 
 /**
  * Hook for offset-based pagination
- *
- * @example
- * ```typescript
- * const { data, fetchNextPage, hasNextPage } = useOffsetPagination({
- *   queryKey: ['posts'],
- *   queryFn: ({ pageParam }) => fetchPosts({ offset: pageParam.offset, limit: pageParam.limit }),
- *   limit: 20,
- * });
- * ```
  */
 export function useOffsetPagination<TData>(
   options: Omit<
@@ -117,6 +92,7 @@ export function useOffsetPagination<TData>(
       OffsetPaginatedResponse<TData>,
       Error,
       OffsetPaginatedResponse<TData>,
+      OffsetPaginatedResponse<TData>,
       readonly unknown[],
       OffsetPageParam
     >,
@@ -136,16 +112,12 @@ export function useOffsetPagination<TData>(
     },
   });
 
-  // Flatten pages into single array
   const flatData = useMemo(() => {
-    const infiniteData = result.data as InfiniteData<OffsetPaginatedResponse<TData>> | undefined;
-    if (!infiniteData?.pages) return [];
-    return infiniteData.pages.flatMap((page) => page.items);
+    if (!result.data?.pages) return [];
+    return result.data.pages.flatMap((page) => page.items);
   }, [result.data]);
 
-  // Calculate total from last page
-  const infiniteData = result.data as InfiniteData<OffsetPaginatedResponse<TData>> | undefined;
-  const total = infiniteData?.pages?.[infiniteData.pages.length - 1]?.total ?? 0;
+  const total = result.data?.pages?.[result.data.pages.length - 1]?.total ?? 0;
 
   return {
     ...result,