@sanity/sdk-react 3.0.0-rc.0 → 3.0.0-rc.2

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

@@ -1,19 +1,16 @@
 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 {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
 
-import {act, renderHook} from '../../../test/test-utils'
 import {ResourceProvider} from '../../context/ResourceProvider'
-import {useSanityInstance} from '../../hooks/context/useSanityInstance'
 import {useWindowConnection, type WindowConnection} from '../comlink/useWindowConnection'
 import {useManageFavorite} from './useManageFavorite'
 
+type MockFetch = (type: string, data?: unknown, options?: unknown) => Promise<{success: boolean}>
+type MockSendMessage = (type: string, data?: unknown) => void
+
 vi.mock(import('@sanity/sdk'), async (importOriginal) => {
   const actual = await importOriginal()
   return {
@@ -27,20 +24,15 @@ vi.mock('../comlink/useWindowConnection', () => ({
   useWindowConnection: vi.fn(),
 }))
 
-vi.mock('../../hooks/context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
-
 describe('useManageFavorite', () => {
   let favoriteStatusSubject: BehaviorSubject<FavoriteStatusResponse>
-  let mockFetch: ReturnType<typeof vi.fn>
-  let mockSendMessage: ReturnType<typeof vi.fn>
+  let mockFetch: Mock<MockFetch>
+  let mockSendMessage: Mock<MockSendMessage>
 
   const mockDocumentHandle = {
     documentId: 'mock-id',
     documentType: 'mock-type',
     resourceType: 'studio' as const,
-    resource: {projectId: 'test', dataset: 'test'},
   }
 
   beforeEach(() => {
@@ -67,32 +59,43 @@ describe('useManageFavorite', () => {
     })
 
     // Mock useWindowConnection
-    mockFetch = vi.fn().mockResolvedValue({success: true})
-    mockSendMessage = vi.fn()
-    vi.mocked(useWindowConnection).mockImplementation(() => {
-      return {
-        fetch: (type: string, data?: unknown, options: unknown = {}) =>
-          mockFetch(type, data, options),
-        sendMessage: mockSendMessage,
-      }
-    })
+    mockFetch = vi.fn<MockFetch>().mockResolvedValue({success: true})
+    mockSendMessage = vi.fn<MockSendMessage>()
+    vi.mocked(useWindowConnection).mockImplementation(
+      () =>
+        ({
+          fetch: (type: string, data?: unknown, options: unknown = {}) =>
+            mockFetch(type, data, options),
+          sendMessage: mockSendMessage,
+        }) as unknown as WindowConnection<Message>,
+    )
   })
 
-  vi.mocked(useSanityInstance).mockImplementation(() => ({}) as unknown as SanityInstance)
-
   afterEach(() => {
     favoriteStatusSubject.complete()
     vi.clearAllMocks()
   })
 
   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)
 
@@ -121,7 +124,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 () => {
@@ -156,7 +165,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)
 
@@ -176,7 +191,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)
@@ -193,7 +214,7 @@ describe('useManageFavorite', () => {
     consoleErrorSpy.mockRestore()
   })
 
-  it('should throw error when studio resource is missing resource', () => {
+  it('should throw error when studio resource is missing projectId or dataset', () => {
     const mockDocumentHandleWithoutProjectId = {
       documentId: 'mock-id',
       documentType: 'mock-type',
@@ -202,8 +223,10 @@ describe('useManageFavorite', () => {
 
     expect(() =>
       renderHook(() => useManageFavorite(mockDocumentHandleWithoutProjectId), {
-        wrapper: ({children}: {children: React.ReactNode}) => (
-          <ResourceProvider fallback={null}>{children}</ResourceProvider>
+        wrapper: ({children}) => (
+          <ResourceProvider projectId={undefined} dataset={undefined} fallback={null}>
+            {children}
+          </ResourceProvider>
         ),
       }),
     ).toThrow('projectId and dataset are required for studio resources')
@@ -215,12 +238,17 @@ describe('useManageFavorite', () => {
       documentType: 'mock-type',
       resourceType: 'media-library' as const,
       resourceId: undefined,
-      resource: {mediaLibraryId: 'media-library-id'},
     }
 
-    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 () => {
@@ -228,7 +256,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()
@@ -241,7 +275,7 @@ describe('useManageFavorite', () => {
           id: 'mock-id',
           type: 'mock-type',
           resource: {
-            id: 'test.test',
+            id: 'test-project.test-dataset',
             type: 'studio',
             schemaName: 'testSchema',
           },
@@ -263,7 +297,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)
   })
 
@@ -272,7 +312,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()
@@ -283,7 +329,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()
@@ -294,7 +346,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()
@@ -305,7 +363,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/dashboard/useManageFavorite.ts

@@ -7,16 +7,14 @@ import {
   type StudioResource,
 } from '@sanity/message-protocol'
 import {
+  type DocumentHandle,
   type FavoriteStatusResponse,
-  type FrameMessage,
   getFavoritesState,
-  isDatasetResource,
   resolveFavoritesState,
 } from '@sanity/sdk'
-import {useCallback, useContext, useMemo, useSyncExternalStore} from 'react'
+import {type FrameMessage} from '@sanity/sdk/comlink'
+import {useCallback, useMemo, useSyncExternalStore} from 'react'
 
-import {type DocumentHandle} from '../../config/handles'
-import {ResourceContext} from '../../context/DefaultResourceContext'
 import {useWindowConnection} from '../comlink/useWindowConnection'
 import {useSanityInstance} from '../context/useSanityInstance'
 
@@ -84,7 +82,8 @@ interface UseManageFavoriteProps extends DocumentHandle {
 export function useManageFavorite({
   documentId,
   documentType,
-  resource: paramResource,
+  projectId: paramProjectId,
+  dataset: paramDataset,
   resourceId: paramResourceId,
   resourceType,
   schemaName,
@@ -94,11 +93,11 @@ export function useManageFavorite({
     connectTo: SDK_CHANNEL_NAME,
   })
   const instance = useSanityInstance()
-  const contextResource = useContext(ResourceContext)
-  const resource = paramResource ?? contextResource
-  const datasetResource = resource && isDatasetResource(resource) ? resource : undefined
-  const projectId = datasetResource?.projectId
-  const dataset = datasetResource?.dataset
+  const {config} = instance
+  const instanceProjectId = config?.projectId
+  const instanceDataset = config?.dataset
+  const projectId = paramProjectId ?? instanceProjectId
+  const dataset = paramDataset ?? instanceDataset
 
   if (resourceType === 'studio' && (!projectId || !dataset)) {
     throw new Error('projectId and dataset are required for studio resources')
@@ -111,21 +110,16 @@ export function useManageFavorite({
     throw new Error('resourceId is required for media-library and canvas resources')
   }
 
-  if (!resource) {
-    throw new Error('resource is required')
-  }
-
   // used for favoriteStore functions like getFavoritesState and resolveFavoritesState
   const context = useMemo(
     () => ({
       documentId,
       documentType,
-      resource,
       resourceId,
       resourceType,
       schemaName,
     }),
-    [documentId, documentType, resource, resourceId, resourceType, schemaName],
+    [documentId, documentType, resourceId, resourceType, schemaName],
   )
 
   // Get favorite status using StateSource

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

@@ -33,7 +33,8 @@ describe('useNavigateToStudioDocument', () => {
   const mockDocumentHandle: DocumentHandle = {
     documentId: 'doc123',
     documentType: 'article',
-    resource: {projectId: 'project1', dataset: 'dataset1'},
+    projectId: 'project1',
+    dataset: 'dataset1',
   }
 
   const mockWorkspace = {
@@ -108,13 +109,13 @@ describe('useNavigateToStudioDocument', () => {
     consoleSpy.mockRestore()
   })
 
-  it('warns and does not navigate when resource is not a dataset resource', () => {
+  it('warns and does not navigate when projectId or dataset is missing', () => {
     const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 
     const incompleteDocumentHandle: DocumentHandle = {
       documentId: 'doc123',
       documentType: 'article',
-      resource: {mediaLibraryId: 'ml123'},
+      // missing projectId and dataset
     }
 
     const {result} = renderHook(() => useNavigateToStudioDocument(incompleteDocumentHandle))
@@ -196,11 +197,8 @@ describe('useNavigateToStudioDocument', () => {
 
     result.current.navigateToStudioDocument()
 
-    const resource = mockDocumentHandle.resource
-    const projectId = 'projectId' in resource ? resource.projectId : undefined
-    const dataset = 'dataset' in resource ? resource.dataset : undefined
     expect(consoleSpy).toHaveBeenCalledWith(
-      `No workspace found for document with projectId: ${projectId} and dataset: ${dataset} or with preferred studio url: ${preferredUrl}`,
+      `No workspace found for document with projectId: ${mockDocumentHandle.projectId} and dataset: ${mockDocumentHandle.dataset} or with preferred studio url: ${preferredUrl}`,
     )
     expect(mockSendMessage).not.toHaveBeenCalled()
 

package/src/hooks/dashboard/useNavigateToStudioDocument.ts

@@ -1,8 +1,7 @@
 import {type Bridge, SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
-import {isDatasetResource} from '@sanity/sdk'
+import {type DocumentHandle} from '@sanity/sdk'
 import {useCallback} from 'react'
 
-import {type DocumentHandle} from '../../config/handles'
 import {useWindowConnection} from '../comlink/useWindowConnection'
 import {
   type DashboardResource,
@@ -72,10 +71,7 @@ export function useNavigateToStudioDocument(
   })
 
   const navigateToStudioDocument = useCallback(() => {
-    const {resource} = documentHandle
-    const datasetResource = resource && isDatasetResource(resource) ? resource : undefined
-    const projectId = datasetResource?.projectId
-    const dataset = datasetResource?.dataset
+    const {projectId, dataset} = documentHandle
 
     if (!projectId || !dataset) {
       // eslint-disable-next-line no-console

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

@@ -15,7 +15,6 @@ describe('useRecordDocumentHistoryEvent', () => {
     documentType: 'mock-type',
     resourceType: 'studio' as const,
     resourceId: 'mock-resource-id',
-    resource: {projectId: 'mock-project-id', dataset: 'mock-dataset'},
   }
 
   beforeEach(() => {
@@ -63,7 +62,6 @@ describe('useRecordDocumentHistoryEvent', () => {
       documentType: 'mock-type',
       resourceType: 'media-library' as const,
       resourceId: undefined,
-      resource: {mediaLibraryId: 'mock-media-library-id'},
     }
 
     expect(() => renderHook(() => useRecordDocumentHistoryEvent(mockMediaDocumentHandle))).toThrow(

package/src/hooks/dashboard/useRecordDocumentHistoryEvent.ts

@@ -6,10 +6,10 @@ import {
   SDK_NODE_NAME,
   type StudioResource,
 } from '@sanity/message-protocol'
-import {type FrameMessage} from '@sanity/sdk'
+import {type DocumentHandle} from '@sanity/sdk'
+import {type FrameMessage} from '@sanity/sdk/comlink'
 import {useCallback} from 'react'
 
-import {type DocumentHandle} from '../../config/handles'
 import {useWindowConnection} from '../comlink/useWindowConnection'
 
 interface DocumentInteractionHistory {