@sanity/sdk-react 0.0.0-alpha.20 → 0.0.0-alpha.21

package/src/hooks/dashboard/useNavigateToStudioDocument.test.ts

@@ -0,0 +1,178 @@
+import {type Status} from '@sanity/comlink'
+import {type DocumentHandle} from '@sanity/sdk'
+import {act, renderHook} from '@testing-library/react'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {useNavigateToStudioDocument} from './useNavigateToStudioDocument'
+
+// Mock dependencies
+const mockSendMessage = vi.fn()
+const mockFetch = vi.fn()
+let mockWorkspacesByResourceId = {}
+let mockWorkspacesIsConnected = true
+let mockStatusCallback: ((status: Status) => void) | null = null
+
+vi.mock('../comlink/useWindowConnection', () => {
+  return {
+    useWindowConnection: ({onStatus}: {onStatus?: (status: Status) => void}) => {
+      mockStatusCallback = onStatus || null
+      return {
+        sendMessage: mockSendMessage,
+        fetch: mockFetch,
+      }
+    },
+  }
+})
+
+vi.mock('./useStudioWorkspacesByResourceId', () => {
+  return {
+    useStudioWorkspacesByResourceId: () => ({
+      workspacesByResourceId: mockWorkspacesByResourceId,
+      error: null,
+      isConnected: mockWorkspacesIsConnected,
+    }),
+  }
+})
+
+describe('useNavigateToStudioDocument', () => {
+  const mockDocumentHandle: DocumentHandle = {
+    _id: 'doc123',
+    _type: 'article',
+    resourceId: 'document:project1.dataset1:doc123',
+  }
+
+  const mockWorkspace = {
+    name: 'workspace1',
+    title: 'Workspace 1',
+    basePath: '/workspace1',
+    dataset: 'dataset1',
+    userApplicationId: 'user1',
+    url: 'https://test.sanity.studio',
+    _ref: 'workspace123',
+  }
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+    mockWorkspacesByResourceId = {
+      'project1:dataset1': [mockWorkspace],
+    }
+    mockWorkspacesIsConnected = true
+    mockStatusCallback = null
+  })
+
+  it('returns a function and connection status', () => {
+    const {result} = renderHook(() => useNavigateToStudioDocument(mockDocumentHandle))
+
+    // Initially not connected
+    expect(result.current.isConnected).toBe(false)
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    expect(result.current).toEqual({
+      navigateToStudioDocument: expect.any(Function),
+      isConnected: true,
+    })
+  })
+
+  it('sends correct navigation message when called', () => {
+    const {result} = renderHook(() => useNavigateToStudioDocument(mockDocumentHandle))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/bridge/navigate-to-resource', {
+      resourceId: 'workspace123',
+      resourceType: 'studio',
+      path: '/intent/edit/id=doc123;type=article',
+    })
+  })
+
+  it('does not send message when not connected', () => {
+    mockWorkspacesByResourceId = {}
+    mockWorkspacesIsConnected = false
+
+    const {result} = renderHook(() => useNavigateToStudioDocument(mockDocumentHandle))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    expect(mockSendMessage).not.toHaveBeenCalled()
+  })
+
+  it('does not send message when no workspace is found', () => {
+    mockWorkspacesByResourceId = {}
+    mockWorkspacesIsConnected = true
+
+    const {result} = renderHook(() => useNavigateToStudioDocument(mockDocumentHandle))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    expect(mockSendMessage).not.toHaveBeenCalled()
+  })
+
+  it('handles invalid resourceId format', () => {
+    const invalidDocHandle: DocumentHandle = {
+      _id: 'doc123',
+      _type: 'article',
+      resourceId: 'document:project1.invalid:doc123' as `document:${string}.${string}:${string}`,
+    }
+
+    const {result} = renderHook(() => useNavigateToStudioDocument(invalidDocHandle))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    expect(mockSendMessage).not.toHaveBeenCalled()
+  })
+
+  it('warns when multiple workspaces are found', () => {
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const mockWorkspace2 = {...mockWorkspace, _ref: 'workspace2'}
+
+    mockWorkspacesByResourceId = {
+      'project1:dataset1': [mockWorkspace, mockWorkspace2],
+    }
+
+    const {result} = renderHook(() => useNavigateToStudioDocument(mockDocumentHandle))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Multiple workspaces found for document',
+      mockDocumentHandle.resourceId,
+    )
+    expect(mockSendMessage).toHaveBeenCalledWith(
+      'dashboard/v1/bridge/navigate-to-resource',
+      expect.objectContaining({
+        resourceId: mockWorkspace._ref,
+      }),
+    )
+
+    consoleSpy.mockRestore()
+  })
+})

