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

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

@@ -1,8 +1,8 @@
 import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
-import {act, renderHook, waitFor} from '@testing-library/react'
-import {BehaviorSubject, firstValueFrom} from 'rxjs'
+import {BehaviorSubject, firstValueFrom, Observable} from 'rxjs'
 import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
+import {act, renderHook, waitFor} from '../../../test/test-utils'
 import {ResourceProvider} from '../../context/ResourceProvider'
 import {useDocumentPermissions} from './useDocumentPermissions'
 
@@ -24,12 +24,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}
@@ -68,7 +68,8 @@ describe('usePermissions', () => {
 
     // Set up the getPermissionsState mock
     vi.mocked(getPermissionsState).mockReturnValue({
-      observable: permissionsSubject.asObservable(),
+      observable:
+        permissionsSubject.asObservable() as unknown as Observable<DocumentPermissionsResult>,
       subscribe: mockSubscribe,
       getCurrent: mockGetCurrent,
     })
@@ -84,20 +85,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)
   })
 
@@ -107,17 +101,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)
@@ -128,58 +112,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'},
+      {
+        ...mockAction,
+        resource: {projectId: 'different-project', dataset: 'dataset1'},
+        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/)
+      renderHook(() => useDocumentPermissions(actions))
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
   it('should throw an error if actions have mismatched datasets', () => {
-    const actions = [mockAction, {...mockAction, dataset: 'different-dataset', documentId: 'doc2'}]
+    const actions = [
+      mockAction,
+      {
+        ...mockAction,
+        resource: {projectId: 'project1', 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/)
+      renderHook(() => useDocumentPermissions(actions))
+    }).toThrow(/Mismatched resources found in actions/)
+  })
+
+  it('should throw an error when mixing different resources', () => {
+    const actions = [
+      mockAction,
+      {
+        type: 'document.publish' as const,
+        documentId: 'doc2',
+        documentType: 'article',
+        resource: {projectId: 'p', dataset: 'd'},
+      },
+    ]
+
+    expect(() => {
+      renderHook(() => useDocumentPermissions(actions))
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
   it('should wait for permissions to be ready before rendering', async () => {
@@ -206,11 +190,7 @@ describe('usePermissions', () => {
       },
       {
         wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
+          <ResourceProvider resource={mockResource} fallback={null}>
             {children}
           </ResourceProvider>
         ),
@@ -226,27 +206,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(() => {
+      renderHook(
+        () =>
+          useDocumentPermissions({
+            type: 'document.publish',
+            documentId: 'doc1',
+            documentType: 'article',
+            // no resource
+          } as never),
+        {
+          wrapper: ({children}) => <ResourceProvider fallback={null}>{children}</ResourceProvider>,
+        },
+      )
+    }).toThrow(/resource is required/)
+  })
+
   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,8 +1,11 @@
 import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
-import {useCallback, useMemo, useSyncExternalStore} from 'react'
+import {useCallback, useContext, useMemo, useSyncExternalStore} from 'react'
 import {filter, firstValueFrom} from 'rxjs'
 
+import {ResourceContext} from '../../context/DefaultResourceContext'
+import {ResourcesContext} from '../../context/ResourcesContext'
 import {useSanityInstance} from '../context/useSanityInstance'
+import {normalizeResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 /**
  *
@@ -84,50 +87,60 @@ import {useSanityInstance} from '../context/useSanityInstance'
 export function useDocumentPermissions(
   actionOrActions: DocumentAction | 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
+  const instance = useSanityInstance()
+  const contextResource = useContext(ResourceContext)
+  const resources = useContext(ResourcesContext)
 
-  for (const action of actions) {
-    if (action.projectId) {
-      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}".`,
+  const normalizedActions = useMemo(() => {
+    return Array.isArray(actionOrActions)
+      ? actionOrActions.map((action) =>
+          normalizeResourceOptions(action, resources, contextResource),
         )
-      }
+      : [normalizeResourceOptions(actionOrActions, resources, contextResource)]
+  }, [actionOrActions, resources, contextResource])
 
-      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}".`,
-          )
-        }
+  // if actions is an array, we need to check that all actions belong to the same resource
+  let resource
+
+  for (const action of normalizedActions) {
+    if (action.resource) {
+      if (!resource) resource = action.resource
+      if (action.resource !== resource) {
+        throw 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)}".`,
+        )
       }
     }
   }
 
-  const instance = useSanityInstance({projectId, dataset})
+  const effectiveResource = resource ?? contextResource
+
+  if (!effectiveResource) {
+    throw new Error(
+      'No resource found. Provide a resource via the action handle or wrap with a resource context.',
+    )
+  }
+
+  const permissionsOptions = useMemo(
+    () => ({resource: effectiveResource, actions: normalizedActions as DocumentAction[]}),
+    [effectiveResource, normalizedActions],
+  )
+
   const isDocumentReady = useCallback(
-    () => getPermissionsState(instance, {actions}).getCurrent() !== undefined,
-    [actions, instance],
+    () => getPermissionsState(instance, permissionsOptions).getCurrent() !== undefined,
+    [permissionsOptions, instance],
   )
   if (!isDocumentReady()) {
     throw firstValueFrom(
-      getPermissionsState(instance, {actions}).observable.pipe(
+      getPermissionsState(instance, permissionsOptions).observable.pipe(
         filter((result) => result !== undefined),
       ),
     )
   }
 
   const {subscribe, getCurrent} = useMemo(
-    () => getPermissionsState(instance, {actions}),
-    [actions, instance],
+    () => getPermissionsState(instance, permissionsOptions),
+    [permissionsOptions, instance],
   )
 
   return useSyncExternalStore(subscribe, getCurrent) as DocumentPermissionsResult

package/src/hooks/document/useDocumentSyncStatus.test.ts

@@ -1,23 +1,33 @@
 import {getDocumentSyncStatus} from '@sanity/sdk'
 import {describe, it} from 'vitest'
 
+import {renderHook} from '../../../test/test-utils'
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
 const mockHook = vi.fn()
 vi.mock('../helpers/createStateSourceHook', () => ({createStateSourceHook: vi.fn(() => mockHook)}))
-vi.mock('@sanity/sdk', () => ({getDocumentSyncStatus: vi.fn()}))
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {
+    ...original,
+    getDocumentSyncStatus: vi.fn(),
+  }
+})
+
+vi.mock('../context/useSanityInstance')
 
 describe('useDocumentSyncStatus', () => {
   it('calls `createStateSourceHook` with `getDocumentSyncStatus`', async () => {
     const {useDocumentSyncStatus} = await import('./useDocumentSyncStatus')
+    renderHook(() => useDocumentSyncStatus({documentId: '1', documentType: 'test'}))
     expect(createStateSourceHook).toHaveBeenCalledWith(
       expect.objectContaining({
         getState: getDocumentSyncStatus,
         shouldSuspend: expect.any(Function),
         suspender: expect.any(Function),
-        getConfig: expect.any(Function),
       }),
     )
-    expect(useDocumentSyncStatus).toBe(mockHook)
+    // Verify that the hook was created and can be called
+    expect(mockHook).toHaveBeenCalled()
   })
 })

package/src/hooks/document/useDocumentSyncStatus.ts

@@ -1,22 +1,23 @@
 import {
-  type DocumentHandle,
+  type DocumentHandle as StrictDocumentHandle,
   getDocumentSyncStatus,
   resolveDocument,
   type SanityInstance,
   type StateSource,
 } from '@sanity/sdk'
-import {identity} from 'rxjs'
 
+import {type DocumentHandle} from '../../config/handles'
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 type UseDocumentSyncStatus = {
   /**
    * Exposes the document's sync status between local and remote document states.
    *
    * @category Documents
-   * @param doc - The document handle to get sync status for. If you pass a `DocumentHandle` with specified `projectId` and `dataset`,
-   * the document will be read from the specified Sanity project and dataset that is included in the handle. If no `projectId` or `dataset` is provided,
-   * the document will use the nearest instance from context.
+   * @param doc - The document handle to get sync status for. If you pass a `resource` in the handle,
+   * the document will be read from the specified resource. If no `resource` is provided,
+   * the resource will be resolved from context.
    * @returns `true` if local changes are synced with remote, `false` if changes are pending. Note: Suspense handles loading states.
    * @example Show sync status indicator
    * ```tsx
@@ -45,17 +46,21 @@ type UseDocumentSyncStatus = {
   (doc: DocumentHandle): boolean
 }
 
-/**
- * @public
- * @function
- */
-export const useDocumentSyncStatus: UseDocumentSyncStatus = createStateSourceHook({
+const useDocumentSyncStatusValue = createStateSourceHook({
   getState: getDocumentSyncStatus as (
     instance: SanityInstance,
-    doc: DocumentHandle,
+    doc: StrictDocumentHandle,
   ) => StateSource<boolean>,
-  shouldSuspend: (instance, doc: DocumentHandle) =>
+  shouldSuspend: (instance, doc: StrictDocumentHandle) =>
     getDocumentSyncStatus(instance, doc).getCurrent() === undefined,
-  suspender: (instance, doc: DocumentHandle) => resolveDocument(instance, doc),
-  getConfig: identity,
+  suspender: (instance, doc: StrictDocumentHandle) => resolveDocument(instance, doc),
 })
+
+/**
+ * @public
+ * @function
+ */
+export const useDocumentSyncStatus: UseDocumentSyncStatus = (options: DocumentHandle) => {
+  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'
 
@@ -40,7 +39,13 @@ const doc = {
 const docHandle = createDocumentHandle({
   documentId: 'doc1',
   documentType: 'book',
+  resource: {projectId: 'test-project', dataset: 'test-dataset'},
 })
+const normalizedDocHandle = {
+  documentId: 'doc1',
+  documentType: 'book',
+  resource: {projectId: 'test-project', dataset: 'test-dataset'},
+}
 
 // Define a single generic TestDocument type
 interface Book extends SanityDocument {
@@ -50,16 +55,6 @@ interface Book extends SanityDocument {
   title?: string
 }
 
-// Scope the TestDocument type to the project/datasets used in tests
-type AllTestSchemaTypes = Book
-
-// Augment the 'groq' module
-declare module 'groq' {
-  interface SanitySchemas {
-    'default:default': AllTestSchemaTypes
-  }
-}
-
 describe('useEditDocument hook', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -76,16 +71,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(normalizedDocHandle, {set: {foo: 'newValue'}})
+    expect(apply).toHaveBeenCalledWith(editDocument(normalizedDocHandle, {set: {foo: 'newValue'}}))
     const actionsResult = await promise
     expect(actionsResult).toEqual({transactionId: 'tx1'})
   })
@@ -103,15 +92,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(normalizedDocHandle, {set: {foo: 'baz'}})])
     const actionsResult = await promise
     expect(actionsResult).toEqual({transactionId: 'tx2'})
   })
@@ -127,16 +110,12 @@ 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(normalizedDocHandle, {set: {foo: 'barUpdated'}})
+    expect(apply).toHaveBeenCalledWith(
+      editDocument(normalizedDocHandle, {set: {foo: 'barUpdated'}}),
+    )
     const actionsResult = await promise
     expect(actionsResult).toEqual({transactionId: 'tx3'})
   })
@@ -153,15 +132,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: Record<string, unknown>) => ({...prevDoc, foo: 'baz'}))
+    expect(apply).toHaveBeenCalledWith([editDocument(normalizedDocHandle, {set: {foo: 'baz'}})])
     const actionsResult = await promise
     expect(actionsResult).toEqual({transactionId: 'tx4'})
   })
@@ -177,13 +150,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 +170,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)