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

package/src/hooks/client/useClient.test.tsx

@@ -6,7 +6,10 @@ import {useClient} from './useClient'
 
 describe('useClient', () => {
   const wrapper = ({children}: {children: React.ReactNode}) => (
-    <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+    <ResourceProvider
+      resource={{projectId: 'test-project', dataset: 'test-dataset'}}
+      fallback={null}
+    >
       {children}
     </ResourceProvider>
   )

package/src/hooks/client/useClient.ts

@@ -39,5 +39,4 @@ export const useClient = createStateSourceHook({
     }
     return getClientState(instance, options)
   },
-  getConfig: (options: ClientOptions) => options,
 })

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

@@ -0,0 +1,25 @@
+import {renderHook} from '@testing-library/react'
+import {describe, expect, it} from 'vitest'
+
+import {ResourceContext} from '../../context/DefaultResourceContext'
+import {useResource} from './useDefaultResource'
+
+describe('useResource', () => {
+  it('returns the resource from context', () => {
+    const resource = {projectId: 'my-project', dataset: 'my-dataset'}
+
+    const {result} = renderHook(() => useResource(), {
+      wrapper: ({children}) => (
+        <ResourceContext.Provider value={resource}>{children}</ResourceContext.Provider>
+      ),
+    })
+
+    expect(result.current).toBe(resource)
+  })
+
+  it('returns undefined when no resource is in context', () => {
+    const {result} = renderHook(() => useResource())
+
+    expect(result.current).toBeUndefined()
+  })
+})

package/src/hooks/context/useDefaultResource.ts

@@ -0,0 +1,30 @@
+import {type DocumentResource} from '@sanity/sdk'
+import {useContext} from 'react'
+
+import {ResourceContext} from '../../context/DefaultResourceContext'
+
+/**
+ * Returns the current {@link DocumentResource} from context.
+ *
+ * @public
+ *
+ * @category Platform
+ * @returns The resource set by the nearest `ResourceProvider`, or `undefined`
+ *
+ * @remarks
+ * With the flat instance model, nested `ResourceProvider`s override the
+ * active resource via React context rather than creating child instances.
+ * Use this hook when you need the current project/dataset/resource for a
+ * subtree instead of reading from `useSanityInstance().config`.
+ *
+ * @example Get the current resource
+ * ```tsx
+ * const resource = useResource()
+ * if (resource && 'projectId' in resource) {
+ *   console.log(resource.projectId, resource.dataset)
+ * }
+ * ```
+ */
+export function useResource(): DocumentResource | undefined {
+  return useContext(ResourceContext)
+}

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

@@ -1,4 +1,4 @@
-import {createSanityInstance, type SanityConfig, type SanityInstance} from '@sanity/sdk'
+import {createSanityInstance, type SanityInstance} from '@sanity/sdk'
 import {renderHook} from '@testing-library/react'
 import {type ReactNode} from 'react'
 import {describe, expect, it} from 'vitest'
@@ -16,158 +16,20 @@ describe('useSanityInstance', () => {
   }
 
   it('should return the Sanity instance from context', () => {
-    // Create a Sanity instance
-    const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+    const instance = createSanityInstance()
 
-    // Render the hook with the wrapper that provides the context
     const {result} = renderHook(() => useSanityInstance(), {
       wrapper: createWrapper(instance),
     })
 
-    // Check that the correct instance is returned
     expect(result.current).toBe(instance)
   })
 
   it('should throw an error if no instance is found in context', () => {
-    // Expect the hook to throw when no instance is in context
     expect(() => {
       renderHook(() => useSanityInstance(), {
         wrapper: createWrapper(null),
       })
     }).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'})
-
-    // Render the hook with the child instance and no config
-    const {result} = renderHook(() => useSanityInstance(), {
-      wrapper: createWrapper(child),
-    })
-
-    // Should return the child instance
-    expect(result.current).toBe(child)
-  })
-
-  it('should match child instance when it satisfies the config', () => {
-    // Create a parent instance
-    const parent = createSanityInstance({projectId: 'parent', dataset: 'parent-ds'})
-
-    // Create a child instance that inherits projectId
-    const child = parent.createChild({dataset: 'child-ds'})
-
-    // Render the hook with the child instance and request by the child's dataset
-    const {result} = renderHook(() => useSanityInstance({dataset: 'child-ds'}), {
-      wrapper: createWrapper(child),
-    })
-
-    // Should match and return the child instance
-    expect(result.current).toBe(child)
-  })
-
-  it('should match partial config correctly', () => {
-    // Create an instance with multiple config values
-    const instance = createSanityInstance({
-      projectId: 'test-proj',
-      dataset: 'test-ds',
-    })
-
-    // Should match when requesting just one property
-    const {result} = renderHook(() => useSanityInstance({dataset: 'test-ds'}), {
-      wrapper: createWrapper(instance),
-    })
-
-    expect(result.current).toBe(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'})
-
-    // Request config matching the root from the leaf
-    const {result} = renderHook(() => useSanityInstance({projectId: 'root', dataset: 'root-ds'}), {
-      wrapper: createWrapper(leaf),
-    })
-
-    // Should find and return the root instance
-    expect(result.current).toBe(root)
-  })
-
-  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(result.current).toBe(rootInstance)
-  })
 })

