@sanity/sdk-react 2.10.0 → 2.11.0

package/src/hooks/document/useEditDocument.test.tsx

@@ -7,10 +7,9 @@ import {
   type StateSource,
 } from '@sanity/sdk'
 import {type SanityDocument} from '@sanity/types'
-import {renderHook} from '@testing-library/react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {ResourceProvider} from '../../context/ResourceProvider'
+import {renderHook} from '../../../test/test-utils'
 import {useApplyDocumentActions} from './useApplyDocumentActions'
 import {useEditDocument} from './useEditDocument'
 
@@ -42,6 +41,11 @@ const docHandle = createDocumentHandle({
   documentType: 'book',
 })
 
+const normalizedDoc = {
+  ...docHandle,
+  resource: {projectId: 'test', dataset: 'test'},
+}
+
 // Define a single generic TestDocument type
 interface Book extends SanityDocument {
   _type: 'book'
@@ -76,16 +80,10 @@ describe('useEditDocument hook', () => {
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx1'})
     vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
-    const {result} = renderHook(() => useEditDocument<string>({...docHandle, path: 'foo'}), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useEditDocument<string>({...docHandle, path: 'foo'}))
     const promise = result.current('newValue')
-    expect(editDocument).toHaveBeenCalledWith(docHandle, {set: {foo: 'newValue'}})
-    expect(apply).toHaveBeenCalledWith(editDocument(docHandle, {set: {foo: 'newValue'}}))
+    expect(editDocument).toHaveBeenCalledWith(normalizedDoc, {set: {foo: 'newValue'}})
+    expect(apply).toHaveBeenCalledWith(editDocument(normalizedDoc, {set: {foo: 'newValue'}}))
     const actionsResult = await promise
     expect(actionsResult).toEqual({transactionId: 'tx1'})
   })
@@ -103,15 +101,9 @@ describe('useEditDocument hook', () => {
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx2'})
     vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
-    const {result} = renderHook(() => useEditDocument(docHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useEditDocument(docHandle))
     const promise = result.current({...doc, foo: 'baz', extra: 'old', _id: 'doc1'})
-    expect(apply).toHaveBeenCalledWith([editDocument(docHandle, {set: {foo: 'baz'}})])
+    expect(apply).toHaveBeenCalledWith([editDocument(normalizedDoc, {set: {foo: 'baz'}})])
     const actionsResult = await promise
     expect(actionsResult).toEqual({transactionId: 'tx2'})
   })
@@ -127,16 +119,10 @@ describe('useEditDocument hook', () => {
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx3'})
     vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
-    const {result} = renderHook(() => useEditDocument<string>({...docHandle, path: 'foo'}), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useEditDocument<string>({...docHandle, path: 'foo'}))
     const promise = result.current((prev: unknown) => `${prev}Updated`) // 'bar' becomes 'barUpdated'
-    expect(editDocument).toHaveBeenCalledWith(docHandle, {set: {foo: 'barUpdated'}})
-    expect(apply).toHaveBeenCalledWith(editDocument(docHandle, {set: {foo: 'barUpdated'}}))
+    expect(editDocument).toHaveBeenCalledWith(normalizedDoc, {set: {foo: 'barUpdated'}})
+    expect(apply).toHaveBeenCalledWith(editDocument(normalizedDoc, {set: {foo: 'barUpdated'}}))
     const actionsResult = await promise
     expect(actionsResult).toEqual({transactionId: 'tx3'})
   })
@@ -153,15 +139,9 @@ describe('useEditDocument hook', () => {
     const apply = vi.fn().mockResolvedValue({transactionId: 'tx4'})
     vi.mocked(useApplyDocumentActions).mockReturnValue(apply)
 
-    const {result} = renderHook(() => useEditDocument(docHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-    const promise = result.current((prevDoc) => ({...prevDoc, foo: 'baz'}))
-    expect(apply).toHaveBeenCalledWith([editDocument(docHandle, {set: {foo: 'baz'}})])
+    const {result} = renderHook(() => useEditDocument(docHandle))
+    const promise = result.current((prevDoc: Book) => ({...prevDoc, foo: 'baz'}))
+    expect(apply).toHaveBeenCalledWith([editDocument(normalizedDoc, {set: {foo: 'baz'}})])
     const actionsResult = await promise
     expect(actionsResult).toEqual({transactionId: 'tx4'})
   })
@@ -177,13 +157,7 @@ describe('useEditDocument hook', () => {
     const fakeApply = vi.fn()
     vi.mocked(useApplyDocumentActions).mockReturnValue(fakeApply)
 
-    const {result} = renderHook(() => useEditDocument(docHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useEditDocument(docHandle))
     expect(() => result.current('notAnObject' as unknown as Book)).toThrowError(
       'No path was provided to `useEditDocument` and the value provided was not a document object.',
     )
@@ -203,22 +177,13 @@ describe('useEditDocument hook', () => {
     vi.mocked(resolveDocument).mockReturnValue(resolveDocPromise)
 
     // Render the hook and capture the thrown promise.
-    const {result} = renderHook(
-      () => {
-        try {
-          return useEditDocument(docHandle)
-        } catch (e) {
-          return e
-        }
-      },
-      {
-        wrapper: ({children}) => (
-          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-            {children}
-          </ResourceProvider>
-        ),
-      },
-    )
+    const {result} = renderHook(() => {
+      try {
+        return useEditDocument(docHandle)
+      } catch (e) {
+        return e
+      }
+    })
 
     // When the document is not ready, the hook throws the promise from resolveDocument.
     expect(result.current).toBe(resolveDocPromise)

package/src/hooks/document/useEditDocument.ts

@@ -286,7 +286,7 @@ export function useEditDocument({
   path,
   ...doc
 }: DocumentOptions<string | undefined>): (updater: Updater<unknown>) => Promise<ActionsResult> {
-  const instance = useSanityInstance(doc)
+  const instance = useSanityInstance()
   trackHookUsage(instance, 'useEditDocument')
   const normalizedDoc = useNormalizedResourceOptions(doc)
 

package/src/hooks/documents/useDocuments.ts

@@ -1,13 +1,15 @@
 import {
   createGroqSearchFilter,
-  type DatasetHandle,
   type DocumentHandle,
+  isDatasetResource,
   type QueryOptions,
 } from '@sanity/sdk'
+import {pickProperties} from '@sanity/sdk/_internal'
 import {type SortOrderingItem} from '@sanity/types'
 import {useCallback, useMemo, useState} from 'react'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {type ResourceHandle} from '../../config/handles'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 import {useQuery} from '../query/useQuery'
 
@@ -24,7 +26,7 @@ export interface DocumentsOptions<
   TDataset extends string = string,
   TProjectId extends string = string,
 >
-  extends DatasetHandle<TDataset, TProjectId>, Pick<QueryOptions, 'perspective' | 'params'> {
+  extends ResourceHandle<TDataset, TProjectId>, Pick<QueryOptions, 'perspective' | 'params'> {
   /**
    * Filter documents by their `_type`. Can be a single type or an array of types.
    */
@@ -201,14 +203,14 @@ export function useDocuments<
   filter,
   orderings,
   documentType,
-  ...options
+  ...rawOptions
 }: DocumentsOptions<TDocumentType, TDataset, TProjectId>): DocumentsResponse<
   TDocumentType,
   TDataset,
   TProjectId
 > {
   useTrackHookUsage('useDocuments')
-  const instance = useSanityInstance(options)
+  const options = useNormalizedResourceOptions(rawOptions)
   const [limit, setLimit] = useState(batchSize)
   const documentTypes = useMemo(
     () =>
@@ -284,9 +286,12 @@ export function useDocuments<
       ...params,
       // these are passed back to the user as part of each document handle
       __handle: {
-        projectId: options.projectId ?? instance.config.projectId,
-        dataset: options.dataset ?? instance.config.dataset,
-        perspective: options.perspective ?? instance.config.perspective,
+        // keep projectId/dataset for backward compat until v4; resource is added
+        // intentionally so that hook consumers can resolve the correct resource
+        ...(options.resource && isDatasetResource(options.resource)
+          ? pickProperties(options.resource, ['projectId', 'dataset'])
+          : {}),
+        ...pickProperties(options, ['perspective', 'resource']),
       },
       __types: documentTypes,
     },

package/src/hooks/helpers/createStateSourceHook.tsx

@@ -19,11 +19,10 @@ export function createStateSourceHook<TParams extends unknown[], TState>(
   options: StateSourceFactory<TParams, TState> | CreateStateSourceHookOptions<TParams, TState>,
 ): (...params: TParams) => TState {
   const getState = typeof options === 'function' ? options : options.getState
-  const getConfig = 'getConfig' in options ? options.getConfig : undefined
   const suspense = 'shouldSuspend' in options && 'suspender' in options ? options : undefined
 
   function useHook(...params: TParams) {
-    const instance = useSanityInstance(getConfig?.(...params))
+    const instance = useSanityInstance()
 
     if (suspense?.suspender && suspense?.shouldSuspend?.(instance, ...params)) {
       throw suspense.suspender(instance, ...params)

package/src/hooks/helpers/useNormalizedResourceOptions.test.tsx

@@ -0,0 +1,253 @@
+import {createSanityInstance, type DocumentHandle} from '@sanity/sdk'
+import {type ReactNode} from 'react'
+import {describe, expect, it} from 'vitest'
+
+import {renderHook, resources} from '../../../test/test-utils'
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {ResourcesContext} from '../../context/ResourcesContext'
+import {SanityInstanceContext} from '../../context/SanityInstanceContext'
+import {useNormalizedResourceOptions} from './useNormalizedResourceOptions'
+
+// Wrapper that sets ResourceContext via the `resource` prop (tier 3).
+// Includes ResourcesContext so resourceName resolution also works in these tests.
+function ResourceContextWrapper({
+  children,
+  resource,
+}: {
+  children: ReactNode
+  resource: {projectId: string; dataset: string}
+}) {
+  return (
+    <ResourceProvider resource={resource} fallback={null}>
+      <ResourcesContext.Provider value={resources}>{children}</ResourcesContext.Provider>
+    </ResourceProvider>
+  )
+}
+
+// Wrapper that provides an instance with no projectId/dataset and no ResourceContext (tier 5).
+const bareInstance = createSanityInstance({})
+function NoResourceWrapper({children}: {children: ReactNode}) {
+  return (
+    <SanityInstanceContext.Provider value={bareInstance}>{children}</SanityInstanceContext.Provider>
+  )
+}
+
+describe('useNormalizedResourceOptions', () => {
+  describe('tier 1 — explicit options', () => {
+    it('uses an explicit dataset resource object', () => {
+      const {result} = renderHook(() =>
+        useNormalizedResourceOptions({resource: {projectId: 'explicit', dataset: 'explicit-ds'}}),
+      )
+      expect(result.current.resource).toEqual({projectId: 'explicit', dataset: 'explicit-ds'})
+    })
+
+    it('uses an explicit media-library resource object', () => {
+      const {result} = renderHook(() =>
+        useNormalizedResourceOptions({resource: {mediaLibraryId: 'ml-123'}}),
+      )
+      expect(result.current.resource).toEqual({mediaLibraryId: 'ml-123'})
+    })
+
+    it('uses an explicit canvas resource object', () => {
+      const {result} = renderHook(() =>
+        useNormalizedResourceOptions({resource: {canvasId: 'canvas-123'}}),
+      )
+      expect(result.current.resource).toEqual({canvasId: 'canvas-123'})
+    })
+
+    it('resolves resourceName to a named dataset resource', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({resourceName: 'dataset'}))
+      expect(result.current.resource).toEqual({
+        projectId: 'resource-project-id',
+        dataset: 'resource-dataset',
+      })
+    })
+
+    it('resolves resourceName to a named media-library resource', () => {
+      const {result} = renderHook(() =>
+        useNormalizedResourceOptions({resourceName: 'media-library'}),
+      )
+      expect(result.current.resource).toEqual({mediaLibraryId: 'media-library-id'})
+    })
+
+    it('resolves resourceName to a named canvas resource', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({resourceName: 'canvas'}))
+      expect(result.current.resource).toEqual({canvasId: 'canvas-id'})
+    })
+
+    it('throws when resourceName is not registered', () => {
+      expect(() =>
+        renderHook(() => useNormalizedResourceOptions({resourceName: 'unknown'})),
+      ).toThrow(/no resource named/i)
+    })
+
+    it('throws when both resource and resourceName are provided', () => {
+      expect(() =>
+        renderHook(() =>
+          useNormalizedResourceOptions({
+            resource: {projectId: 'p', dataset: 'd'},
+            resourceName: 'dataset',
+          }),
+        ),
+      ).toThrow()
+    })
+
+    it('resolves deprecated `source` as `resource`', () => {
+      const {result} = renderHook(() =>
+        useNormalizedResourceOptions({source: {projectId: 'src', dataset: 'src-ds'}}),
+      )
+      expect(result.current.resource).toEqual({projectId: 'src', dataset: 'src-ds'})
+    })
+
+    it('resolves deprecated `sourceName` as `resourceName`', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({sourceName: 'dataset'}))
+      expect(result.current.resource).toEqual({
+        projectId: 'resource-project-id',
+        dataset: 'resource-dataset',
+      })
+    })
+  })
+
+  describe('tier 2 — bare projectId/dataset in options', () => {
+    it('synthesizes a resource from projectId + dataset', () => {
+      const {result} = renderHook(() =>
+        useNormalizedResourceOptions({projectId: 'opt', dataset: 'opt-ds'}),
+      )
+      expect(result.current.resource).toEqual({projectId: 'opt', dataset: 'opt-ds'})
+    })
+
+    it('falls through to context when only projectId is provided (no dataset)', () => {
+      // Only projectId is not enough to synthesize — should fall back to context resource
+      const {result} = renderHook(() => useNormalizedResourceOptions({projectId: 'opt'}))
+      // Default test-utils: ResourceProvider projectId="test" dataset="test" → tier-3 via config synthesis
+      expect(result.current.resource).toEqual({projectId: 'test', dataset: 'test'})
+    })
+  })
+
+  describe('tier 3 — ResourceContext', () => {
+    it('uses ResourceContext set via ResourceProvider `resource` prop', () => {
+      const contextResource = {projectId: 'ctx-project', dataset: 'ctx-dataset'}
+      const {result} = renderHook(() => useNormalizedResourceOptions({}), {
+        wrapper: ({children}) => (
+          <ResourceContextWrapper resource={contextResource}>{children}</ResourceContextWrapper>
+        ),
+      })
+      expect(result.current.resource).toEqual(contextResource)
+    })
+
+    it('uses ResourceContext synthesized from ResourceProvider projectId/dataset', () => {
+      // ResourceProvider with projectId/dataset (no explicit resource prop) synthesizes ResourceContext
+      const {result} = renderHook(() => useNormalizedResourceOptions({}))
+      // Default test-utils: ResourceProvider projectId="test" dataset="test"
+      expect(result.current.resource).toEqual({projectId: 'test', dataset: 'test'})
+    })
+
+    it('explicit resource in options takes precedence over ResourceContext', () => {
+      const {result} = renderHook(
+        () =>
+          useNormalizedResourceOptions({resource: {projectId: 'explicit', dataset: 'explicit-ds'}}),
+        {
+          wrapper: ({children}) => (
+            <ResourceContextWrapper resource={{projectId: 'ctx-project', dataset: 'ctx-dataset'}}>
+              {children}
+            </ResourceContextWrapper>
+          ),
+        },
+      )
+      expect(result.current.resource).toEqual({projectId: 'explicit', dataset: 'explicit-ds'})
+    })
+  })
+
+  describe('tier 4 — SanityInstance config fallback', () => {
+    it('falls back to instance projectId/dataset when ResourceContext is not set', () => {
+      // Bare SanityInstanceContext with config — no ResourceProvider, so no ResourceContext
+      const instanceWithConfig = createSanityInstance({projectId: 'inst', dataset: 'inst-ds'})
+      const {result} = renderHook(() => useNormalizedResourceOptions({}), {
+        wrapper: ({children}) => (
+          <SanityInstanceContext.Provider value={instanceWithConfig}>
+            {children}
+          </SanityInstanceContext.Provider>
+        ),
+      })
+      expect(result.current.resource).toEqual({projectId: 'inst', dataset: 'inst-ds'})
+    })
+  })
+
+  describe('tier 5 — no resource available', () => {
+    it('returns no resource when neither options, context, nor instance config provide one', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({}), {
+        wrapper: NoResourceWrapper,
+      })
+      expect(result.current).not.toHaveProperty('resource')
+    })
+  })
+
+  describe('perspective resolution', () => {
+    it('uses explicit perspective from options', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({perspective: 'published'}))
+      expect(result.current.perspective).toBe('published')
+    })
+
+    it('falls back to PerspectiveContext when no perspective in options', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({}), {
+        wrapper: ({children}) => (
+          <ResourceProvider perspective="previewDrafts" fallback={null}>
+            {children}
+          </ResourceProvider>
+        ),
+      })
+      expect(result.current.perspective).toBe('previewDrafts')
+    })
+
+    it('explicit perspective overrides PerspectiveContext', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({perspective: 'published'}), {
+        wrapper: ({children}) => (
+          <ResourceProvider perspective="previewDrafts" fallback={null}>
+            {children}
+          </ResourceProvider>
+        ),
+      })
+      expect(result.current.perspective).toBe('published')
+    })
+
+    it('omits perspective from result when not set', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({}), {
+        wrapper: NoResourceWrapper,
+      })
+      expect(result.current).not.toHaveProperty('perspective')
+    })
+  })
+
+  describe('field stripping', () => {
+    it('strips resourceName from the result', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({resourceName: 'dataset'}))
+      expect(result.current).not.toHaveProperty('resourceName')
+    })
+
+    it('strips projectId and dataset from the result when synthesized into resource', () => {
+      const {result} = renderHook(() =>
+        useNormalizedResourceOptions({projectId: 'p', dataset: 'd'}),
+      )
+      expect(result.current).not.toHaveProperty('projectId')
+      expect(result.current).not.toHaveProperty('dataset')
+    })
+
+    it('strips deprecated source from the result', () => {
+      const {result} = renderHook(() =>
+        useNormalizedResourceOptions({source: {projectId: 'src', dataset: 'src-ds'}}),
+      )
+      expect(result.current).not.toHaveProperty('source')
+    })
+
+    it('strips deprecated sourceName from the result', () => {
+      const {result} = renderHook(() => useNormalizedResourceOptions({sourceName: 'dataset'}))
+      expect(result.current).not.toHaveProperty('sourceName')
+    })
+
+    it('preserves unrelated fields', () => {
+      const opts: DocumentHandle = {documentId: 'doc-1', documentType: 'article'}
+      const {result} = renderHook(() => useNormalizedResourceOptions(opts))
+      expect(result.current).toMatchObject({documentId: 'doc-1', documentType: 'article'})
+    })
+  })
+})