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

package/src/hooks/query/useQuery.ts

@@ -5,21 +5,100 @@ 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 {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
+import {
+  useNormalizedResourceOptions,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
+import {trackHookUsage} from '../helpers/useTrackHookUsage'
+/**
+ * Hook options for useQuery, supporting both direct resource and resourceName.
+ * @beta
+ */
+type UseQueryOptions<
+  TQuery extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+> = WithResourceNameSupport<QueryOptions<TQuery, TDataset, TProjectId>>
 
-/** Options for useQuery: QueryOptions with resource made optional (resolved from context) */
-type ReactQueryOptions = Omit<QueryOptions, 'resource' | 'resourceName'> & ResourceHandle
+// 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
+}
 
-// Overload 1: Explicit Type Provided
+// Overload 2: 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`, `resource`, etc.
+ * @param options - Configuration for the query, including `query`, optional `params`, `projectId`, `dataset`, 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
@@ -43,7 +122,7 @@ type ReactQueryOptions = Omit<QueryOptions, 'resource' | 'resourceName'> & Resou
  * }
  * ```
  */
-export function useQuery<TData>(options: ReactQueryOptions): {
+export function useQuery<TData>(options: WithResourceNameSupport<QueryOptions>): {
   /** 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) */
@@ -63,16 +142,18 @@ export function useQuery<TData>(options: ReactQueryOptions): {
  * - 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: ReactQueryOptions): {
+export function useQuery(options: WithResourceNameSupport<QueryOptions>): {
   data: unknown
   isPending: boolean
 } {
   // Implementation returns unknown, overloads define specifics
   const instance = useSanityInstance()
+  trackHookUsage(instance, 'useQuery')
 
   // Normalize options: resolve resourceName to resource and strip resourceName
   const normalized = useNormalizedResourceOptions(options)
@@ -123,11 +204,12 @@ export function useQuery(options: ReactQueryOptions): {
     const currentSignal = ref.current.signal
     const deferred = parseQueryKey(deferredQueryKey)
 
+    // eslint-disable-next-line react-hooks/refs -- intentional during suspended render; see comment above.
     throw resolveQuery(instance, {...deferred, signal: currentSignal})
   }
 
   // Subscribe to updates and get the current data
   // useSyncExternalStore ensures the component re-renders when the data changes
-  const data = useSyncExternalStore(subscribe, getCurrent) as unknown
+  const data = useSyncExternalStore(subscribe, getCurrent) as SanityQueryResult
   return useMemo(() => ({data, isPending}), [data, isPending])
 }

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

@@ -20,14 +20,14 @@ describe('useActiveReleases', () => {
     vi.clearAllMocks()
   })
 
-  it('should suspend when initial state is undefined', () => {
+  it('suspends until the releases state source emits, then resolves with the data', async () => {
     const mockSubject = new BehaviorSubject<ReleaseDocument[] | undefined>(undefined)
     const mockStateSource = {
       subscribe: vi.fn((callback) => {
         const subscription = mockSubject.subscribe(callback)
         return () => subscription.unsubscribe()
       }),
-      getCurrent: vi.fn(() => undefined),
+      getCurrent: vi.fn(() => mockSubject.getValue()),
       observable: mockSubject,
     }
 
@@ -43,22 +43,28 @@ describe('useActiveReleases', () => {
       },
       {
         wrapper: ({children}) => (
-          <ResourceProvider resource={{projectId: 'p', dataset: 'd'}} fallback={<p>Loading...</p>}>
+          <ResourceProvider projectId="p" dataset="d" fallback={<p>Loading...</p>}>
             {children}
           </ResourceProvider>
         ),
       },
     )
 
-    // Verify that the hook threw a promise (suspended)
     expect(result.current).toBeInstanceOf(Promise)
     expect(mockStateSource.getCurrent).toHaveBeenCalled()
+
+    const resolved: ReleaseDocument[] = [
+      {_id: 'release1', _type: 'release'} as unknown as ReleaseDocument,
+    ]
+    mockSubject.next(resolved)
+
+    await expect(result.current).resolves.toEqual(resolved)
   })
 
   it('should resolve with releases when data is available', () => {
     const mockReleases: ReleaseDocument[] = [
-      {_id: 'release1', _type: 'release'} as ReleaseDocument,
-      {_id: 'release2', _type: 'release'} as ReleaseDocument,
+      {_id: 'release1', _type: 'release'} as unknown as ReleaseDocument,
+      {_id: 'release2', _type: 'release'} as unknown as ReleaseDocument,
     ]
 
     const mockSubject = new BehaviorSubject<ReleaseDocument[]>(mockReleases)
@@ -75,7 +81,7 @@ describe('useActiveReleases', () => {
 
     const {result} = renderHook(() => useActiveReleases(), {
       wrapper: ({children}) => (
-        <ResourceProvider resource={{projectId: 'p', dataset: 'd'}} fallback={<p>Loading...</p>}>
+        <ResourceProvider projectId="p" dataset="d" fallback={<p>Loading...</p>}>
           {children}
         </ResourceProvider>
       ),

package/src/hooks/releases/useActiveReleases.ts

@@ -2,23 +2,44 @@ import {
   type DocumentResource,
   getActiveReleasesState,
   type ReleaseDocument,
+  type SanityConfig,
   type SanityInstance,
   type StateSource,
 } from '@sanity/sdk'
 import {filter, firstValueFrom} from 'rxjs'
 
-import {type ResourceHandle} from '../../config/handles'
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
-import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
+import {
+  useNormalizedResourceOptions,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
+
+type UseActiveReleasesValue = {
+  (options?: {resource?: DocumentResource}): ReleaseDocument[]
+}
+
+const useActiveReleasesValue: 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
+ *
  * Returns the active releases for the current project,
  * represented as a list of release documents.
  *
  * @returns The active releases for the current project.
- * @category Projects
+ * @category Releases
  * @example
  * ```tsx
  * import {useActiveReleases} from '@sanity/sdk-react'
