@sanity/sdk-react 2.2.0 → 2.3.0

package/src/hooks/document/{useDocumentPermissions.test.ts → useDocumentPermissions.test.tsx}

@@ -1,24 +1,18 @@
-import {
-  type DocumentAction,
-  type DocumentPermissionsResult,
-  getPermissionsState,
-  type SanityInstance,
-} from '@sanity/sdk'
+import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
 import {act, renderHook, waitFor} from '@testing-library/react'
 import {BehaviorSubject, firstValueFrom} from 'rxjs'
 import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {useDocumentPermissions} from './useDocumentPermissions'
 
-// Mock dependencies before any imports
-vi.mock('../context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
-
-vi.mock('@sanity/sdk', () => ({
-  getPermissionsState: vi.fn(),
-}))
+vi.mock('@sanity/sdk', async (importActual) => {
+  const actual = await importActual<typeof import('@sanity/sdk')>()
+  return {
+    ...actual,
+    getPermissionsState: vi.fn(),
+  }
+})
 
 // Move this mock to the top level
 vi.mock('rxjs', async (importOriginal) => {
@@ -30,7 +24,6 @@ vi.mock('rxjs', async (importOriginal) => {
 })
 
 describe('usePermissions', () => {
-  const mockInstance = {id: 'mock-instance'} as unknown as SanityInstance
   const mockAction: DocumentAction = {
     type: 'document.publish',
     documentId: 'doc1',
@@ -59,8 +52,6 @@ describe('usePermissions', () => {
   beforeEach(() => {
     vi.clearAllMocks()
 
-    vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
-
     // Create a subject to simulate permissions state updates
     permissionsSubject = new BehaviorSubject<DocumentPermissionsResult | undefined>(
       mockPermissionAllowed,
@@ -93,13 +84,20 @@ describe('usePermissions', () => {
       permissionsSubject.next(mockPermissionAllowed)
     })
 
-    const {result} = renderHook(() => useDocumentPermissions(mockAction))
-
-    expect(useSanityInstance).toHaveBeenCalledWith({
-      projectId: mockAction.projectId,
-      dataset: mockAction.dataset,
+    const {result} = renderHook(() => useDocumentPermissions(mockAction), {
+      wrapper: ({children}) => (
+        <ResourceProvider
+          projectId={mockAction.projectId}
+          dataset={mockAction.dataset}
+          fallback={null}
+        >
+          {children}
+        </ResourceProvider>
+      ),
     })
-    expect(getPermissionsState).toHaveBeenCalledWith(mockInstance, mockAction)
+
+    // ResourceProvider handles the instance configuration
+    expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), mockAction)
     expect(result.current).toEqual(mockPermissionAllowed)
   })
 
@@ -109,7 +107,17 @@ describe('usePermissions', () => {
       permissionsSubject.next(mockPermissionDenied)
     })
 
-    const {result} = renderHook(() => useDocumentPermissions(mockAction))
+    const {result} = renderHook(() => useDocumentPermissions(mockAction), {
+      wrapper: ({children}) => (
+        <ResourceProvider
+          projectId={mockAction.projectId}
+          dataset={mockAction.dataset}
+          fallback={null}
+        >
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current).toEqual(mockPermissionDenied)
     expect(result.current.allowed).toBe(false)
@@ -120,9 +128,19 @@ describe('usePermissions', () => {
   it('should accept an array of actions', () => {
     const actions = [mockAction, {...mockAction, documentId: 'doc2'}]
 
-    renderHook(() => useDocumentPermissions(actions))
+    renderHook(() => useDocumentPermissions(actions), {
+      wrapper: ({children}) => (
+        <ResourceProvider
+          projectId={mockAction.projectId}
+          dataset={mockAction.dataset}
+          fallback={null}
+        >
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
-    expect(getPermissionsState).toHaveBeenCalledWith(mockInstance, actions)
+    expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), actions)
   })
 
   it('should throw an error if actions have mismatched project IDs', () => {
@@ -132,7 +150,17 @@ describe('usePermissions', () => {
     ]
 
     expect(() => {
-      renderHook(() => useDocumentPermissions(actions))
+      renderHook(() => useDocumentPermissions(actions), {
+        wrapper: ({children}) => (
+          <ResourceProvider
+            projectId={mockAction.projectId}
+            dataset={mockAction.dataset}
+            fallback={null}
+          >
+            {children}
+          </ResourceProvider>
+        ),
+      })
     }).toThrow(/Mismatched project IDs found in actions/)
   })
 
@@ -140,7 +168,17 @@ describe('usePermissions', () => {
     const actions = [mockAction, {...mockAction, dataset: 'different-dataset', documentId: 'doc2'}]
 
     expect(() => {
-      renderHook(() => useDocumentPermissions(actions))
+      renderHook(() => useDocumentPermissions(actions), {
+        wrapper: ({children}) => (
+          <ResourceProvider
+            projectId={mockAction.projectId}
+            dataset={mockAction.dataset}
+            fallback={null}
+          >
+            {children}
+          </ResourceProvider>
+        ),
+      })
     }).toThrow(/Mismatched datasets found in actions/)
   })
 
@@ -155,16 +193,29 @@ describe('usePermissions', () => {
     vi.mocked(firstValueFrom).mockReturnValueOnce(mockPromise)
 
     // This should throw the promise and suspend
-    const {result} = renderHook(() => {
-      try {
-        return useDocumentPermissions(mockAction)
-      } catch (error) {
-        if (error instanceof Promise) {
-          return 'suspended'
+    const {result} = renderHook(
+      () => {
+        try {
+          return useDocumentPermissions(mockAction)
+        } catch (error) {
+          if (error instanceof Promise) {
+            return 'suspended'
+          }
+          throw error
         }
-        throw error
-      }
-    })
+      },
+      {
+        wrapper: ({children}) => (
+          <ResourceProvider
+            projectId={mockAction.projectId}
+            dataset={mockAction.dataset}
+            fallback={null}
+          >
+            {children}
+          </ResourceProvider>
+        ),
+      },
+    )
 
     expect(result.current).toBe('suspended')
 
@@ -175,7 +226,7 @@ describe('usePermissions', () => {
 
     // Now it should render properly
     await waitFor(() => {
-      expect(getPermissionsState).toHaveBeenCalledWith(mockInstance, mockAction)
+      expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), mockAction)
     })
   })
 
@@ -185,7 +236,17 @@ describe('usePermissions', () => {
       permissionsSubject.next(mockPermissionAllowed)
     })
 
-    const {result, rerender} = renderHook(() => useDocumentPermissions(mockAction))
+    const {result, rerender} = renderHook(() => useDocumentPermissions(mockAction), {
+      wrapper: ({children}) => (
+        <ResourceProvider
+          projectId={mockAction.projectId}
+          dataset={mockAction.dataset}
+          fallback={null}
+        >
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current).toEqual(mockPermissionAllowed)
 

package/src/hooks/document/{useEditDocument.test.ts → useEditDocument.test.tsx}

@@ -1,7 +1,6 @@
 // tests/useEditDocument.test.ts
 import {
   createDocumentHandle,
-  createSanityInstance,
   editDocument,
   getDocumentState,
   resolveDocument,
@@ -11,7 +10,7 @@ import {type SanityDocument} from '@sanity/types'
 import {renderHook} from '@testing-library/react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {useApplyDocumentActions} from './useApplyDocumentActions'
 import {useEditDocument} from './useEditDocument'
 
@@ -25,17 +24,10 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
   }
 })
 
-vi.mock('../context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
-
 vi.mock('./useApplyDocumentActions', () => ({
   useApplyDocumentActions: vi.fn(),
 }))
 
-// Create a fake instance to be returned by useSanityInstance.
-const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-
 const doc = {
   _id: 'doc1',
   foo: 'bar',
@@ -71,7 +63,6 @@ declare module 'groq' {
 describe('useEditDocument hook', () => {
   beforeEach(() => {
     vi.clearAllMocks()
-    vi.mocked(useSanityInstance).mockReturnValue(instance)
   })
 
   it('applies a single edit action for the given path', async () => {
@@ -85,7 +76,13 @@ describe('useEditDocument hook', () => {
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx1'})
     vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
-    const {result} = renderHook(() => useEditDocument<string>({...docHandle, path: 'foo'}))
+    const {result} = renderHook(() => useEditDocument<string>({...docHandle, path: 'foo'}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     const promise = result.current('newValue')
     expect(editDocument).toHaveBeenCalledWith(docHandle, {set: {foo: 'newValue'}})
     expect(apply).toHaveBeenCalledWith(editDocument(docHandle, {set: {foo: 'newValue'}}))
@@ -106,7 +103,13 @@ describe('useEditDocument hook', () => {
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx2'})
     vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
-    const {result} = renderHook(() => useEditDocument(docHandle))
+    const {result} = renderHook(() => useEditDocument(docHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     const promise = result.current({...doc, foo: 'baz', extra: 'old', _id: 'doc1'})
     expect(apply).toHaveBeenCalledWith([editDocument(docHandle, {set: {foo: 'baz'}})])
     const actionsResult = await promise
@@ -124,7 +127,13 @@ describe('useEditDocument hook', () => {
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx3'})
     vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
-    const {result} = renderHook(() => useEditDocument<string>({...docHandle, path: 'foo'}))
+    const {result} = renderHook(() => useEditDocument<string>({...docHandle, path: 'foo'}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     const promise = result.current((prev: unknown) => `${prev}Updated`) // 'bar' becomes 'barUpdated'
     expect(editDocument).toHaveBeenCalledWith(docHandle, {set: {foo: 'barUpdated'}})
     expect(apply).toHaveBeenCalledWith(editDocument(docHandle, {set: {foo: 'barUpdated'}}))
@@ -144,7 +153,13 @@ describe('useEditDocument hook', () => {
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx4'})
     vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
-    const {result} = renderHook(() => useEditDocument(docHandle))
+    const {result} = renderHook(() => useEditDocument(docHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     const promise = result.current((prevDoc) => ({...prevDoc, foo: 'baz'}))
     expect(apply).toHaveBeenCalledWith([editDocument(docHandle, {set: {foo: 'baz'}})])
     const actionsResult = await promise
@@ -162,7 +177,13 @@ describe('useEditDocument hook', () => {
     const fakeApply = vi.fn()
     vi.mocked(useApplyDocumentActions).mockReturnValue(fakeApply)
 
-    const {result} = renderHook(() => useEditDocument(docHandle))
+    const {result} = renderHook(() => useEditDocument(docHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     expect(() => result.current('notAnObject' as unknown as Book)).toThrowError(
       'No path was provided to `useEditDocument` and the value provided was not a document object.',
     )
@@ -182,13 +203,22 @@ describe('useEditDocument hook', () => {
     vi.mocked(resolveDocument).mockReturnValue(resolveDocPromise)
 
     // Render the hook and capture the thrown promise.
-    const {result} = renderHook(() => {
-      try {
-        return useEditDocument(docHandle)
-      } catch (e) {
-        return e
-      }
-    })
+    const {result} = renderHook(
+      () => {
+        try {
+          return useEditDocument(docHandle)
+        } catch (e) {
+          return e
+        }
+      },
+      {
+        wrapper: ({children}) => (
+          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+            {children}
+          </ResourceProvider>
+        ),
+      },
+    )
 
     // When the document is not ready, the hook throws the promise from resolveDocument.
     expect(result.current).toBe(resolveDocPromise)

package/src/hooks/documents/useDocuments.test.tsx

@@ -1,14 +1,12 @@
-import {type SanityInstance} from '@sanity/sdk'
 import {act, renderHook} from '@testing-library/react'
+import {evaluateSync, parse, toJS} from 'groq-js'
 import {describe, vi} from 'vitest'
 
-import {evaluateSync, parse} from '../_synchronous-groq-js.mjs'
-import {useSanityInstance} from '../context/useSanityInstance'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {useQuery} from '../query/useQuery'
 import {useDocuments} from './useDocuments'
 
 vi.mock('../query/useQuery')
-vi.mock('../context/useSanityInstance')
 
 describe('useDocuments', () => {
   beforeEach(() => {
@@ -69,24 +67,35 @@ describe('useDocuments', () => {
     ]
 
     vi.mocked(useQuery).mockImplementation(({query, ...options}) => {
-      const result = evaluateSync(parse(query), {dataset, params: options?.params}).get()
+      const result = toJS(evaluateSync(parse(query), {dataset, params: options?.params}))
       return {
         data: result,
         isPending: false,
       }
     })
-    vi.mocked(useSanityInstance).mockReturnValue({config: {}} as SanityInstance)
   })
 
   it('should respect custom page size', () => {
     const customBatchSize = 2
-    const {result} = renderHook(() => useDocuments({batchSize: customBatchSize}))
+    const {result} = renderHook(() => useDocuments({batchSize: customBatchSize}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current.data.length).toBe(customBatchSize)
   })
 
   it('should filter by document type', () => {
-    const {result} = renderHook(() => useDocuments({filter: '_type == "movie"'}))
+    const {result} = renderHook(() => useDocuments({filter: '_type == "movie"'}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current.data.every((doc) => doc.documentType === 'movie')).toBe(true)
     expect(result.current.count).toBe(5) // 5 movies in the dataset
@@ -94,18 +103,32 @@ describe('useDocuments', () => {
 
   // groq-js doesn't support search filters yet
   it.skip('should apply search filter', () => {
-    const {result} = renderHook(() => useDocuments({search: 'inter'}))
+    const {result} = renderHook(() => useDocuments({search: 'inter'}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     // Should match "Interstellar"
     expect(result.current.data.some((doc) => doc.documentId === 'movie3')).toBe(true)
   })
 
   it('should apply ordering', () => {
-    const {result} = renderHook(() =>
-      useDocuments({
-        filter: '_type == "movie"',
-        orderings: [{field: 'releaseYear', direction: 'desc'}],
-      }),
+    const {result} = renderHook(
+      () =>
+        useDocuments({
+          filter: '_type == "movie"',
+          orderings: [{field: 'releaseYear', direction: 'desc'}],
+        }),
+      {
+        wrapper: ({children}) => (
+          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+            {children}
+          </ResourceProvider>
+        ),
+      },
     )
 
     // First item should be the most recent movie (Interstellar, 2014)
@@ -114,7 +137,13 @@ describe('useDocuments', () => {
 
   it('should load more data when loadMore is called', () => {
     const batchSize = 2
-    const {result} = renderHook(() => useDocuments({batchSize: batchSize}))
+    const {result} = renderHook(() => useDocuments({batchSize: batchSize}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current.data.length).toBe(batchSize)
 
@@ -126,7 +155,13 @@ describe('useDocuments', () => {
   })
 
   it('should indicate when there is more data to load', () => {
-    const {result} = renderHook(() => useDocuments({batchSize: 3}))
+    const {result} = renderHook(() => useDocuments({batchSize: 3}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     expect(result.current.hasMore).toBe(true)
     // Load all remaining data
     act(() => {
@@ -139,6 +174,11 @@ describe('useDocuments', () => {
   it('should reset limit when filter changes', () => {
     const {result, rerender} = renderHook((props) => useDocuments(props), {
       initialProps: {batchSize: 2, filter: ''},
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
     })
     // Initially, data length equals pageSize (2)
     expect(result.current.data.length).toBe(2)
@@ -155,15 +195,13 @@ describe('useDocuments', () => {
   })
 
   it('should add projectId and dataset to document handles', () => {
-    // Update the mock to include specific projectId and dataset
-    vi.mocked(useSanityInstance).mockReturnValue({
-      config: {
-        projectId: 'test-project',
-        dataset: 'test-dataset',
-      },
-    } as SanityInstance)
-
-    const {result} = renderHook(() => useDocuments({}))
+    const {result} = renderHook(() => useDocuments({}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     // Check that the first document handle has the projectId and dataset
     expect(result.current.data[0].projectId).toBe('test-project')

package/src/hooks/helpers/createCallbackHook.test.tsx

@@ -1,15 +1,10 @@
-import {createSanityInstance, type SanityInstance} from '@sanity/sdk'
+import {type SanityInstance} from '@sanity/sdk'
 import {renderHook} from '@testing-library/react'
 import {describe, expect, it, vi} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {createCallbackHook} from './createCallbackHook'
 
-// Mock the useSanityInstance hook
-vi.mock('../context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
-
 describe('createCallbackHook', () => {
   // Reset all mocks before each test
   beforeEach(() => {
@@ -17,12 +12,6 @@ describe('createCallbackHook', () => {
   })
 
   it('should create a hook that provides a memoized callback', () => {
-    // Create a mock Sanity instance
-    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
-
-    // Mock the useSanityInstance to return our mock instance
-    vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
-
     // Create a test callback function
     const testCallback = (instance: object, param1: string, param2: number) => {
       return `${param1}-${param2}-${instance ? 'valid' : 'invalid'}`
@@ -32,7 +21,13 @@ describe('createCallbackHook', () => {
     const useTestHook = createCallbackHook(testCallback)
 
     // Render the hook
-    const {result, rerender} = renderHook(() => useTestHook())
+    const {result, rerender} = renderHook(() => useTestHook(), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="p" dataset="d" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     // Test the callback with parameters
     const result1 = result.current('test', 123)
@@ -48,38 +43,41 @@ describe('createCallbackHook', () => {
   })
 
   it('should create new callback when instance changes', () => {
-    // Create two different mock instances
-    const mockInstance1 = createSanityInstance({projectId: 'p1', dataset: 'd'})
-    const mockInstance2 = createSanityInstance({projectId: 'p2', dataset: 'd'})
-
-    vi.mocked(useSanityInstance).mockReturnValueOnce(mockInstance1)
-
     // Create a test callback
     const testCallback = (instance: SanityInstance) => instance.config.projectId
 
-    // Create and render our hook
+    // Create and render our hook with first provider
     const useTestHook = createCallbackHook(testCallback)
-    const {result, rerender} = renderHook(() => useTestHook())
+    const {result, unmount} = renderHook(() => useTestHook(), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="p1" dataset="d" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
-    // Store the first callback reference
+    // Store the first callback reference and result
     const firstCallback = result.current
+    const firstResult = firstCallback()
+    expect(firstResult).toBe('p1')
+
+    unmount()
+
+    // Re-render with different provider configuration
+    const {result: result2} = renderHook(() => useTestHook(), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="p2" dataset="d" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
-    // Change the instance
-    vi.mocked(useSanityInstance).mockReturnValueOnce(mockInstance2)
-    rerender()
-
-    // Verify the callback reference changed
-    expect(result.current).not.toBe(firstCallback)
-
-    // Verify the callbacks return different results
-    expect(firstCallback()).toBe('p1')
-    expect(result.current()).toBe('p2')
+    // Verify the callback reference changed and returns different result
+    expect(result2.current).not.toBe(firstCallback)
+    expect(result2.current()).toBe('p2')
   })
 
   it('should handle callbacks with multiple parameters', () => {
-    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
-
     // Create a callback with multiple parameters
     const testCallback = (
       instance: SanityInstance,
@@ -93,7 +91,13 @@ describe('createCallbackHook', () => {
     })
 
     const useTestHook = createCallbackHook(testCallback)
-    const {result} = renderHook(() => useTestHook())
+    const {result} = renderHook(() => useTestHook(), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="p" dataset="d" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     const response = result.current('/users', 'POST', {name: 'Test User'})
 

package/src/hooks/paginatedDocuments/usePaginatedDocuments.test.tsx

@@ -1,8 +1,8 @@
 import {act, renderHook} from '@testing-library/react'
+import {evaluateSync, parse, toJS} from 'groq-js'
 import {describe, vi} from 'vitest'
 
 import {ResourceProvider} from '../../context/ResourceProvider'
-import {evaluateSync, parse} from '../_synchronous-groq-js.mjs'
 import {useQuery} from '../query/useQuery'
 import {usePaginatedDocuments} from './usePaginatedDocuments'
 
@@ -73,7 +73,7 @@ describe('usePaginatedDocuments', () => {
     ]
 
     vi.mocked(useQuery).mockImplementation(({query, ...options}) => {
-      const result = evaluateSync(parse(query), {dataset, params: options?.params}).get()
+      const result = toJS(evaluateSync(parse(query), {dataset, params: options?.params}))
       return {
         data: result,
         isPending: false,