@navios/react-query 0.5.2 → 0.6.1

package/README.md

@@ -1,376 +1,508 @@
-# Navios Zod React
+# @navios/react-query
 
-`Navios Zod React` is a helper for a navios zod to use with Tanstack React Query.
+Type-safe React Query integration for Navios API client with Zod schema validation.
 
-## Why?
+## Features
 
-- **Type Safety**: By using Zod schemas, you can ensure that the data you receive from your API matches the expected structure. This helps catch errors early in the development process.
-- **Validation**: Zod provides powerful validation capabilities, allowing you to define complex validation rules for your data. This ensures that the data you work with is always valid and meets your requirements.
-- **Integration with Navios**: Navios is a powerful HTTP client that simplifies API requests. By combining it with Zod, you can create a robust and type-safe API client.
-- **React Query Support**: This package is designed to work seamlessly with Tanstack React Query, making it easy to manage API requests and responses in your React applications.
-- **Declarative API**: The API is designed to be declarative, allowing you to define your API endpoints and their schemas in a clear and concise manner. This makes it easy to understand and maintain your API client.
-- **Discriminated Union Support**: The package supports discriminated unions, allowing you to handle different response types based on a common property. This is useful for APIs that return different data structures based on the request.
-- **Customizable**: The package allows you to customize the behavior of the API client, such as using a custom Navios client or enabling/disabling certain features like whole response validation.
-- **Error Handling**: The package provides built-in error handling capabilities, allowing you to handle API errors gracefully and provide meaningful feedback to users.
+- **Type Safety** - Full TypeScript support with Zod schema inference
+- **Schema Validation** - Request and response validation using Zod schemas
+- **React Query Integration** - Seamless integration with TanStack Query v5
+- **Declarative API** - Define endpoints once, use everywhere
+- **URL Parameters** - Built-in support for parameterized URLs (`/users/$userId`)
+- **Optimistic Updates** - First-class support via `onMutate` callback
+- **Stream Support** - Handle file downloads and blob responses
 
 ## Installation
 
 ```bash
-npm install --save @navios/navios-zod @navios/navios-zod-react zod navios
+npm install @navios/react-query @navios/builder navios zod @tanstack/react-query
 ```
 
-or
+## Quick Start
 
-```bash
-yarn add @navios/navios-zod @navios/navios-zod-react zod navios
-```
+```typescript
+import { builder } from '@navios/builder'
+import { declareClient } from '@navios/react-query'
+import { create } from 'navios'
+import { z } from 'zod/v4'
 
-## Usage of Mutations
+// Create the API builder
+const api = builder({})
+api.provideClient(create({ baseURL: 'https://api.example.com' }))
 
-```tsx
-import { createAPI } from '@navios/navios-zod/v4'
-import { declareClient } from '@navios/navios-zod-react'
+// Create the client
+const client = declareClient({ api })
+```
 
-import { z } from 'zod/v4'
+## Queries
 
-const publicApi = createAPI({
-  baseURL: 'https://example.com/api/',
-  useDiscriminatorResponse: true,
+### Basic Query
+
+```typescript
+const getUsers = client.query({
+  method: 'GET',
+  url: '/users',
+  responseSchema: z.array(z.object({
+    id: z.string(),
+    name: z.string(),
+    email: z.string().email(),
+  })),
 })
 
