@umituz/react-native-tanstack 1.2.9 → 1.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-tanstack",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "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

@@ -3,37 +3,33 @@
  * Presentation layer - Optimistic update helper
  */
 
-import { useMutation, useQueryClient, type UseMutationOptions } from '@tanstack/react-query';
-
-/**
- * Context type for optimistic updates
- */
-interface OptimisticContext<TData> {
-  previousData: TData | undefined;
-}
+import { useMutation, useQueryClient } from '@tanstack/react-query';
 
 /**
  * Optimistic update configuration
  */
-export interface OptimisticUpdateConfig<TData, TVariables> {
+export interface OptimisticUpdateConfig<TData, TVariables, TError = Error> {
   queryKey: readonly unknown[];
   updater: (oldData: TData | undefined, variables: TVariables) => TData;
   invalidateOnSuccess?: boolean;
+  mutationFn: (variables: TVariables) => Promise<TData>;
+  onError?: (error: TError, variables: TVariables, context: unknown) => void;
+  onSettled?: (data: TData | undefined, error: TError | null, variables: TVariables, context: unknown) => void;
+  onSuccess?: (data: TData, variables: TVariables, context: unknown) => void;
 }
 
 /**
  * Hook for mutations with optimistic updates and automatic rollback
  */
 export function useOptimisticUpdate<TData = unknown, TVariables = unknown, TError = Error>(
-  config: OptimisticUpdateConfig<TData, TVariables> &
-    Omit<UseMutationOptions<TData, TError, TVariables, OptimisticContext<TData>>, 'onMutate'>,
+  config: OptimisticUpdateConfig<TData, TVariables, TError>,
 ) {
   const queryClient = useQueryClient();
-  const { queryKey, updater, invalidateOnSuccess = true, onError, onSettled, ...mutationOptions } = config;
+  const { queryKey, updater, invalidateOnSuccess = true, onError, onSettled, onSuccess, mutationFn } = config;
 
-  return useMutation<TData, TError, TVariables, OptimisticContext<TData>>({
-    ...mutationOptions,
-    onMutate: async (variables) => {
+  return useMutation({
+    mutationFn,
+    onMutate: async (variables: TVariables) => {
       await queryClient.cancelQueries({ queryKey });
       const previousData = queryClient.getQueryData<TData>(queryKey);
 
@@ -49,9 +45,11 @@ export function useOptimisticUpdate<TData = unknown, TVariables = unknown, TErro
 
       return { previousData };
     },
-    onError: (error, variables, context) => {
-      if (context?.previousData !== undefined) {
-        queryClient.setQueryData(queryKey, context.previousData);
+    onError: (error: TError, variables: TVariables, context: unknown) => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const ctx = context as any;
+      if (ctx?.previousData !== undefined) {
+        queryClient.setQueryData(queryKey, ctx.previousData);
 
         if (__DEV__) {
           // eslint-disable-next-line no-console
@@ -63,7 +61,12 @@ export function useOptimisticUpdate<TData = unknown, TVariables = unknown, TErro
         onError(error, variables, context);
       }
     },
-    onSettled: (data, error, variables, context) => {
+    onSuccess: (data: TData, variables: TVariables, context: unknown) => {
+      if (onSuccess) {
+        onSuccess(data, variables, context);
+      }
+    },
+    onSettled: (data: TData | undefined, error: TError | null, variables: TVariables, context: unknown) => {
       if (invalidateOnSuccess && !error) {
         queryClient.invalidateQueries({ queryKey });
       }
@@ -79,8 +82,7 @@ export function useOptimisticUpdate<TData = unknown, TVariables = unknown, TErro
  * Hook for list mutations with optimistic updates
  */
 export function useOptimisticListUpdate<TData extends unknown[], TVariables = unknown>(
-  config: OptimisticUpdateConfig<TData, TVariables> &
-    Omit<UseMutationOptions<TData, Error, TVariables, OptimisticContext<TData>>, 'onMutate'>,
+  config: OptimisticUpdateConfig<TData, TVariables, Error>,
 ) {
-  return useOptimisticUpdate<TData, TVariables>(config);
+  return useOptimisticUpdate<TData, TVariables, Error>(config);
 }

package/src/presentation/hooks/usePaginatedQuery.ts

@@ -3,10 +3,7 @@
  * Presentation layer - Pagination helper
  */
 
-import {
-  useInfiniteQuery,
-  type UseInfiniteQueryOptions,
-} from '@tanstack/react-query';
+import { useInfiniteQuery } from '@tanstack/react-query';
 import { useMemo } from 'react';
 
 /**
@@ -44,31 +41,31 @@ 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
  */
-export function useCursorPagination<TData>(
-  options: Omit<
-    UseInfiniteQueryOptions<
-      CursorPaginatedResponse<TData>,
-      Error,
-      CursorPaginatedResponse<TData>,
-      CursorPaginatedResponse<TData>,
-      readonly unknown[],
-      string | undefined
-    >,
-    'getNextPageParam' | 'initialPageParam'
-  > & {
-    limit?: number;
-  },
-) {
-  const { limit: _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,
   });
 
   const flatData = useMemo(() => {
@@ -83,33 +80,33 @@ 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
  */
-export function useOffsetPagination<TData>(
-  options: Omit<
-    UseInfiniteQueryOptions<
-      OffsetPaginatedResponse<TData>,
-      Error,
-      OffsetPaginatedResponse<TData>,
-      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,
   });
 
   const flatData = useMemo(() => {