@sanity/sdk-react 2.9.0 → 2.10.0

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

@@ -176,7 +176,7 @@ describe('useApplyDocumentActions', () => {
     }).toThrow(/Mismatched datasets found in actions/)
   })
 
-  it('throws when actions have mismatched sources', async () => {
+  it('throws when actions have mismatched resources', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
       result.current([
@@ -184,19 +184,19 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          source: {projectId: 'p', dataset: 'd1'},
+          resource: {projectId: 'p', dataset: 'd1'},
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          source: {projectId: 'p', dataset: 'd2'},
+          resource: {projectId: 'p', dataset: 'd2'},
         },
       ])
-    }).toThrow(/Mismatched sources found in actions/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when mixing projectId and source (projectId first)', async () => {
+  it('throws when mixing projectId and resource (projectId first)', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
       result.current([
@@ -210,13 +210,13 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          source: {projectId: 'p', dataset: 'd'},
+          resource: {projectId: 'p', dataset: 'd'},
         },
       ])
-    }).toThrow(/Mismatches between projectId\/dataset options and source/)
+    }).toThrow(/Mismatches between projectId\/dataset options and resource/)
   })
 
-  it('throws when mixing source and projectId (source first)', async () => {
+  it('throws when mixing resource and projectId (resource first)', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
       result.current([
@@ -224,7 +224,7 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          source: {projectId: 'p', dataset: 'd'},
+          resource: {projectId: 'p', dataset: 'd'},
         },
         {
           type: 'document.edit',
@@ -233,6 +233,6 @@ describe('useApplyDocumentActions', () => {
           projectId: 'p',
         },
       ])
-    }).toThrow(/Mismatches between projectId\/dataset options and source/)
+    }).toThrow(/Mismatches between projectId\/dataset options and resource/)
   })
 })

package/src/hooks/document/useApplyDocumentActions.ts

@@ -7,12 +7,12 @@ import {
 import {type SanityDocument} from 'groq'
 import {useContext} from 'react'
 
-import {SourcesContext} from '../../context/SourcesContext'
+import {ResourcesContext} from '../../context/ResourcesContext'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {
-  normalizeSourceOptions,
-  type WithSourceNameSupport,
-} from '../helpers/useNormalizedSourceOptions'
+  normalizeResourceOptions,
+  type WithResourceNameSupport,
+} 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'
@@ -29,7 +29,7 @@ interface UseApplyDocumentActions {
     action:
       | DocumentAction<TDocumentType, TDataset, TProjectId>
       | DocumentAction<TDocumentType, TDataset, TProjectId>[],
-    options?: WithSourceNameSupport<ApplyDocumentActionsOptions>,
+    options?: WithResourceNameSupport<ApplyDocumentActionsOptions>,
   ) => Promise<ActionsResult<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
 }
 
