@sanity/sdk-react 2.9.0 → 2.11.0

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

@@ -1,8 +1,9 @@
 import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
-import {act, renderHook, waitFor} from '@testing-library/react'
+import {renderHook as reactRenderHook} from '@testing-library/react'
 import {BehaviorSubject, firstValueFrom, Observable} from 'rxjs'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+import {afterEach, beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
 
+import {act, renderHook, waitFor} from '../../../test/test-utils'
 import {ResourceProvider} from '../../context/ResourceProvider'
 import {useDocumentPermissions} from './useDocumentPermissions'
 
@@ -24,12 +25,12 @@ vi.mock('rxjs', async (importOriginal) => {
 })
 
 describe('usePermissions', () => {
+  const mockResource = {projectId: 'project1', dataset: 'dataset1'}
   const mockAction: DocumentAction = {
     type: 'document.publish',
     documentId: 'doc1',
     documentType: 'article',
-    projectId: 'project1',
-    dataset: 'dataset1',
+    resource: mockResource,
   }
 
   const mockPermissionAllowed: DocumentPermissionsResult = {allowed: true}
@@ -46,8 +47,8 @@ describe('usePermissions', () => {
   }
 
   let permissionsSubject: BehaviorSubject<DocumentPermissionsResult | undefined>
-  let mockSubscribe: ReturnType<typeof vi.fn>
-  let mockGetCurrent: ReturnType<typeof vi.fn>
+  let mockSubscribe: Mock<(onStoreChanged?: () => void) => () => void>
+  let mockGetCurrent: Mock<() => DocumentPermissionsResult | undefined>
 
   beforeEach(() => {
     vi.clearAllMocks()
@@ -71,7 +72,7 @@ describe('usePermissions', () => {
       observable:
         permissionsSubject.asObservable() as unknown as Observable<DocumentPermissionsResult>,
       subscribe: mockSubscribe,
-      getCurrent: mockGetCurrent,
+      getCurrent: mockGetCurrent as unknown as () => DocumentPermissionsResult,
     })
   })
 
@@ -85,20 +86,13 @@ describe('usePermissions', () => {
       permissionsSubject.next(mockPermissionAllowed)
     })
 
-    const {result} = renderHook(() => useDocumentPermissions(mockAction), {
-      wrapper: ({children}) => (
-        <ResourceProvider
-          projectId={mockAction.projectId}
-          dataset={mockAction.dataset}
-          fallback={null}
-        >
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useDocumentPermissions(mockAction))
 
     // ResourceProvider handles the instance configuration
-    expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), {actions: [mockAction]})
+    expect(getPermissionsState).toHaveBeenCalledWith(
+      expect.any(Object),
+      expect.objectContaining({actions: [mockAction], resource: mockResource}),
+    )
     expect(result.current).toEqual(mockPermissionAllowed)
   })
 
@@ -108,17 +102,7 @@ describe('usePermissions', () => {
       permissionsSubject.next(mockPermissionDenied)
     })
 
-    const {result} = renderHook(() => useDocumentPermissions(mockAction), {
-      wrapper: ({children}) => (
-        <ResourceProvider
-          projectId={mockAction.projectId}
-          dataset={mockAction.dataset}
-          fallback={null}
-        >
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useDocumentPermissions(mockAction))
 
     expect(result.current).toEqual(mockPermissionDenied)
     expect(result.current.allowed).toBe(false)
@@ -129,141 +113,58 @@ describe('usePermissions', () => {
   it('should accept an array of actions', () => {
     const actions = [mockAction, {...mockAction, documentId: 'doc2'}]
 
-    renderHook(() => useDocumentPermissions(actions), {
-      wrapper: ({children}) => (
-        <ResourceProvider
-          projectId={mockAction.projectId}
-          dataset={mockAction.dataset}
-          fallback={null}
-        >
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    renderHook(() => useDocumentPermissions(actions))
 
-    expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), {actions})
+    expect(getPermissionsState).toHaveBeenCalledWith(
+      expect.any(Object),
+      expect.objectContaining({actions, resource: mockResource}),
+    )
   })
 
-  it('should throw an error if actions have mismatched project IDs', () => {
+  it('should throw an error if actions have mismatched resources', () => {
     const actions = [
       mockAction,
-      {...mockAction, projectId: 'different-project', documentId: 'doc2'},
-    ]
-
-    expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatched project IDs found in actions/)
-  })
-
-  it('should throw an error if actions have mismatched datasets', () => {
-    const actions = [mockAction, {...mockAction, dataset: 'different-dataset', documentId: 'doc2'}]
-
-    expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatched datasets found in actions/)
-  })
-
-  it('should throw an error if actions have mismatched sources', () => {
-    const actions = [
-      {
-        type: 'document.publish' as const,
-        documentId: 'doc1',
-        documentType: 'article',
-        source: {projectId: 'p1', dataset: 'd1'},
-      },
       {
-        type: 'document.publish' as const,
+        ...mockAction,
+        resource: {projectId: 'different-project', dataset: 'dataset1'},
         documentId: 'doc2',
-        documentType: 'article',
-        source: {projectId: 'p2', dataset: 'd2'},
       },
     ]
 
     expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatched sources found in actions/)
+      renderHook(() => useDocumentPermissions(actions))
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('should throw an error when mixing projectId and source (projectId first)', () => {
+  it('should throw an error if actions have mismatched datasets', () => {
     const actions = [
       mockAction,
       {
-        type: 'document.publish' as const,
+        ...mockAction,
+        resource: {projectId: 'project1', dataset: 'different-dataset'},
         documentId: 'doc2',
-        documentType: 'article',
-        source: {projectId: 'p', dataset: 'd'},
       },
     ]
 
     expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatches between projectId\/dataset options and source/)
+      renderHook(() => useDocumentPermissions(actions))
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('should throw an error when mixing source and projectId (source first)', () => {
+  it('should throw an error when mixing different resources', () => {
     const actions = [
+      mockAction,
       {
         type: 'document.publish' as const,
-        documentId: 'doc1',
+        documentId: 'doc2',
         documentType: 'article',
-        source: {projectId: 'p', dataset: 'd'},
+        resource: {projectId: 'p', dataset: 'd'},
       },
-      mockAction,
     ]
 
     expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatches between projectId\/dataset options and source/)
+      renderHook(() => useDocumentPermissions(actions))
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
   it('should wait for permissions to be ready before rendering', async () => {
@@ -277,7 +178,7 @@ describe('usePermissions', () => {
     vi.mocked(firstValueFrom).mockReturnValueOnce(mockPromise)
 
     // This should throw the promise and suspend
-    const {result} = renderHook(
+    const {result} = reactRenderHook(
       () => {
         try {
           return useDocumentPermissions(mockAction)
@@ -290,11 +191,7 @@ describe('usePermissions', () => {
       },
       {
         wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
+          <ResourceProvider resource={mockResource} fallback={null}>
             {children}
           </ResourceProvider>
         ),
@@ -310,27 +207,38 @@ describe('usePermissions', () => {
 
     // Now it should render properly
     await waitFor(() => {
-      expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), {actions: [mockAction]})
+      expect(getPermissionsState).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({actions: [mockAction], resource: mockResource}),
+      )
     })
   })
 
+  it('throws when no resource is found from action or context', () => {
+    // Provide SanityInstance via ResourceProvider but no resource, so contextResource is undefined
+    expect(() => {
+      reactRenderHook(
+        () =>
+          useDocumentPermissions({
+            type: 'document.publish',
+            documentId: 'doc1',
+            documentType: 'article',
+            // no resource
+          } as never),
+        {
+          wrapper: ({children}) => <ResourceProvider fallback={null}>{children}</ResourceProvider>,
+        },
+      )
+    }).toThrow(/No resource found/)
+  })
+
   it('should react to permission state changes', async () => {
     // Start with permission allowed
     act(() => {
       permissionsSubject.next(mockPermissionAllowed)
     })
 
-    const {result, rerender} = renderHook(() => useDocumentPermissions(mockAction), {
-      wrapper: ({children}) => (
-        <ResourceProvider
-          projectId={mockAction.projectId}
-          dataset={mockAction.dataset}
-          fallback={null}
-        >
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result, rerender} = renderHook(() => useDocumentPermissions(mockAction))
 
     expect(result.current).toEqual(mockPermissionAllowed)
 

package/src/hooks/document/useDocumentPermissions.ts

@@ -1,10 +1,20 @@
 import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
-import {useCallback, useMemo, useSyncExternalStore} from 'react'
+import {isDeepEqual} from '@sanity/sdk/_internal'
+import {useCallback, useContext, useMemo, useSyncExternalStore} from 'react'
 import {filter, firstValueFrom} from 'rxjs'
 
+import {ResourcesContext} from '../../context/ResourcesContext'
 import {useSanityInstance} from '../context/useSanityInstance'
+import {
+  normalizeResourceOptions,
+  useEffectiveContextResource,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
 import {trackHookUsage} from '../helpers/useTrackHookUsage'
 
+const noopSubscribe = () => () => {}
+const returnUndefined = () => undefined
+
 /**
  *
  * @public
@@ -83,74 +93,87 @@ import {trackHookUsage} from '../helpers/useTrackHookUsage'
  * ```
  */
 export function useDocumentPermissions(
-  actionOrActions: DocumentAction | DocumentAction[],
+  actionOrActions:
+    | WithResourceNameSupport<DocumentAction>
+    | WithResourceNameSupport<DocumentAction>[],
 ): DocumentPermissionsResult {
-  const actions = useMemo(
-    () => (Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]),
-    [actionOrActions],
-  )
-  // if actions is an array, we need to check that all actions belong to the same project and dataset
-  let projectId
-  let dataset
-  let source
+  const instance = useSanityInstance()
+  trackHookUsage(instance, 'useDocumentPermissions')
+  const effectiveContextResource = useEffectiveContextResource()
+  const resources = useContext(ResourcesContext)
 
-  for (const action of actions) {
-    if (action.projectId) {
-      if (source) {
-        throw new Error(
-          `Mismatches between projectId/dataset options and source in actions. Found projectId "${action.projectId}" and dataset "${action.dataset}" but expected source "${source}".`,
+  const {
+    actions: normalizedActions,
+    resource: actionResource,
+    error: validationError,
+  } = useMemo(() => {
+    const normalized = Array.isArray(actionOrActions)
+      ? actionOrActions.map((action) =>
+          normalizeResourceOptions(action, resources, effectiveContextResource),
         )
-      }
-      if (!projectId) projectId = action.projectId
-      if (action.projectId !== projectId) {
-        throw new Error(
-          `Mismatched project IDs found in actions. All actions must belong to the same project. Found "${action.projectId}" but expected "${projectId}".`,
-        )
-      }
+      : [normalizeResourceOptions(actionOrActions, resources, effectiveContextResource)]
 
-      if (action.dataset) {
-        if (!dataset) dataset = action.dataset
-        if (action.dataset !== dataset) {
-          throw new Error(
-            `Mismatched datasets found in actions. All actions must belong to the same dataset. Found "${action.dataset}" but expected "${dataset}".`,
-          )
+    let resource
+    for (const action of normalized) {
+      if (action.resource) {
+        if (!resource) resource = action.resource
+        if (!isDeepEqual(action.resource, resource)) {
+          return {
+            actions: normalized,
+            resource,
+            error: new Error(
+              `Mismatched resources found in actions. All actions must belong to the same resource. Found "${JSON.stringify(action.resource)}" but expected "${JSON.stringify(resource)}".`,
+            ),
+          }
         }
       }
     }
+    return {actions: normalized, resource, error: undefined}
+  }, [actionOrActions, resources, effectiveContextResource])
 
-    if (action.source) {
-      if (!source) source = action.source
-      if (action.source !== source) {
-        throw new Error(
-          `Mismatched sources found in actions. All actions must belong to the same source. Found "${action.source}" but expected "${source}".`,
-        )
-      }
-      if (projectId || dataset) {
-        throw new Error(
-          `Mismatches between projectId/dataset options and source in actions. Found "${action.source}" but expected project "${projectId}" and dataset "${dataset}".`,
-        )
-      }
-    }
-  }
+  const effectiveResource = actionResource ?? effectiveContextResource
+
+  // Keep hooks unconditional — validation errors and missing-resource errors are
+  // thrown after all hooks so that the hook call count stays stable across renders.
+  const permissionsOptions = useMemo(
+    () =>
+      effectiveResource
+        ? {
+            resource: effectiveResource,
+            // `Omit<>` on `DocumentAction` loses the discriminant; runtime values are still actions.
+            actions: normalizedActions as DocumentAction[],
+          }
+        : undefined,
+    [effectiveResource, normalizedActions],
+  )
+
+  const stateSource = useMemo(
+    () => (permissionsOptions ? getPermissionsState(instance, permissionsOptions) : undefined),
+    [permissionsOptions, instance],
+  )
 
-  const instance = useSanityInstance({projectId, dataset})
-  trackHookUsage(instance, 'useDocumentPermissions')
   const isDocumentReady = useCallback(
-    () => getPermissionsState(instance, {actions}).getCurrent() !== undefined,
-    [actions, instance],
+    () => stateSource !== undefined && stateSource.getCurrent() !== undefined,
+    [stateSource],
+  )
+
+  const result = useSyncExternalStore(
+    stateSource?.subscribe ?? noopSubscribe,
+    stateSource?.getCurrent ?? returnUndefined,
   )
+
+  // All hooks have been called — safe to throw now.
+  if (validationError) throw validationError
+  if (!effectiveResource) {
+    throw new Error(
+      'No resource found. Provide a resource via the action handle or wrap with a resource context.',
+    )
+  }
   if (!isDocumentReady()) {
     throw firstValueFrom(
-      getPermissionsState(instance, {actions}).observable.pipe(
-        filter((result) => result !== undefined),
-      ),
+      stateSource!.observable.pipe(filter((permissions) => permissions !== undefined)),
     )
   }
 
-  const {subscribe, getCurrent} = useMemo(
-    () => getPermissionsState(instance, {actions}),
-    [actions, instance],
-  )
-
-  return useSyncExternalStore(subscribe, getCurrent) as DocumentPermissionsResult
+  return result as DocumentPermissionsResult
 }

package/src/hooks/document/useDocumentSyncStatus.ts

@@ -9,7 +9,7 @@ import {
 import {identity} from 'rxjs'
 
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
-import {useNormalizedSourceOptions} from '../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 type UseDocumentSyncStatus = {
   /**
@@ -65,6 +65,6 @@ const useDocumentSyncStatusValue = createStateSourceHook({
 export const useDocumentSyncStatus: UseDocumentSyncStatus = (
   options: DocumentOptions<string | undefined>,
 ) => {
-  const normalizedOptions = useNormalizedSourceOptions(options)
+  const normalizedOptions = useNormalizedResourceOptions(options)
   return useDocumentSyncStatusValue(normalizedOptions)
 }

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

@@ -10,7 +10,7 @@ import {type SanityDocument} from 'groq'
 import {useCallback} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
-import {useNormalizedSourceOptions} from '../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {trackHookUsage} from '../helpers/useTrackHookUsage'
 import {useApplyDocumentActions} from './useApplyDocumentActions'
 
@@ -286,9 +286,9 @@ 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 = useNormalizedSourceOptions(doc)
+  const normalizedDoc = useNormalizedResourceOptions(doc)
 
   const apply = useApplyDocumentActions()
   const isDocumentReady = useCallback(