@sanity/sdk-react 2.9.0 → 2.11.0

package/src/hooks/document/{useApplyDocumentActions.test.ts → useApplyDocumentActions.test.tsx}

@@ -1,7 +1,9 @@
-import {applyDocumentActions, type SanityInstance} from '@sanity/sdk'
+import {applyDocumentActions, createSanityInstance} from '@sanity/sdk'
+import {renderHook as reactRenderHook} from '@testing-library/react'
 import {describe, it} from 'vitest'
 
 import {renderHook} from '../../../test/test-utils'
+import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {useApplyDocumentActions} from './useApplyDocumentActions'
 
@@ -12,18 +14,7 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
 
 vi.mock('../context/useSanityInstance')
 
-// These are quite fragile mocks, but they are useful enough for now.
-const instances: Record<string, SanityInstance | undefined> = {
-  'p123.d': {__id: 'p123.d'} as unknown as SanityInstance,
-  'p.d123': {__id: 'p.d123'} as unknown as SanityInstance,
-  'p123.d123': {__id: 'p123.d123'} as unknown as SanityInstance,
-}
-
-const instance = {
-  match({projectId = 'p', dataset = 'd'}): SanityInstance | undefined {
-    return instances[`${projectId}.${dataset}`]
-  },
-} as unknown as SanityInstance
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 
 describe('useApplyDocumentActions', () => {
   beforeEach(() => {
@@ -31,7 +22,7 @@ describe('useApplyDocumentActions', () => {
     vi.mocked(useSanityInstance).mockReturnValueOnce(instance)
   })
 
-  it('uses the SanityInstance', async () => {
+  it('uses the effective context resource', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     result.current({
       type: 'document.edit',
@@ -45,43 +36,28 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
+          // resource named in test-utils
+          resource: {projectId: 'test', dataset: 'test'},
         },
       ],
+      resource: {projectId: 'test', dataset: 'test'},
     })
   })
 
-  it('uses SanityInstance.match when projectId is overrideen', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
-    result.current({
-      type: 'document.edit',
-      documentType: 'post',
-      documentId: 'abc',
-
-      projectId: 'p123',
-    })
-
-    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instances['p123.d'], {
-      actions: [
-        {
-          type: 'document.edit',
-          documentType: 'post',
-          documentId: 'abc',
-
-          projectId: 'p123',
-        },
-      ],
-    })
-  })
-
-  it('uses SanityInstance when dataset is overrideen', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
-    result.current({
-      type: 'document.edit',
-      documentType: 'post',
-      documentId: 'abc',
-
-      dataset: 'd123',
+  it('uses the SanityInstance when resource is not provided', async () => {
+    const {result} = reactRenderHook(() => useApplyDocumentActions(), {
+      wrapper: ({children}) => (
+        <SanityInstanceContext.Provider value={instance}>{children}</SanityInstanceContext.Provider>
+      ),
     })
+    result.current(
+      {
+        type: 'document.edit',
+        documentType: 'post',
+        documentId: 'abc',
+      },
+      {},
+    )
 
     expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
       actions: [
@@ -89,51 +65,36 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-
-          dataset: 'd123',
+          resource: {projectId: 'p', dataset: 'd'},
         },
       ],
+      resource: {projectId: 'p', dataset: 'd'},
     })
   })
 
-  it('uses SanityInstance.amcth when projectId and dataset is overrideen', async () => {
+  it('resolves resource from projectId and dataset in action', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     result.current({
       type: 'document.edit',
       documentType: 'post',
       documentId: 'abc',
-
-      projectId: 'p123',
+      projectId: 'p',
       dataset: 'd123',
     })
 
-    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instances['p123.d123'], {
+    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
       actions: [
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-
-          projectId: 'p123',
-          dataset: 'd123',
+          resource: {projectId: 'p', dataset: 'd123'},
         },
       ],
+      resource: {projectId: 'p', dataset: 'd123'},
     })
   })
 
-  it("throws if SanityInstance.match doesn't find anything", async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
-    expect(() => {
-      result.current({
-        type: 'document.edit',
-        documentType: 'post',
-        documentId: 'abc',
-
-        projectId: 'other',
-      })
-    }).toThrow()
-  })
-
   it('throws when actions have mismatched project IDs', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
@@ -143,15 +104,17 @@ describe('useApplyDocumentActions', () => {
           documentType: 'post',
           documentId: 'abc',
           projectId: 'p123',
+          dataset: 'd',
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
           projectId: 'p456',
+          dataset: 'd',
         },
       ])
