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

package/src/hooks/projection/useDocumentProjection.ts

@@ -1,13 +1,10 @@
-import {type DocumentHandle, getProjectionState, resolveProjection} from '@sanity/sdk'
-import {type SanityProjectionResult} from 'groq'
+import {getProjectionState, resolveProjection} from '@sanity/sdk'
 import {useCallback, useMemo, useSyncExternalStore} from 'react'
 import {distinctUntilChanged, EMPTY, Observable, startWith, switchMap} from 'rxjs'
 
+import {type DocumentHandle} from '../../config/handles'
 import {useSanityInstance} from '../context/useSanityInstance'
-import {
-  useNormalizedSourceOptions,
-  type WithSourceNameSupport,
-} from '../helpers/useNormalizedSourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 /**
  * @public
@@ -18,7 +15,7 @@ export interface useDocumentProjectionOptions<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
-> extends WithSourceNameSupport<DocumentHandle<TDocumentType, TDataset, TProjectId>> {
+> extends DocumentHandle<TDocumentType, TDataset, TProjectId> {
   /** The GROQ projection string */
   projection: TProjection
   /** Optional parameters for the projection query */
@@ -48,83 +45,13 @@ export interface useDocumentProjectionResults<TData> {
  *
  * @category Documents
  * @remarks
- * This hook has multiple signatures allowing for fine-grained control over type inference:
- * - Using Typegen: Infers the return type based on the `documentType`, `dataset`, `projectId`, and `projection`.
- * - Using explicit type parameter: Allows specifying a custom return type `TData`.
+ * This hook allows specifying an explicit type parameter `TData` for the projected result.
  *
  * @param options - An object containing the `DocumentHandle` properties (`documentId`, `documentType`, etc.), the `projection` string, optional `params`, and an optional `ref`.
  * @returns An object containing the projection results (`data`) and a boolean indicating whether the resolution is pending (`isPending`). Note: Suspense handles initial loading states; `data` being `undefined` after initial loading means the document doesn't exist or the projection yielded no result.
  */
 
-// Overload 1: Relies on Typegen
-/**
- * @public
- * Fetch a projection, relying on Typegen for the return type based on the handle and projection.
- *
- * @category Documents
- * @param options - Options including the document handle properties (`documentId`, `documentType`, etc.) and the `projection`.
- * @returns The projected data, typed based on Typegen.
- *
- * @example Using Typegen for a book preview
- * ```tsx
- * // ProjectionComponent.tsx
- * import {useDocumentProjection, type DocumentHandle} from '@sanity/sdk-react'
- * import {useRef} from 'react'
- * import {defineProjection} from 'groq'
- *
- * // Define props using DocumentHandle with the specific document type
- * type ProjectionComponentProps = {
- *   doc: DocumentHandle<'book'> // Typegen knows 'book'
- * }
- *
- * // This is required for typegen to generate the correct return type
- * const myProjection = defineProjection(`{
- *   title,
- *   'coverImage': cover.asset->url,
- *   'authors': array::join(authors[]->{'name': firstName + ' ' + lastName}.name, ', ')
- * }`)
- *
- * export default function ProjectionComponent({ doc }: ProjectionComponentProps) {
- *   const ref = useRef(null) // Optional ref to track viewport intersection for lazy loading
- *
- *   // Spread the doc handle into the options
- *   // Typegen infers the return type based on 'book' and the projection
- *   const { data } = useDocumentProjection({
- *     ...doc, // Pass the handle properties
- *     ref,
- *     projection: myProjection,
- *   })
- *
- *   // Suspense handles initial load, check for data existence after
- *   return (
- *     <article ref={ref}>
- *       <h2>{data.title ?? 'Untitled'}</h2>
- *       {data.coverImage && <img src={data.coverImage} alt={data.title} />}
- *       <p>{data.authors ?? 'Unknown authors'}</p>
- *     </article>
- *   )
- * }
- *
- * // Usage:
- * // import {createDocumentHandle} from '@sanity/sdk-react'
- * // const myDocHandle = createDocumentHandle({ documentId: 'book123', documentType: 'book' })
- * // <Suspense fallback='Loading preview...'>
- * //   <ProjectionComponent doc={myDocHandle} />
- * // </Suspense>
- * ```
- */
-export function useDocumentProjection<
-  TProjection extends string = string,
-  TDocumentType extends string = string,
-  TDataset extends string = string,
-  TProjectId extends string = string,
->(
-  options: useDocumentProjectionOptions<TProjection, TDocumentType, TDataset, TProjectId>,
-): useDocumentProjectionResults<
-  SanityProjectionResult<TProjection, TDocumentType, `${TProjectId}.${TDataset}`>
->
-
-// Overload 2: Explicit type provided
+// Overload 1: Explicit type provided
 /**
  * @public
  * Fetch a projection with an explicitly defined return type `TData`.
@@ -180,15 +107,15 @@ export function useDocumentProjection<TData extends object>({
   projection,
   ...docHandle
 }: useDocumentProjectionOptions): useDocumentProjectionResults<TData> {
-  const instance = useSanityInstance(docHandle)
+  const instance = useSanityInstance()
 
   // Normalize projection string to handle template literals with whitespace
   // This ensures that the same projection content produces the same state source
   // even if the string reference changes (e.g., from inline template literals)
   const normalizedProjection = useMemo(() => projection.trim(), [projection])
 
-  // Normalize options: resolve sourceName to source and strip sourceName
-  const normalizedDocHandle = useNormalizedSourceOptions(docHandle)
+  // Normalize options: resolve resourceName to resource and strip resourceName
+  const normalizedDocHandle = useNormalizedResourceOptions(docHandle)
 
   // Memoize stateSource based on normalized projection and docHandle properties
   // This prevents creating a new StateSource on every render when projection content is the same

package/src/hooks/projects/useProject.test.ts

@@ -40,8 +40,7 @@ describe('useProject', () => {
       expect.objectContaining({
         getState: expect.any(Function),
         shouldSuspend: expect.any(Function),
-        suspender: expect.any(Function), // Actual function reference doesn't matter here as it's mocked
-        getConfig: expect.any(Function), // Actual function reference doesn't matter here
+        suspender: expect.any(Function),
       }),
     )
   })

package/src/hooks/projects/useProject.ts

@@ -6,7 +6,6 @@ import {
   type SanityProject,
   type StateSource,
 } from '@sanity/sdk'
-import {identity} from 'rxjs'
 
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
 
@@ -16,12 +15,12 @@ type UseProject = {
    * Returns metadata for a given project
    *
    * @category Projects
-   * @param projectId - The ID of the project to retrieve metadata for
+   * @param projectHandle - An optional project handle identifying which project to retrieve metadata for
    * @returns The metadata for the project
    * @example
    * ```tsx
    *  function ProjectMetadata({ projectId }: { projectId: string }) {
-   *    const project = useProject(projectId)
+   *    const project = useProject({ projectId })
    *
    *    return (
    *      <figure style={{ backgroundColor: project.metadata.color || 'lavender'}}>
@@ -44,8 +43,8 @@ export const useProject: UseProject = createStateSourceHook({
     instance: SanityInstance,
     projectHandle?: ProjectHandle,
   ) => StateSource<SanityProject>,
-  shouldSuspend: (instance, projectHandle) =>
-    getProjectState(instance, projectHandle).getCurrent() === undefined,
-  suspender: resolveProject,
-  getConfig: identity,
-})
+  shouldSuspend: (instance: SanityInstance, projectHandle?: ProjectHandle) =>
+    getProjectState(instance, projectHandle as ProjectHandle).getCurrent() === undefined,
+  suspender: (instance: SanityInstance, projectHandle?: ProjectHandle) =>
+    resolveProject(instance, projectHandle as ProjectHandle),
+}) as UseProject

package/src/hooks/query/useQuery.test.tsx

@@ -33,7 +33,7 @@ describe('useQuery', () => {
     } as StateSource<unknown>)
 
     function TestComponent() {
-      const {data, isPending} = useQuery({query: 'test query'})
+      const {data, isPending} = useQuery<string>({query: 'test query'})
       return (
         <div data-testid="output">
           {data} - {isPending ? 'pending' : 'not pending'}
@@ -42,7 +42,7 @@ describe('useQuery', () => {
     }
 
     render(
-      <ResourceProvider projectId="p" dataset="d" fallback={<p>Loading...</p>}>
+      <ResourceProvider resource={{projectId: 'p', dataset: 'd'}} fallback={<p>Loading...</p>}>
         <TestComponent />
       </ResourceProvider>,
     )
@@ -82,14 +82,13 @@ describe('useQuery', () => {
     )
 
     function TestComponent() {
-      const {data} = useQuery({query: 'test query'})
+      const {data} = useQuery<string>({query: 'test query'})
       return <div data-testid="output">{data}</div>
     }
 
     render(
       <ResourceProvider
-        projectId="p"
-        dataset="d"
+        resource={{projectId: 'p', dataset: 'd'}}
         fallback={<div data-testid="fallback">Loading...</div>}
       >
         <TestComponent />
@@ -164,7 +163,7 @@ describe('useQuery', () => {
     }
 
     render(
-      <ResourceProvider projectId="p" dataset="d" fallback={<p>Loading...</p>}>
+      <ResourceProvider resource={{projectId: 'p', dataset: 'd'}} fallback={<p>Loading...</p>}>
         <WrapperComponent />
       </ResourceProvider>,
     )

package/src/hooks/query/useQuery.ts

@@ -5,99 +5,21 @@ import {
   type QueryOptions,
   resolveQuery,
 } from '@sanity/sdk'
-import {type SanityQueryResult} from 'groq'
 import {useEffect, useMemo, useRef, useState, useSyncExternalStore, useTransition} from 'react'
 
+import {type ResourceHandle} from '../../config/handles'
 import {useSanityInstance} from '../context/useSanityInstance'
-import {
-  useNormalizedSourceOptions,
-  type WithSourceNameSupport,
-} from '../helpers/useNormalizedSourceOptions'
-/**
- * Hook options for useQuery, supporting both direct source and sourceName.
- * @beta
- */
-type UseQueryOptions<
-  TQuery extends string = string,
-  TDataset extends string = string,
-  TProjectId extends string = string,
-> = WithSourceNameSupport<QueryOptions<TQuery, TDataset, TProjectId>>
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
-// Overload 1: Inferred Type (using Typegen)
-/**
- * @public
- * Executes a GROQ query, inferring the result type from the query string and options.
- * Leverages Sanity Typegen if configured for enhanced type safety.
- *
- * @param options - Configuration for the query, including `query`, optional `params`, `projectId`, `dataset`, etc.
- * @returns An object containing `data` (typed based on the query) and `isPending` (for transitions).
- *
- * @example Basic usage (Inferred Type)
- * ```tsx
- * import {useQuery} from '@sanity/sdk-react'
- * import {defineQuery} from 'groq'
- *
- * const myQuery = defineQuery(`*[_type == "movie"]{_id, title}`)
- *
- * function MovieList() {
- *   // Typegen infers the return type for data
- *   const {data} = useQuery({ query: myQuery })
- *
- *   return (
- *     <div>
- *       <h2>Movies</h2>
- *       <ul>
- *         {data.map(movie => <li key={movie._id}>{movie.title}</li>)}
- *       </ul>
- *     </div>
- *   )
- * }
- * // Suspense boundary should wrap <MovieList /> for initial load
- * ```
- *
- * @example Using parameters (Inferred Type)
- * ```tsx
- * import {useQuery} from '@sanity/sdk-react'
- * import {defineQuery} from 'groq'
- *
- * const myQuery = defineQuery(`*[_type == "movie" && _id == $id][0]`)
- *
- * function MovieDetails({movieId}: {movieId: string}) {
- *   // Typegen infers the return type based on query and params
- *   const {data, isPending} = useQuery({
- *     query: myQuery,
- *     params: { id: movieId }
- *   })
- *
- *   return (
- *     // utilize `isPending` to signal to users that new data is coming in
- *     // (e.g. the `movieId` changed and we're loading in the new one)
- *     <div style={{ opacity: isPending ? 0.5 : 1 }}>
- *       {data ? <h1>{data.title}</h1> : <p>Movie not found</p>}
- *     </div>
- *   )
- * }
- * ```
- */
-export function useQuery<
-  TQuery extends string = string,
-  TDataset extends string = string,
-  TProjectId extends string = string,
->(
-  options: UseQueryOptions<TQuery, TDataset, TProjectId>,
-): {
-  /** The query result, typed based on the GROQ query string */
-  data: SanityQueryResult<TQuery, `${TProjectId}.${TDataset}`>
-  /** True if a query transition is in progress */
-  isPending: boolean
-}
+/** Options for useQuery: QueryOptions with resource made optional (resolved from context) */
+type ReactQueryOptions = Omit<QueryOptions, 'resource' | 'resourceName'> & ResourceHandle
 
-// Overload 2: Explicit Type Provided
+// Overload 1: Explicit Type Provided
 /**
  * @public
  * Executes a GROQ query with an explicitly provided result type `TData`.
  *
- * @param options - Configuration for the query, including `query`, optional `params`, `projectId`, `dataset`, etc.
+ * @param options - Configuration for the query, including `query`, optional `params`, `resource`, etc.
  * @returns An object containing `data` (cast to `TData`) and `isPending` (indicates whether a query resolution is pending; note that Suspense handles initial loading states). *
  * @example Manually typed query result
  * ```tsx
@@ -121,7 +43,7 @@ export function useQuery<
  * }
  * ```
  */
-export function useQuery<TData>(options: WithSourceNameSupport<QueryOptions>): {
+export function useQuery<TData>(options: ReactQueryOptions): {
   /** The query result, cast to the provided type TData */
   data: TData
   /** True if another query is resolving in the background (suspense handles the initial loading state) */
@@ -141,20 +63,19 @@ export function useQuery<TData>(options: WithSourceNameSupport<QueryOptions>): {
  * - Subscribes to changes, providing real-time updates.
  * - Integrates with React Suspense for handling initial loading states.
  * - Uses React Transitions for managing loading states during query/parameter changes (indicated by `isPending`).
- * - Supports type inference based on the GROQ query when using Sanity Typegen.
  * - Allows specifying an explicit return type `TData` for the query result.
  *
  * @category GROQ
  */
-export function useQuery(options: WithSourceNameSupport<QueryOptions>): {
+export function useQuery(options: ReactQueryOptions): {
   data: unknown
   isPending: boolean
 } {
   // Implementation returns unknown, overloads define specifics
-  const instance = useSanityInstance(options)
+  const instance = useSanityInstance()
 
-  // Normalize options: resolve sourceName to source and strip sourceName
-  const normalized = useNormalizedSourceOptions(options)
+  // Normalize options: resolve resourceName to resource and strip resourceName
+  const normalized = useNormalizedResourceOptions(options)
 
   // Use React's useTransition to avoid UI jank when queries change
   const [isPending, startTransition] = useTransition()
@@ -207,6 +128,6 @@ export function useQuery(options: WithSourceNameSupport<QueryOptions>): {
 
   // Subscribe to updates and get the current data
   // useSyncExternalStore ensures the component re-renders when the data changes
-  const data = useSyncExternalStore(subscribe, getCurrent) as SanityQueryResult
+  const data = useSyncExternalStore(subscribe, getCurrent) as unknown
   return useMemo(() => ({data, isPending}), [data, isPending])
 }

package/src/hooks/releases/useActiveReleases.test.tsx

@@ -43,7 +43,7 @@ describe('useActiveReleases', () => {
       },
       {
         wrapper: ({children}) => (
-          <ResourceProvider projectId="p" dataset="d" fallback={<p>Loading...</p>}>
+          <ResourceProvider resource={{projectId: 'p', dataset: 'd'}} fallback={<p>Loading...</p>}>
             {children}
           </ResourceProvider>
         ),
@@ -75,7 +75,7 @@ describe('useActiveReleases', () => {
 
     const {result} = renderHook(() => useActiveReleases(), {
       wrapper: ({children}) => (
-        <ResourceProvider projectId="p" dataset="d" fallback={<p>Loading...</p>}>
+        <ResourceProvider resource={{projectId: 'p', dataset: 'd'}} fallback={<p>Loading...</p>}>
           {children}
         </ResourceProvider>
       ),

package/src/hooks/releases/useActiveReleases.ts

@@ -1,4 +1,5 @@
 import {
+  type DocumentResource,
   getActiveReleasesState,
   type ReleaseDocument,
   type SanityInstance,
@@ -6,14 +7,9 @@ import {
 } from '@sanity/sdk'
 import {filter, firstValueFrom} from 'rxjs'
 
+import {type ResourceHandle} from '../../config/handles'
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
-
-/**
- * @public
- */
-type UseActiveReleases = {
-  (): ReleaseDocument[]
-}
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 /**
  * @public
@@ -30,10 +26,26 @@ type UseActiveReleases = {
  * const activeReleases = useActiveReleases()
  * ```
  */
-export const useActiveReleases: UseActiveReleases = createStateSourceHook({
-  getState: getActiveReleasesState as (instance: SanityInstance) => StateSource<ReleaseDocument[]>,
-  shouldSuspend: (instance: SanityInstance) =>
-    getActiveReleasesState(instance).getCurrent() === undefined,
-  suspender: (instance: SanityInstance) =>
-    firstValueFrom(getActiveReleasesState(instance).observable.pipe(filter(Boolean))),
+type UseActiveReleases = {
+  (options?: ResourceHandle | undefined): ReleaseDocument[]
+}
+
+const useActiveReleasesValue = createStateSourceHook({
+  getState: getActiveReleasesState as (
+    instance: SanityInstance,
+    options: {resource: DocumentResource},
+  ) => StateSource<ReleaseDocument[]>,
+  shouldSuspend: (instance: SanityInstance, options: {resource: DocumentResource}) =>
+    getActiveReleasesState(instance, options).getCurrent() === undefined,
+  suspender: (instance: SanityInstance, options: {resource: DocumentResource}) =>
+    firstValueFrom(getActiveReleasesState(instance, options).observable.pipe(filter(Boolean))),
 })
+
+/**
+ * @public
+ * @function
+ */
+export const useActiveReleases: UseActiveReleases = (options: ResourceHandle | undefined) => {
+  const normalizedOptions = useNormalizedResourceOptions(options ?? {})
+  return useActiveReleasesValue(normalizedOptions)
+}

package/src/hooks/releases/usePerspective.test.tsx

@@ -5,11 +5,10 @@ import {
   type PerspectiveHandle,
   type ReleaseDocument,
 } from '@sanity/sdk'
-import {renderHook} from '@testing-library/react'
 import {BehaviorSubject} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
 
-import {ResourceProvider} from '../../context/ResourceProvider'
+import {renderHook} from '../../../test/test-utils'
 import {usePerspective} from './usePerspective'
 
 // Mock the SDK functions
@@ -68,18 +67,13 @@ describe('usePerspective', () => {
     vi.mocked(getPerspectiveState).mockReturnValue(mockStateSource)
     vi.mocked(getActiveReleasesState).mockReturnValue(mockReleasesStateSource)
 
-    const {result} = renderHook(
-      () => {
-        try {
-          return usePerspective(perspectiveHandle)
-        } catch (e) {
-          return e
-        }
-      },
-      {
-        wrapper: ({children}) => <ResourceProvider fallback={null}>{children}</ResourceProvider>,
-      },
-    )
+    const {result} = renderHook(() => {
+      try {
+        return usePerspective(perspectiveHandle)
+      } catch (e) {
+        return e
+      }
+    })
 
     // Verify that the hook threw a promise (suspended)
     expect(result.current).toBeInstanceOf(Promise)
@@ -104,9 +98,7 @@ describe('usePerspective', () => {
 
     vi.mocked(getPerspectiveState).mockReturnValue(mockStateSource)
 
-    const {result} = renderHook(() => usePerspective(perspectiveHandle), {
-      wrapper: ({children}) => <ResourceProvider fallback={null}>{children}</ResourceProvider>,
-    })
+    const {result} = renderHook(() => usePerspective(perspectiveHandle))
 
     // Verify that the hook returned the perspective without suspending
     expect(result.current).toEqual(mockPerspective)

package/src/hooks/releases/usePerspective.ts

@@ -1,20 +1,14 @@
 import {
-  getActiveReleasesState,
+  type DocumentResource,
   getPerspectiveState,
-  type PerspectiveHandle,
   type SanityInstance,
   type StateSource,
 } from '@sanity/sdk'
 import {filter, firstValueFrom} from 'rxjs'
 
+import {type ResourceHandle} from '../../config/handles'
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
-
-/**
- * @public
- */
-type UsePerspective = {
-  (perspectiveHandle: PerspectiveHandle): string | string[]
-}
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 /**
  * @public
@@ -29,22 +23,39 @@ type UsePerspective = {
  * @example
  * ```tsx
  * import {usePerspective, useQuery} from '@sanity/sdk-react'
-
- * const perspective = usePerspective({perspective: 'rxg1346', projectId: 'abc123', dataset: 'production'})
- * const {data} = useQuery<Movie[]>('*[_type == "movie"]', {
- *   perspective: perspective,
+ *
+ * const perspective = usePerspective({
+ *   perspective: 'rxg1346',
+ *   resource: {projectId: 'abc123', dataset: 'production'},
+ * })
+ * const {data} = useQuery<Movie[]>({
+ *   query: '*[_type == "movie"]',
+ *   perspective,
  * })
  * ```
  *
  * @returns The perspective for the given perspective handle.
  */
-export const usePerspective: UsePerspective = createStateSourceHook({
+type UsePerspective = {
+  (perspectiveHandle?: ResourceHandle): string | string[]
+}
+
+const usePerspectiveValue = createStateSourceHook({
   getState: getPerspectiveState as (
     instance: SanityInstance,
-    perspectiveHandle?: PerspectiveHandle,
+    perspectiveHandle: {resource: DocumentResource; perspective?: unknown},
   ) => StateSource<string | string[]>,
-  shouldSuspend: (instance: SanityInstance, options: PerspectiveHandle): boolean =>
+  shouldSuspend: (instance: SanityInstance, options: {resource: DocumentResource}): boolean =>
     getPerspectiveState(instance, options).getCurrent() === undefined,
-  suspender: (instance: SanityInstance, _options?: PerspectiveHandle) =>
-    firstValueFrom(getActiveReleasesState(instance).observable.pipe(filter(Boolean))),
+  suspender: (instance: SanityInstance, _options?: {resource: DocumentResource}) =>
+    firstValueFrom(getPerspectiveState(instance, _options).observable.pipe(filter(Boolean))),
 })
+
+/**
+ * @public
+ * @function
+ */
+export const usePerspective: UsePerspective = (options: ResourceHandle | undefined) => {
+  const normalizedOptions = useNormalizedResourceOptions(options ?? {})
+  return usePerspectiveValue(normalizedOptions)
+}

package/src/hooks/users/useUser.test.tsx

@@ -88,7 +88,7 @@ describe('useUser', () => {
     }
 
     render(
-      <ResourceProvider projectId="p" fallback={null}>
+      <ResourceProvider resource={{projectId: 'p', dataset: 'production'}} fallback={null}>
         <TestComponent />
       </ResourceProvider>,
     )
@@ -340,7 +340,10 @@ describe('useUser', () => {
     }
 
     render(
-      <ResourceProvider projectId="test-project" fallback={null}>
+      <ResourceProvider
+        resource={{projectId: 'test-project', dataset: 'production'}}
+        fallback={null}
+      >
         <TestComponent />
       </ResourceProvider>,
     )
@@ -387,7 +390,10 @@ describe('useUser', () => {
     }
 
     render(
-      <ResourceProvider projectId="test-project" fallback={null}>
+      <ResourceProvider
+        resource={{projectId: 'test-project', dataset: 'production'}}
+        fallback={null}
+      >
         <WrapperComponent />
       </ResourceProvider>,
     )

package/src/hooks/users/useUser.ts

@@ -58,7 +58,7 @@ export interface UserResult {
  * ```
  */
 export function useUser(options: GetUserOptions): UserResult {
-  const instance = useSanityInstance(options)
+  const instance = useSanityInstance()
   // Use React's useTransition to avoid UI jank when user options change
   const [isPending, startTransition] = useTransition()
 

package/src/hooks/users/useUsers.test.tsx

@@ -313,7 +313,10 @@ describe('useUsers', () => {
     }
 
     render(
-      <ResourceProvider projectId="p" fallback={<div data-testid="fallback">Loading...</div>}>
+      <ResourceProvider
+        resource={{projectId: 'p', dataset: 'production'}}
+        fallback={<div data-testid="fallback">Loading...</div>}
+      >
         <TestComponent />
       </ResourceProvider>,
     )
@@ -327,7 +330,7 @@ describe('useUsers', () => {
 
     // Verify that loadMoreUsers was called with the correct arguments
     expect(loadMoreUsers).toHaveBeenCalledWith(
-      expect.objectContaining({config: {projectId: 'p'}}),
+      expect.objectContaining({instanceId: expect.any(String)}),
       {
         resourceType: 'organization',
         organizationId: 'test-org',

package/src/hooks/users/useUsers.ts

@@ -68,7 +68,7 @@ export interface UsersResult {
  * ```
  */
 export function useUsers(options?: GetUsersOptions): UsersResult {
-  const instance = useSanityInstance(options)
+  const instance = useSanityInstance()
   // Use React's useTransition to avoid UI jank when user options change
   const [isPending, startTransition] = useTransition()
 

package/src/context/SourcesContext.tsx

@@ -1,7 +0,0 @@
-import {type DocumentSource} from '@sanity/sdk'
-import {createContext} from 'react'
-
-/** Context for sources.
- * @beta
- */
-export const SourcesContext = createContext<Record<string, DocumentSource>>({})