@sanity/sdk-react 2.9.0 → 2.11.0

package/src/hooks/context/useSanityInstance.ts

@@ -3,78 +3,56 @@ import {useContext} from 'react'
 
 import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 
+const warnedCallers = new Set<string>()
+
 /**
- * Retrieves the current Sanity instance or finds a matching instance from the hierarchy
+ * Retrieves the current Sanity instance from context
  *
  * @public
  *
  * @category Platform
- * @param config - Optional configuration to match against when finding an instance
- * @returns The current or matching Sanity instance
+ * @param config - Deprecated. Formerly used to match against the instance hierarchy.
+ * @returns The current Sanity instance
  *
  * @remarks
- * This hook accesses the nearest Sanity instance from the React context. When provided with
- * a configuration object, it traverses up the instance hierarchy to find the closest instance
- * that matches the specified configuration using shallow comparison of properties.
- *
+ * This hook accesses the nearest Sanity instance from the React context.
  * The hook must be used within a component wrapped by a `ResourceProvider` or `SanityApp`.
  *
- * Use this hook when you need to:
- * - Access the current SanityInstance from context
- * - Find a specific instance with matching project/dataset configuration
- * - Access a parent instance with specific configuration values
- *
  * @example Get the current instance
  * ```tsx
- * // Get the current instance from context
  * const instance = useSanityInstance()
  * console.log(instance.config.projectId)
  * ```
  *
- * @example Find an instance with specific configuration
- * ```tsx
- * // Find an instance matching the given project and dataset
- * const instance = useSanityInstance({
- *   projectId: 'abc123',
- *   dataset: 'production'
- * })
- *
- * // Use instance for API calls
- * const fetchDocument = (docId) => {
- *   // Instance is guaranteed to have the matching config
- *   return client.fetch(`*[_id == $id][0]`, { id: docId })
- * }
- * ```
- *
- * @example Match partial configuration
- * ```tsx
- * // Find an instance with specific auth configuration
- * const instance = useSanityInstance({
- *   auth: { requireLogin: true }
- * })
- * ```
- *
  * @throws Error if no SanityInstance is found in context
- * @throws Error if no matching instance is found for the provided config
  */
-export const useSanityInstance = (config?: SanityConfig): SanityInstance => {
-  const instance = useContext(SanityInstanceContext)
-
-  if (!instance) {
-    throw new Error(
-      `SanityInstance context not found. ${config ? `Requested config: ${JSON.stringify(config, null, 2)}. ` : ''}Please ensure that your component is wrapped in a ResourceProvider or a SanityApp component.`,
-    )
+export const useSanityInstance = (
+  /**
+   * @deprecated Passing a config to match against the instance hierarchy is deprecated.
+   * Use `useSanityInstance()` without arguments instead.
+   */
+  config?: SanityConfig,
+): SanityInstance => {
+  if (config !== undefined) {
+    const caller = new Error().stack?.split('\n')[2]?.trim() ?? 'unknown'
+    if (!warnedCallers.has(caller)) {
+      warnedCallers.add(caller)
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[useSanityInstance] Passing a config argument is deprecated and has no effect. ' +
+          'SDK apps use a single instance for all resources, so the config argument is no longer needed. ' +
+          'Call useSanityInstance() without arguments instead, or useResource() to get your currently active resource.',
+      )
+    }
   }
 
-  if (!config) return instance
+  const instance = useContext(SanityInstanceContext)
 
-  const match = instance.match(config)
-  if (!match) {
+  if (!instance) {
     throw new Error(
-      `Could not find a matching Sanity instance for the requested configuration: ${JSON.stringify(config, null, 2)}.
-Please ensure there is a ResourceProvider component with a matching configuration in the component hierarchy.`,
+      `SanityInstance context not found. Please ensure that your component is wrapped in a ResourceProvider or a SanityApp component.`,
     )
   }
 
-  return match
+  return instance
 }

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

@@ -1,4 +1,5 @@
 import {type DocumentHandle} from '@sanity/sdk'
+import {renderHook as reactRenderHook} from '@testing-library/react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {renderHook} from '../../../test/test-utils'
@@ -167,11 +168,11 @@ describe('useDispatchIntent', () => {
     })
   })
 
