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

package/src/hooks/datasets/useDatasets.ts

@@ -1,12 +1,5 @@
 import {type DatasetsResponse} from '@sanity/client'
-import {
-  getDatasetsState,
-  type ProjectHandle,
-  resolveDatasets,
-  type SanityInstance,
-  type StateSource,
-} from '@sanity/sdk'
-import {identity} from 'rxjs'
+import {getDatasetsState, resolveDatasets, type SanityInstance, type StateSource} from '@sanity/sdk'
 
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
@@ -16,11 +9,12 @@ type UseDatasets = {
    * Returns metadata for each dataset the current user has access to.
    *
    * @category Datasets
-   * @returns The metadata for your the datasets
+   * @param options - An object containing the `projectId` to list datasets for.
+   * @returns The metadata for the datasets
    *
    * @example
    * ```tsx
-   * const datasets = useDatasets()
+   * const datasets = useDatasets({projectId: 'my-project-id'})
    *
    * return (
    *   <select>
@@ -32,7 +26,7 @@ type UseDatasets = {
    * ```
    *
    */
-  (): DatasetsResponse
+  (options: {projectId: string}): DatasetsResponse
 }
 
 /**
@@ -42,11 +36,9 @@ type UseDatasets = {
 export const useDatasets: UseDatasets = createStateSourceHook({
   getState: getDatasetsState as (
     instance: SanityInstance,
-    projectHandle?: ProjectHandle,
+    options: {projectId: string},
   ) => StateSource<DatasetsResponse>,
-  shouldSuspend: (instance, projectHandle?: ProjectHandle) =>
-    // remove `undefined` since we're suspending when that is the case
-    getDatasetsState(instance, projectHandle).getCurrent() === undefined,
+  shouldSuspend: (instance, options: {projectId: string}) =>
+    getDatasetsState(instance, options).getCurrent() === undefined,
   suspender: resolveDatasets,
-  getConfig: identity as (projectHandle?: ProjectHandle) => ProjectHandle,
 })

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

@@ -1,6 +1,8 @@
 import {applyDocumentActions, type SanityInstance} from '@sanity/sdk'
+import React from 'react'
 import {describe, it} from 'vitest'
 
+import {renderHook} from '../../../test/test-utils'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {useApplyDocumentActions} from './useApplyDocumentActions'
 
@@ -11,18 +13,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 = {instanceId: 'test'} as unknown as SanityInstance
 
 describe('useApplyDocumentActions', () => {
   beforeEach(() => {
@@ -30,12 +21,13 @@ describe('useApplyDocumentActions', () => {
     vi.mocked(useSanityInstance).mockReturnValueOnce(instance)
   })
 
-  it('uses the SanityInstance', async () => {
-    const apply = useApplyDocumentActions()
-    apply({
+  it('uses the SanityInstance and injects resource from context', async () => {
+    const {result} = renderHook(() => useApplyDocumentActions())
+    result.current({
       type: 'document.edit',
       documentType: 'post',
       documentId: 'abc',
+      resource: {projectId: 'p123', dataset: 'd123'},
     })
 
     expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
@@ -44,42 +36,42 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
+          resource: {projectId: 'p123', dataset: 'd123'},
         },
       ],
+      resource: {projectId: 'p123', dataset: 'd123'},
     })
   })
 
-  it('uses SanityInstance.match when projectId is overrideen', async () => {
-    const apply = useApplyDocumentActions()
-    apply({
+  it('passes resource from action to applyDocumentActions', async () => {
+    const {result} = renderHook(() => useApplyDocumentActions())
+    result.current({
       type: 'document.edit',
       documentType: 'post',
       documentId: 'abc',
-
-      projectId: 'p123',
+      resource: {projectId: 'p123', dataset: 'd123'},
     })
 
-    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instances['p123.d'], {
+    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
       actions: [
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-
-          projectId: 'p123',
+          resource: {projectId: 'p123', dataset: 'd123'},
         },
       ],
+      resource: {projectId: 'p123', dataset: 'd123'},
     })
   })
 
-  it('uses SanityInstance when dataset is overrideen', async () => {
-    const apply = useApplyDocumentActions()
-    apply({
+  it('uses context resource when action has no resource', async () => {
+    const {result} = renderHook(() => useApplyDocumentActions())
+    result.current({
       type: 'document.edit',
       documentType: 'post',
       documentId: 'abc',
-
-      dataset: 'd123',
+      resource: {projectId: 'test', dataset: 'test'},
     })
 
     expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
@@ -88,48 +80,102 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-
-          dataset: 'd123',
+          resource: {projectId: 'test', dataset: 'test'},
         },
       ],
+      resource: {projectId: 'test', dataset: 'test'},
     })
   })
 
-  it('uses SanityInstance.amcth when projectId and dataset is overrideen', async () => {
-    const apply = useApplyDocumentActions()
-    apply({
-      type: 'document.edit',
-      documentType: 'post',
-      documentId: 'abc',
-
-      projectId: 'p123',
-      dataset: 'd123',
-    })
+  it('throws when actions have mismatched resources', async () => {
+    const {result} = renderHook(() => useApplyDocumentActions())
+    expect(() => {
+      result.current([
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'abc',
+          resource: {projectId: 'p', dataset: 'd1'},
+        },
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'def',
+          resource: {projectId: 'p', dataset: 'd2'},
+        },
+      ])
+    }).toThrow(/Mismatched resources found in actions/)
+  })
 
-    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instances['p123.d123'], {
-      actions: [
+  it('throws when actions have mismatched project IDs', async () => {
+    const {result} = renderHook(() => useApplyDocumentActions())
+    expect(() => {
+      result.current([
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
+          resource: {projectId: 'p123', dataset: 'd1'},
+        },
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'def',
+          resource: {projectId: 'p456', dataset: 'd1'},
+        },
+      ])
+    }).toThrow(/Mismatched resources found in actions/)
+  })
 
-          projectId: 'p123',
-          dataset: 'd123',
+  it('throws when actions have mismatched datasets', async () => {
+    const {result} = renderHook(() => useApplyDocumentActions())
+    expect(() => {
+      result.current([
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'abc',
+          resource: {projectId: 'p', dataset: 'd1'},
         },
-      ],
-    })
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'def',
+          resource: {projectId: 'p', dataset: 'd2'},
+        },
+      ])
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it("throws if SanityInstance.match doesn't find anything", async () => {
-    const apply = useApplyDocumentActions()
+  it('throws when no resource is found from actions or context', async () => {
+    // Use a minimal wrapper without resource context so contextResource is undefined
+    const {result} = renderHook(() => useApplyDocumentActions(), {
+      wrapper: (props) => React.createElement(React.Fragment, null, props.children),
+    })
+
     expect(() => {
-      apply({
+      result.current({
         type: 'document.edit',
         documentType: 'post',
         documentId: 'abc',
+        // no resource
+      } as never)
+    }).toThrow(/resource is required/)
+  })
+
+  it('throws when options resource mismatches action resource', async () => {
+    const {result} = renderHook(() => useApplyDocumentActions())
 
-        projectId: 'other',
-      })
-    }).toThrow()
+    expect(() => {
+      result.current(
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'abc',
+          resource: {projectId: 'p1', dataset: 'd1'},
+        },
+        {resource: {projectId: 'p2', dataset: 'd2'}},
+      )
+    }).toThrow(/Mismatched resources found in actions/)
   })
 })

package/src/hooks/document/useApplyDocumentActions.ts

@@ -1,12 +1,11 @@
-import {
-  type ActionsResult,
-  applyDocumentActions,
-  type ApplyDocumentActionsOptions,
-  type DocumentAction,
-} from '@sanity/sdk'
-import {type SanityDocument} from 'groq'
+import {type ActionsResult, applyDocumentActions, type DocumentAction} from '@sanity/sdk'
+import {useContext} from 'react'
 
+import {type ResourceHandle} from '../../config/handles'
+import {ResourceContext} from '../../context/DefaultResourceContext'
+import {ResourcesContext} from '../../context/ResourcesContext'
 import {useSanityInstance} from '../context/useSanityInstance'
+import {normalizeResourceOptions} 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'
@@ -23,8 +22,8 @@ interface UseApplyDocumentActions {
     action:
       | DocumentAction<TDocumentType, TDataset, TProjectId>
       | DocumentAction<TDocumentType, TDataset, TProjectId>[],
-    options?: ApplyDocumentActionsOptions,
-  ) => Promise<ActionsResult<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
+    options?: ResourceHandle,
+  ) => Promise<ActionsResult>
 }
 
 /**
@@ -152,44 +151,43 @@ interface UseApplyDocumentActions {
  */
 export const useApplyDocumentActions: UseApplyDocumentActions = () => {
   const instance = useSanityInstance()
+  const resources = useContext(ResourcesContext)
+  const contextResource = useContext(ResourceContext)
 
   return (actionOrActions, options) => {
     const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]
+    const optionsResource = options
+      ? normalizeResourceOptions(options, resources, contextResource).resource
+      : undefined
 
-    let projectId
-    let dataset
-    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 = actions.map((action) =>
+      normalizeResourceOptions(action, resources, contextResource),
+    )
+    let resource
 
-        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 (projectId || dataset) {
-      const actualInstance = instance.match({projectId, dataset})
-      if (!actualInstance) {
+    for (const action of normalizedActions) {
+      if (!resource) resource = action.resource
+      if (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 && 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, ...options})
+    const effectiveResource = resource ?? optionsResource
+    if (!effectiveResource) {
+      throw new Error('No resource found. Provide a resource via the action handle or context.')
     }
 
-    return applyDocumentActions(instance, {actions, ...options})
+    return applyDocumentActions(instance, {
+      actions,
+      resource: effectiveResource,
+    })
   }
 }

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

@@ -2,7 +2,6 @@
 import {getDocumentState, resolveDocument, type StateSource} from '@sanity/sdk'
 import {type SanityDocument} from '@sanity/types'
 import {renderHook} from '@testing-library/react'
-import {type SchemaOrigin} from 'groq'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {ResourceProvider} from '../../context/ResourceProvider'
@@ -13,40 +12,6 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
   return {...original, getDocumentState: vi.fn(), resolveDocument: vi.fn()}
 })
 