-const publicClient = declareClient({
-  api: publicApi,
+// In a component
+function UsersList() {
+  const { data } = getUsers.useSuspense({})
+  return (
+    <ul>
+      {data.map(user => <li key={user.id}>{user.name}</li>)}
+    </ul>
+  )
+}
+```
+
+### Query with URL Parameters
+
+```typescript
+const getUser = client.query({
+  method: 'GET',
+  url: '/users/$userId',
+  responseSchema: z.object({
+    id: z.string(),
+    name: z.string(),
+  }),
 })
 
-const RequestSchema = z.object({
-  email: z.string().email(),
-  password: z.string().min(8).max(32),
+function UserProfile({ userId }: { userId: string }) {
+  const { data } = getUser.useSuspense({
+    urlParams: { userId },
+  })
+  return <h1>{data.name}</h1>
+}
+```
+
+### Query with Query Parameters
+
+```typescript
+const searchUsers = client.query({
+  method: 'GET',
+  url: '/users',
+  querySchema: z.object({
+    page: z.number().default(1),
+    limit: z.number().default(10),
+    search: z.string().optional(),
+  }),
+  responseSchema: z.object({
+    users: z.array(UserSchema),
+    total: z.number(),
+  }),
 })
 
-const loginMutation = publicClient.mutation({
-  url: 'auth/login',
-  method: 'post',
-  // Navios Zod also validates the request body
-  requestSchema: RequestSchema,
+function UsersPage() {
+  const { data } = searchUsers.useSuspense({
+    params: { page: 1, limit: 20, search: 'john' },
+  })
+  return <div>Found {data.total} users</div>
+}
+```
+
+### Query with Response Transformation
+
+```typescript
+const getUsers = client.query({
+  method: 'GET',
+  url: '/users',
   responseSchema: z.discriminatedUnion('success', [
     z.object({
       success: z.literal(true),
-      data: z.object({
-        accessToken: z.string(),
-        refreshToken: z.string(),
-      }),
+      data: z.array(UserSchema),
     }),
     z.object({
       success: z.literal(false),
-      error: z.object({
-        message: z.string(),
-      }),
+      error: z.object({ message: z.string() }),
     }),
   ]),
   processResponse: (response) => {
-    if (response.success) {
-      return response.data
-    } else {
+    if (!response.success) {
       throw new Error(response.error.message)
     }
+    return response.data
   },
 })
+```
 
-export function Login() {
-  const { mutateAsync: login, data, isSuccess, error } = loginMutation()
+### Query Helpers
 
-  const form = useForm({
-    resolver: zodResolver(RequestSchema),
-    defaultValues: {
-      email: '',
-      password: '',
-    },
-  })
+```typescript
+// Get query options for use with useQuery
+const options = getUsers({ params: { page: 1 } })
 
-  useEffect(() => {
-    if (isSuccess) {
-      console.log('Login successful:', data)
-    }
-  }, [isSuccess, data])
+// Helper hooks
+const { data } = getUsers.use({ params: { page: 1 } })
+const { data } = getUsers.useSuspense({ params: { page: 1 } })
+
+// Invalidation
+getUsers.invalidate({ params: { page: 1 } })
+getUsers.invalidateAll({}) // Invalidate all pages
+```
+
+## Infinite Queries
+
+```typescript
+const getUsers = client.infiniteQuery({
+  method: 'GET',
+  url: '/users',
+  querySchema: z.object({
+    cursor: z.string().optional(),
+    limit: z.number().default(20),
+  }),
+  responseSchema: z.object({
+    users: z.array(UserSchema),
+    nextCursor: z.string().nullable(),
+  }),
+  getNextPageParam: (lastPage) => lastPage.nextCursor ?? undefined,
+})
+
+function InfiniteUsersList() {
+  const { data, fetchNextPage, hasNextPage } = getUsers.useSuspense({
+    params: { limit: 20 },
+  })
 
   return (
-    <form onSubmit={form.handleSubmit(login)}>
-      {error && <p>{error.message}</p>}
-      <input {...form.register('email')} placeholder="Email" />
-      <input
-        {...form.register('password')}
-        type="password"
-        placeholder="Password"
-      />
-      <button type="submit">Login</button>
-    </form>
+    <div>
+      {data.pages.flatMap(page =>
+        page.users.map(user => <UserCard key={user.id} user={user} />)
+      )}
+      {hasNextPage && (
+        <button onClick={() => fetchNextPage()}>Load More</button>
+      )}
+    </div>
   )
 }
 ```
 
-## Usage of Queries
+## Mutations
 
-```tsx
-import { createAPI } from '@navios/navios-zod/v4'
-import { declareClient } from '@navios/navios-zod-react'
-
-import { z } from 'zod/v4'
+### Basic Mutation
 
-const publicApi = createAPI({
-  baseURL: 'https://example.com/api/',
-  useDiscriminatorResponse: true,
+```typescript
+const createUser = client.mutation({
+  method: 'POST',
+  url: '/users',
+  requestSchema: z.object({
+    name: z.string(),
+    email: z.string().email(),
+  }),
+  responseSchema: z.object({
+    id: z.string(),
+    name: z.string(),
+  }),
+  processResponse: (data) => data,
 })
 
-const publicClient = declareClient({
-  api: publicApi,
-})
+function CreateUserForm() {
+  const { mutateAsync, isPending } = createUser()
 
-const usersList = publicClient.query({
-  url: 'users',
-  method: 'GET',
-  querySchema: z.object({
-    page: z.number().optional().default(1),
-    limit: z.number().optional().default(10),
+  const handleSubmit = async (formData: FormData) => {
+    await mutateAsync({
+      data: {
+        name: formData.get('name') as string,
+        email: formData.get('email') as string,
+      },
+    })
+  }
+
+  return <form onSubmit={handleSubmit}>...</form>
+}
+```
+
+### Mutation with URL Parameters
+
+```typescript
+const updateUser = client.mutation({
+  method: 'PUT',
+  url: '/users/$userId',
+  requestSchema: z.object({
+    name: z.string(),
   }),
-  responseSchema: z.discriminatedUnion('success', [
-    z.object({
-      success: z.literal(true),
-      data: z.array(
-        z.object({
-          id: z.string(),
-          name: z.string(),
-          email: z.string().email(),
-        }),
-      ),
-    }),
-    z.object({
-      success: z.literal(false),
-      error: z.object({
-        message: z.string(),
-      }),
-    }),
-  ]),
-  processResponse: (response) => {
-    if (response.success) {
-      return response.data
-    } else {
-      throw new Error(response.error.message)
-    }
-  },
+  responseSchema: UserSchema,
+  processResponse: (data) => data,
 })
 
-export function UsersList() {
-  const { page, limit } = routeApi.useSearch()
-  const navigate = routeApi.useNavigate()
-  const { data, isLoading, error } = usersList.use({
-    params: {
-      page,
-      limit,
-    },
-  })
+function EditUserForm({ userId }: { userId: string }) {
+  const { mutateAsync } = updateUser()
 
-  if (isLoading) {
-    return <p>Loading...</p>
+  const handleSubmit = async (name: string) => {
+    await mutateAsync({
+      urlParams: { userId },
+      data: { name },
+    })
   }
 
-  if (error) {
-    return <p>{error.message}</p>
-  }
-
-  return (
-    <ul>
-      {data?.map((user) => (
-        <li key={user.id}>{user.name}</li>
-      ))}
-    </ul>
-  )
+  return <form>...</form>
 }
 ```
 
-## Usage of Infinite Queries
-
-```tsx
-import { createAPI } from '@navios/navios-zod/v4'
-import { declareClient } from '@navios/navios-zod-react'
+### Mutation with Callbacks and Optimistic Updates
 
-import { z } from 'zod/v4'
+```typescript
+const updateUser = client.mutation({
+  method: 'PUT',
+  url: '/users/$userId',
+  requestSchema: z.object({ name: z.string() }),
+  responseSchema: UserSchema,
+  processResponse: (data) => data,
 
-const publicApi = createAPI({
-  baseURL: 'https://example.com/api/',
-  useDiscriminatorResponse: true,
-})
+  // Provide context (e.g., queryClient) via hook
+  useContext: () => {
+    const queryClient = useQueryClient()
+    return { queryClient }
+  },
 
-const publicClient = declareClient({
-  api: publicApi,
-})
+  // Called before mutation - return value available as context.onMutateResult
+  onMutate: async (variables, context) => {
+    // Cancel outgoing queries
+    await context.queryClient.cancelQueries({
+      queryKey: ['users', variables.urlParams.userId]
+    })
+
+    // Snapshot previous value
+    const previousUser = context.queryClient.getQueryData(
+      ['users', variables.urlParams.userId]
+    )
+
+    // Optimistically update
+    context.queryClient.setQueryData(
+      ['users', variables.urlParams.userId],
+      { ...previousUser, name: variables.data.name }
+    )
+
+    return { previousUser }
+  },
 
-const usersList = publicClient.infiniteQuery({
-  url: 'users',
-  method: 'GET',
-  querySchema: z.object({
-    page: z.number().optional().default(1),
-    limit: z.number().optional().default(10),
-  }),
-  responseSchema: z.discriminatedUnion('success', [
-    z.object({
-      success: z.literal(true),
-      data: z.array(
-        z.object({
-          id: z.string(),
-          name: z.string(),
-          email: z.string().email(),
-        }),
-      ),
-      meta: z.object({
-        total: z.number(),
-        totalPages: z.number(),
-        page: z.number(),
-      }),
-    }),
-    z.object({
-      success: z.literal(false),
-      error: z.object({
-        message: z.string(),
-      }),
-    }),
-  ]),
-  processResponse: (response) => {
-    if (response.success) {
-      return response.data
-    } else {
-      throw new Error(response.error.message)
-    }
+  // Called on success
+  onSuccess: (data, variables, context) => {
+    context.queryClient.invalidateQueries({ queryKey: ['users'] })
   },
-  getNextPageParam: (lastPage, pages) => {
-    if (lastPage.meta.page < lastPage.meta.totalPages) {
-      return lastPage.meta.page + 1
+
+  // Called on error - rollback optimistic update
+  onError: (error, variables, context) => {
+    if (context.onMutateResult?.previousUser) {
+      context.queryClient.setQueryData(
+        ['users', variables.urlParams.userId],
+        context.onMutateResult.previousUser
+      )
     }
-    return undefined
   },
-  select: (data) => {
-    return data.pages.flatMap((page) => page.data)
+
+  // Called on both success and error
+  onSettled: (data, error, variables, context) => {
+    context.queryClient.invalidateQueries({
+      queryKey: ['users', variables.urlParams.userId]
+    })
   },
 })
+```
 
-export function UsersList() {
-  const { page, limit } = routeApi.useSearch()
-  const { data, isLoading, error, fetchNextPage, hasNextPage } = usersList.use({
-    params: {
-      page,
-      limit,
-    },
-  })
+### DELETE Mutation
 
-  if (isLoading) {
-    return <p>Loading...</p>
-  }
+```typescript
+const deleteUser = client.mutation({
+  method: 'DELETE',
+  url: '/users/$userId',
+  responseSchema: z.object({ success: z.boolean() }),
+  processResponse: (data) => data,
+})
 
-  if (error) {
-    return <p>{error.message}</p>
-  }
+const { mutateAsync } = deleteUser()
+await mutateAsync({ urlParams: { userId: '123' } })
+```
 
-  return (
-    <div>
-      <ul>
-        {data?.map((page) =>
-          page.data.map((user) => <li key={user.id}>{user.name}</li>),
-        )}
-      </ul>
-      <button disabled={!hasNextPage} onClick={() => fetchNextPage()}>
-        Load more
-      </button>
-    </div>
-  )
-}
+### Mutation with useKey (Scoped Mutations)
+
+When `useKey` is true, mutations are scoped by URL parameters, preventing parallel mutations to the same resource:
+
+```typescript
+const updateUser = client.mutation({
+  method: 'PUT',
+  url: '/users/$userId',
+  useKey: true,
+  requestSchema: UpdateUserSchema,
+  responseSchema: UserSchema,
+  processResponse: (data) => data,
+})
+
+// With useKey, you must pass urlParams when calling the hook
+const { mutateAsync, isPending } = updateUser({
+  urlParams: { userId: '123' }
+})
+
+// Check if any mutation for this user is in progress
+const isMutating = updateUser.useIsMutating({ userId: '123' })
 ```
 
-## API
+## Stream Endpoints (File Downloads)
 
-### `declareClient`
+```typescript
+// Define stream endpoint
+const downloadFile = api.declareStream({
+  method: 'GET',
+  url: '/files/$fileId/download',
+})
 
-This function is used to create a client for the API. It takes an object with the following properties:
+// Create mutation from stream endpoint
+const useDownloadFile = client.mutationFromEndpoint(downloadFile, {
+  // processResponse is optional - defaults to returning Blob
+  processResponse: (blob) => URL.createObjectURL(blob),
 
-- `api`: The API object created using `declareAPI` or `createAPI` from `@navios/navios-zod`.
+  onSuccess: (url, variables, context) => {
+    window.open(url)
+  },
+})
 
-The client object will have the following properties:
+function DownloadButton({ fileId }: { fileId: string }) {
+  const { mutate, isPending } = useDownloadFile()
 
-- `query`: A function that takes a configuration object and returns a query object.
-- `mutation`: A function that takes a configuration object and returns a mutation object.
-- `infiniteQuery`: A function that takes a configuration object and returns an infinite query object.
+  return (
+    <button
+      onClick={() => mutate({ urlParams: { fileId } })}
+      disabled={isPending}
+    >
+      {isPending ? 'Downloading...' : 'Download'}
+    </button>
+  )
+}
+```
 
-#### `query`
+## Using Existing Endpoints
 
-This function is used to create a query for the API. It takes a configuration object with the following properties:
+If you have endpoints defined separately, you can use them with the client:
 
-- `url`: The URL of the API endpoint. For parameterized URLs, use the format `/users/$userId`.
-- `method`: The HTTP method to use (GET, POST, PUT, DELETE, etc.).
-- `querySchema`: A Zod schema for validating the query parameters. (optional)
-- `responseSchema`: A Zod schema for validating the response data.
-- `processResponse`: A function that takes the response data and returns the processed data. (optional, but recommended)
+```typescript
+// Define endpoint separately
+const getUserEndpoint = api.declareEndpoint({
+  method: 'GET',
+  url: '/users/$userId',
+  responseSchema: UserSchema,
+})
 
-The result is a function that can be used to get query options. The function takes an object with the following properties:
+// Create query from endpoint
+const getUser = client.queryFromEndpoint(getUserEndpoint, {
+  processResponse: (data) => data,
+})
 
-- `params`: An object with the query parameters to send with the request. (required if `querySchema` is defined)
-- `urlParams`: An object with the URL parameters to send with the request. (required if `url` contains URL parameters)
+// Create mutation from endpoint
+const updateUser = client.mutationFromEndpoint(updateUserEndpoint, {
+  processResponse: (data) => data,
+  onSuccess: (data, variables, context) => {
+    console.log('Updated:', data)
+  },
+})
+```
 
-Function returns options for `useQuery` or `useSuspenseQuery` from `@tanstack/react-query`.
+## Multipart Mutations (File Uploads)
+
+```typescript
+const uploadAvatar = client.multipartMutation({
+  method: 'POST',
+  url: '/users/$userId/avatar',
+  requestSchema: z.object({
+    file: z.instanceof(File),
+  }),
+  responseSchema: z.object({
+    url: z.string(),
+  }),
+  processResponse: (data) => data,
+})
+
+function AvatarUpload({ userId }: { userId: string }) {
+  const { mutateAsync } = uploadAvatar()
+
+  const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (file) {
+      const result = await mutateAsync({
+        urlParams: { userId },
+        data: { file },
+      })
+      console.log('Uploaded to:', result.url)
+    }
+  }
+
+  return <input type="file" onChange={handleFileChange} />
+}
+```
 
-##### `queryName.use`
+## API Reference
 
-This function is a helper hook which is a wrapper around `useQuery` from `@tanstack/react-query`. It takes the same parameters as the `query` result function and returns the query result.
+### `declareClient(options)`
 
-##### `queryName.useSuspense`
+Creates a client instance for making type-safe queries and mutations.
 
-This function is a helper hook which is a wrapper around `useSuspenseQuery` from `@tanstack/react-query`. It takes the same parameters as the `query` result function and returns the query result.
+**Options:**
+- `api` - The API builder created with `@navios/builder`
+- `defaults` - Default options applied to all queries/mutations
 
-##### `queryName.invalidate`
+**Returns:** `ClientInstance` with the following methods:
 
-This function is a helper function which is a wrapper around `invalidateQueries` from `@tanstack/react-query`. It takes parameters:
+### Query Methods
 
-- `queryClient`: The query client to use. (optional, defaults to the query client from the context)
-- `params`: An object with `urlParams` and `params` to invalidate the query. (required if `url` contains URL parameters or `querySchema` is defined)
+- `client.query(config)` - Create a query
+- `client.queryFromEndpoint(endpoint, options)` - Create a query from an existing endpoint
+- `client.infiniteQuery(config)` - Create an infinite query
+- `client.infiniteQueryFromEndpoint(endpoint, options)` - Create an infinite query from an endpoint
 
-This function is used to invalidate the query in the cache. It can be used to refetch the query data when the data changes or when the user navigates to a different page.
+### Mutation Methods
 
-##### `queryName.invalidateAll`
+- `client.mutation(config)` - Create a mutation
+- `client.mutationFromEndpoint(endpoint, options)` - Create a mutation from an existing endpoint
+- `client.multipartMutation(config)` - Create a multipart/form-data mutation
 
-This function is a helper function which is a wrapper around `invalidateQueries` from `@tanstack/react-query`. It takes parameters:
+### Query Config
 
-- `queryClient`: The query client to use. (optional, defaults to the query client from the context)
-- `params`: An object with `urlParams` to invalidate the query. (required if `url` contains URL parameters)
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `method` | `'GET' \| 'POST' \| 'HEAD' \| 'OPTIONS'` | Yes | HTTP method |
+| `url` | `string` | Yes | URL pattern (e.g., `/users/$userId`) |
+| `responseSchema` | `ZodSchema` | Yes | Zod schema for response validation |
+| `querySchema` | `ZodObject` | No | Zod schema for query parameters |
+| `requestSchema` | `ZodSchema` | No | Zod schema for request body (POST queries) |
+| `processResponse` | `(data) => Result` | No | Transform the response |
 
-This function is used to invalidate query ignoring query params. It can be used to refetch all query data when the data changes or when the user navigates to a different page.
+### Mutation Config
 
-#### `mutation`
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| `method` | `'POST' \| 'PUT' \| 'PATCH' \| 'DELETE'` | Yes | HTTP method |
+| `url` | `string` | Yes | URL pattern (e.g., `/users/$userId`) |
+| `responseSchema` | `ZodSchema` | Yes | Zod schema for response validation |
+| `requestSchema` | `ZodSchema` | No | Zod schema for request body |
+| `querySchema` | `ZodObject` | No | Zod schema for query parameters |
+| `processResponse` | `(data) => Result` | No | Transform the response |
+| `useKey` | `boolean` | No | Enable mutation key for scoping |
+| `useContext` | `() => Context` | No | Hook to provide context to callbacks |
+| `onMutate` | `(variables, context) => onMutateResult` | No | Called before mutation |
+| `onSuccess` | `(data, variables, context) => void` | No | Called on success |
+| `onError` | `(error, variables, context) => void` | No | Called on error |
+| `onSettled` | `(data, error, variables, context) => void` | No | Called on completion |
 
-This function is used to create a mutation for the API. It takes a configuration object with the following properties:
+### Context Object
 
-- `url`: The URL of the API endpoint. For parameterized URLs, use the format `/users/$userId`.
-- `method`: The HTTP method to use (PATCH, POST, PUT, DELETE, etc.).
-- `requestSchema`: A Zod schema for validating the request body.
-- `responseSchema`: A Zod schema for validating the response data.
-- `processResponse`: A function that takes the response data and returns the processed data. (optional, but recommended)
-- `useContext`: A function that is called before the mutation is executed. It can be used to set the context for the onSuccess and onError. (optional)
-- `onSuccess`: A function that is called when the mutation is successful. (optional)
-- `onError`: A function that is called when the mutation fails. (optional)
-- `useKey`: If true, the mutation will have a mutation key which can be used to get the mutation status, limit parallel requests, etc. (optional, defaults to false)
+The context passed to mutation callbacks includes:
 
-The result is a function that can be used to get mutation in react query. When `useKey` is true, the function requires a `urlParams` argument.
+- Properties from `useContext()` return value
+- `mutationId` - TanStack Query mutation ID
+- `meta` - Mutation metadata
+- `onMutateResult` - Return value from `onMutate` (in `onSuccess`, `onError`, `onSettled`)
 
-The result is a react query mutation object
+## Migration from 0.5.x
 
-#### `infiniteQuery`
+See [CHANGELOG.md](./CHANGELOG.md) for migration guide from 0.5.x to 0.6.0.
 
-This function is used to create an infinite query for the API. It takes a configuration object with the following properties:
+Key changes:
+- Mutation callbacks now receive `(data, variables, context)` instead of `(queryClient, data, variables)`
+- Use `useContext` hook to provide `queryClient` and other dependencies
+- New `onMutate` and `onSettled` callbacks for optimistic updates
 
-- `url`: The URL of the API endpoint. For parameterized URLs, use the format `/users/$userId`.
-- `method`: The HTTP method to use (GET, POST, PUT, DELETE, etc.).
-- `querySchema`: A Zod schema for validating the query parameters. (required)
-- `responseSchema`: A Zod schema for validating the response data.
-- `processResponse`: A function that takes the response data and returns the processed data. (optional, but recommended)
-- `getNextPageParam`: A function that takes the last page and all pages and returns the next page param. (required)
-- `initialPageData`: The initial data to use for the first page. (optional)
-- `getPreviousPageParam`: A function that takes the first page and all pages and returns the previous page param. (optional)
-- `select`: A function that takes the data and returns the selected data. (optional)
+## License
 
-It works the same as `query`, but it returns an infinite query object. Please refer to the `query` section for more details.
+MIT