@@ -218,20 +218,20 @@ interface UseApplyDocumentActions {
  */
 export const useApplyDocumentActions: UseApplyDocumentActions = () => {
   const instance = useSanityInstance()
-  const sources = useContext(SourcesContext)
+  const resources = useContext(ResourcesContext)
 
   return (actionOrActions, options) => {
     const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]
-    const normalizedOptions = options ? normalizeSourceOptions(options, sources) : undefined
+    const normalizedOptions = options ? normalizeResourceOptions(options, resources) : undefined
 
     let projectId
     let dataset
-    let source
+    let resource
     for (const action of actions) {
       if (action.projectId) {
-        if (source) {
+        if (resource) {
           throw new Error(
-            `Mismatches between projectId/dataset options and source in actions. Found projectId "${action.projectId}" and dataset "${action.dataset}" but expected source "${source}".`,
+            `Mismatches between projectId/dataset options and resource in actions. Found projectId "${action.projectId}" and dataset "${action.dataset}" but expected resource "${resource}".`,
           )
         }
         if (!projectId) projectId = action.projectId
@@ -251,16 +251,16 @@ export const useApplyDocumentActions: UseApplyDocumentActions = () => {
         }
       }
 
-      if (action.source) {
-        if (!source) source = action.source
-        if (action.source !== source) {
+      if (action.resource) {
+        if (!resource) resource = action.resource
+        if (action.resource !== resource) {
           throw new Error(
-            `Mismatched sources found in actions. All actions must belong to the same source. Found "${action.source}" but expected "${source}".`,
+            `Mismatched resources found in actions. All actions must belong to the same resource. Found "${action.resource}" but expected "${resource}".`,
           )
         }
         if (projectId || dataset) {
           throw new Error(
-            `Mismatches between projectId/dataset options and source in actions. Found "${action.source}" but expected project "${projectId}" and dataset "${dataset}".`,
+            `Mismatches between projectId/dataset options and resource in actions. Found "${action.resource}" but expected project "${projectId}" and dataset "${dataset}".`,
           )
         }
       }
@@ -277,14 +277,14 @@ export const useApplyDocumentActions: UseApplyDocumentActions = () => {
 
       return applyDocumentActions(actualInstance, {
         actions,
-        source,
+        resource,
         ...normalizedOptions,
       })
     }
 
     return applyDocumentActions(instance, {
       actions,
-      source,
+      resource,
       ...normalizedOptions,
     })
   }

package/src/hooks/document/useDocument.ts

@@ -4,9 +4,9 @@ import {identity} from 'rxjs'
 
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
 import {
-  useNormalizedSourceOptions,
-  type WithSourceNameSupport,
-} from '../helpers/useNormalizedSourceOptions'
+  useNormalizedResourceOptions,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 // used in an `{@link useDocumentProjection}` and `{@link useQuery}`
 // eslint-disable-next-line import/consistent-type-specifier-style, unused-imports/no-unused-imports
@@ -43,7 +43,7 @@ type UseDocumentOptions<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
-> = WithSourceNameSupport<DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>>
+> = WithResourceNameSupport<DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>>
 
 interface UseDocument {
   /** @internal */
@@ -240,6 +240,6 @@ interface UseDocument {
  */
 export const useDocument = wrapHookWithData((options: UseDocumentOptions) => {
   useTrackHookUsage('useDocument')
-  const normalizedOptions = useNormalizedSourceOptions(options)
+  const normalizedOptions = useNormalizedResourceOptions(options)
   return useDocumentValue(normalizedOptions)
 }) as UseDocument

package/src/hooks/document/useDocumentEvent.ts

@@ -2,7 +2,7 @@ import {type DatasetHandle, type DocumentEvent, subscribeDocumentEvents} from '@
 import {useCallback, useEffect, useInsertionEffect, useRef} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
-import {useNormalizedSourceOptions} from '../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 
 /**
@@ -79,7 +79,7 @@ export function useDocumentEvent<
 ): void {
   useTrackHookUsage('useDocumentEvent')
   // Destructure handler and datasetHandle from options
-  const normalizedOptions = useNormalizedSourceOptions(options)
+  const normalizedOptions = useNormalizedResourceOptions(options)
   const {onEvent, ...datasetHandle} = normalizedOptions
   const ref = useRef(onEvent)
 
@@ -95,7 +95,7 @@ export function useDocumentEvent<
   useEffect(() => {
     return subscribeDocumentEvents(instance, {
       eventHandler: stableHandler,
-      source: datasetHandle.source,
+      resource: datasetHandle.resource,
     })
-  }, [instance, datasetHandle.source, stableHandler])
+  }, [instance, datasetHandle.resource, stableHandler])
 }

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

@@ -183,19 +183,19 @@ describe('usePermissions', () => {
     }).toThrow(/Mismatched datasets found in actions/)
   })
 
-  it('should throw an error if actions have mismatched sources', () => {
+  it('should throw an error if actions have mismatched resources', () => {
     const actions = [
       {
         type: 'document.publish' as const,
         documentId: 'doc1',
         documentType: 'article',
-        source: {projectId: 'p1', dataset: 'd1'},
+        resource: {projectId: 'p1', dataset: 'd1'},
       },
       {
         type: 'document.publish' as const,
         documentId: 'doc2',
         documentType: 'article',
-        source: {projectId: 'p2', dataset: 'd2'},
+        resource: {projectId: 'p2', dataset: 'd2'},
       },
     ]
 
@@ -211,17 +211,17 @@ describe('usePermissions', () => {
           </ResourceProvider>
         ),
       })
-    }).toThrow(/Mismatched sources found in actions/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('should throw an error when mixing projectId and source (projectId first)', () => {
+  it('should throw an error when mixing projectId and resource (projectId first)', () => {
     const actions = [
       mockAction,
       {
         type: 'document.publish' as const,
         documentId: 'doc2',
         documentType: 'article',
-        source: {projectId: 'p', dataset: 'd'},
+        resource: {projectId: 'p', dataset: 'd'},
       },
     ]
 
@@ -237,16 +237,16 @@ describe('usePermissions', () => {
           </ResourceProvider>
         ),
       })
-    }).toThrow(/Mismatches between projectId\/dataset options and source/)
+    }).toThrow(/Mismatches between projectId\/dataset options and resource/)
   })
 
-  it('should throw an error when mixing source and projectId (source first)', () => {
+  it('should throw an error when mixing resource and projectId (resource first)', () => {
     const actions = [
       {
         type: 'document.publish' as const,
         documentId: 'doc1',
         documentType: 'article',
-        source: {projectId: 'p', dataset: 'd'},
+        resource: {projectId: 'p', dataset: 'd'},
       },
       mockAction,
     ]
@@ -263,7 +263,7 @@ describe('usePermissions', () => {
           </ResourceProvider>
         ),
       })
-    }).toThrow(/Mismatches between projectId\/dataset options and source/)
+    }).toThrow(/Mismatches between projectId\/dataset options and resource/)
   })
 
   it('should wait for permissions to be ready before rendering', async () => {

package/src/hooks/document/useDocumentPermissions.ts

@@ -92,13 +92,13 @@ export function useDocumentPermissions(
   // if actions is an array, we need to check that all actions belong to the same project and dataset
   let projectId
   let dataset
-  let source
+  let resource
 
   for (const action of actions) {
     if (action.projectId) {
-      if (source) {
+      if (resource) {
         throw new Error(
-          `Mismatches between projectId/dataset options and source in actions. Found projectId "${action.projectId}" and dataset "${action.dataset}" but expected source "${source}".`,
+          `Mismatches between projectId/dataset options and resource in actions. Found projectId "${action.projectId}" and dataset "${action.dataset}" but expected resource "${resource}".`,
         )
       }
       if (!projectId) projectId = action.projectId
@@ -118,16 +118,16 @@ export function useDocumentPermissions(
       }
     }
 
-    if (action.source) {
-      if (!source) source = action.source
-      if (action.source !== source) {
+    if (action.resource) {
+      if (!resource) resource = action.resource
+      if (action.resource !== resource) {
         throw new Error(
-          `Mismatched sources found in actions. All actions must belong to the same source. Found "${action.source}" but expected "${source}".`,
+          `Mismatched resources found in actions. All actions must belong to the same resource. Found "${action.resource}" but expected "${resource}".`,
         )
       }
       if (projectId || dataset) {
         throw new Error(
-          `Mismatches between projectId/dataset options and source in actions. Found "${action.source}" but expected project "${projectId}" and dataset "${dataset}".`,
+          `Mismatches between projectId/dataset options and resource in actions. Found "${action.resource}" but expected project "${projectId}" and dataset "${dataset}".`,
         )
       }
     }

package/src/hooks/document/useDocumentSyncStatus.ts

@@ -9,7 +9,7 @@ import {
 import {identity} from 'rxjs'
 
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
-import {useNormalizedSourceOptions} from '../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 type UseDocumentSyncStatus = {
   /**
@@ -65,6 +65,6 @@ const useDocumentSyncStatusValue = createStateSourceHook({
 export const useDocumentSyncStatus: UseDocumentSyncStatus = (
   options: DocumentOptions<string | undefined>,
 ) => {
-  const normalizedOptions = useNormalizedSourceOptions(options)
+  const normalizedOptions = useNormalizedResourceOptions(options)
   return useDocumentSyncStatusValue(normalizedOptions)
 }

package/src/hooks/document/useEditDocument.ts

@@ -10,7 +10,7 @@ import {type SanityDocument} from 'groq'
 import {useCallback} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
-import {useNormalizedSourceOptions} from '../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {trackHookUsage} from '../helpers/useTrackHookUsage'
 import {useApplyDocumentActions} from './useApplyDocumentActions'
 
@@ -288,7 +288,7 @@ export function useEditDocument({
 }: DocumentOptions<string | undefined>): (updater: Updater<unknown>) => Promise<ActionsResult> {
   const instance = useSanityInstance(doc)
   trackHookUsage(instance, 'useEditDocument')
-  const normalizedDoc = useNormalizedSourceOptions(doc)
+  const normalizedDoc = useNormalizedResourceOptions(doc)
 
   const apply = useApplyDocumentActions()
   const isDocumentReady = useCallback(

package/src/hooks/documents/useDocuments.ts

@@ -5,8 +5,7 @@ import {
   type QueryOptions,
 } from '@sanity/sdk'
 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 {useSanityInstance} from '../context/useSanityInstance'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
@@ -230,9 +229,11 @@ export function useDocuments<
     types: documentTypes,
     ...options,
   })
-  useEffect(() => {
+  const [prevKey, setPrevKey] = useState(key)
+  if (prevKey !== key) {
+    setPrevKey(key)
     setLimit(batchSize)
-  }, [key, batchSize])
+  }
 
   const filterClause = useMemo(() => {
     const conditions: string[] = []
@@ -281,9 +282,11 @@ export function useDocuments<
     query: `{"count":${countQuery},"data":${dataQuery}}`,
     params: {
       ...params,
+      // these are passed back to the user as part of each document handle
       __handle: {
-        ...pick(instance.config, 'projectId', 'dataset', 'perspective'),
-        ...pick(options, 'projectId', 'dataset', 'perspective'),
+        projectId: options.projectId ?? instance.config.projectId,
+        dataset: options.dataset ?? instance.config.dataset,
+        perspective: options.perspective ?? instance.config.perspective,
       },
       __types: documentTypes,
     },

package/src/hooks/helpers/useNormalizedResourceOptions.ts

@@ -0,0 +1,131 @@
+import {type DocumentResource} from '@sanity/sdk'
+import {useContext} from 'react'
+
+import {ResourcesContext} from '../../context/ResourcesContext'
+
+/**
+ * Adds React hook support (resourceName resolution) to core types.
+ * This wrapper allows hooks to accept `resourceName` as a convenience,
+ * which is then resolved to a `DocumentResource` at the React layer.
+ * For now, we are trying to avoid resource name resolution in core --
+ * functions having resources explicitly passed will reduce complexity.
+ *
+ * @typeParam T - The core type to extend (must have optional `resource` field)
+ * @beta
+ */
+export type WithResourceNameSupport<T extends {resource?: DocumentResource}> = T & {
+  /**
+   * Optional name of a resource to resolve from context.
+   * If provided, will be resolved to a `DocumentResource` via `ResourcesContext`.
+   * @beta
+   */
+  resourceName?: string
+  /**
+   * @deprecated Use `resourceName` instead.
+   * @beta
+   */
+  sourceName?: string
+}
+
+/**
+ * Pure function that normalizes options by resolving `resourceName` to a `DocumentResource`
+ * using the provided resources map. 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)
+ * @returns Normalized options with `resourceName` removed and `resource` resolved
+ * @internal
+ */
+export function normalizeResourceOptions<
+  T extends {
+    resource?: DocumentResource
+    resourceName?: string
+    source?: DocumentResource
+    sourceName?: string
+  },
+>(
+  options: T,
+  resources: Record<string, DocumentResource>,
+): Omit<T, 'resourceName' | 'source' | 'sourceName'> {
+  const {resourceName, sourceName, source, ...rest} = options
+
+  // Coalesce deprecated aliases to their canonical equivalents
+  const effectiveResourceName = resourceName ?? sourceName
+  const effectiveResource = options.resource ?? source
+
+  if (!effectiveResourceName && !effectiveResource) {
+    return rest as Omit<T, 'resourceName' | 'source' | 'sourceName'>
+  }
+
+  const hasNameKey = Object.hasOwn(options, 'resourceName') || Object.hasOwn(options, 'sourceName')
+  const hasResourceKey = Object.hasOwn(options, 'resource') || Object.hasOwn(options, 'source')
+
+  if (hasNameKey && hasResourceKey) {
+    throw new Error(
+      `Resource name ${JSON.stringify(effectiveResourceName)} and resource ${JSON.stringify(effectiveResource)} cannot be used together.`,
+    )
+  }
+
+  let resolvedResource: DocumentResource | undefined
+
+  if (effectiveResource) {
+    resolvedResource = effectiveResource
+  }
+
+  if (effectiveResourceName && !Object.hasOwn(resources, effectiveResourceName)) {
+    throw new Error(
+      `There's no resource named ${JSON.stringify(effectiveResourceName)} in context. Please use <ResourceProvider>.`,
+    )
+  }
+
+  if (effectiveResourceName && resources[effectiveResourceName]) {
+    resolvedResource = resources[effectiveResourceName]
+  }
+
+  return {
+    ...rest,
+    resource: resolvedResource,
+  }
+}
+
+/**
+ * Normalizes hook options by resolving `resourceName` to a `DocumentResource`.
+ * This hook ensures that options passed to core layer functions only contain
+ * `resource` (never `resourceName`), preventing duplicate cache keys and 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 `resource` resolved
+ *
+ * @remarks
+ * Resolution priority:
+ * 1. If `resourceName` is provided, resolves it via `ResourcesContext` and uses that
+ * 2. Otherwise, uses the inline `resource` if provided
+ * 3. If neither is provided, returns options without a resource field
+ *
+ * @example
+ * ```tsx
+ * function useQuery(options: WithResourceNameSupport<QueryOptions>) {
+ *   const instance = useSanityInstance(options)
+ *   const normalized = useNormalizedOptions(options)
+ *   // normalized now has resource but never resourceName
+ *   const queryKey = getQueryKey(normalized)
+ * }
+ * ```
+ *
+ * @beta
+ */
+export function useNormalizedResourceOptions<
+  T extends {
+    resource?: DocumentResource
+    resourceName?: string
+    source?: DocumentResource
+    sourceName?: string
+  },
+>(options: T): Omit<T, 'resourceName' | 'source' | 'sourceName'> {
+  const resources = useContext(ResourcesContext)
+  return normalizeResourceOptions(options, resources)
+}

package/src/hooks/helpers/useTrackHookUsage.ts

@@ -18,8 +18,8 @@ import {useSanityInstance} from '../context/useSanityInstance'
  */
 export function useTrackHookUsage(hookName: string): void {
   const instance = useSanityInstance()
-  const tracked = useRef(false)
-  if (!tracked.current) {
+  const tracked = useRef<true | null>(null)
+  if (tracked.current === null) {
     tracked.current = true
     trackHookMounted(instance, hookName)
   }

package/src/hooks/paginatedDocuments/usePaginatedDocuments.ts

@@ -1,7 +1,6 @@
 import {createGroqSearchFilter, type DocumentHandle, type QueryOptions} from '@sanity/sdk'
 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 {useSanityInstance} from '../context/useSanityInstance'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
@@ -243,11 +242,12 @@ export function usePaginatedDocuments<
   const instance = useSanityInstance(options)
   const [pageIndex, setPageIndex] = useState(0)
   const key = JSON.stringify({filter, search, params, orderings, pageSize})
-  // 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
@@ -303,8 +303,9 @@ export function usePaginatedDocuments<
       ...params,
       __types: documentTypes,
       __handle: {
-        ...pick(instance.config, 'projectId', 'dataset', 'perspective'),
-        ...pick(options, 'projectId', 'dataset', 'perspective'),
+        projectId: options.projectId ?? instance.config.projectId,
+        dataset: options.dataset ?? instance.config.dataset,
+        perspective: options.perspective ?? instance.config.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,45 @@ 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 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()
+  })
 })