@sanity/sdk-react 2.10.0 → 2.11.1

package/src/hooks/context/useResource.test.tsx

@@ -0,0 +1,32 @@
+import {renderHook as reactRenderHook} from '@testing-library/react'
+import {type ReactNode} from 'react'
+import {describe, expect, it} from 'vitest'
+
+import {renderHook} from '../../../test/test-utils'
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {useResource} from './useResource'
+
+describe('useResource', () => {
+  it('returns the resource from the instance config when no explicit resource is set', () => {
+    // test-utils wraps with ResourceProvider projectId="test" dataset="test"
+    const {result} = renderHook(() => useResource())
+    expect(result.current).toEqual({projectId: 'test', dataset: 'test'})
+  })
+
+  it('returns the explicit resource when ResourceProvider has a resource prop', () => {
+    const resource = {projectId: 'explicit-project', dataset: 'explicit-dataset'}
+    const {result} = reactRenderHook(() => useResource(), {
+      wrapper: ({children}: {children: ReactNode}) => (
+        <ResourceProvider resource={resource} fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
+    expect(result.current).toEqual(resource)
+  })
+
+  it('returns undefined when no resource or instance config is available', () => {
+    const {result} = reactRenderHook(() => useResource())
+    expect(result.current).toBeUndefined()
+  })
+})

package/src/hooks/context/useResource.ts

@@ -0,0 +1,24 @@
+import {type DocumentResource} from '@sanity/sdk'
+
+import {useEffectiveContextResource} from '../helpers/useNormalizedResourceOptions'
+
+/**
+ * Returns the currently active `DocumentResource` for the nearest resource context.
+ *
+ * Resolves in priority order:
+ * 1. A `resource` prop on the nearest `<ResourceProvider>`
+ * 2. The `projectId`/`dataset` from the current `SanityInstance` config
+ * 3. `undefined` when neither is available
+ *
+ * @public
+ * @category Platform
+ *
+ * @example
+ * ```tsx
+ * const resource = useResource()
+ * console.log(resource?.projectId, resource?.dataset)
+ * ```
+ */
+export function useResource(): DocumentResource | undefined {
+  return useEffectiveContextResource()
+}

package/src/hooks/context/useSanityInstance.test.tsx

@@ -1,7 +1,7 @@
 import {createSanityInstance, type SanityConfig, type SanityInstance} from '@sanity/sdk'
 import {renderHook} from '@testing-library/react'
 import {type ReactNode} from 'react'
-import {describe, expect, it} from 'vitest'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 import {useSanityInstance} from './useSanityInstance'
@@ -37,137 +37,68 @@ describe('useSanityInstance', () => {
     }).toThrow('SanityInstance context not found')
   })
 
-  it('should include the requested config in error message when no instance found', () => {
-    const requestedConfig = {projectId: 'test', dataset: 'test'}
-
-    // Expect the hook to throw and include the requested config in the error
-    expect(() => {
-      renderHook(() => useSanityInstance(requestedConfig), {
-        wrapper: createWrapper(null),
-      })
-    }).toThrow(JSON.stringify(requestedConfig, null, 2))
-  })
-
-  it('should find a matching instance with provided config', () => {
-    // Create a parent instance
-    const parentInstance = createSanityInstance({
-      projectId: 'parent-project',
-      dataset: 'parent-dataset',
-    })
-
-    // Create a child instance
-    const childInstance = parentInstance.createChild({dataset: 'child-dataset'})
-
-    // Render the hook with the child instance and request the parent config
-    const {result} = renderHook(
-      () => useSanityInstance({projectId: 'parent-project', dataset: 'parent-dataset'}),
-      {wrapper: createWrapper(childInstance)},
-    )
-
-    // Should match and return the parent instance
-    expect(result.current).toBe(parentInstance)
-  })
-
-  it('should throw an error if no matching instance is found for config', () => {
-    // Create an instance
-    const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
-
-    // Request a config that doesn't match
-    const requestedConfig: SanityConfig = {
-      projectId: 'non-existent',
-      dataset: 'not-found',
-    }
-
-    // Expect the hook to throw for a non-matching config
-    expect(() => {
-      renderHook(() => useSanityInstance(requestedConfig), {
-        wrapper: createWrapper(instance),
-      })
-    }).toThrow('Could not find a matching Sanity instance')
-  })
-
-  it('should include the requested config in error message when no matching instance', () => {
-    const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
-    const requestedConfig = {projectId: 'different', dataset: 'different'}
-
-    // Expect the error to include the requested config details
-    expect(() => {
-      renderHook(() => useSanityInstance(requestedConfig), {
-        wrapper: createWrapper(instance),
-      })
-    }).toThrow(JSON.stringify(requestedConfig, null, 2))
-  })
-
   it('should return the current instance when no config is provided', () => {
-    // Create a hierarchy of instances
-    const grandparent = createSanityInstance({projectId: 'gp', dataset: 'gp-ds'})
-    const parent = grandparent.createChild({projectId: 'p'})
-    const child = parent.createChild({dataset: 'child-ds'})
+    // Create a Sanity instance
+    const instance = createSanityInstance({projectId: 'gp', dataset: 'gp-ds'})
 
-    // Render the hook with the child instance and no config
+    // Render the hook with the wrapper that provides the context
     const {result} = renderHook(() => useSanityInstance(), {
-      wrapper: createWrapper(child),
+      wrapper: createWrapper(instance),
     })
 
-    // Should return the child instance
-    expect(result.current).toBe(child)
+    // Should return the instance
+    expect(result.current).toBe(instance)
   })
 
-  it('should match child instance when it satisfies the config', () => {
-    // Create a parent instance
-    const parent = createSanityInstance({projectId: 'parent', dataset: 'parent-ds'})
+  describe('deprecated config parameter', () => {
+    let warnSpy: ReturnType<typeof vi.spyOn>
 
-    // Create a child instance that inherits projectId
-    const child = parent.createChild({dataset: 'child-ds'})
+    beforeEach(() => {
+      warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    })
 
-    // Render the hook with the child instance and request by the child's dataset
-    const {result} = renderHook(() => useSanityInstance({dataset: 'child-ds'}), {
-      wrapper: createWrapper(child),
+    afterEach(() => {
+      warnSpy.mockRestore()
     })
 
-    // Should match and return the child instance
-    expect(result.current).toBe(child)
-  })
+    it('should return the current context instance regardless of config', () => {
+      const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+      const requestedConfig: SanityConfig = {projectId: 'test-project', dataset: 'test-dataset'}
 
-  it('should match partial config correctly', () => {
-    // Create an instance with multiple config values
-    const instance = createSanityInstance({
-      projectId: 'test-proj',
-      dataset: 'test-ds',
+      const {result} = renderHook(() => useSanityInstance(requestedConfig), {
+        wrapper: createWrapper(instance),
+      })
+
+      expect(result.current).toBe(instance)
     })
 
-    // Should match when requesting just one property
-    const {result} = renderHook(() => useSanityInstance({dataset: 'test-ds'}), {
-      wrapper: createWrapper(instance),
+    it('should throw if no instance in context even when config is provided', () => {
+      expect(() => {
+        renderHook(() => useSanityInstance({projectId: 'test'}), {
+          wrapper: createWrapper(null),
+        })
+      }).toThrow('SanityInstance context not found')
     })
 
-    expect(result.current).toBe(instance)
-  })
+    it('warns once when a config argument is passed', () => {
+      const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+      const {rerender} = renderHook(() => useSanityInstance({projectId: 'test-project'}), {
+        wrapper: createWrapper(instance),
+      })
 
-  it("should match deeper in hierarchy when current instance doesn't match", () => {
-    // Create a three-level hierarchy
-    const root = createSanityInstance({projectId: 'root', dataset: 'root-ds'})
-    const middle = root.createChild({projectId: 'middle'})
-    const leaf = middle.createChild({dataset: 'leaf-ds'})
+      expect(warnSpy).toHaveBeenCalledTimes(1)
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('[useSanityInstance]'))
 
-    // Request config matching the root from the leaf
-    const {result} = renderHook(() => useSanityInstance({projectId: 'root', dataset: 'root-ds'}), {
-      wrapper: createWrapper(leaf),
+      rerender()
+      rerender()
+      expect(warnSpy).toHaveBeenCalledTimes(1)
     })
 
-    // Should find and return the root instance
-    expect(result.current).toBe(root)
-  })
+    it('does not warn when no config is passed', () => {
+      const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+      renderHook(() => useSanityInstance(), {wrapper: createWrapper(instance)})
 
-  it('should match undefined values in config', () => {
-    // Create instance with only projectId
-    const rootInstance = createSanityInstance({projectId: 'test'})
-
-    // Match specifically looking for undefined dataset
-    const {result} = renderHook(() => useSanityInstance({dataset: undefined}), {
-      wrapper: createWrapper(rootInstance),
+      expect(warnSpy).not.toHaveBeenCalled()
     })
-
-    expect(result.current).toBe(rootInstance)
   })
 })

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'
@@ -227,12 +228,14 @@ describe('useDispatchIntent', () => {
 
   describe('error handling', () => {
     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,
@@ -242,6 +245,7 @@ describe('useDispatchIntent', () => {
       expect(() => result.current.dispatchIntent()).toThrow(
         '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 WithResourceNameSupport} from '../helpers/useNormalizedResourceOptions'
 import {useResourceIdFromDocumentHandle} from './utils/useResourceIdFromDocumentHandle'
 
 /**
@@ -42,7 +42,7 @@ interface DispatchIntent {
 interface UseDispatchIntentParams {
   action?: 'edit'
   intentId?: string
-  documentHandle: WithResourceNameSupport<DocumentHandle>
+  documentHandle: DocumentHandle
   parameters?: Record<string, unknown>
 }
 

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.ts

@@ -19,13 +19,9 @@ export function useResourceIdFromDocumentHandle(
   documentHandle: DocumentHandle,
 ): DashboardMessageResource {
   const options = useNormalizedResourceOptions(documentHandle)
-  const {projectId, dataset, resource} = options
+  const {resource} = options
   let resourceId: string = ''
   let resourceType: 'media-library' | 'canvas' | undefined
-  if (projectId && dataset) {
-    resourceId = `${projectId}.${dataset}`
-  }
-
   if (resource) {
     if (isDatasetResource(resource)) {
       resourceId = `${resource.projectId}.${resource.dataset}`