-    }).toThrow(/Mismatched project IDs found in actions/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
   it('throws when actions have mismatched datasets', async () => {
@@ -173,10 +136,10 @@ describe('useApplyDocumentActions', () => {
           dataset: 'd2',
         },
       ])
-    }).toThrow(/Mismatched datasets found in actions/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when actions have mismatched sources', async () => {
+  it('throws when actions have mismatched resources', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
       result.current([
@@ -184,19 +147,19 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          source: {projectId: 'p', dataset: 'd1'},
+          resource: {projectId: 'p', dataset: 'd1'},
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          source: {projectId: 'p', dataset: 'd2'},
+          resource: {projectId: 'p', dataset: 'd2'},
         },
       ])
-    }).toThrow(/Mismatched sources found in actions/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when mixing projectId and source (projectId first)', async () => {
+  it('throws when mixing projectId/dataset and resource with a mismatch (projectId first)', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
       result.current([
@@ -204,19 +167,20 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          projectId: 'p',
+          projectId: 'p1',
+          dataset: 'd',
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          source: {projectId: 'p', dataset: 'd'},
+          resource: {projectId: 'p2', dataset: 'd'},
         },
       ])
-    }).toThrow(/Mismatches between projectId\/dataset options and source/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when mixing source and projectId (source first)', async () => {
+  it('throws when mixing resource and projectId/dataset with a mismatch (resource first)', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
       result.current([
@@ -224,15 +188,16 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          source: {projectId: 'p', dataset: 'd'},
+          resource: {projectId: 'p1', dataset: 'd'},
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          projectId: 'p',
+          projectId: 'p2',
+          dataset: 'd',
         },
       ])
-    }).toThrow(/Mismatches between projectId\/dataset options and source/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 })

package/src/hooks/document/useApplyDocumentActions.ts

@@ -1,18 +1,15 @@
-import {
-  type ActionsResult,
-  applyDocumentActions,
-  type ApplyDocumentActionsOptions,
-  type DocumentAction,
-} from '@sanity/sdk'
+import {type ActionsResult, applyDocumentActions, type DocumentAction} from '@sanity/sdk'
+import {isDeepEqual} from '@sanity/sdk/_internal'
 import {type SanityDocument} from 'groq'
 import {useContext} from 'react'
 
-import {SourcesContext} from '../../context/SourcesContext'
+import {type ResourceHandle} from '../../config/handles'
+import {ResourcesContext} from '../../context/ResourcesContext'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {
-  normalizeSourceOptions,
-  type WithSourceNameSupport,
-} from '../helpers/useNormalizedSourceOptions'
+  normalizeResourceOptions,
+  useEffectiveContextResource,
+} from '../helpers/useNormalizedResourceOptions'
 // this import is used in an `{@link useEditDocument}`
 // eslint-disable-next-line unused-imports/no-unused-imports, import/consistent-type-specifier-style
 import type {useEditDocument} from './useEditDocument'
@@ -29,7 +26,7 @@ interface UseApplyDocumentActions {
     action:
       | DocumentAction<TDocumentType, TDataset, TProjectId>
       | DocumentAction<TDocumentType, TDataset, TProjectId>[],
-    options?: WithSourceNameSupport<ApplyDocumentActionsOptions>,
+    options?: ResourceHandle,
   ) => Promise<ActionsResult<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
 }
 
@@ -218,74 +215,43 @@ interface UseApplyDocumentActions {
  */
 export const useApplyDocumentActions: UseApplyDocumentActions = () => {
   const instance = useSanityInstance()
-  const sources = useContext(SourcesContext)
+  const resources = useContext(ResourcesContext)
+  const effectiveContextResource = useEffectiveContextResource()
 
   return (actionOrActions, options) => {
     const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]
-    const normalizedOptions = options ? normalizeSourceOptions(options, sources) : undefined
-
-    let projectId
-    let dataset
-    let source
-    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}".`,
-          )
-        }
-        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 optionsResource = options
+      ? normalizeResourceOptions(options, resources, effectiveContextResource).resource
+      : undefined
 
-        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}".`,
-            )
-          }
-        }
-      }
+    const normalizedActions = actions.map((action) =>
+      normalizeResourceOptions(action, resources, effectiveContextResource),
+    )
+    let resource
 
