@sanity/sdk-react 2.2.0 → 2.3.0

package/src/hooks/auth/useVerifyOrgProjects.test.tsx

@@ -3,7 +3,7 @@ import {act, renderHook, waitFor} from '@testing-library/react'
 import {Subject} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {useVerifyOrgProjects} from './useVerifyOrgProjects'
 
 // Mock dependencies
@@ -14,33 +14,46 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
     observeOrganizationVerificationState: vi.fn(),
   }
 })
-vi.mock('../context/useSanityInstance')
 
 describe('useVerifyOrgProjects', () => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const mockInstance = {config: {}} as any // Dummy instance
   const mockObserve = vi.mocked(observeOrganizationVerificationState)
-  const mockUseInstance = vi.mocked(useSanityInstance)
   const testProjectIds = ['proj-1']
 
   beforeEach(() => {
     vi.clearAllMocks()
-    mockUseInstance.mockReturnValue(mockInstance)
   })
 
   it('should return null and not observe state if disabled', () => {
-    const {result} = renderHook(() => useVerifyOrgProjects(true, testProjectIds))
+    const {result} = renderHook(() => useVerifyOrgProjects(true, testProjectIds), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current).toBeNull()
     expect(mockObserve).not.toHaveBeenCalled()
   })
 
   it('should return null and not observe state if projectIds is missing or empty', () => {
-    const {result: resultUndefined} = renderHook(() => useVerifyOrgProjects(false, undefined))
+    const {result: resultUndefined} = renderHook(() => useVerifyOrgProjects(false, undefined), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     expect(resultUndefined.current).toBeNull()
     expect(mockObserve).not.toHaveBeenCalled()
 
-    const {result: resultEmpty} = renderHook(() => useVerifyOrgProjects(false, []))
+    const {result: resultEmpty} = renderHook(() => useVerifyOrgProjects(false, []), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     expect(resultEmpty.current).toBeNull()
     expect(mockObserve).not.toHaveBeenCalled()
   })
@@ -49,17 +62,29 @@ describe('useVerifyOrgProjects', () => {
     const subject = new Subject<OrgVerificationResult>()
     mockObserve.mockReturnValue(subject.asObservable())
 
-    const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds))
+    const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current).toBeNull()
-    expect(mockObserve).toHaveBeenCalledWith(mockInstance, testProjectIds)
+    expect(mockObserve).toHaveBeenCalledWith(expect.any(Object), testProjectIds)
   })
 
   it('should return null if observable emits { error: null }', async () => {
     const subject = new Subject<OrgVerificationResult>()
     mockObserve.mockReturnValue(subject.asObservable())
 
-    const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds))
+    const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     act(() => {
       subject.next({error: null})
@@ -75,7 +100,13 @@ describe('useVerifyOrgProjects', () => {
     const errorMessage = 'Org mismatch'
     mockObserve.mockReturnValue(subject.asObservable())
 
-    const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds))
+    const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     act(() => {
       subject.next({error: errorMessage})
@@ -91,7 +122,13 @@ describe('useVerifyOrgProjects', () => {
     const unsubscribeSpy = vi.spyOn(subject, 'unsubscribe')
     mockObserve.mockReturnValue(subject)
 
-    const {unmount} = renderHook(() => useVerifyOrgProjects(false, testProjectIds))
+    const {unmount} = renderHook(() => useVerifyOrgProjects(false, testProjectIds), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(unsubscribeSpy).not.toHaveBeenCalled()
     unmount()
@@ -114,6 +151,11 @@ describe('useVerifyOrgProjects', () => {
       ({disabled, pIds}) => useVerifyOrgProjects(disabled, pIds),
       {
         initialProps: {disabled: false, pIds: testProjectIds},
+        wrapper: ({children}) => (
+          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+            {children}
+          </ResourceProvider>
+        ),
       },
     )
 

package/src/hooks/dashboard/{useManageFavorite.test.ts → useManageFavorite.test.tsx}

@@ -1,16 +1,11 @@
 import {type Message} from '@sanity/comlink'
-import {
-  type FavoriteStatusResponse,
-  getFavoritesState,
-  resolveFavoritesState,
-  type SanityInstance,
-} from '@sanity/sdk'
+import {type FavoriteStatusResponse, getFavoritesState, resolveFavoritesState} from '@sanity/sdk'
+import {act, renderHook} from '@testing-library/react'
 import {BehaviorSubject} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {act, renderHook} from '../../../test/test-utils'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {useWindowConnection, type WindowConnection} from '../comlink/useWindowConnection'
-import {useSanityInstance} from '../context/useSanityInstance'
 import {useManageFavorite} from './useManageFavorite'
 
 vi.mock(import('@sanity/sdk'), async (importOriginal) => {
@@ -22,8 +17,6 @@ vi.mock(import('@sanity/sdk'), async (importOriginal) => {
   }
 })
 
-vi.mock('../context/useSanityInstance')
-
 vi.mock('../comlink/useWindowConnection', () => ({
   useWindowConnection: vi.fn(),
 }))
@@ -62,14 +55,6 @@ describe('useManageFavorite', () => {
       return newValue
     })
 
-    // Default mock for useSanityInstance
-    vi.mocked(useSanityInstance).mockReturnValue({
-      config: {
-        projectId: 'test',
-        dataset: 'test',
-      },
-    } as unknown as SanityInstance)
-
     // Mock useWindowConnection
     mockFetch = vi.fn().mockResolvedValue({success: true})
     mockSendMessage = vi.fn()
@@ -88,13 +73,25 @@ describe('useManageFavorite', () => {
   })
 
   it('should initialize with default states', () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current.isFavorited).toBe(false)
   })
 
   it('should handle favorite action and update state', async () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test" dataset="test" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current.isFavorited).toBe(false)
 
@@ -123,7 +120,13 @@ describe('useManageFavorite', () => {
   })
 
   it('should handle unfavorite action and update state', async () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test" dataset="test" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     // Set initial state to favorited
     await act(async () => {
@@ -158,7 +161,13 @@ describe('useManageFavorite', () => {
   it('should not update state if favorite action fails', async () => {
     mockFetch.mockResolvedValueOnce({success: false})
 
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current.isFavorited).toBe(false)
 
@@ -178,7 +187,13 @@ describe('useManageFavorite', () => {
       throw new Error(errorMessage)
     })
 
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     await act(async () => {
       await expect(result.current.favorite()).rejects.toThrow(errorMessage)
@@ -196,23 +211,21 @@ describe('useManageFavorite', () => {
   })
 
   it('should throw error when studio resource is missing projectId or dataset', () => {
-    // Mock the Sanity instance to not have projectId or dataset
-    vi.mocked(useSanityInstance).mockReturnValue({
-      config: {
-        projectId: undefined,
-        dataset: undefined,
-      },
-    } as unknown as SanityInstance)
-
     const mockDocumentHandleWithoutProjectId = {
       documentId: 'mock-id',
       documentType: 'mock-type',
       resourceType: 'studio' as const,
     }
 
-    expect(() => renderHook(() => useManageFavorite(mockDocumentHandleWithoutProjectId))).toThrow(
-      'projectId and dataset are required for studio resources',
-    )
+    expect(() =>
+      renderHook(() => useManageFavorite(mockDocumentHandleWithoutProjectId), {
+        wrapper: ({children}) => (
+          <ResourceProvider projectId={undefined} dataset={undefined} fallback={null}>
+            {children}
+          </ResourceProvider>
+        ),
+      }),
+    ).toThrow('projectId and dataset are required for studio resources')
   })
 
   it('should throw error when resourceId is missing for non-studio resources', () => {
@@ -223,9 +236,15 @@ describe('useManageFavorite', () => {
       resourceId: undefined,
     }
 
-    expect(() => renderHook(() => useManageFavorite(mockMediaDocumentHandle))).toThrow(
-      'resourceId is required for media-library and canvas resources',
-    )
+    expect(() =>
+      renderHook(() => useManageFavorite(mockMediaDocumentHandle), {
+        wrapper: ({children}) => (
+          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+            {children}
+          </ResourceProvider>
+        ),
+      }),
+    ).toThrow('resourceId is required for media-library and canvas resources')
   })
 
   it('should include schemaName in payload when provided', async () => {
@@ -233,7 +252,13 @@ describe('useManageFavorite', () => {
       ...mockDocumentHandle,
       schemaName: 'testSchema',
     }
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandleWithSchema))
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandleWithSchema), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     await act(async () => {
       await result.current.favorite()
@@ -246,7 +271,7 @@ describe('useManageFavorite', () => {
           id: 'mock-id',
           type: 'mock-type',
           resource: {
-            id: 'test.test',
+            id: 'test-project.test-dataset',
             type: 'studio',
             schemaName: 'testSchema',
           },
@@ -268,7 +293,13 @@ describe('useManageFavorite', () => {
       getCurrent: () => undefined,
       observable: favoriteStatusSubject.asObservable(),
     }))
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     expect(result.current.isFavorited).toBe(false)
   })
 
@@ -277,7 +308,13 @@ describe('useManageFavorite', () => {
       fetch: undefined,
       sendMessage: mockSendMessage,
     } as unknown as WindowConnection<Message>)
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle))
+    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     await act(async () => {
       await result.current.favorite()
       await result.current.unfavorite()
@@ -288,7 +325,13 @@ describe('useManageFavorite', () => {
   it('should do nothing if documentId is missing', async () => {
     const handle = {...mockDocumentHandle, documentId: undefined}
     // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle))
+    const {result} = renderHook(() => useManageFavorite(handle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     await act(async () => {
       await result.current.favorite()
       await result.current.unfavorite()
@@ -299,7 +342,13 @@ describe('useManageFavorite', () => {
   it('should do nothing if documentType is missing', async () => {
     const handle = {...mockDocumentHandle, documentType: undefined}
     // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle))
+    const {result} = renderHook(() => useManageFavorite(handle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     await act(async () => {
       await result.current.favorite()
       await result.current.unfavorite()
@@ -310,7 +359,13 @@ describe('useManageFavorite', () => {
   it('should do nothing if resourceType is missing', async () => {
     const handle = {...mockDocumentHandle, resourceType: undefined, resourceId: 'studio'}
     // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle))
+    const {result} = renderHook(() => useManageFavorite(handle), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     await act(async () => {
       await result.current.favorite()
       await result.current.unfavorite()

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

@@ -1,16 +1,11 @@
 // tests/useDocument.test.ts
-import {
-  createSanityInstance,
-  getDocumentState,
-  resolveDocument,
-  type StateSource,
-} from '@sanity/sdk'
+import {getDocumentState, resolveDocument, type StateSource} from '@sanity/sdk'
 import {type SanityDocument} from '@sanity/types'
 import {renderHook} from '@testing-library/react'
 import {type SchemaOrigin} from 'groq'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {useDocument} from './useDocument'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
@@ -18,10 +13,6 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
   return {...original, getDocumentState: vi.fn(), resolveDocument: vi.fn()}
 })
 
-vi.mock('../context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
-
 // Define a single generic TestDocument type
 type UseDocumentTestType = SchemaOrigin<
   SanityDocument & {
@@ -56,8 +47,6 @@ declare module 'groq' {
   }
 }
 
-// Create a fake instance to be returned by useSanityInstance.
-const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 const book: SanityDocument = {
   _id: 'doc1',
   foo: 'bar',
@@ -70,7 +59,6 @@ const book: SanityDocument = {
 describe('useDocument hook', () => {
   beforeEach(() => {
     vi.resetAllMocks()
-    vi.mocked(useSanityInstance).mockReturnValue(instance)
   })
 
   it('returns the current document when ready (without a path)', () => {
@@ -81,7 +69,13 @@ describe('useDocument hook', () => {
       subscribe,
     } as unknown as StateSource<unknown>)
 
-    const {result} = renderHook(() => useDocument({documentId: 'doc1', documentType: 'book'}))
+    const {result} = renderHook(() => useDocument({documentId: 'doc1', documentType: 'book'}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(result.current.data).toEqual(book)
     expect(getCurrent).toHaveBeenCalled()
@@ -102,13 +96,22 @@ describe('useDocument hook', () => {
     vi.mocked(resolveDocument).mockReturnValue(resolveDocPromise)
 
     // Render the hook and capture the thrown promise.
-    const {result} = renderHook(() => {
-      try {
-        return useDocument({documentId: 'doc1', documentType: 'book'})
-      } catch (e) {
-        return e
-      }
-    })
+    const {result} = renderHook(
+      () => {
+        try {
+          return useDocument({documentId: 'doc1', documentType: 'book'})
+        } 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/document/{useDocumentEvent.test.ts → useDocumentEvent.test.tsx}

@@ -1,14 +1,9 @@
 // tests/useDocumentEvent.test.ts
-import {
-  createSanityInstance,
-  type DocumentEvent,
-  type DocumentHandle,
-  subscribeDocumentEvents,
-} from '@sanity/sdk'
+import {type DocumentEvent, type DocumentHandle, subscribeDocumentEvents} from '@sanity/sdk'
 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 {useDocumentEvent} from './useDocumentEvent'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
@@ -16,11 +11,6 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
   return {...original, subscribeDocumentEvents: vi.fn()}
 })
 
-vi.mock('../context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
-
-const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 const docHandle: DocumentHandle = {
   documentId: 'doc1',
   documentType: 'book',
@@ -29,7 +19,6 @@ const docHandle: DocumentHandle = {
 describe('useDocumentEvent hook', () => {
   beforeEach(() => {
     vi.resetAllMocks()
-    vi.mocked(useSanityInstance).mockReturnValue(instance)
   })
 
   it('calls subscribeDocumentEvents with instance and a stable handler', () => {
@@ -37,10 +26,16 @@ describe('useDocumentEvent hook', () => {
     const unsubscribe = vi.fn()
     vi.mocked(subscribeDocumentEvents).mockReturnValue(unsubscribe)
 
-    renderHook(() => useDocumentEvent({...docHandle, onEvent: handleEvent}))
+    renderHook(() => useDocumentEvent({...docHandle, onEvent: handleEvent}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     expect(vi.mocked(subscribeDocumentEvents)).toHaveBeenCalledTimes(1)
-    expect(vi.mocked(subscribeDocumentEvents).mock.calls[0][0]).toBe(instance)
+    expect(vi.mocked(subscribeDocumentEvents).mock.calls[0][0]).toEqual(expect.any(Object))
 
     const stableHandler = vi.mocked(subscribeDocumentEvents).mock.calls[0][1]
     expect(typeof stableHandler).toBe('function')
@@ -55,7 +50,13 @@ describe('useDocumentEvent hook', () => {
     const unsubscribe = vi.fn()
     vi.mocked(subscribeDocumentEvents).mockReturnValue(unsubscribe)
 
-    const {unmount} = renderHook(() => useDocumentEvent({...docHandle, onEvent: handleEvent}))
+    const {unmount} = renderHook(() => useDocumentEvent({...docHandle, onEvent: handleEvent}), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
     unmount()
     expect(unsubscribe).toHaveBeenCalledTimes(1)
   })