@@ -26,26 +47,9 @@ import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOpti
  * const activeReleases = useActiveReleases()
  * ```
  */
-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) => {
+export function useActiveReleases(
+  options?: WithResourceNameSupport<SanityConfig> | undefined,
+): ReleaseDocument[] {
   const normalizedOptions = useNormalizedResourceOptions(options ?? {})
   return useActiveReleasesValue(normalizedOptions)
 }

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

@@ -0,0 +1,93 @@
+import {getAllReleasesState, 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 {useAllReleases} from './useAllReleases'
+
+vi.mock('@sanity/sdk', async () => {
+  const actual = await vi.importActual('@sanity/sdk')
+  return {
+    ...actual,
+    getAllReleasesState: vi.fn(),
+  }
+})
+
+describe('useAllReleases', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('suspends until the releases state source emits, then resolves with the data', async () => {
+    const mockSubject = new BehaviorSubject<ReleaseDocument[] | undefined>(undefined)
+    const mockStateSource = {
+      subscribe: vi.fn((callback) => {
+        const subscription = mockSubject.subscribe(callback)
+        return () => subscription.unsubscribe()
+      }),
+      getCurrent: vi.fn(() => mockSubject.getValue()),
+      observable: mockSubject,
+    }
+
+    vi.mocked(getAllReleasesState).mockReturnValue(mockStateSource)
+
+    const {result} = renderHook(
+      () => {
+        try {
+          return useAllReleases()
+        } catch (e) {
+          return e
+        }
+      },
+      {
+        wrapper: ({children}) => (
+          <ResourceProvider projectId="p" dataset="d" fallback={<p>Loading...</p>}>
+            {children}
+          </ResourceProvider>
+        ),
+      },
+    )
+
+    expect(result.current).toBeInstanceOf(Promise)
+    expect(mockStateSource.getCurrent).toHaveBeenCalled()
+
+    const resolved: ReleaseDocument[] = [
+      {_id: 'r-active', _type: 'system.release', state: 'active'} as ReleaseDocument,
+    ]
+    mockSubject.next(resolved)
+
+    await expect(result.current).resolves.toEqual(resolved)
+  })
+
+  it('returns every release including archived and published once loaded', () => {
+    const mockReleases: ReleaseDocument[] = [
+      {_id: 'r-active', _type: 'system.release', state: 'active'} as ReleaseDocument,
+      {_id: 'r-archived', _type: 'system.release', state: 'archived'} as ReleaseDocument,
+      {_id: 'r-published', _type: 'system.release', state: 'published'} as ReleaseDocument,
+    ]
+
+    const mockSubject = new BehaviorSubject<ReleaseDocument[]>(mockReleases)
+    const mockStateSource = {
+      subscribe: vi.fn((callback) => {
+        const subscription = mockSubject.subscribe(callback)
+        return () => subscription.unsubscribe()
+      }),
+      getCurrent: vi.fn(() => mockReleases),
+      observable: mockSubject,
+    }
+
+    vi.mocked(getAllReleasesState).mockReturnValue(mockStateSource)
+
+    const {result} = renderHook(() => useAllReleases(), {
+      wrapper: ({children}) => (
+        <ResourceProvider projectId="p" dataset="d" fallback={<p>Loading...</p>}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
+
+    expect(result.current).toEqual(mockReleases)
+    expect(mockStateSource.getCurrent).toHaveBeenCalled()
+  })
+})

package/src/hooks/releases/useAllReleases.ts

@@ -0,0 +1,62 @@
+import {
+  type DocumentResource,
+  getAllReleasesState,
+  type ReleaseDocument,
+  type SanityConfig,
+  type SanityInstance,
+  type StateSource,
+} from '@sanity/sdk'
+import {filter, firstValueFrom} from 'rxjs'
+
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {
+  useNormalizedResourceOptions,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
+
+type UseAllReleasesValue = {
+  (options?: {resource?: DocumentResource}): ReleaseDocument[]
+}
+
+const useAllReleasesValue: UseAllReleasesValue = createStateSourceHook({
+  getState: getAllReleasesState as (
+    instance: SanityInstance,
+    options?: {resource?: DocumentResource},
+  ) => StateSource<ReleaseDocument[]>,
+  shouldSuspend: (instance: SanityInstance, options?: {resource?: DocumentResource}) =>
+    getAllReleasesState(instance, options ?? {}).getCurrent() === undefined,
+  suspender: (instance: SanityInstance, options?: {resource?: DocumentResource}) =>
+    firstValueFrom(getAllReleasesState(instance, options ?? {}).observable.pipe(filter(Boolean))),
+})
+
+/**
+ * @public
+ * @function
+ *
+ * Returns every release the dataset has — including `archived`, `published`,
+ * and mid-transition states (`archiving`, `unarchiving`, `publishing`,
+ * `scheduling`).
+ *
+ * Use this hook when you're building a release-management UI (listing
+ * releases, surfacing lifecycle controls, etc.) so a release stays visible
+ * across its full lifecycle — including after it's been published or
+ * archived. For perspective / content queries, prefer
+ * {@link useActiveReleases}, which filters to releases that still affect
+ * what's queryable.
+ *
+ * @returns Every release for the current project, sorted to match the order
+ * used by {@link useActiveReleases}.
+ * @category Releases
+ * @example
+ * ```tsx
+ * import {useAllReleases} from '@sanity/sdk-react'
+ *
+ * const releases = useAllReleases()
+ * ```
+ */
+export function useAllReleases(
+  options?: WithResourceNameSupport<SanityConfig> | undefined,
+): ReleaseDocument[] {
+  const normalizedOptions = useNormalizedResourceOptions(options ?? {})
+  return useAllReleasesValue(normalizedOptions)
+}

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

@@ -0,0 +1,66 @@
+import {applyDocumentActions, createSanityInstance} from '@sanity/sdk'
+import {describe, it} from 'vitest'
+
+import {renderHook} from '../../../test/test-utils'
+import {useSanityInstance} from '../context/useSanityInstance'
+import {useApplyReleaseActions} from './useApplyReleaseActions'
+
+// Resource resolution, mismatch detection, and context fallback are covered
+// by hooks/helpers/useApplyActions.test.tsx — both this hook and
+// useApplyDocumentActions are typed wrappers over that shared implementation.
+// These tests just verify the wrapper forwards release actions through and
+// supports batching them in a single transaction.
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...original, applyDocumentActions: vi.fn()}
+})
+
+vi.mock('../context/useSanityInstance')
+
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+
+describe('useApplyReleaseActions', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    vi.mocked(useSanityInstance).mockReturnValueOnce(instance)
+  })
+
+  it('forwards a release action to applyDocumentActions with the resolved resource', () => {
+    const {result} = renderHook(() => useApplyReleaseActions())
+    result.current({type: 'release.create', releaseId: 'r1', metadata: {releaseType: 'asap'}})
+
+    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
+      actions: [
+        {
+          type: 'release.create',
+          releaseId: 'r1',
+          metadata: {releaseType: 'asap'},
+          resource: {projectId: 'test', dataset: 'test'},
+        },
+      ],
+      resource: {projectId: 'test', dataset: 'test'},
+    })
+  })
+
+  it('forwards an array of release actions as a single transaction', () => {
+    const {result} = renderHook(() => useApplyReleaseActions())
+    result.current([
+      {type: 'release.create', releaseId: 'r1', metadata: {releaseType: 'asap'}},
+      {type: 'release.publish', releaseId: 'r1'},
+    ])
+
+    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
+      actions: [
+        {
+          type: 'release.create',
+          releaseId: 'r1',
+          metadata: {releaseType: 'asap'},
+          resource: {projectId: 'test', dataset: 'test'},
+        },
+        {type: 'release.publish', releaseId: 'r1', resource: {projectId: 'test', dataset: 'test'}},
+      ],
+      resource: {projectId: 'test', dataset: 'test'},
+    })
+  })
+})

package/src/hooks/releases/useApplyReleaseActions.ts

@@ -0,0 +1,82 @@
+import {type ActionsResult, type ReleaseAction} from '@sanity/sdk'
+
+import {type ResourceHandle} from '../../config/handles'
+import {useApplyActions} from '../helpers/useApplyActions'
+
+/**
+ * @public
+ */
+interface UseApplyReleaseActions {
+  (): (action: ReleaseAction | ReleaseAction[], options?: ResourceHandle) => Promise<ActionsResult>
+}
+
+/**
+ * @public
+ *
+ * Provides a stable callback function for applying one or more release actions.
+ *
+ * This hook wraps the core `applyDocumentActions` functionality from `@sanity/sdk`,
+ * integrating it with the React component lifecycle and {@link SanityInstance}.
+ * It accepts release-lifecycle actions generated by {@link createRelease},
+ * {@link editRelease}, {@link publishRelease}, {@link scheduleRelease},
+ * {@link unscheduleRelease}, {@link archiveRelease}, {@link unarchiveRelease},
+ * and {@link deleteRelease}.
+ *
+ * Note that actions submitted via this hook will cascade to the documents in the release.
+ * For example, if you create a release and then publish it, the documents in the release will be published.
+ * If you delete a published release, the version documents will be deleted.
+ *
+ * Features:
+ * - Applies one or multiple `ReleaseAction` objects.
+ * - Supports optimistic updates for create/edit/delete: local release state
+ *   reflects changes immediately while in-flight.
+ * - Handles batching: multiple actions passed together are submitted as a
+ *   single atomic transaction.
+ *
+ * Release actions cannot be combined with `liveEdit` document actions in the
+ * same transaction. Submit them as separate transactions if you need both.
+ *
+ * @category Releases
+ * @returns A stable callback. When called with a single `ReleaseAction` or an
+ * array of `ReleaseAction`s, it returns a promise that resolves to an
+ * {@link ActionsResult}.
+ *
+ * @example Create and schedule a release
+ * ```tsx
+ * import {
+ *   createRelease,
+ *   scheduleRelease,
+ *   useApplyReleaseActions,
+ *   type ReleaseHandle,
+ * } from '@sanity/sdk-react'
+ *
+ * function ScheduleReleaseButton({release}: {release: ReleaseHandle}) {
+ *   const applyRelease = useApplyReleaseActions()
+ *
+ *   const handleSchedule = () =>
+ *     applyRelease([
+ *       createRelease(release, {title: 'Summer drop', releaseType: 'asap'}),
+ *       scheduleRelease(release, '2026-06-01T00:00:00Z'),
+ *     ])
+ *
+ *   return <button onClick={handleSchedule}>Schedule</button>
+ * }
+ * ```
+ *
+ * @example Publish a release
+ * ```tsx
+ * import {publishRelease, useApplyReleaseActions} from '@sanity/sdk-react'
+ *
+ * function PublishButton({releaseId}: {releaseId: string}) {
+ *   const applyRelease = useApplyReleaseActions()
+ *   return (
+ *     <button onClick={() => applyRelease(publishRelease({releaseId}))}>
+ *       Publish all documents in the release
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export const useApplyReleaseActions: UseApplyReleaseActions = () => {
+  return useApplyActions() as ReturnType<UseApplyReleaseActions>
+}

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

@@ -5,10 +5,11 @@ 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 {renderHook} from '../../../test/test-utils'
+import {ResourceProvider} from '../../context/ResourceProvider'
 import {usePerspective} from './usePerspective'
 
 // Mock the SDK functions
@@ -46,7 +47,7 @@ describe('usePerspective', () => {
     // Mock the active releases observable for the suspender
     const mockReleaseDoc: ReleaseDocument = {
       _id: 'release1',
-      _type: 'release',
+      _type: 'system.release',
       _createdAt: '2021-01-01T00:00:00Z',
       _updatedAt: '2021-01-01T00:00:00Z',
       _rev: 'rev1',
@@ -67,13 +68,18 @@ describe('usePerspective', () => {
     vi.mocked(getPerspectiveState).mockReturnValue(mockStateSource)
     vi.mocked(getActiveReleasesState).mockReturnValue(mockReleasesStateSource)
 
-    const {result} = renderHook(() => {
-      try {
-        return usePerspective(perspectiveHandle)
-      } catch (e) {
-        return e
-      }
-    })
+    const {result} = renderHook(
+      () => {
+        try {
+          return usePerspective(perspectiveHandle)
+        } catch (e) {
+          return e
+        }
+      },
+      {
+        wrapper: ({children}) => <ResourceProvider fallback={null}>{children}</ResourceProvider>,
+      },
+    )
 
     // Verify that the hook threw a promise (suspended)
     expect(result.current).toBeInstanceOf(Promise)
@@ -98,7 +104,9 @@ describe('usePerspective', () => {
 
     vi.mocked(getPerspectiveState).mockReturnValue(mockStateSource)
 
-    const {result} = renderHook(() => usePerspective(perspectiveHandle))
+    const {result} = renderHook(() => usePerspective(perspectiveHandle), {
+      wrapper: ({children}) => <ResourceProvider fallback={null}>{children}</ResourceProvider>,
+    })
 
     // Verify that the hook returned the perspective without suspending
     expect(result.current).toEqual(mockPerspective)