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

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

@@ -1,7 +1,7 @@
 import {type SanityInstance} from '@sanity/sdk'
+import {renderHook} from '@testing-library/react'
 import {describe, expect, it, vi} from 'vitest'
 
-import {renderHook} from '../../../test/test-utils'
 import {ResourceProvider} from '../../context/ResourceProvider'
 import {createCallbackHook} from './createCallbackHook'
 
@@ -21,7 +21,13 @@ describe('createCallbackHook', () => {
     const useTestHook = createCallbackHook(testCallback)
 
     // Render the hook
-    const {result, rerender} = renderHook(() => useTestHook())
+    const {result, rerender} = renderHook(() => useTestHook(), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="p" dataset="d" fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
 
     // Test the callback with parameters
     const result1 = result.current('test', 123)
@@ -38,17 +44,13 @@ describe('createCallbackHook', () => {
 
   it('should create new callback when instance changes', () => {
     // Create a test callback
-    const testCallback = (instance: SanityInstance) => instance.config.studio?.projectId
+    const testCallback = (instance: SanityInstance) => instance.config.projectId
 
     // Create and render our hook with first provider
     const useTestHook = createCallbackHook(testCallback)
     const {result, unmount} = renderHook(() => useTestHook(), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          studio={{projectId: 'p1'}}
-          resource={{projectId: 'p1', dataset: 'd'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="p1" dataset="d" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -64,11 +66,7 @@ describe('createCallbackHook', () => {
     // Re-render with different provider configuration
     const {result: result2} = renderHook(() => useTestHook(), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          studio={{projectId: 'p2'}}
-          resource={{projectId: 'p2', dataset: 'd'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="p2" dataset="d" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -87,7 +85,7 @@ describe('createCallbackHook', () => {
       method: string,
       data: object,
     ) => ({
-      url: `${instance.config.studio?.projectId}${path}`,
+      url: `${instance.config.projectId}${path}`,
       method,
       data,
     })
@@ -95,11 +93,7 @@ describe('createCallbackHook', () => {
     const useTestHook = createCallbackHook(testCallback)
     const {result} = renderHook(() => useTestHook(), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          studio={{projectId: 'p'}}
-          resource={{projectId: 'p', dataset: 'd'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="p" dataset="d" fallback={null}>
           {children}
         </ResourceProvider>
       ),

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

@@ -0,0 +1,180 @@
+import {createSanityInstance} from '@sanity/sdk'
+import {defineFetcher, type Fetcher, type FetcherSnapshot} from '@sanity/sdk/_internal'
+import {renderHook} from '@testing-library/react'
+import {of, throwError} from 'rxjs'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+import {createFetcherHook} from './createFetcherHook'
+
+vi.mock('../context/useSanityInstance', () => ({
+  useSanityInstance: vi.fn(),
+}))
+
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+
+const makeFetcher = (snapshot: FetcherSnapshot<string>): Fetcher<[id: string], string> => {
+  const fetcher = {
+    getState: vi.fn(() => ({
+      subscribe: vi.fn(() => () => {}),
+      getCurrent: () => snapshot,
+      observable: throwError(() => new Error('unexpected usage of observable')),
+    })),
+    resolveState: vi.fn(() => Promise.resolve('resolved')),
+    refetch: vi.fn(() => Promise.resolve('refetched')),
+    invalidate: vi.fn(),
+    invalidateAll: vi.fn(),
+    setData: vi.fn(() => ({undo: vi.fn()})),
+  }
+  return fetcher as unknown as Fetcher<[id: string], string>
+}
+
+const success: FetcherSnapshot<string> = {
+  status: 'success',
+  data: 'DATA',
+  error: undefined,
+  isFetching: false,
+  dataUpdatedAt: 1,
+}
+
+describe('createFetcherHook', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(useSanityInstance).mockReturnValue(instance)
+  })
+
+  it('returns {data, isFetching, error, refetch} from a success snapshot', () => {
+    const fetcher = makeFetcher(success)
+    const useThing = createFetcherHook(fetcher)
+    const {result} = renderHook(() => useThing('a'))
+
+    expect(result.current.data).toBe('DATA')
+    expect(result.current.isFetching).toBe(false)
+    expect(result.current.error).toBeUndefined()
+    expect(typeof result.current.refetch).toBe('function')
+  })
+
+  it('surfaces isFetching and the background error on the success arm', () => {
+    const boom = new Error('background')
+    const fetcher = makeFetcher({...success, isFetching: true, error: boom})
+    const useThing = createFetcherHook(fetcher)
+    const {result} = renderHook(() => useThing('a'))
+
+    expect(result.current.isFetching).toBe(true)
+    expect(result.current.error).toBe(boom)
+  })
+
+  it('refetch() calls the fetcher with the instance and params', () => {
+    const fetcher = makeFetcher(success)
+    const useThing = createFetcherHook(fetcher)
+    const {result} = renderHook(() => useThing('a'))
+
+    const returned = result.current.refetch()
+
+    expect(fetcher.refetch).toHaveBeenCalledWith(instance, 'a')
+    expect(returned).toBeInstanceOf(Promise)
+  })
+
+  it('suspends on a pending snapshot by throwing resolveState', () => {
+    const fetcher = makeFetcher({
+      status: 'pending',
+      data: undefined,
+      error: undefined,
+      isFetching: true,
+      dataUpdatedAt: undefined,
+    })
+    const useThing = createFetcherHook(fetcher)
+    const {result} = renderHook(() => {
+      try {
+        return useThing('a')
+      } catch (thrown) {
+        return thrown
+      }
+    })
+
+    expect(fetcher.resolveState).toHaveBeenCalledWith(instance, 'a')
+    expect(result.current).toBe(vi.mocked(fetcher.resolveState).mock.results[0]!.value)
+  })
+
+  it('throws the error arm to the error boundary', () => {
+    const boom = new Error('fatal')
+    const fetcher = makeFetcher({
+      status: 'error',
+      data: undefined,
+      error: boom,
+      isFetching: false,
+      dataUpdatedAt: undefined,
+    })
+    const useThing = createFetcherHook(fetcher)
+    const {result} = renderHook(() => {
+      try {
+        return useThing('a')
+      } catch (thrown) {
+        return thrown
+      }
+    })
+
+    expect(result.current).toBe(boom)
+  })
+
+  // Regression: the mocked fetcher above can never reproduce the real bug — its
+  // `getCurrent` returns a fixed snapshot object. A real fetcher store replaces
+  // the cache entry on every (un)subscribe, so `getCurrent` yields a new snapshot
+  // reference each time. Feeding that straight through `useSyncExternalStore`
+  // makes React see the store "change" on every commit and re-render forever
+  // ("Maximum update depth exceeded", React #185).
+  it('does not re-render forever over a real fetcher store (SDK-1448)', () => {
+    const fetcher = defineFetcher<[id: string], string>({
+      name: `regression-loop-${Math.random().toString(36).slice(2)}`,
+      getKey: (_instance, id) => id,
+      fetch: () => (id) => of(`DATA:${id}`),
+    })
+    // Seed a success entry so we skip Suspense and land in useSyncExternalStore.
+    fetcher.setData(instance, ['a'], 'DATA:a')
+
+    const useThing = createFetcherHook(fetcher)
+
+    let renders = 0
+    const {result} = renderHook(() => {
+      renders += 1
+      if (renders > 25) throw new Error(`infinite render loop: ${renders} renders`)
+      return useThing('a')
+    })
+
+    expect(result.current.data).toBe('DATA:a')
+    expect(renders).toBeLessThan(25)
+  })
+
+  // The realistic case: `data` is an object, not a primitive. The store hands
+  // back a fresh snapshot object on every (un)subscribe, so the dedup must keep
+  // returning the *same* `data` reference while the entry is unchanged —
+  // otherwise consumers that key off `data` identity (memo deps, effects)
+  // re-render on every commit even though nothing changed. This is the property
+  // the snapshot-equality check guards.
+  it('keeps a stable object data reference across re-renders (SDK-1448)', () => {
+    const data = {id: 'a', title: 'Thing', tags: ['x', 'y']}
+    const fetcher = defineFetcher<[id: string], typeof data>({
+      name: `regression-object-${Math.random().toString(36).slice(2)}`,
+      getKey: (_instance, id) => id,
+      fetch: () => () => of(data),
+    })
+    fetcher.setData(instance, ['a'], data)
+
+    const useThing = createFetcherHook(fetcher)
+
+    let renders = 0
+    const seen: unknown[] = []
+    const {result} = renderHook(() => {
+      renders += 1
+      if (renders > 25) throw new Error(`infinite render loop: ${renders} renders`)
+      const value = useThing('a')
+      seen.push(value.data)
+      return value
+    })
+
+    expect(result.current.data).toBe(data)
+    expect(renders).toBeLessThan(25)
+    // Every commit observed the identical object — no churn from fresh snapshots.
+    expect(seen.every((d) => d === data)).toBe(true)
+  })
+})

package/src/hooks/helpers/createFetcherHook.ts

@@ -0,0 +1,69 @@
+import {type Fetcher, type FetcherSnapshot, isDeepEqual} from '@sanity/sdk/_internal'
+import {useRef, useSyncExternalStore} from 'react'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+
+/**
+ * The value returned by a fetcher-backed hook. The hook suspends until the
+ * first fetch succeeds, so `data` is always present once your component renders.
+ *
+ * @public
+ */
+export interface FetcherHookResult<TData> {
+  /** The resolved data. Guaranteed present — the hook suspends until the first fetch succeeds. */
+  data: TData
+  /** A fetch for this entry is in flight (background revalidation or a `refetch()`). */
+  isFetching: boolean
+  /** The most recent background-fetch failure while data still renders; cleared by the next success. */
+  error: unknown
+  /** Imperatively refetch, bypassing staleness. Resolves with the refreshed data. */
+  refetch: () => Promise<TData>
+}
+
+/**
+ * Builds a Suspense hook over a {@link Fetcher}: it suspends until the first
+ * success via the snapshot's `status`, throws the error arm to the nearest error
+ * boundary, and returns the live `{data, isFetching, error, refetch}` envelope.
+ *
+ * @internal
+ */
+export function createFetcherHook<TParams extends unknown[], TData>(
+  fetcher: Fetcher<TParams, TData>,
+): (...params: TParams) => FetcherHookResult<TData> {
+  return function useFetcherHook(...params: TParams): FetcherHookResult<TData> {
+    const instance = useSanityInstance()
+    const source = fetcher.getState(instance, ...params)
+
+    // No entry/data yet — suspend on the first fetch (matches an 'error' below never reaching here).
+    if (source.getCurrent().status === 'pending') {
+      throw fetcher.resolveState(instance, ...params)
+    }
+
+    // The store replaces its cache entry on every (un)subscribe (it bumps a
+    // subscription counter), so `getCurrent()` hands back a fresh snapshot object
+    // with identical fields on each commit. Passed raw to `useSyncExternalStore`
+    // — which compares by `Object.is` — that reads as a perpetual change and
+    // re-renders forever. Reuse the previous snapshot while its fields are
+    // unchanged so React sees a stable reference.
+    const previous = useRef<FetcherSnapshot<TData> | null>(null)
+    const snapshot = useSyncExternalStore(source.subscribe, () => {
+      const next = source.getCurrent()
+      const prev = previous.current
+      if (prev && isDeepEqual(prev, next)) return prev
+      previous.current = next
+      return next
+    })
+
+    if (snapshot.status !== 'success') {
+      // 'pending' already suspended above; 'error' surfaces to the error boundary.
+      throw snapshot.status === 'error' ? snapshot.error : fetcher.resolveState(instance, ...params)
+    }
+
+    return {
+      data: snapshot.data,
+      isFetching: snapshot.isFetching,
+      error: snapshot.error,
+      refetch: () => fetcher.refetch(instance, ...params),
+    }
+  }
+}

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

@@ -0,0 +1,125 @@
+import {createSanityInstance} from '@sanity/sdk'
+import {type MutationResult} from '@sanity/sdk/_internal'
+import {act, renderHook} from '@testing-library/react'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+import {createMutationHook} from './createMutationHook'
+
+vi.mock('../context/useSanityInstance', () => ({
+  useSanityInstance: vi.fn(),
+}))
+
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+
+const settled = <T,>(data: T): MutationResult<T> => ({data, invalidated: Promise.resolve()})
+
+describe('createMutationHook', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(useSanityInstance).mockReturnValue(instance)
+  })
+
+  it('starts idle', () => {
+    const useThing = createMutationHook(vi.fn())
+    const {result} = renderHook(() => useThing())
+
+    expect(result.current.isPending).toBe(false)
+    expect(result.current.data).toBeUndefined()
+    expect(result.current.error).toBeUndefined()
+  })
+
+  it('calls the mutation with the instance and resolves with the server data', async () => {
+    const mutation = vi.fn((_instance, input: string) =>
+      Promise.resolve(settled(`created:${input}`)),
+    )
+    const useThing = createMutationHook(mutation)
+    const {result} = renderHook(() => useThing())
+
+    let resolved: string | undefined
+    await act(async () => {
+      resolved = await result.current.mutate('a')
+    })
+
+    expect(mutation).toHaveBeenCalledWith(instance, 'a')
+    expect(resolved).toBe('created:a')
+    expect(result.current.data).toBe('created:a')
+    expect(result.current.error).toBeUndefined()
+    expect(result.current.isPending).toBe(false)
+  })
+
+  it('reports isPending while the mutation is in flight', async () => {
+    let release!: (value: MutationResult<string>) => void
+    const mutation = vi.fn(
+      () => new Promise<MutationResult<string>>((resolve) => (release = resolve)),
+    )
+    const useThing = createMutationHook(mutation)
+    const {result} = renderHook(() => useThing())
+
+    act(() => {
+      void result.current.mutate('a')
+    })
+    expect(result.current.isPending).toBe(true)
+
+    await act(async () => {
+      release(settled('done'))
+    })
+    expect(result.current.isPending).toBe(false)
+    expect(result.current.data).toBe('done')
+  })
+
+  it('rejects on failure and captures the error in state', async () => {
+    const boom = new Error('nope')
+    const mutation = vi.fn(() => Promise.reject(boom))
+    const useThing = createMutationHook(mutation)
+    const {result} = renderHook(() => useThing())
+
+    await act(async () => {
+      await expect(result.current.mutate('a')).rejects.toBe(boom)
+    })
+
+    expect(result.current.error).toBe(boom)
+    expect(result.current.data).toBeUndefined()
+    expect(result.current.isPending).toBe(false)
+  })
+
+  it('reset() returns to idle', async () => {
+    const mutation = vi.fn((_instance, input: string) => Promise.resolve(settled(input)))
+    const useThing = createMutationHook(mutation)
+    const {result} = renderHook(() => useThing())
+
+    await act(async () => {
+      await result.current.mutate('a')
+    })
+    expect(result.current.data).toBe('a')
+
+    act(() => result.current.reset())
+    expect(result.current.data).toBeUndefined()
+    expect(result.current.error).toBeUndefined()
+    expect(result.current.isPending).toBe(false)
+  })
+
+  it('only the latest call writes state, so a stale call cannot clobber it', async () => {
+    const releases: Array<(value: MutationResult<string>) => void> = []
+    const mutation = vi.fn(
+      () => new Promise<MutationResult<string>>((resolve) => releases.push(resolve)),
+    )
+    const useThing = createMutationHook(mutation)
+    const {result} = renderHook(() => useThing())
+
+    let first!: Promise<string>
+    let second!: Promise<string>
+    act(() => {
+      first = result.current.mutate('first')
+      second = result.current.mutate('second')
+    })
+
+    await act(async () => {
+      releases[1]!(settled('second-result')) // latest resolves first
+      releases[0]!(settled('first-result')) // stale resolves after
+      await Promise.all([first, second])
+    })
+
+    expect(result.current.data).toBe('second-result')
+  })
+})

package/src/hooks/helpers/createMutationHook.tsx

@@ -0,0 +1,93 @@
+import {type SanityInstance} from '@sanity/sdk'
+import {type MutationResult} from '@sanity/sdk/_internal'
+import {useCallback, useRef, useState} from 'react'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+
+/**
+ * The value returned by a mutation-backed hook. The write-side counterpart to
+ * {@link FetcherHookResult}: local `{mutate, isPending, error, data, reset}`
+ * state around a core mutation action.
+ *
+ * @public
+ */
+export interface MutationHookResult<TInput, TResult> {
+  /**
+   * Runs the mutation. Resolves with the server response; rejects on failure
+   * (the failure is also captured in {@link MutationHookResult.error}, so a
+   * fire-and-forget caller should read `error` and an `await`ing caller should
+   * `try`/`catch`).
+   */
+  mutate: (input: TInput) => Promise<TResult>
+  /** A mutation is currently in flight. */
+  isPending: boolean
+  /** The most recent failure; cleared by the next `mutate` or `reset`. */
+  error: unknown
+  /** The last successful server response, or `undefined` before the first success. */
+  data: TResult | undefined
+  /** Clears state back to idle and abandons any in-flight result. */
+  reset: () => void
+}
+
+type MutationState<TResult> =
+  | {status: 'idle'; data: undefined; error: undefined}
+  | {status: 'pending'; data: TResult | undefined; error: undefined}
+  | {status: 'success'; data: TResult; error: undefined}
+  | {status: 'error'; data: TResult | undefined; error: unknown}
+
+/**
+ * Builds a hook over a core mutation action (the result of `defineMutation`).
+ * The write-side counterpart to {@link createFetcherHook}: it binds the action
+ * to the current {@link SanityInstance} and tracks `{isPending, error, data}`
+ * locally. `mutate` resolves with the server response only — the mutation's
+ * `invalidated` promise is intentionally not exposed, since cache
+ * reconciliation is handled by the fetcher stores.
+ *
+ * @internal
+ */
+export function createMutationHook<TInput, TResult>(
+  mutation: (instance: SanityInstance, input: TInput) => Promise<MutationResult<TResult>>,
+): () => MutationHookResult<TInput, TResult> {
+  const idle: MutationState<TResult> = {status: 'idle', data: undefined, error: undefined}
+
+  return function useMutationHook(): MutationHookResult<TInput, TResult> {
+    const instance = useSanityInstance()
+    const [state, setState] = useState<MutationState<TResult>>(idle)
+    // Increments per call; only the latest call is allowed to write state, so an
+    // earlier in-flight mutation can't clobber a later one (or a `reset`).
+    const callId = useRef(0)
+
+    const mutate = useCallback(
+      (input: TInput): Promise<TResult> => {
+        const id = ++callId.current
+        setState((prev) => ({status: 'pending', data: prev.data, error: undefined}))
+        return mutation(instance, input).then(
+          ({data}) => {
+            if (id === callId.current) setState({status: 'success', data, error: undefined})
+            return data
+          },
+          (error: unknown) => {
+            if (id === callId.current) {
+              setState((prev) => ({status: 'error', data: prev.data, error}))
+            }
+            throw error
+          },
+        )
+      },
+      [instance],
+    )
+
+    const reset = useCallback(() => {
+      callId.current++ // abandon any in-flight response so it can't revive stale state
+      setState(idle)
+    }, [])
+
+    return {
+      mutate,
+      isPending: state.status === 'pending',
+      error: state.error,
+      data: state.data,
+      reset,
+    }
+  }
+}

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

@@ -1,4 +1,4 @@
-import {createSanityInstance, type DatasetResource, type SanityInstance} from '@sanity/sdk'
+import {createSanityInstance, 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()
+    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
     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()
+    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
     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({defaultResource: {projectId: 'p1', dataset: 'd'}})
-    const mockInstance2 = createSanityInstance({defaultResource: {projectId: 'p2', dataset: 'd'}})
+    const mockInstance1 = createSanityInstance({projectId: 'p1', dataset: 'd'})
+    const mockInstance2 = createSanityInstance({projectId: 'p2', dataset: 'd'})
 
     vi.mocked(useSanityInstance).mockReturnValueOnce(mockInstance1)
 
     const stateSourceFactory = vi.fn((instance: SanityInstance) => ({
       subscribe: vi.fn(),
-      getCurrent: () => (instance.config.defaultResource as DatasetResource)?.projectId,
+      getCurrent: () => instance.config.projectId,
       observable: throwError(() => new Error('unexpected usage of observable')),
     }))
 
@@ -89,7 +89,7 @@ describe('createStateSourceHook', () => {
   })
 
   it('should handle subscription functionality', () => {
-    const mockInstance = createSanityInstance()
+    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
     vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
 
     const mockSubscribe = vi.fn()
@@ -110,7 +110,7 @@ describe('createStateSourceHook', () => {
   })
 
   it('should handle multiple parameters', () => {
-    const mockInstance = createSanityInstance()
+    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
     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()
+    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
     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()
+    const mockInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
     vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
 
     const mockState = {value: 'test'}

package/src/hooks/helpers/createStateSourceHook.tsx

@@ -1,4 +1,4 @@
-import {type SanityInstance, type StateSource} from '@sanity/sdk'
+import {type SanityConfig, type SanityInstance, type StateSource} from '@sanity/sdk'
 import {useSyncExternalStore} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
@@ -12,6 +12,7 @@ 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>(