-  it('should send intent message with media library source', () => {
+  it('should send intent message with media library resource', () => {
     const mockMediaLibraryHandle = {
       documentId: 'test-asset-id',
       documentType: 'sanity.asset',
-      sourceName: 'media-library',
+      resourceName: 'media-library',
     } as const
 
     const {result} = renderHook(() =>
@@ -196,11 +197,11 @@ describe('useDispatchIntent', () => {
     })
   })
 
-  it('should send intent message with canvas source', () => {
+  it('should send intent message with canvas resource', () => {
     const mockCanvasHandle = {
       documentId: 'test-canvas-document-id',
       documentType: 'sanity.canvas.document',
-      sourceName: 'canvas',
+      resourceName: 'canvas',
     } as const
 
     const {result} = renderHook(() =>
@@ -226,13 +227,15 @@ describe('useDispatchIntent', () => {
   })
 
   describe('error handling', () => {
-    it('should throw error when neither source nor projectId/dataset is provided', () => {
+    it('should throw error when neither resource nor projectId/dataset is provided', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
       const invalidHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
       }
 
-      const {result} = renderHook(() =>
+      // Use a minimal wrapper with no resource context so the normalization has nothing to fall back to
+      const {result} = reactRenderHook(() =>
         useDispatchIntent({
           action: 'edit',
           documentHandle: invalidHandle as unknown as DocumentHandle,
@@ -240,8 +243,9 @@ describe('useDispatchIntent', () => {
       )
 
       expect(() => result.current.dispatchIntent()).toThrow(
-        'useDispatchIntent: Unable to determine resource. Either `source`, `sourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
+        'useDispatchIntent: Unable to determine resource. Either `resource`, `resourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
       )
+      consoleErrorSpy.mockRestore()
     })
   })
 })

package/src/hooks/dashboard/useDispatchIntent.ts

@@ -1,9 +1,9 @@
 import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
-import {type DocumentHandle, type FrameMessage} from '@sanity/sdk'
+import {type FrameMessage} from '@sanity/sdk'
 import {useCallback} from 'react'
 
+import {type DocumentHandle} from '../../config/handles'
 import {useWindowConnection} from '../comlink/useWindowConnection'
-import {type WithSourceNameSupport} from '../helpers/useNormalizedSourceOptions'
 import {useResourceIdFromDocumentHandle} from './utils/useResourceIdFromDocumentHandle'
 
 /**
@@ -42,7 +42,7 @@ interface DispatchIntent {
 interface UseDispatchIntentParams {
   action?: 'edit'
   intentId?: string
-  documentHandle: WithSourceNameSupport<DocumentHandle>
+  documentHandle: DocumentHandle
   parameters?: Record<string, unknown>
 }
 
@@ -56,8 +56,8 @@ interface UseDispatchIntentParams {
  *   - `action` - Action to perform (currently only 'edit' is supported). Will prompt a picker if multiple handlers are available.
  *   - `intentId` - Specific ID of the intent to dispatch. Either `action` or `intentId` is required.
  *   - `documentHandle` - The document handle containing document ID, type, and either:
- *     - `projectId` and `dataset` for traditional dataset sources, like `{documentId: '123', documentType: 'book', projectId: 'abc123', dataset: 'production'}`
- *     - `source` for media library, canvas, or dataset sources, like `{documentId: '123', documentType: 'sanity.asset', source: mediaLibrarySource('ml123')}` or `{documentId: '123', documentType: 'sanity.canvas.document', source: canvasSource('canvas123')}`
+ *     - `projectId` and `dataset` for traditional dataset resources, like `{documentId: '123', documentType: 'book', projectId: 'abc123', dataset: 'production'}`
+ *     - `resource` for media library, canvas, or dataset resources, like `{documentId: '123', documentType: 'sanity.asset', resource: mediaLibrarySource('ml123')}` or `{documentId: '123', documentType: 'sanity.canvas.document', resource: canvasSource('canvas123')}`
  *   - `paremeters` - Optional parameters to include in the dispatch; will be passed to the resolved intent handler
  * @returns An object containing:
  * - `dispatchIntent` - Function to dispatch the intent message
@@ -119,10 +119,10 @@ export function useDispatchIntent(params: UseDispatchIntentParams): DispatchInte
         )
       }
 
-      // Validate that we have a resource ID (which is computed from source/sourceName or projectId+dataset)
+      // Validate that we have a resource ID (which is computed from resource/resourceName or projectId+dataset)
       if (!resource.id) {
         throw new Error(
-          'useDispatchIntent: Unable to determine resource. Either `source`, `sourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
+          'useDispatchIntent: Unable to determine resource. Either `resource`, `resourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
         )
       }
 

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

@@ -2,12 +2,15 @@ import {type Message} from '@sanity/comlink'
 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 {ResourceProvider} from '../../context/ResourceProvider'
 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 {
@@ -23,8 +26,8 @@ vi.mock('../comlink/useWindowConnection', () => ({
 
 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',
@@ -56,15 +59,16 @@ 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>,
+    )
   })
 
   afterEach(() => {

package/src/hooks/dashboard/utils/useResourceIdFromDocumentHandle.test.ts

@@ -23,11 +23,11 @@ describe('getResourceIdFromDocumentHandle', () => {
   })
 
   describe('with DocumentHandleWithSource - media library', () => {
-    it('should return media library ID and resourceType when media library source is provided', () => {
+    it('should return media library ID and resourceType when media library resource is provided', () => {
       const documentHandle = {
         documentId: 'test-asset-id',
         documentType: 'sanity.asset',
-        sourceName: 'media-library',
+        resourceName: 'media-library',
       } as const
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
@@ -38,13 +38,13 @@ describe('getResourceIdFromDocumentHandle', () => {
       })
     })
 
-    it('should prioritize source over projectId/dataset when both are provided', () => {
+    it('should prioritize resource over projectId/dataset when both are provided', () => {
       const documentHandle = {
         documentId: 'test-asset-id',
         documentType: 'sanity.asset',
         projectId: 'test-project-id',
         dataset: 'test-dataset',
-        sourceName: 'media-library',
+        resourceName: 'media-library',
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
@@ -57,11 +57,11 @@ describe('getResourceIdFromDocumentHandle', () => {
   })
 
   describe('with DocumentHandleWithSource - canvas', () => {
-    it('should return canvas ID and resourceType when canvas source is provided', () => {
+    it('should return canvas ID and resourceType when canvas resource is provided', () => {
       const documentHandle = {
         documentId: 'test-canvas-document-id',
         documentType: 'sanity.canvas.document',
-        sourceName: 'canvas',
+        resourceName: 'canvas',
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
@@ -73,48 +73,48 @@ describe('getResourceIdFromDocumentHandle', () => {
     })
   })
 
-  describe('with DocumentHandleWithSource - dataset source', () => {
-    it('should return dataset resource ID when dataset source is provided', () => {
+  describe('with DocumentHandleWithSource - dataset resource', () => {
+    it('should return dataset resource ID when dataset resource is provided', () => {
       const documentHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
-        sourceName: 'dataset',
+        resourceName: 'dataset',
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
 
       expect(result.current).toEqual({
-        id: 'source-project-id.source-dataset',
+        id: 'resource-project-id.resource-dataset',
         type: undefined,
       })
     })
 
-    it('should use dataset source over projectId/dataset when both are provided', () => {
+    it('should use dataset resource over projectId/dataset when both are provided', () => {
       const documentHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
         projectId: 'test-project-id',
         dataset: 'test-dataset',
-        sourceName: 'dataset',
+        resourceName: 'dataset',
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))
 
       expect(result.current).toEqual({
-        id: 'source-project-id.source-dataset',
+        id: 'resource-project-id.resource-dataset',
         type: undefined,
       })
     })
   })
 
   describe('edge cases', () => {
-    it('should handle DocumentHandleWithSource with undefined source', () => {
+    it('should handle DocumentHandleWithSource with undefined resource', () => {
       const documentHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
         projectId: 'test-project-id',
         dataset: 'test-dataset',
-        sourceName: undefined,
+        resourceName: undefined,
       }
 
       const {result} = renderHook(() => useResourceIdFromDocumentHandle(documentHandle))

package/src/hooks/dashboard/utils/useResourceIdFromDocumentHandle.ts

@@ -1,11 +1,11 @@
 import {
   type DocumentHandle,
-  isCanvasSource,
-  isDatasetSource,
-  isMediaLibrarySource,
+  isCanvasResource,
+  isDatasetResource,
+  isMediaLibraryResource,
 } from '@sanity/sdk'
 
-import {useNormalizedSourceOptions} from '../../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../../helpers/useNormalizedResourceOptions'
 
 interface DashboardMessageResource {
   id: string
@@ -18,23 +18,19 @@ interface DashboardMessageResource {
 export function useResourceIdFromDocumentHandle(
   documentHandle: DocumentHandle,
 ): DashboardMessageResource {
-  const options = useNormalizedSourceOptions(documentHandle)
-  const {projectId, dataset, source} = options
+  const options = useNormalizedResourceOptions(documentHandle)
+  const {resource} = options
   let resourceId: string = ''
   let resourceType: 'media-library' | 'canvas' | undefined
-  if (projectId && dataset) {
-    resourceId = `${projectId}.${dataset}`
-  }
-
-  if (source) {
-    if (isDatasetSource(source)) {
-      resourceId = `${source.projectId}.${source.dataset}`
+  if (resource) {
+    if (isDatasetResource(resource)) {
+      resourceId = `${resource.projectId}.${resource.dataset}`
       resourceType = undefined
-    } else if (isMediaLibrarySource(source)) {
-      resourceId = source.mediaLibraryId
+    } else if (isMediaLibraryResource(resource)) {
+      resourceId = resource.mediaLibraryId
       resourceType = 'media-library'
-    } else if (isCanvasSource(source)) {
-      resourceId = source.canvasId
+    } else if (isCanvasResource(resource)) {
+      resourceId = resource.canvasId
       resourceType = 'canvas'
     }
   }