package/src/hooks/dashboard/useNavigateToStudioDocument.ts

@@ -1,4 +1,5 @@
 import {type Status} from '@sanity/comlink'
+import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
 import {type DocumentHandle} from '@sanity/sdk'
 import {useCallback, useState} from 'react'
 
@@ -6,7 +7,7 @@ import {useWindowConnection} from '../comlink/useWindowConnection'
 import {useStudioWorkspacesByResourceId} from './useStudioWorkspacesByResourceId'
 
 interface NavigateToResourceMessage {
-  type: 'core/v1/bridge/navigate-to-resource'
+  type: 'dashboard/v1/bridge/navigate-to-resource'
   data: {
     /**
      * Resource ID
@@ -32,10 +33,35 @@ interface NavigateToStudioResult {
 /**
  * @public
  * Hook that provides a function to navigate to a studio document.
+ * Currently, requires a document handle with a resourceId.
+ * That resourceId is currently formatted like: `document:projectId.dataset:documentId`
+ * If the hook you used to retrieve the document handle doesn't provide a resourceId like this,
+ * you can construct it according to the above format with the document handle's _id.
+ *
+ * This will only work if you have deployed a studio with a workspace
+ * with this projectId / dataset combination.
+ * It may be able to take a custom URL in the future.
+ *
+ * This will likely change in the future.
  * @param documentHandle - The document handle containing document ID, type, and resource ID
  * @returns An object containing:
  * - navigateToStudioDocument - Function that when called will navigate to the studio document
- * - isConnected - Boolean indicating if connection to Core UI is established
+ * - isConnected - Boolean indicating if connection to Dashboard is established
+ *
+ * @example
+ * ```ts
+ * import {navigateToStudioDocument, type DocumentHandle} from '@sanity/sdk'
+ *
+ * function MyComponent({documentHandle}: {documentHandle: DocumentHandle}) {
+ *   const {navigateToStudioDocument, isConnected} = useNavigateToStudioDocument(documentHandle)
+ *
+ *   return (
+ *     <button onClick={navigateToStudioDocument} disabled={!isConnected}>
+ *       Navigate to Studio Document
+ *     </button>
+ *   )
+ * }
+ * ```
  */
 export function useNavigateToStudioDocument(
   documentHandle: DocumentHandle,
@@ -44,8 +70,8 @@ export function useNavigateToStudioDocument(
     useStudioWorkspacesByResourceId()
   const [status, setStatus] = useState<Status>('idle')
   const {sendMessage} = useWindowConnection<NavigateToResourceMessage, never>({
-    name: 'core/nodes/sdk',
-    connectTo: 'core/channels/sdk',
+    name: SDK_NODE_NAME,
+    connectTo: SDK_CHANNEL_NAME,
     onStatus: setStatus,
   })
 
@@ -79,7 +105,7 @@ export function useNavigateToStudioDocument(
     const workspace = workspaces[0]
 
     const message: NavigateToResourceMessage = {
-      type: 'core/v1/bridge/navigate-to-resource',
+      type: 'dashboard/v1/bridge/navigate-to-resource',
       data: {
         resourceId: workspace._ref,
         resourceType: 'studio',

package/src/hooks/dashboard/useStudioWorkspacesByResourceId.test.tsx

@@ -140,7 +140,11 @@ describe('useStudioWorkspacesByResourceId', () => {
       expect(result.current.isConnected).toBe(true)
     })
 
-    expect(mockFetch).toHaveBeenCalledWith('core/v1/bridge/context', undefined, expect.any(Object))
+    expect(mockFetch).toHaveBeenCalledWith(
+      'dashboard/v1/bridge/context',
+      undefined,
+      expect.any(Object),
+    )
   })
 
   it('should handle fetch errors', async () => {

package/src/hooks/dashboard/useStudioWorkspacesByResourceId.ts

@@ -1,4 +1,5 @@
 import {type Status} from '@sanity/comlink'
+import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
 import {useEffect, useState} from 'react'
 
 import {useWindowConnection} from '../comlink/useWindowConnection'
@@ -33,8 +34,8 @@ export function useStudioWorkspacesByResourceId(): StudioWorkspacesResult {
   const [error, setError] = useState<string | null>(null)
 
   const {fetch} = useWindowConnection({
-    name: 'core/nodes/sdk',
-    connectTo: 'core/channels/sdk',
+    name: SDK_NODE_NAME,
+    connectTo: SDK_CHANNEL_NAME,
     onStatus: setStatus,
   })
 
@@ -47,7 +48,7 @@ export function useStudioWorkspacesByResourceId(): StudioWorkspacesResult {
       try {
         const data = await fetch<{
           context: {availableResources: Array<{projectId: string; workspaces: Workspace[]}>}
-        }>('core/v1/bridge/context', undefined, {signal})
+        }>('dashboard/v1/bridge/context', undefined, {signal})
 
         const workspaceMap: WorkspacesByResourceId = {}
 

package/src/hooks/datasets/useDatasets.ts

@@ -6,10 +6,10 @@ import {createStateSourceHook} from '../helpers/createStateSourceHook'
 type UseDatasets = {
   /**
    *
-   * Returns metadata for each dataset in your organization.
+   * Returns metadata for each dataset the current user has access to.
    *
    * @category Datasets
-   * @returns The metadata for your organization's datasets
+   * @returns The metadata for your the datasets
    *
    * @example
    * ```tsx
@@ -28,7 +28,10 @@ type UseDatasets = {
   (): DatasetsResponse
 }
 
-/** @public */
+/**
+ * @public
+ * @function
+ */
 export const useDatasets: UseDatasets = createStateSourceHook({
   // remove `undefined` since we're suspending when that is the case
   getState: getDatasetsState as (instance: SanityInstance) => StateSource<DatasetsResponse>,

package/src/hooks/document/useApplyDocumentActions.test.ts

@@ -0,0 +1,25 @@
+import {applyDocumentActions, createDocument, type ResourceId} from '@sanity/sdk'
+import {describe, it} from 'vitest'
+
+import {createCallbackHook} from '../helpers/createCallbackHook'
+
+vi.mock('../helpers/createCallbackHook', () => ({
+  createCallbackHook: vi.fn((cb) => () => cb),
+}))
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...original, applyDocumentActions: vi.fn()}
+})
+
+describe('useApplyDocumentActions', () => {
+  it('calls `createCallbackHook` with `applyDocumentActions`', async () => {
+    const {useApplyDocumentActions} = await import('./useApplyDocumentActions')
+    const resourceId: ResourceId = 'project1.dataset1'
+    expect(createCallbackHook).not.toHaveBeenCalled()
+
+    expect(applyDocumentActions).not.toHaveBeenCalled()
+    const apply = useApplyDocumentActions(resourceId)
+    apply(createDocument({_type: 'author'}))
+    expect(applyDocumentActions).toHaveBeenCalledWith(createDocument({_type: 'author'}))
+  })
+})

package/src/hooks/document/{useApplyActions.ts → useApplyDocumentActions.ts}

@@ -1,7 +1,7 @@
 import {
   type ActionsResult,
-  applyActions,
-  type ApplyActionsOptions,
+  applyDocumentActions,
+  type ApplyDocumentActionsOptions,
   type DocumentAction,
   type ResourceId,
 } from '@sanity/sdk'
@@ -21,9 +21,9 @@ import {createCallbackHook} from '../helpers/createCallbackHook'
  * @example Publish or unpublish a document
  * ```
  * import { publishDocument, unpublishDocument } from '@sanity/sdk'
- * import { useApplyActions } from '@sanity/sdk-react'
+ * import { useApplyDocumentActions } from '@sanity/sdk-react'
  *
- * const apply = useApplyActions()
+ * const apply = useApplyDocumentActions()
  * const myDocument = { _id: 'my-document-id', _type: 'my-document-type' }
  *
  * return (
@@ -35,9 +35,9 @@ import {createCallbackHook} from '../helpers/createCallbackHook'
  * @example Create and publish a new document
  * ```
  * import { createDocument, publishDocument } from '@sanity/sdk'
- * import { useApplyActions } from '@sanity/sdk-react'
+ * import { useApplyDocumentActions } from '@sanity/sdk-react'
  *
- * const apply = useApplyActions()
+ * const apply = useApplyDocumentActions()
  *
  * const handleCreateAndPublish = () => {
  *   const handle = { _id: window.crypto.randomUUID(), _type: 'my-document-type' }
@@ -54,21 +54,22 @@ import {createCallbackHook} from '../helpers/createCallbackHook'
  * )
  * ```
  */
-export function useApplyActions(
+export function useApplyDocumentActions(
   resourceId?: ResourceId,
 ): <TDocument extends SanityDocument>(
   action: DocumentAction<TDocument> | DocumentAction<TDocument>[],
-  options?: ApplyActionsOptions,
+  options?: ApplyDocumentActionsOptions,
 ) => Promise<ActionsResult<TDocument>>
 
 /** @beta */
-export function useApplyActions(
+export function useApplyDocumentActions(
   resourceId?: ResourceId,
 ): (
   action: DocumentAction | DocumentAction[],
-  options?: ApplyActionsOptions,
+  options?: ApplyDocumentActionsOptions,
 ) => Promise<ActionsResult> {
-  return _useApplyActions(resourceId)()
+  return _useApplyDocumentActions(resourceId)()
 }
 
-const _useApplyActions = (resourceId?: ResourceId) => createCallbackHook(applyActions, resourceId)
+const _useApplyDocumentActions = (resourceId?: ResourceId) =>
+  createCallbackHook(applyDocumentActions, resourceId)

package/src/hooks/document/{usePermissions.ts → useDocumentPermissions.ts}

@@ -1,8 +1,8 @@
 import {
   type DocumentAction,
+  type DocumentPermissionsResult,
   getPermissionsState,
   getResourceId,
-  type PermissionsResult,
 } from '@sanity/sdk'
 import {useCallback, useMemo, useSyncExternalStore} from 'react'
 import {filter, firstValueFrom} from 'rxjs'
@@ -21,12 +21,12 @@ import {useSanityInstance} from '../context/useSanityInstance'
  *
  * @example Checking for permission to publish a document
  * ```ts
- * import {usePermissions, useApplyActions} from '@sanity/sdk-react'
+ * import {useDocumentPermissions, useApplyDocumentActions} from '@sanity/sdk-react'
  * import {publishDocument} from '@sanity/sdk'
  *
  * export function PublishButton({doc}: {doc: DocumentHandle}) {
- *   const publishPermissions = usePermissions(publishDocument(doc))
- *   const applyAction = useApplyActions()
+ *   const publishPermissions = useDocumentPermissions(publishDocument(doc))
+ *   const applyAction = useApplyDocumentActions()
  *
  *   return (
  *     <>
@@ -47,7 +47,9 @@ import {useSanityInstance} from '../context/useSanityInstance'
  * }
  * ```
  */
-export function usePermissions(actions: DocumentAction | DocumentAction[]): PermissionsResult {
+export function useDocumentPermissions(
+  actions: DocumentAction | DocumentAction[],
+): DocumentPermissionsResult {
   // if actions is an array, we need to check each action to see if the resourceId is the same
   if (Array.isArray(actions)) {
     const resourceIds = actions.map((action) => action.resourceId)
@@ -78,5 +80,5 @@ export function usePermissions(actions: DocumentAction | DocumentAction[]): Perm
     [actions, instance],
   )
 
-  return useSyncExternalStore(subscribe, getCurrent) as PermissionsResult
+  return useSyncExternalStore(subscribe, getCurrent) as DocumentPermissionsResult
 }

package/src/hooks/document/useDocumentSyncStatus.ts

@@ -25,6 +25,9 @@ type UseDocumentSyncStatus = {
   (doc: DocumentHandle): boolean | undefined
 }
 
-/** @beta */
+/**
+ * @beta
+ * @function
+ */
 export const useDocumentSyncStatus: UseDocumentSyncStatus =
   createStateSourceHook(getDocumentSyncStatus)

package/src/hooks/document/useEditDocument.test.ts

@@ -12,7 +12,7 @@ import {renderHook} from '@testing-library/react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {useSanityInstance} from '../context/useSanityInstance'
-import {useApplyActions} from './useApplyActions'
+import {useApplyDocumentActions} from './useApplyDocumentActions'
 import {useEditDocument} from './useEditDocument'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
@@ -29,8 +29,8 @@ vi.mock('../context/useSanityInstance', () => ({
   useSanityInstance: vi.fn(),
 }))
 
-vi.mock('./useApplyActions', () => ({
-  useApplyActions: vi.fn(),
+vi.mock('./useApplyDocumentActions', () => ({
+  useApplyDocumentActions: vi.fn(),
 }))
 
 // Create a fake instance to be returned by useSanityInstance.
@@ -66,7 +66,7 @@ describe('useEditDocument hook', () => {
     } as unknown as StateSource<SanityDocument>)
 
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx1'})
-    vi.mocked(useApplyActions).mockReturnValue(apply)
+    vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
     const {result} = renderHook(() => useEditDocument(docHandle, 'foo'))
     const promise = result.current('newValue')
@@ -87,7 +87,7 @@ describe('useEditDocument hook', () => {
     } as unknown as StateSource<SanityDocument>)
 
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx2'})
-    vi.mocked(useApplyActions).mockReturnValue(apply)
+    vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
     const {result} = renderHook(() => useEditDocument(docHandle))
     const promise = result.current({...doc, foo: 'baz', extra: 'old', _id: 'doc1'})
@@ -105,7 +105,7 @@ describe('useEditDocument hook', () => {
     } as unknown as StateSource<SanityDocument>)
 
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx3'})
-    vi.mocked(useApplyActions).mockReturnValue(apply)
+    vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
     const {result} = renderHook(() => useEditDocument(docHandle, 'foo'))
     const promise = result.current((prev: unknown) => `${prev}Updated`) // 'bar' becomes 'barUpdated'
@@ -125,7 +125,7 @@ describe('useEditDocument hook', () => {
     } as unknown as StateSource<SanityDocument>)
 
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx4'})
-    vi.mocked(useApplyActions).mockReturnValue(apply)
+    vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
     const {result} = renderHook(() => useEditDocument(docHandle))
     const promise = result.current((prevDoc) => ({...prevDoc, foo: 'baz'}))
@@ -143,7 +143,7 @@ describe('useEditDocument hook', () => {
     } as unknown as StateSource<SanityDocument>)
 
     const fakeApply = vi.fn()
-    vi.mocked(useApplyActions).mockReturnValue(fakeApply)
+    vi.mocked(useApplyDocumentActions).mockReturnValue(fakeApply)
 
     const {result} = renderHook(() => useEditDocument(docHandle))
     expect(() => result.current('notAnObject' as unknown as SanityDocument)).toThrowError(

package/src/hooks/document/useEditDocument.ts

@@ -12,7 +12,7 @@ import {type SanityDocument} from '@sanity/types'
 import {useCallback} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
-import {useApplyActions} from './useApplyActions'
+import {useApplyDocumentActions} from './useApplyDocumentActions'
 
 const ignoredKeys = ['_id', '_type', '_createdAt', '_updatedAt', '_rev']
 
@@ -154,7 +154,7 @@ export function useEditDocument(
   const resourceId = getResourceId(doc.resourceId)!
   const documentId = doc._id
   const instance = useSanityInstance(resourceId)
-  const apply = useApplyActions(resourceId)
+  const apply = useApplyDocumentActions(resourceId)
   const isDocumentReady = useCallback(
     () => getDocumentState(instance, documentId).getCurrent() !== undefined,
     [instance, documentId],

package/src/hooks/{infiniteList/useInfiniteList.test.tsx → documents/useDocuments.test.tsx}

@@ -3,11 +3,11 @@ import {describe, vi} from 'vitest'
 
 import {evaluateSync, parse} from '../_synchronous-groq-js.mjs'
 import {useQuery} from '../query/useQuery'
-import {useInfiniteList} from './useInfiniteList'
+import {useDocuments} from './useDocuments'
 
 vi.mock('../query/useQuery')
 
-describe('useInfiniteList', () => {
+describe('useDocuments', () => {
   beforeEach(() => {
     const dataset = [
       {
@@ -76,13 +76,13 @@ describe('useInfiniteList', () => {
 
   it('should respect custom page size', () => {
     const customBatchSize = 2
-    const {result} = renderHook(() => useInfiniteList({batchSize: customBatchSize}))
+    const {result} = renderHook(() => useDocuments({batchSize: customBatchSize}))
 
     expect(result.current.data.length).toBe(customBatchSize)
   })
 
   it('should filter by document type', () => {
-    const {result} = renderHook(() => useInfiniteList({filter: '_type == "movie"'}))
+    const {result} = renderHook(() => useDocuments({filter: '_type == "movie"'}))
 
     expect(result.current.data.every((doc) => doc._type === 'movie')).toBe(true)
     expect(result.current.count).toBe(5) // 5 movies in the dataset
@@ -90,7 +90,7 @@ describe('useInfiniteList', () => {
 
   // groq-js doesn't support search filters yet
   it.skip('should apply search filter', () => {
-    const {result} = renderHook(() => useInfiniteList({search: 'inter'}))
+    const {result} = renderHook(() => useDocuments({search: 'inter'}))
 
     // Should match "Interstellar"
     expect(result.current.data.some((doc) => doc._id === 'movie3')).toBe(true)
@@ -98,7 +98,7 @@ describe('useInfiniteList', () => {
 
   it('should apply ordering', () => {
     const {result} = renderHook(() =>
-      useInfiniteList({
+      useDocuments({
         filter: '_type == "movie"',
         orderings: [{field: 'releaseYear', direction: 'desc'}],
       }),
@@ -110,7 +110,7 @@ describe('useInfiniteList', () => {
 
   it('should load more data when loadMore is called', () => {
     const batchSize = 2
-    const {result} = renderHook(() => useInfiniteList({batchSize: batchSize}))
+    const {result} = renderHook(() => useDocuments({batchSize: batchSize}))
 
     expect(result.current.data.length).toBe(batchSize)
 
@@ -122,7 +122,7 @@ describe('useInfiniteList', () => {
   })
 
   it('should indicate when there is more data to load', () => {
-    const {result} = renderHook(() => useInfiniteList({batchSize: 3}))
+    const {result} = renderHook(() => useDocuments({batchSize: 3}))
     expect(result.current.hasMore).toBe(true)
     // Load all remaining data
     act(() => {
@@ -133,7 +133,7 @@ describe('useInfiniteList', () => {
 
   // New test case for resetting limit when filter changes
   it('should reset limit when filter changes', () => {
-    const {result, rerender} = renderHook((props) => useInfiniteList(props), {
+    const {result, rerender} = renderHook((props) => useDocuments(props), {
       initialProps: {batchSize: 2, filter: ''},
     })
     // Initially, data length equals pageSize (2)