@sanity/sdk-react 0.0.0-alpha.7 → 0.0.0-alpha.9

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

@@ -0,0 +1,134 @@
+// tests/useEditDocument.test.ts
+import {
+  createSanityInstance,
+  editDocument,
+  getDocumentState,
+  resolveDocument,
+  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 {useSanityInstance} from '../context/useSanityInstance'
+import {useApplyActions} from './useApplyActions'
+import {useEditDocument} from './useEditDocument'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {
+    ...original,
+    getDocumentState: vi.fn(),
+    resolveDocument: vi.fn(),
+    editDocument: vi.fn(original.editDocument),
+  }
+})
+
+vi.mock('../context/useSanityInstance', () => ({
+  useSanityInstance: vi.fn(),
+}))
+
+vi.mock('./useApplyActions', () => ({
+  useApplyActions: vi.fn(),
+}))
+
+// Create a fake instance to be returned by useSanityInstance.
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+
+const doc: SanityDocument = {
+  _id: 'doc1',
+  foo: 'bar',
+  _type: 'book',
+  _rev: 'tx0',
+  _createdAt: '2025-02-06T00:11:00.000Z',
+  _updatedAt: '2025-02-06T00:11:00.000Z',
+}
+
+describe('useEditDocument hook', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(useSanityInstance).mockReturnValue(instance)
+  })
+
+  it('applies a single edit action for the given path', async () => {
+    const getCurrent = vi.fn().mockReturnValue(doc)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<SanityDocument>)
+
+    const apply = vi.fn().mockResolvedValue({transactionId: 'tx1'})
+    vi.mocked(useApplyActions).mockReturnValue(apply)
+
+    const {result} = renderHook(() => useEditDocument('doc1', 'foo'))
+    const promise = result.current('newValue')
+    expect(editDocument).toHaveBeenCalledWith('doc1', {set: {foo: 'newValue'}})
+    expect(apply).toHaveBeenCalledWith(editDocument('doc1', {set: {foo: 'newValue'}}))
+    const actionsResult = await promise
+    expect(actionsResult).toEqual({transactionId: 'tx1'})
+  })
+
+  it('applies edit actions for changed fields', async () => {
+    // Set up current document state.
+    const currentDoc = {...doc, foo: 'bar', extra: 'old'}
+    const getCurrent = vi.fn().mockReturnValue(currentDoc)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<SanityDocument>)
+
+    const apply = vi.fn().mockResolvedValue({transactionId: 'tx2'})
+    vi.mocked(useApplyActions).mockReturnValue(apply)
+
+    const {result} = renderHook(() => useEditDocument('doc1'))
+    const promise = result.current({foo: 'baz', extra: 'old', _id: 'doc1'})
+    expect(apply).toHaveBeenCalledWith([editDocument('doc1', {set: {foo: 'baz'}})])
+    const actionsResult = await promise
+    expect(actionsResult).toEqual({transactionId: 'tx2'})
+  })
+
+  it('throws an error if next value is not an object', () => {
+    const getCurrent = vi.fn().mockReturnValue(doc)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<SanityDocument>)
+
+    const fakeApply = vi.fn()
+    vi.mocked(useApplyActions).mockReturnValue(fakeApply)
+
+    const {result} = renderHook(() => useEditDocument('doc1'))
+    expect(() => result.current('notAnObject' as unknown as Partial<SanityDocument>)).toThrowError(
+      'No path was provided to `useEditDocument` and the value provided was not a document object.',
+    )
+  })
+
+  it('throws a promise (suspends) when the document is not ready', () => {
+    const getCurrent = vi.fn().mockReturnValue(undefined)
+    const subscribe = vi.fn().mockReturnValue(vi.fn())
+    vi.mocked(getDocumentState).mockReturnValue({
+      getCurrent,
+      subscribe,
+    } as unknown as StateSource<unknown>)
+
+    const resolveDocPromise = Promise.resolve(doc)
+
+    // Also, simulate resolveDocument to return a known promise.
+    vi.mocked(resolveDocument).mockReturnValue(resolveDocPromise)
+
+    // Render the hook and capture the thrown promise.
+    const {result} = renderHook(() => {
+      try {
+        return useEditDocument('doc1')
+      } 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

@@ -0,0 +1,67 @@
+import {
+  type ActionsResult,
+  type DocumentHandle,
+  editDocument,
+  getDocumentState,
+  type JsonMatch,
+  type JsonMatchPath,
+  resolveDocument,
+} from '@sanity/sdk'
+import {type SanityDocument} from '@sanity/types'
+import {useCallback} from 'react'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+import {useApplyActions} from './useApplyActions'
+
+const ignoredKeys = ['_id', '_type', '_createdAt', '_updatedAt', '_rev']
+
+/** @beta */
+export function useEditDocument<
+  TDocument extends SanityDocument,
+  TPath extends JsonMatchPath<TDocument>,
+>(
+  doc: string | DocumentHandle<TDocument>,
+  path: TPath,
+): (nextValue: JsonMatch<TDocument, TPath>) => Promise<ActionsResult<TDocument>>
+/** @beta */
+export function useEditDocument<TDocument extends SanityDocument>(
+  doc: string | DocumentHandle<TDocument>,
+): (nextValue: Partial<TDocument>) => Promise<ActionsResult<TDocument>>
+/** @beta */
+export function useEditDocument(
+  doc: string | DocumentHandle,
+  path?: string,
+): (nextValue: unknown) => Promise<ActionsResult> {
+  const documentId = typeof doc === 'string' ? doc : doc._id
+  const instance = useSanityInstance()
+  const apply = useApplyActions()
+  const isDocumentReady = useCallback(
+    () => getDocumentState(instance, documentId).getCurrent() !== undefined,
+    [instance, documentId],
+  )
+  if (!isDocumentReady()) throw resolveDocument(instance, documentId)
+
+  return useCallback(
+    (next: unknown) => {
+      if (path) {
+        return apply(editDocument(documentId, {set: {[path]: next}}))
+      }
+
+      const current = getDocumentState(instance, documentId).getCurrent()
+
+      if (typeof next !== 'object' || !next) {
+        throw new Error(
+          `No path was provided to \`useEditDocument\` and the value provided was not a document object.`,
+        )
+      }
+
+      const editActions = Object.entries(next)
+        .filter(([key]) => !ignoredKeys.includes(key))
+        .filter(([key, value]) => current?.[key] !== value)
+        .map(([key, value]) => editDocument(documentId, {set: {[key]: value}}))
+
+      return apply(editActions)
+    },
+    [apply, documentId, instance, path],
+  )
+}