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

package/src/hooks/organizations/useOrganizations.test.ts

@@ -0,0 +1,63 @@
+import {type Organizations, organizations, type StateSource} from '@sanity/sdk'
+import {type FetcherSnapshot} from '@sanity/sdk/_internal'
+import {type Observable} from 'rxjs'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {renderHook} from '../../../test/test-utils'
+import {useOrganizations} from './useOrganizations'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...original, organizations: {getState: vi.fn(), resolveState: vi.fn(), refetch: vi.fn()}}
+})
+
+const stateSource = (
+  current: Organizations | undefined,
+): StateSource<FetcherSnapshot<Organizations>> => {
+  const snapshot = current
+    ? {status: 'success', data: current, error: undefined, isFetching: false, dataUpdatedAt: 1}
+    : {
+        status: 'pending',
+        data: undefined,
+        error: undefined,
+        isFetching: true,
+        dataUpdatedAt: undefined,
+      }
+  return {
+    getCurrent: vi.fn(() => snapshot),
+    subscribe: vi.fn(() => () => {}),
+    get observable(): Observable<unknown> {
+      throw new Error('Not implemented')
+    },
+  } as unknown as StateSource<FetcherSnapshot<Organizations>>
+}
+
+const sanityInstance = expect.objectContaining({config: expect.any(Object)})
+
+describe('useOrganizations', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(organizations.getState).mockReturnValue(
+      stateSource([{id: 'org_1'}] as unknown as Organizations),
+    )
+  })
+
+  it('reads the organizations fetcher with the passed options', () => {
+    renderHook(() => useOrganizations({includeMembers: true}))
+    expect(organizations.getState).toHaveBeenCalledWith(sanityInstance, {includeMembers: true})
+  })
+
+  it('returns the fetcher data in the result envelope', () => {
+    const {result} = renderHook(() => useOrganizations())
+    expect(result.current.data).toEqual([{id: 'org_1'}])
+    expect(result.current.isFetching).toBe(false)
+    expect(typeof result.current.refetch).toBe('function')
+  })
+
+  it('suspends via the organizations fetcher until data is available', () => {
+    vi.mocked(organizations.getState).mockReturnValue(stateSource(undefined))
+    vi.mocked(organizations.resolveState).mockReturnValue(new Promise(() => {}))
+    renderHook(() => useOrganizations())
+    expect(organizations.resolveState).toHaveBeenCalled()
+  })
+})

package/src/hooks/organizations/useOrganizations.ts

@@ -0,0 +1,39 @@
+import {type Organizations, organizations, type OrganizationsOptions} from '@sanity/sdk'
+
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
+
+/**
+ * Returns metadata for each organisation the current user has access to.
+ *
+ * @category Organizations
+ * @param options - Configuration options
+ * @returns A {@link FetcherHookResult} whose `data` is an array of organisation
+ *   metadata. `members` is included only when `includeMembers: true`; `features`
+ *   is included only when `includeFeatures: true`.
+ * @example
+ * ```tsx
+ * const {data: organizations} = useOrganizations()
+ *
+ * return (
+ *   <select>
+ *     {organizations.map((organization) => (
+ *       <option key={organization.id}>{organization.name}</option>
+ *     ))}
+ *   </select>
+ * )
+ * ```
+ * @example
+ * ```tsx
+ * const {data: organizationsWithMembers} = useOrganizations({includeMembers: true})
+ * const {data: organizationsWithFeatures} = useOrganizations({includeFeatures: true})
+ * const {data: organizationsIncludingImplicit} = useOrganizations({includeImplicitMemberships: true})
+ * ```
+ * @public
+ * @function
+ */
+export const useOrganizations = createFetcherHook(organizations) as <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+>(
+  options?: OrganizationsOptions<IncludeMembers, IncludeFeatures>,
+) => FetcherHookResult<Organizations<IncludeMembers, IncludeFeatures>>

package/src/hooks/paginatedDocuments/usePaginatedDocuments.test.tsx

