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

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

@@ -1,10 +1,11 @@
-import {applyDocumentActions, type SanityInstance} from '@sanity/sdk'
-import React from 'react'
+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'
+import {useApplyActions} from './useApplyActions'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
   const original = await importOriginal<typeof import('@sanity/sdk')>()
@@ -13,21 +14,20 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
 
 vi.mock('../context/useSanityInstance')
 
-const instance = {instanceId: 'test'} as unknown as SanityInstance
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 
-describe('useApplyDocumentActions', () => {
+describe('useApplyActions', () => {
   beforeEach(() => {
     vi.resetAllMocks()
     vi.mocked(useSanityInstance).mockReturnValueOnce(instance)
   })
 
-  it('uses the SanityInstance and injects resource from context', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
+  it('uses the effective context resource', async () => {
+    const {result} = renderHook(() => useApplyActions())
     result.current({
       type: 'document.edit',
       documentType: 'post',
       documentId: 'abc',
-      resource: {projectId: 'p123', dataset: 'd123'},
     })
 
     expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
@@ -36,21 +36,28 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          resource: {projectId: 'p123', dataset: 'd123'},
+          // resource named in test-utils
+          resource: {projectId: 'test', dataset: 'test'},
         },
       ],
-      resource: {projectId: 'p123', dataset: 'd123'},
+      resource: {projectId: 'test', dataset: 'test'},
     })
   })
 
-  it('passes resource from action to applyDocumentActions', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
-    result.current({
-      type: 'document.edit',
-      documentType: 'post',
-      documentId: 'abc',
-      resource: {projectId: 'p123', dataset: 'd123'},
+  it('uses the SanityInstance when resource is not provided', async () => {
+    const {result} = reactRenderHook(() => useApplyActions(), {
+      wrapper: ({children}) => (
+        <SanityInstanceContext.Provider value={instance}>{children}</SanityInstanceContext.Provider>
+      ),
     })
+    result.current(
+      {
+        type: 'document.edit',
+        documentType: 'post',
+        documentId: 'abc',
+      },
+      {},
+    )
 
     expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
       actions: [
@@ -58,20 +65,21 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          resource: {projectId: 'p123', dataset: 'd123'},
+          resource: {projectId: 'p', dataset: 'd'},
         },
       ],
-      resource: {projectId: 'p123', dataset: 'd123'},
+      resource: {projectId: 'p', dataset: 'd'},
     })
   })
 
-  it('uses context resource when action has no resource', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
+  it('resolves resource from projectId and dataset on the action', async () => {
+    const {result} = renderHook(() => useApplyActions())
     result.current({
       type: 'document.edit',
       documentType: 'post',
       documentId: 'abc',
-      resource: {projectId: 'test', dataset: 'test'},
+      projectId: 'p',
+      dataset: 'd123',
     })
 
     expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
@@ -80,55 +88,59 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          resource: {projectId: 'test', dataset: 'test'},
+          resource: {projectId: 'p', dataset: 'd123'},
         },
       ],
-      resource: {projectId: 'test', dataset: 'test'},
+      resource: {projectId: 'p', dataset: 'd123'},
     })
   })
 