-// Define a single generic TestDocument type
-type UseDocumentTestType = SchemaOrigin<
-  SanityDocument & {
-    _type: 'use-document-test-type'
-    foo?: string
-    extra?: boolean
-    title?: string
-    nested?: {
-      value?: number
-    }
-  },
-  'p.use-document-test-dataset'
->
-
-type UseDocumentTestTypeAlt = SchemaOrigin<
-  SanityDocument & {
-    _type: 'use-document-test-type'
-    bar: string[]
-    nested?: {
-      value?: number
-    }
-  },
-  'p.use-document-test-alt-dataset'
->
-
-// Scope the TestDocument type to the project/datasets used in tests
-
-declare module 'groq' {
-  interface SanitySchemas {
-    'p.use-document-test-dataset': UseDocumentTestType
-    'p.use-document-test-alt-dataset': UseDocumentTestTypeAlt
-  }
-}
-
 const book: SanityDocument = {
   _id: 'doc1',
   foo: 'bar',
@@ -71,7 +36,10 @@ describe('useDocument hook', () => {
 
     const {result} = renderHook(() => useDocument({documentId: 'doc1', documentType: 'book'}), {
       wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+        <ResourceProvider
+          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
+          fallback={null}
+        >
           {children}
         </ResourceProvider>
       ),
@@ -106,7 +74,10 @@ describe('useDocument hook', () => {
       },
       {
         wrapper: ({children}) => (
-          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+          <ResourceProvider
+            resource={{projectId: 'test-project', dataset: 'test-dataset'}}
+            fallback={null}
+          >
             {children}
           </ResourceProvider>
         ),