@umituz/react-native-tanstack 1.2.8 → 1.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-tanstack",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "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/presentation/hooks/useOptimisticUpdate.ts

@@ -1,68 +1,35 @@
 /**
  * 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';
+import { useMutation, useQueryClient, type MutationOptions } from '@tanstack/react-query';
 
 /**
  * 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>,
+    MutationOptions<TData, TError, TVariables>,
 ) {
   const queryClient = useQueryClient();
   const { queryKey, updater, invalidateOnSuccess = true, onError, onSettled, ...mutationOptions } = config;
 
   return useMutation({
     ...mutationOptions,
-    onMutate: async (variables) => {
-      // Cancel outgoing refetches to avoid overwriting optimistic update
+    onMutate: async (variables: TVariables) => {
       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 +40,10 @@ 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
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onError: (error: TError, variables: TVariables, context: any) => {
       if (context?.previousData !== undefined) {
         queryClient.setQueryData(queryKey, context.previousData);
 
@@ -87,40 +53,29 @@ 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
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    onSettled: (data: TData | undefined, error: TError | null, variables: TVariables, context: any) => {
       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>,
+    MutationOptions<TData, Error, TVariables>,
 ) {
   return useOptimisticUpdate<TData, TVariables>(config);
 }

package/src/presentation/hooks/usePaginatedQuery.ts

@@ -1,15 +1,9 @@
 /**
  * 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 { useInfiniteQuery } from '@tanstack/react-query';
 import { useMemo } from 'react';
 
 /**
@@ -47,49 +41,36 @@ export interface OffsetPaginatedResponse<TData> {
   limit: number;
 }
 
+/**
+ * Cursor pagination options
+ */
+export interface CursorPaginationOptions<TData> {
+  queryKey: readonly unknown[];
+  queryFn: (context: { pageParam?: string }) => Promise<CursorPaginatedResponse<TData>>;
+  limit?: number;
+  enabled?: boolean;
+  staleTime?: number;
+  gcTime?: number;
+}
+
 /**
  * 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<
-    UseInfiniteQueryOptions<
-      CursorPaginatedResponse<TData>,
-      Error,
-      CursorPaginatedResponse<TData>,
-      readonly unknown[],
-      string | undefined
-    >,
-    'getNextPageParam' | 'initialPageParam'
-  > & {
-    limit?: number;
-  },
-) {
-  const { limit = 20, ...queryOptions } = options;
+export function useCursorPagination<TData>(options: CursorPaginationOptions<TData>) {
+  const { queryKey, queryFn, limit: _limit = 20, ...restOptions } = options;
 
   const result = useInfiniteQuery({
-    ...queryOptions,
-    initialPageParam: undefined,
+    queryKey,
+    queryFn: ({ pageParam }) => queryFn({ pageParam }),
+    initialPageParam: undefined as string | undefined,
     getNextPageParam: (lastPage: CursorPaginatedResponse<TData>) =>
       lastPage.hasMore ? lastPage.nextCursor : undefined,
+    ...restOptions,
   });
 
-  // 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 {
@@ -99,53 +80,41 @@ export function useCursorPagination<TData>(
   };
 }
 
+/**
+ * Offset pagination options
+ */
+export interface OffsetPaginationOptions<TData> {
+  queryKey: readonly unknown[];
+  queryFn: (context: { pageParam: OffsetPageParam }) => Promise<OffsetPaginatedResponse<TData>>;
+  limit?: number;
+  enabled?: boolean;
+  staleTime?: number;
+  gcTime?: number;
+}
+
 /**
  * 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<
-    UseInfiniteQueryOptions<
-      OffsetPaginatedResponse<TData>,
-      Error,
-      OffsetPaginatedResponse<TData>,
-      readonly unknown[],
-      OffsetPageParam
-    >,
-    'getNextPageParam' | 'initialPageParam'
-  > & {
-    limit?: number;
-  },
-) {
-  const { limit = 20, ...queryOptions } = options;
+export function useOffsetPagination<TData>(options: OffsetPaginationOptions<TData>) {
+  const { queryKey, queryFn, limit = 20, ...restOptions } = options;
 
   const result = useInfiniteQuery({
-    ...queryOptions,
+    queryKey,
+    queryFn: ({ pageParam }) => queryFn({ pageParam }),
     initialPageParam: { offset: 0, limit },
     getNextPageParam: (lastPage: OffsetPaginatedResponse<TData>) => {
       const nextOffset = lastPage.offset + lastPage.limit;
       return nextOffset < lastPage.total ? { offset: nextOffset, limit } : undefined;
     },
+    ...restOptions,
   });
 
-  // 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,