-  it('throws when actions have mismatched resources', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
+  it('throws when actions have mismatched project IDs', async () => {
+    const {result} = renderHook(() => useApplyActions())
     expect(() => {
       result.current([
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          resource: {projectId: 'p', dataset: 'd1'},
+          projectId: 'p123',
+          dataset: 'd',
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          resource: {projectId: 'p', dataset: 'd2'},
+          projectId: 'p456',
+          dataset: 'd',
         },
       ])
     }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when actions have mismatched project IDs', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
+  it('throws when actions have mismatched datasets', async () => {
+    const {result} = renderHook(() => useApplyActions())
     expect(() => {
       result.current([
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          resource: {projectId: 'p123', dataset: 'd1'},
+          projectId: 'p',
+          dataset: 'd1',
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          resource: {projectId: 'p456', dataset: 'd1'},
+          projectId: 'p',
+          dataset: 'd2',
         },
       ])
     }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when actions have mismatched datasets', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
+  it('throws when actions have mismatched resources', async () => {
+    const {result} = renderHook(() => useApplyActions())
     expect(() => {
       result.current([
         {
@@ -147,34 +159,61 @@ describe('useApplyDocumentActions', () => {
     }).toThrow(/Mismatched resources found in actions/)
   })
 
-  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),
-    })
-
+  it('throws when mixing projectId/dataset and resource with a mismatch (projectId first)', async () => {
+    const {result} = renderHook(() => useApplyActions())
     expect(() => {
-      result.current({
-        type: 'document.edit',
-        documentType: 'post',
-        documentId: 'abc',
-        // no resource
-      } as never)
-    }).toThrow(/resource is required/)
+      result.current([
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'abc',
+          projectId: 'p1',
+          dataset: 'd',
+        },
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'def',
+          resource: {projectId: 'p2', dataset: 'd'},
+        },
+      ])
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when options resource mismatches action resource', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
-
+  it('throws when mixing resource and projectId/dataset with a mismatch (resource first)', async () => {
+    const {result} = renderHook(() => useApplyActions())
     expect(() => {
-      result.current(
+      result.current([
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          resource: {projectId: 'p1', dataset: 'd1'},
+          resource: {projectId: 'p1', dataset: 'd'},
+        },
+        {
+          type: 'document.edit',
+          documentType: 'post',
+          documentId: 'def',
+          projectId: 'p2',
+          dataset: 'd',
         },
-        {resource: {projectId: 'p2', dataset: 'd2'}},
+      ])
+    }).toThrow(/Mismatched resources found in actions/)
+  })
+
+  it('throws when a top-level options resource conflicts with an action resource', async () => {
+    const {result} = renderHook(() => useApplyActions())
+    expect(() => {
+      result.current(
+        [
+          {
+            type: 'document.edit',
+            documentType: 'post',
+            documentId: 'abc',
+            resource: {projectId: 'p', dataset: 'd1'},
+          },
+        ],
+        {resource: {projectId: 'p', dataset: 'd2'}},
       )
     }).toThrow(/Mismatched resources found in actions/)
   })

package/src/hooks/helpers/useApplyActions.ts

@@ -0,0 +1,68 @@
+import {type Action, type ActionsResult, applyDocumentActions} from '@sanity/sdk'
+import {isDeepEqual} from '@sanity/sdk/_internal'
+import {useContext} from 'react'
+
+import {type ResourceHandle} from '../../config/handles'
+import {ResourcesContext} from '../../context/ResourcesContext'
+import {useSanityInstance} from '../context/useSanityInstance'
+import {normalizeResourceOptions, useEffectiveContextResource} from './useNormalizedResourceOptions'
+
+/**
+ * @internal
+ *
+ * Shared implementation behind `useApplyDocumentActions` and
+ * `useApplyReleaseActions`. Resolves the effective resource from the action
+ * handles, top-level `options`, or context (in that order), validates that
+ * everything agrees on a single resource, and forwards to
+ * `applyDocumentActions`.
+ *
+ * The two public hooks differ only in their input/output types — at runtime
+ * they're identical because core's `applyDocumentActions` accepts the full
+ * `Action` union.
+ */
+export function useApplyActions(): (
+  actionOrActions: Action | Action[],
+  options?: ResourceHandle,
+) => Promise<ActionsResult> {
+  const instance = useSanityInstance()
+  const resources = useContext(ResourcesContext)
+  const effectiveContextResource = useEffectiveContextResource()
+
+  return (actionOrActions, options) => {
+    const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]
+    const optionsResource = options
+      ? normalizeResourceOptions(options, resources, effectiveContextResource).resource
+      : undefined
+
+    const normalizedActions = actions.map((action) =>
+      normalizeResourceOptions(action, resources, effectiveContextResource),
+    )
+
+    let resource
+    for (const action of normalizedActions) {
+      const actionResource = action['resource']
+      if (!resource && actionResource) resource = actionResource
+      if (!isDeepEqual(actionResource, resource)) {
+        throw new Error(
+          `Mismatched resources found in actions. All actions must belong to the same resource. Found "${JSON.stringify(actionResource)}" 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)}".`,
+      )
+    }
+
+    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: normalizedActions as Action[],
+      resource: effectiveResource,
+    })
+  }
+}

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

@@ -0,0 +1,226 @@
+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()
+    })
+  })
+
+  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('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'})
+    })
+  })
+})