package/src/hooks/context/useSanityInstance.ts

@@ -1,80 +1,36 @@
-import {type SanityConfig, type SanityInstance} from '@sanity/sdk'
+import {type SanityInstance} from '@sanity/sdk'
 import {useContext} from 'react'
 
 import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 
 /**
- * Retrieves the current Sanity instance or finds a matching instance from the hierarchy
+ * Retrieves the current Sanity instance from React context.
  *
  * @public
  *
  * @category Platform
- * @param config - Optional configuration to match against when finding an instance
- * @returns The current or matching Sanity instance
+ * @returns The current 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.
- *
- * 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
+ * This hook accesses the nearest Sanity instance from React context,
+ * provided by a `ResourceProvider` or `SanityApp`.
  *
  * @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 }
- * })
+ * console.log(instance.config)
  * ```
  *
  * @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 => {
+export const useSanityInstance = (): 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.`,
-    )
-  }
-
-  if (!config) return instance
-
-  const match = instance.match(config)
-  if (!match) {
-    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

@@ -16,8 +16,7 @@ describe('useDispatchIntent', () => {
   const mockDocumentHandle: DocumentHandle = {
     documentId: 'test-document-id',
     documentType: 'test-document-type',
-    projectId: 'test-project-id',
-    dataset: 'test-dataset',
+    resource: {projectId: 'test-project-id', dataset: 'test-dataset'},
   }
 
   beforeEach(() => {
@@ -37,11 +36,13 @@ describe('useDispatchIntent', () => {
   })
 
   it('should throw error when neither action nor intentId is provided', () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
     const {result} = renderHook(() => useDispatchIntent({documentHandle: mockDocumentHandle}))
 
     expect(() => result.current.dispatchIntent()).toThrow(
       'useDispatchIntent: Either `action` or `intentId` must be provided.',
     )
+    consoleErrorSpy.mockRestore()
   })
 
   it('should handle errors gracefully', () => {
@@ -90,8 +91,7 @@ describe('useDispatchIntent', () => {
     const newDocumentHandle: DocumentHandle = {
       documentId: 'new-document-id',
       documentType: 'new-document-type',
-      projectId: 'new-project-id',
-      dataset: 'new-dataset',
+      resource: {projectId: 'new-project-id', dataset: 'new-dataset'},
     }
 
     rerender({action: 'edit' as const, documentHandle: newDocumentHandle})
@@ -165,11 +165,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(() =>
@@ -194,11 +194,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(() =>
@@ -223,9 +223,9 @@ describe('useDispatchIntent', () => {
     })
   })
 
-  describe('error handling', () => {
-    it('should throw error when neither source nor projectId/dataset is provided', () => {
-      const invalidHandle = {
+  describe('default resource fallback', () => {
+    it('should use default resource from context when handle has no explicit targeting', () => {
+      const minimalHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
       }
@@ -233,13 +233,22 @@ describe('useDispatchIntent', () => {
       const {result} = renderHook(() =>
         useDispatchIntent({
           action: 'edit',
-          documentHandle: invalidHandle as unknown as DocumentHandle,
+          documentHandle: minimalHandle as unknown as DocumentHandle,
         }),
       )
 
-      expect(() => result.current.dispatchIntent()).toThrow(
-        'useDispatchIntent: Unable to determine resource. Either `source`, `sourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
-      )
+      result.current.dispatchIntent()
+
+      expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
+        action: 'edit',
+        document: {
+          id: 'test-document-id',
+          type: 'test-document-type',
+        },
+        resource: {
+          id: 'test.test',
+        },
+      })
     })
   })
 })

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: mediaLibraryResource('ml123')}` or `{documentId: '123', documentType: 'sanity.canvas.document', resource: canvasResource('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.',
         )
       }