-      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}".`,
-          )
-        }
-      }
-    }
-
-    if (projectId || dataset) {
-      const actualInstance = instance.match({projectId, dataset})
-      if (!actualInstance) {
+    for (const action of normalizedActions) {
+      if (!resource && action.resource) resource = action.resource
+      if (!isDeepEqual(action.resource, resource)) {
         throw new Error(
-          `Could not find a matching Sanity instance for the requested action: ${JSON.stringify({projectId, dataset}, null, 2)}.
-  Please ensure there is a ResourceProvider component with a matching configuration in the component hierarchy.`,
+          `Mismatched resources found in actions. All actions must belong to the same resource. Found "${JSON.stringify(action.resource)}" but expected "${JSON.stringify(resource)}".`,
         )
       }
+    }
+
+    if (optionsResource && resource && !isDeepEqual(optionsResource, resource)) {
+      throw new Error(
+        `Mismatched resources found in actions. Found top-level resource "${JSON.stringify(optionsResource)}" but expected resource from action handles "${JSON.stringify(resource)}".`,
+      )
+    }
 
-      return applyDocumentActions(actualInstance, {
-        actions,
-        source,
-        ...normalizedOptions,
-      })
+    const effectiveResource = resource ?? optionsResource ?? effectiveContextResource
+    if (!effectiveResource) {
+      throw new Error('No resource found. Provide a resource via the action handle or context.')
     }
 
     return applyDocumentActions(instance, {
-      actions,
-      source,
-      ...normalizedOptions,
+      actions: normalizedActions as DocumentAction[],
+      resource: effectiveResource,
     })
   }
 }

package/src/hooks/document/useDocument.ts

@@ -2,11 +2,9 @@ import {type DocumentOptions, getDocumentState, type JsonMatch, resolveDocument}
 import {type SanityDocument} from 'groq'
 import {identity} from 'rxjs'
 
+import {type DocumentHandle} from '../../config/handles'
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
-import {
-  useNormalizedSourceOptions,
-  type WithSourceNameSupport,
-} from '../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 // used in an `{@link useDocumentProjection}` and `{@link useQuery}`
 // eslint-disable-next-line import/consistent-type-specifier-style, unused-imports/no-unused-imports
@@ -43,7 +41,7 @@ type UseDocumentOptions<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
-> = WithSourceNameSupport<DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>>
+> = DocumentHandle<TDocumentType, TDataset, TProjectId> & {path?: TPath}
 
 interface UseDocument {
   /** @internal */
@@ -240,6 +238,6 @@ interface UseDocument {
  */
 export const useDocument = wrapHookWithData((options: UseDocumentOptions) => {
   useTrackHookUsage('useDocument')
-  const normalizedOptions = useNormalizedSourceOptions(options)
+  const normalizedOptions = useNormalizedResourceOptions(options)
   return useDocumentValue(normalizedOptions)
 }) as UseDocument

package/src/hooks/document/useDocumentEvent.ts

@@ -1,8 +1,9 @@
-import {type DatasetHandle, type DocumentEvent, subscribeDocumentEvents} from '@sanity/sdk'
+import {type DocumentEvent, subscribeDocumentEvents} from '@sanity/sdk'
 import {useCallback, useEffect, useInsertionEffect, useRef} from 'react'
 
+import {type ResourceHandle} from '../../config/handles'
 import {useSanityInstance} from '../context/useSanityInstance'
-import {useNormalizedSourceOptions} from '../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 
 /**
@@ -11,7 +12,7 @@ import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 export interface UseDocumentEventOptions<
   TDataset extends string = string,
   TProjectId extends string = string,
-> extends DatasetHandle<TDataset, TProjectId> {
+> extends ResourceHandle<TDataset, TProjectId> {
   onEvent: (documentEvent: DocumentEvent) => void
 }
 
@@ -79,7 +80,7 @@ export function useDocumentEvent<
 ): void {
   useTrackHookUsage('useDocumentEvent')
   // Destructure handler and datasetHandle from options
-  const normalizedOptions = useNormalizedSourceOptions(options)
+  const normalizedOptions = useNormalizedResourceOptions(options)
   const {onEvent, ...datasetHandle} = normalizedOptions
   const ref = useRef(onEvent)
 
@@ -91,11 +92,11 @@ export function useDocumentEvent<
     return ref.current(documentEvent)
   }, [])
 
-  const instance = useSanityInstance(datasetHandle)
+  const instance = useSanityInstance()
   useEffect(() => {
     return subscribeDocumentEvents(instance, {
       eventHandler: stableHandler,
-      source: datasetHandle.source,
+      resource: datasetHandle.resource,
     })
-  }, [instance, datasetHandle.source, stableHandler])
+  }, [instance, datasetHandle.resource, stableHandler])
 }