@@ -1,14 +1,20 @@
-import {type DatasetResource} from '@sanity/sdk'
+import {act, renderHook} from '@testing-library/react'
 import {evaluateSync, parse, toJS} from 'groq-js'
 import {describe, vi} from 'vitest'
 
-import {act, renderHook} from '../../../test/test-utils'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {useQuery} from '../query/useQuery'
 import {usePaginatedDocuments} from './usePaginatedDocuments'
 
 vi.mock('../query/useQuery')
 
 describe('usePaginatedDocuments', () => {
+  const wrapper = ({children}: {children: React.ReactNode}) => (
+    <ResourceProvider projectId="p" dataset="d" fallback={null}>
+      {children}
+    </ResourceProvider>
+  )
+
   beforeEach(() => {
     const dataset = [
       {
@@ -77,14 +83,16 @@ describe('usePaginatedDocuments', () => {
 
   it('should respect custom page size', () => {
     const customPageSize = 2
-    const {result} = renderHook(() => usePaginatedDocuments({pageSize: customPageSize}))
+    const {result} = renderHook(() => usePaginatedDocuments({pageSize: customPageSize}), {wrapper})
 
     expect(result.current.pageSize).toBe(customPageSize)
     expect(result.current.data.length).toBeLessThanOrEqual(customPageSize)
   })
 
   it('should filter by document type', () => {
-    const {result} = renderHook(() => usePaginatedDocuments({filter: '_type == "movie"'}))
+    const {result} = renderHook(() => usePaginatedDocuments({filter: '_type == "movie"'}), {
+      wrapper,
+    })
 
     expect(result.current.data.every((doc) => doc.documentType === 'movie')).toBe(true)
     expect(result.current.count).toBe(5) // 5 movies in the dataset
@@ -92,18 +100,20 @@ describe('usePaginatedDocuments', () => {
 
   // groq-js doesn't support search filters yet
   it.skip('should apply search filter', () => {
-    const {result} = renderHook(() => usePaginatedDocuments({search: 'inter'}))
+    const {result} = renderHook(() => usePaginatedDocuments({search: 'inter'}), {wrapper})
 
     // Should match "Interstellar"
     expect(result.current.data.some((doc) => doc.documentId === 'movie3')).toBe(true)
   })
 
   it('should apply ordering', () => {
-    const {result} = renderHook(() =>
-      usePaginatedDocuments({
-        filter: '_type == "movie"',
-        orderings: [{field: 'releaseYear', direction: 'desc'}],
-      }),
+    const {result} = renderHook(
+      () =>
+        usePaginatedDocuments({
+          filter: '_type == "movie"',
+          orderings: [{field: 'releaseYear', direction: 'desc'}],
+        }),
+      {wrapper},
     )
 
     // First item should be the most recent movie (Interstellar, 2014)
@@ -112,7 +122,7 @@ describe('usePaginatedDocuments', () => {
 
   it('should calculate pagination values correctly', () => {
     const pageSize = 2
-    const {result} = renderHook(() => usePaginatedDocuments({pageSize}))
+    const {result} = renderHook(() => usePaginatedDocuments({pageSize}), {wrapper})
 
     expect(result.current.currentPage).toBe(1)
     expect(result.current.totalPages).toBe(3) // 6 items with page size 2
@@ -123,7 +133,7 @@ describe('usePaginatedDocuments', () => {
 
   it('should navigate to next page', () => {
     const pageSize = 2
-    const {result} = renderHook(() => usePaginatedDocuments({pageSize}))
+    const {result} = renderHook(() => usePaginatedDocuments({pageSize}), {wrapper})
 
     expect(result.current.currentPage).toBe(1)
     expect(result.current.data.length).toBe(pageSize)
@@ -139,7 +149,7 @@ describe('usePaginatedDocuments', () => {
 
   it('should navigate to previous page', () => {
     const pageSize = 2
-    const {result} = renderHook(() => usePaginatedDocuments({pageSize}))
+    const {result} = renderHook(() => usePaginatedDocuments({pageSize}), {wrapper})
 
     // Go to page 2 first
     act(() => {
@@ -159,7 +169,7 @@ describe('usePaginatedDocuments', () => {
 
   it('should navigate to first page', () => {
     const pageSize = 2
-    const {result} = renderHook(() => usePaginatedDocuments({pageSize}))
+    const {result} = renderHook(() => usePaginatedDocuments({pageSize}), {wrapper})
 
     // Go to last page first
     act(() => {
@@ -179,7 +189,7 @@ describe('usePaginatedDocuments', () => {
 
   it('should navigate to last page', () => {
     const pageSize = 2
-    const {result} = renderHook(() => usePaginatedDocuments({pageSize}))
+    const {result} = renderHook(() => usePaginatedDocuments({pageSize}), {wrapper})
 
     act(() => {
       result.current.lastPage()
@@ -191,7 +201,7 @@ describe('usePaginatedDocuments', () => {
 
   it('should navigate to specific page', () => {
     const pageSize = 2
-    const {result} = renderHook(() => usePaginatedDocuments({pageSize}))
+    const {result} = renderHook(() => usePaginatedDocuments({pageSize}), {wrapper})
 
     act(() => {
       result.current.goToPage(2) // Go to page 2
@@ -216,7 +226,7 @@ describe('usePaginatedDocuments', () => {
 
   it('should set page availability flags correctly', () => {
     const pageSize = 2
-    const {result} = renderHook(() => usePaginatedDocuments({pageSize}))
+    const {result} = renderHook(() => usePaginatedDocuments({pageSize}), {wrapper})
     // On first page
     expect(result.current.hasFirstPage).toBe(false)
     expect(result.current.hasPreviousPage).toBe(false)
@@ -244,6 +254,7 @@ describe('usePaginatedDocuments', () => {
   it('should reset current page when filter changes', () => {
     const {result, rerender} = renderHook((props) => usePaginatedDocuments(props), {
       initialProps: {pageSize: 2, filter: ''},
+      wrapper,
     })
     // Initially, current page should be 1
     expect(result.current.currentPage).toBe(1)
@@ -259,19 +270,15 @@ describe('usePaginatedDocuments', () => {
   })
 
   it('should add projectId and dataset to document handles', () => {
-    const {result} = renderHook(() => usePaginatedDocuments({}))
+    const {result} = renderHook(() => usePaginatedDocuments({}), {wrapper})
 
     // Check that the first document handle has the projectId and dataset
-    expect((result.current.data[0].resource as DatasetResource).projectId).toBe('test')
-    expect((result.current.data[0].resource as DatasetResource).dataset).toBe('test')
+    expect(result.current.data[0].projectId).toBe('p')
+    expect(result.current.data[0].dataset).toBe('d')
 
     // Verify all document handles have these properties
-    expect(
-      result.current.data.every(
-        (doc) =>
-          (doc.resource as DatasetResource).projectId === 'test' &&
-          (doc.resource as DatasetResource).dataset === 'test',
-      ),
-    ).toBe(true)
+    expect(result.current.data.every((doc) => doc.projectId === 'p' && doc.dataset === 'd')).toBe(
+      true,
+    )
   })
 })

package/src/hooks/paginatedDocuments/usePaginatedDocuments.ts

@@ -1,10 +1,13 @@
-import {createGroqSearchFilter, type QueryOptions} from '@sanity/sdk'
+import {type DocumentHandle, isDatasetResource, type QueryOptions} from '@sanity/sdk'
+import {createGroqSearchFilter, pickProperties} from '@sanity/sdk/_internal'
 import {type SortOrderingItem} from '@sanity/types'
-import {pick} from 'lodash-es'
-import {useCallback, useEffect, useMemo, useState} from 'react'
+import {useCallback, useMemo, useState} from 'react'
 
-import {type DocumentHandle, type ResourceHandle} from '../../config/handles'
-import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
+import {
+  useNormalizedResourceOptions,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
+import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 import {useQuery} from '../query/useQuery'
 
 /**
@@ -17,10 +20,9 @@ export interface PaginatedDocumentsOptions<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
->
-  extends
-    ResourceHandle<TProjectId, TDataset>,
-    Pick<QueryOptions<TDocumentType, TDataset, TProjectId>, 'params'> {
+> extends WithResourceNameSupport<
+  Omit<QueryOptions<TDocumentType, TDataset, TProjectId>, 'query'>
+> {
   documentType?: TDocumentType | TDocumentType[]
   /**
    * GROQ filter expression to apply to the query
@@ -141,16 +143,18 @@ export interface PaginatedDocumentsResponse<
  * @returns An object containing the list of document handles, pagination details, and functions to navigate between pages
  *
  * @remarks
- * - The returned document handles include resource information from the current Sanity instance
+ * - The returned document handles include projectId and dataset information from the current Sanity instance
  * - This makes them ready to use with document operations and other document hooks
- * - The hook automatically uses the correct Sanity instance based on the resource in the options
+ * - The hook automatically uses the correct Sanity instance based on the projectId and dataset in the options
  *
  * @example Paginated list of documents with navigation
  * ```tsx
  * import {
  *   usePaginatedDocuments,
+ *   createDatasetHandle,
+ *   type DatasetHandle,
  *   type DocumentHandle,
- *   type DocumentResource,
+ *   type SortOrderingItem,
  *   useDocumentProjection
  * } from '@sanity/sdk-react'
  * import {Suspense} from 'react'
@@ -173,10 +177,10 @@ export interface PaginatedDocumentsResponse<
  * // Define props for the list component
  * interface PaginatedDocumentListProps {
  *   documentType: string
- *   resource?: DocumentResource
+ *   dataset?: DatasetHandle
  * }
  *
- * function PaginatedDocumentList({documentType, resource}: PaginatedDocumentListProps) {
+ * function PaginatedDocumentList({documentType, dataset}: PaginatedDocumentListProps) {
  *   const {
  *     data,
  *     isPending,
@@ -187,7 +191,7 @@ export interface PaginatedDocumentsResponse<
  *     hasNextPage,
  *     hasPreviousPage
  *   } = usePaginatedDocuments({
- *     resource,
+ *     ...dataset,
  *     documentType,
  *     pageSize: 10,
  *     orderings: [{field: '_createdAt', direction: 'desc'}],
@@ -219,7 +223,8 @@ export interface PaginatedDocumentsResponse<
  * }
  *
  * // Usage:
- * // <PaginatedDocumentList resource={{projectId: 'p1', dataset: 'production'}} documentType="post" />
+ * // const myDatasetHandle = createDatasetHandle({ projectId: 'p1', dataset: 'production' })
+ * // <PaginatedDocumentList dataset={myDatasetHandle} documentType="post" />
  * ```
  */
 export function usePaginatedDocuments<
@@ -239,14 +244,16 @@ export function usePaginatedDocuments<
   TDataset,
   TProjectId
 > {
+  useTrackHookUsage('usePaginatedDocuments')
   const options = useNormalizedResourceOptions(rawOptions)
   const [pageIndex, setPageIndex] = useState(0)
   const key = JSON.stringify({filter, search, params, orderings, pageSize, ...options})
-  // Reset the pageIndex to 0 whenever any query parameters (filter, search,
-  // params, orderings) or pageSize changes
-  useEffect(() => {
+  // Reset pageIndex to 0 whenever any query parameter changes.
+  const [prevKey, setPrevKey] = useState(key)
+  if (prevKey !== key) {
+    setPrevKey(key)
     setPageIndex(0)
-  }, [key])
+  }
 
   const startIndex = pageIndex * pageSize
   const endIndex = (pageIndex + 1) * pageSize
@@ -301,8 +308,14 @@ export function usePaginatedDocuments<
     params: {
       ...params,
       __types: documentTypes,
-      // these are passed back to the user as part of each document handle
-      __handle: pick(options, ['resource', 'perspective']),
+      __handle: {
+        // keep projectId/dataset for backward compat until v4; resource is added
+        // intentionally so that hook consumers can resolve the correct resource
+        ...(options.resource && isDatasetResource(options.resource)
+          ? pickProperties(options.resource, ['projectId', 'dataset'])
+          : {}),
+        ...pickProperties(options, ['perspective', 'resource']),
+      },
     },
   })
 

package/src/hooks/presence/usePresence.test.tsx

@@ -102,21 +102,6 @@ describe('usePresence', () => {
     }).toThrow('usePresence() does not support media library resources')
   })
 
-  it('should throw an error when used with a canvas resource', () => {
-    expect(() => {
-      renderHook(() => usePresence({resource: {canvasId: 'canvas123'}}), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow('usePresence() does not support canvas resources')
-  })
-
   it('should work with a dataset resource', () => {
     const mockPresenceSource = {
       getCurrent: vi.fn().mockReturnValue([]),

package/src/hooks/presence/usePresence.ts

@@ -1,38 +1,40 @@
-import {getPresence, isCanvasResource, isMediaLibraryResource, type UserPresence} from '@sanity/sdk'
+import {getPresence, isMediaLibraryResource, type UserPresence} from '@sanity/sdk'
 import {useCallback, useMemo, useSyncExternalStore} from 'react'
 
 import {type ResourceHandle} from '../../config/handles'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
+import {trackHookUsage} from '../helpers/useTrackHookUsage'
 
 /**
- * A hook for subscribing to presence information for the current project.
+ * Every participant in the current project and dataset, or Canvas.
+ *
+ * Reading presence never announces anything. Call `useReportPresence` to make the
+ * current user visible to others, including to the Studio, which shares the same
+ * presence room.
+ *
+ * This returns everyone in the whole resource and leaves the filtering to you.
+ * Prefer `usePresenceForDocument` when you care about one document: it scopes and
+ * flattens the result for rendering. Note that participants are counted by session,
+ * so one person in two tabs appears twice.
+ *
+ * Presence is scoped to a single project and dataset. It is not a list of everyone
+ * signed in to your organization.
+ *
  * @public
  */
 export function usePresence(options: ResourceHandle = {}): {
   locations: UserPresence[]
 } {
   const normalizedOptions = useNormalizedResourceOptions(options)
-  const sanityInstance = useSanityInstance()
-
-  // Validate resource type before attempting to create the presence store
-  // This provides immediate, clear feedback instead of hanging
-  if (normalizedOptions.resource) {
-    if (isMediaLibraryResource(normalizedOptions.resource)) {
-      throw new Error(
-        'usePresence() does not support media library resources. Presence tracking requires a dataset resource. ' +
-          'Either remove the resourceName parameter or use a dataset resource instead.',
-      )
-    }
-
-    if (isCanvasResource(normalizedOptions.resource)) {
-      throw new Error(
-        'usePresence() does not support canvas resources. Presence tracking requires a dataset resource. ' +
-          'Either remove the resourceName parameter or use a dataset resource instead.',
-      )
-    }
+  if (normalizedOptions.resource && isMediaLibraryResource(normalizedOptions.resource)) {
+    throw new Error(
+      'usePresence() does not support media library resources. Presence tracking requires a canvas or dataset resource.',
+    )
   }
 
+  const sanityInstance = useSanityInstance()
+  trackHookUsage(sanityInstance, 'usePresence')
   const source = useMemo(
     () => getPresence(sanityInstance, normalizedOptions),
     [sanityInstance, normalizedOptions],

package/src/hooks/presence/usePresenceForDocument.test.tsx

@@ -0,0 +1,141 @@
+import {type DocumentPresence, getDocumentPresence} from '@sanity/sdk'
+import {act, renderHook} from '@testing-library/react'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {usePresenceForDocument} from './usePresenceForDocument'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...actual, getDocumentPresence: vi.fn()}
+})
+
+const entry = (sessionId: string): DocumentPresence =>
+  ({
+    sessionId,
+    documentId: 'movie-1',
+    path: ['title'],
+    lastActiveAt: '2026-07-30T12:00:00Z',
+    user: {sanityUserId: 'u1', profile: {id: 'u1'}, memberships: []},
+  }) as unknown as DocumentPresence
+
+/** A minimal StateSource stand-in whose value can be pushed. */
+function createSource(initial: DocumentPresence[]) {
+  let current = initial
+  const listeners = new Set<() => void>()
+  return {
+    source: {
+      getCurrent: () => current,
+      subscribe: (cb: () => void) => {
+        listeners.add(cb)
+        return () => listeners.delete(cb)
+      },
+    },
+    push: (next: DocumentPresence[]) => {
+      current = next
+      listeners.forEach((cb) => cb())
+    },
+  }
+}
+
+const wrapper = ({children}: {children: React.ReactNode}) => (
+  <ResourceProvider projectId="p" dataset="d" fallback={null}>
+    {children}
+  </ResourceProvider>
+)
+
+describe('usePresenceForDocument', () => {
+  beforeEach(() => {
+    // Without this, `mock.calls[0]` is whatever the previous test did.
+    vi.clearAllMocks()
+  })
+
+  it('returns presence and updates when the store changes', () => {
+    const {source, push} = createSource([entry('s1')])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    const {result} = renderHook(
+      () => usePresenceForDocument({documentId: 'movie-1', documentType: 'movie'}),
+      {wrapper},
+    )
+
+    expect(result.current.presence).toHaveLength(1)
+
+    act(() => push([entry('s1'), entry('s2')]))
+    expect(result.current.presence).toHaveLength(2)
+  })
+
+  it('passes the document, path, and excludeVersions through', () => {
+    const {source} = createSource([])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    renderHook(
+      () =>
+        usePresenceForDocument({
+          documentId: 'drafts.movie-1',
+          documentType: 'movie',
+          path: ['cast', {_key: 'm1'}],
+          excludeVersions: true,
+        }),
+      {wrapper},
+    )
+
+    // Already a draft id, so resolution leaves it alone.
+    expect(vi.mocked(getDocumentPresence).mock.calls[0][1]).toMatchObject({
+      documentId: 'drafts.movie-1',
+      path: ['cast', {_key: 'm1'}],
+      excludeVersions: true,
+    })
+  })
+
+  it('reads the same id useReportPresence writes, or reads never match writes', () => {
+    const {source} = createSource([])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    // Forwarded unresolved, exactly as `useReportPresence` forwards it, so core
+    // resolves both the same way. If these diverged, field-level presence would
+    // silently never match.
+    renderHook(
+      () =>
+        usePresenceForDocument({
+          documentId: 'movie-1',
+          documentType: 'movie',
+          perspective: 'published',
+        }),
+      {wrapper},
+    )
+
+    expect(vi.mocked(getDocumentPresence).mock.calls[0][1]).toMatchObject({
+      documentId: 'movie-1',
+      perspective: 'published',
+    })
+  })
+
+  it('does not rebuild the source when a caller passes a fresh path each render', () => {
+    const {source} = createSource([])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    const {rerender} = renderHook(
+      // A new array identity every render, which is what real callers write.
+      () => usePresenceForDocument({documentId: 'movie-1', documentType: 'movie', path: ['title']}),
+      {wrapper},
+    )
+
+    rerender()
+    rerender()
+
+    expect(vi.mocked(getDocumentPresence)).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns an empty array rather than undefined before anything arrives', () => {
+    const {source} = createSource(undefined as unknown as DocumentPresence[])
+    vi.mocked(getDocumentPresence).mockReturnValue(source as never)
+
+    const {result} = renderHook(
+      () => usePresenceForDocument({documentId: 'movie-1', documentType: 'movie'}),
+      {wrapper},
+    )
+
+    expect(result.current.presence).toEqual([])
+  })
+})