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

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

@@ -1,4 +1,4 @@
-import {createSanityInstance, type SanityInstance} from '@sanity/sdk'
+import {createSanityInstance, type DatasetResource, type SanityInstance} from '@sanity/sdk'
 import {renderHook} from '@testing-library/react'
 import {throwError} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
@@ -17,7 +17,7 @@ describe('createStateSourceHook', () => {
   })
 
   it('should create a hook that provides access to state source', () => {
-    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    const mockInstance = createSanityInstance()
     vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
 
     const mockState = {count: 0}
@@ -39,7 +39,7 @@ describe('createStateSourceHook', () => {
   })
 
   it('should recreate state source when params change', () => {
-    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    const mockInstance = createSanityInstance()
     vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
 
     const subscribe = vi.fn()
@@ -65,14 +65,14 @@ describe('createStateSourceHook', () => {
   })
 
   it('should recreate state source when instance changes', () => {
-    const mockInstance1 = createSanityInstance({projectId: 'p1', dataset: 'd'})
-    const mockInstance2 = createSanityInstance({projectId: 'p2', dataset: 'd'})
+    const mockInstance1 = createSanityInstance({defaultResource: {projectId: 'p1', dataset: 'd'}})
+    const mockInstance2 = createSanityInstance({defaultResource: {projectId: 'p2', dataset: 'd'}})
 
     vi.mocked(useSanityInstance).mockReturnValueOnce(mockInstance1)
 
     const stateSourceFactory = vi.fn((instance: SanityInstance) => ({
       subscribe: vi.fn(),
-      getCurrent: () => instance.config.projectId,
+      getCurrent: () => (instance.config.defaultResource as DatasetResource)?.projectId,
       observable: throwError(() => new Error('unexpected usage of observable')),
     }))
 
@@ -89,7 +89,7 @@ describe('createStateSourceHook', () => {
   })
 
   it('should handle subscription functionality', () => {
-    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    const mockInstance = createSanityInstance()
     vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
 
     const mockSubscribe = vi.fn()
@@ -110,7 +110,7 @@ describe('createStateSourceHook', () => {
   })
 
   it('should handle multiple parameters', () => {
-    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    const mockInstance = createSanityInstance()
     vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
 
     const stateSourceFactory = vi.fn(
@@ -129,7 +129,7 @@ describe('createStateSourceHook', () => {
   })
 
   it('should throw suspender promise when shouldSuspend is true', () => {
-    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    const mockInstance = createSanityInstance()
     vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
 
     const mockGetState = vi.fn().mockReturnValue({
@@ -163,7 +163,7 @@ describe('createStateSourceHook', () => {
   })
 
   it('should not suspend when shouldSuspend returns false', () => {
-    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    const mockInstance = createSanityInstance()
     vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
 
     const mockState = {value: 'test'}

package/src/hooks/helpers/createStateSourceHook.tsx

@@ -1,4 +1,4 @@
-import {type SanityConfig, type SanityInstance, type StateSource} from '@sanity/sdk'
+import {type SanityInstance, type StateSource} from '@sanity/sdk'
 import {useSyncExternalStore} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
@@ -12,18 +12,16 @@ interface CreateStateSourceHookOptions<TParams extends unknown[], TState> {
   getState: StateSourceFactory<TParams, TState>
   shouldSuspend?: (instance: SanityInstance, ...params: TParams) => boolean
   suspender?: (instance: SanityInstance, ...params: TParams) => Promise<unknown>
-  getConfig?: (...params: TParams) => SanityConfig | undefined
 }
 
 export function createStateSourceHook<TParams extends unknown[], TState>(
   options: StateSourceFactory<TParams, TState> | CreateStateSourceHookOptions<TParams, TState>,
 ): (...params: TParams) => TState {
   const getState = typeof options === 'function' ? options : options.getState
-  const getConfig = 'getConfig' in options ? options.getConfig : undefined
   const suspense = 'shouldSuspend' in options && 'suspender' in options ? options : undefined
 
   function useHook(...params: TParams) {
-    const instance = useSanityInstance(getConfig?.(...params))
+    const instance = useSanityInstance()
 
     if (suspense?.suspender && suspense?.shouldSuspend?.(instance, ...params)) {
       throw suspense.suspender(instance, ...params)

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

@@ -0,0 +1,65 @@
+import {describe, expect, it} from 'vitest'
+
+import {normalizeResourceOptions} from './useNormalizedResourceOptions'
+
+describe('normalizeResourceOptions', () => {
+  it('throws when both resource and resourceName are provided together', () => {
+    const resource = {projectId: 'p', dataset: 'd'}
+
+    expect(() =>
+      normalizeResourceOptions(
+        {resource, resourceName: 'my-resource'},
+        {'my-resource': resource},
+        undefined,
+      ),
+    ).toThrow(/cannot be used together/)
+  })
+
+  it('throws when no resource can be resolved from any source', () => {
+    expect(() =>
+      normalizeResourceOptions(
+        {},
+        {}, // no named resources
+        undefined, // no context resource
+      ),
+    ).toThrow(/resource is required/)
+  })
+
+  it('uses explicit resource when provided', () => {
+    const resource = {projectId: 'project-a', dataset: 'staging'}
+
+    const normalized = normalizeResourceOptions(
+      {resource},
+      {},
+      {projectId: 'default', dataset: 'prod'},
+    )
+
+    expect(normalized).toEqual({resource: {projectId: 'project-a', dataset: 'staging'}})
+  })
+
+  it('resolves resource from resourceName', () => {
+    const resource = {projectId: 'p', dataset: 'd'}
+
+    const normalized = normalizeResourceOptions(
+      {resourceName: 'my-resource'},
+      {'my-resource': resource},
+      undefined,
+    )
+
+    expect(normalized).toEqual({resource})
+  })
+
+  it('throws when resourceName is not found in resources map', () => {
+    expect(() => normalizeResourceOptions({resourceName: 'missing'}, {}, undefined)).toThrow(
+      /no resource named/,
+    )
+  })
+
+  it('falls back to context resource when neither resource nor resourceName is provided', () => {
+    const contextResource = {projectId: 'default', dataset: 'prod'}
+
+    const normalized = normalizeResourceOptions({}, {}, contextResource)
+
+    expect(normalized).toEqual({resource: contextResource})
+  })
+})

package/src/hooks/helpers/useNormalizedResourceOptions.ts

@@ -0,0 +1,127 @@
+import {type DocumentResource, type PerspectiveHandle} from '@sanity/sdk'
+import {useContext} from 'react'
+
+import {ResourceContext} from '../../context/DefaultResourceContext'
+import {PerspectiveContext} from '../../context/PerspectiveContext'
+import {ResourcesContext} from '../../context/ResourcesContext'
+
+/**
+ * You should generally prefer to use the React-layer handle types (ResourceHandle, DocumentHandle) from '\@sanity/sdk-react' instead.
+ * This type is useful for non-handles (like document actions) that we still want to resolve resources for.
+ * Adds React hook support (resourceName resolution) to core types.
+ * @internal
+ */
+export type WithResourceNameSupport<T> = Omit<T, 'resource'> & {
+  resource?: DocumentResource
+  /**
+   * Optional name of a resource to resolve from context.
+   * If provided, will be resolved to a `DocumentResource` via `ResourcesContext`.
+   * @beta
+   */
+  resourceName?: string
+}
+
+/**
+ * Pure function that normalizes options by resolving `resourceName` to a `DocumentResource`
+ * using the provided resources map, and injecting defaults from context when not provided.
+ * Use this when options are only available at call time (e.g. inside a callback)
+ * and you cannot call the {@link useNormalizedResourceOptions} hook.
+ *
+ * @typeParam T - The options type (must include optional resource field)
+ * @param options - Options that may include `resourceName` and/or `resource`
+ * @param resources - Map of resource names to DocumentResource (e.g. from ResourcesContext)
+ * @param contextResource - Resource from context (injected by ResourceProvider)
+ * @param contextPerspective - Perspective from context (injected by ResourceProvider)
+ * @returns Normalized options with `resourceName` removed and defaults injected
+ * @internal
+ */
+export function normalizeResourceOptions<
+  T extends {
+    resource?: DocumentResource
+    resourceName?: string
+    perspective?: unknown
+  },
+>(
+  options: T,
+  resources: Record<string, DocumentResource>,
+  contextResource?: DocumentResource,
+  contextPerspective?: PerspectiveHandle['perspective'],
+): Omit<T, 'resourceName' | 'resource'> & {resource: DocumentResource} {
+  const {resourceName, ...rest} = options
+
+  if (resourceName && Object.hasOwn(options, 'resource')) {
+    throw new Error(
+      `Resource name ${JSON.stringify(resourceName)} and resource ${JSON.stringify(options.resource)} cannot be used together.`,
+    )
+  }
+
+  let resolvedResource: DocumentResource | undefined = options.resource
+
+  if (!resolvedResource && resourceName) {
+    if (!Object.hasOwn(resources, resourceName)) {
+      throw new Error(
+        `There's no resource named ${JSON.stringify(resourceName)} in context. ` +
+          'Register it via the resources prop on <SanityApp>.',
+      )
+    }
+    resolvedResource = resources[resourceName]
+  }
+
+  if (!resolvedResource) {
+    resolvedResource = contextResource
+  }
+
+  if (resolvedResource === undefined) {
+    throw new Error(
+      'A resource is required. Provide `resource`, `resourceName`, or ensure a default resource is available from context (e.g. via <ResourceProvider> or <SanityApp>).',
+    )
+  }
+
+  const resolvedPerspective = Object.hasOwn(options, 'perspective')
+    ? options.perspective
+    : contextPerspective
+
+  return {
+    ...rest,
+    resource: resolvedResource,
+    ...(resolvedPerspective !== undefined && {perspective: resolvedPerspective}),
+  } as Omit<T, 'resourceName' | 'resource'> & {resource: DocumentResource}
+}
+
+/**
+ * Normalizes hook options by resolving `resourceName` to a `DocumentResource`
+ * and injecting resource/perspective from context.
+ *
+ * This hook ensures that options passed to core layer functions contain
+ * the correct `resource` and `perspective` values, maintaining clean
+ * separation between React and core layers.
+ *
+ * @typeParam T - The options type (must include optional resource field)
+ * @param options - Hook options that may include `resourceName` and/or `resource`
+ * @returns Normalized options with `resourceName` removed and defaults injected
+ *
+ * @remarks
+ * Resolution priority for resource:
+ * 1. If both `resourceName` and `resource` are provided, throws an error
+ * 2. If `resource` is provided, uses it directly
+ * 3. If `resourceName` is provided, resolves it via `ResourcesContext`
+ * 4. If neither is provided, injects the value from `ResourceContext`
+ *
+ * Resolution priority for perspective:
+ * 1. If `perspective` is explicitly provided in options, uses it
+ * 2. Otherwise, injects the value from `PerspectiveContext`
+ *
+ * @internal
+ */
+export function useNormalizedResourceOptions<
+  T extends {
+    resource?: DocumentResource
+    resourceName?: string
+    perspective?: unknown
+  },
+>(options: T): Omit<T, 'resourceName' | 'resource'> & {resource: DocumentResource} {
+  const resources = useContext(ResourcesContext)
+  const contextResource = useContext(ResourceContext)
+  const contextPerspective = useContext(PerspectiveContext)
+  return normalizeResourceOptions(options, resources, contextResource, contextPerspective)
+}

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

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

package/src/hooks/paginatedDocuments/usePaginatedDocuments.ts

@@ -1,9 +1,10 @@
-import {createGroqSearchFilter, type DocumentHandle, type QueryOptions} from '@sanity/sdk'
+import {createGroqSearchFilter, type QueryOptions} from '@sanity/sdk'
 import {type SortOrderingItem} from '@sanity/types'
 import {pick} from 'lodash-es'
 import {useCallback, useEffect, useMemo, useState} from 'react'
 
-import {useSanityInstance} from '../context/useSanityInstance'
+import {type DocumentHandle, type ResourceHandle} from '../../config/handles'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {useQuery} from '../query/useQuery'
 
 /**
@@ -16,7 +17,10 @@ export interface PaginatedDocumentsOptions<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
-> extends Omit<QueryOptions<TDocumentType, TDataset, TProjectId>, 'query'> {
+>
+  extends
+    ResourceHandle<TProjectId, TDataset>,
+    Pick<QueryOptions<TDocumentType, TDataset, TProjectId>, 'params'> {
   documentType?: TDocumentType | TDocumentType[]
   /**
    * GROQ filter expression to apply to the query
@@ -137,18 +141,16 @@ 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 projectId and dataset information from the current Sanity instance
+ * - The returned document handles include resource 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 projectId and dataset in the options
+ * - The hook automatically uses the correct Sanity instance based on the resource in the options
  *
  * @example Paginated list of documents with navigation
  * ```tsx
  * import {
  *   usePaginatedDocuments,
- *   createDatasetHandle,
- *   type DatasetHandle,
  *   type DocumentHandle,
- *   type SortOrderingItem,
+ *   type DocumentResource,
  *   useDocumentProjection
  * } from '@sanity/sdk-react'
  * import {Suspense} from 'react'
@@ -171,10 +173,10 @@ export interface PaginatedDocumentsResponse<
  * // Define props for the list component
  * interface PaginatedDocumentListProps {
  *   documentType: string
- *   dataset?: DatasetHandle
+ *   resource?: DocumentResource
  * }
  *
- * function PaginatedDocumentList({documentType, dataset}: PaginatedDocumentListProps) {
+ * function PaginatedDocumentList({documentType, resource}: PaginatedDocumentListProps) {
  *   const {
  *     data,
  *     isPending,
@@ -185,7 +187,7 @@ export interface PaginatedDocumentsResponse<
  *     hasNextPage,
  *     hasPreviousPage
  *   } = usePaginatedDocuments({
- *     ...dataset,
+ *     resource,
  *     documentType,
  *     pageSize: 10,
  *     orderings: [{field: '_createdAt', direction: 'desc'}],
@@ -217,8 +219,7 @@ export interface PaginatedDocumentsResponse<
  * }
  *
  * // Usage:
- * // const myDatasetHandle = createDatasetHandle({ projectId: 'p1', dataset: 'production' })
- * // <PaginatedDocumentList dataset={myDatasetHandle} documentType="post" />
+ * // <PaginatedDocumentList resource={{projectId: 'p1', dataset: 'production'}} documentType="post" />
  * ```
  */
 export function usePaginatedDocuments<
@@ -232,15 +233,15 @@ export function usePaginatedDocuments<
   params = {},
   orderings,
   search,
-  ...options
+  ...rawOptions
 }: PaginatedDocumentsOptions<TDocumentType, TDataset, TProjectId>): PaginatedDocumentsResponse<
   TDocumentType,
   TDataset,
   TProjectId
 > {
-  const instance = useSanityInstance(options)
+  const options = useNormalizedResourceOptions(rawOptions)
   const [pageIndex, setPageIndex] = useState(0)
-  const key = JSON.stringify({filter, search, params, orderings, pageSize})
+  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(() => {
@@ -300,10 +301,8 @@ export function usePaginatedDocuments<
     params: {
       ...params,
       __types: documentTypes,
-      __handle: {
-        ...pick(instance.config, 'projectId', 'dataset', 'perspective'),
-        ...pick(options, 'projectId', 'dataset', 'perspective'),
-      },
+      // these are passed back to the user as part of each document handle
+      __handle: pick(options, ['resource', 'perspective']),
     },
   })
 

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

@@ -6,14 +6,17 @@ import {describe, expect, it, vi} from 'vitest'
 import {ResourceProvider} from '../../context/ResourceProvider'
 import {usePresence} from './usePresence'
 
-vi.mock('@sanity/sdk', () => ({
-  getPresence: vi.fn(),
-  createSanityInstance: vi.fn(() => ({
-    createChild: vi.fn(),
-    isDisposed: vi.fn(() => false),
-    dispose: vi.fn(),
-  })),
-}))
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@sanity/sdk')>()
+  return {
+    ...actual,
+    getPresence: vi.fn(),
+    createSanityInstance: vi.fn(() => ({
+      isDisposed: vi.fn(() => false),
+      dispose: vi.fn(),
+    })),
+  }
+})
 
 describe('usePresence', () => {
   it('should return presence locations and update when the store changes', () => {
@@ -59,7 +62,10 @@ describe('usePresence', () => {
 
     const {result, unmount} = renderHook(() => usePresence(), {
       wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
+        <ResourceProvider
+          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
+          fallback={null}
+        >
           {children}
         </ResourceProvider>
       ),
@@ -80,4 +86,60 @@ describe('usePresence', () => {
     expect(result.current.locations).toEqual(updatedLocations)
     unmount()
   })
+
+  it('should throw an error when used with a media library resource', () => {
+    expect(() => {
+      renderHook(() => usePresence({resource: {mediaLibraryId: 'ml123'}}), {
+        wrapper: ({children}) => (
+          <ResourceProvider
+            resource={{projectId: 'test-project', dataset: 'test-dataset'}}
+            fallback={null}
+          >
+            {children}
+          </ResourceProvider>
+        ),
+      })
+    }).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([]),
+      subscribe: vi.fn(() => () => {}),
+      observable: NEVER,
+    }
+    vi.mocked(getPresence).mockReturnValue(mockPresenceSource)
+
+    const {result, unmount} = renderHook(
+      () => usePresence({resource: {projectId: 'test-project', dataset: 'test-dataset'}}),
+      {
+        wrapper: ({children}) => (
+          <ResourceProvider
+            resource={{projectId: 'test-project', dataset: 'test-dataset'}}
+            fallback={null}
+          >
+            {children}
+          </ResourceProvider>
+        ),
+      },
+    )
+
+    expect(result.current.locations).toEqual([])
+    unmount()
+  })
 })