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

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

@@ -1,112 +1,59 @@
-import {getProjectsState, type SanityInstance} from '@sanity/sdk'
+import {type Project, projects, type StateSource} from '@sanity/sdk'
+import {type FetcherSnapshot} from '@sanity/sdk/_internal'
+import {type Observable} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {renderHook} from '../../../test/test-utils'
+import {useProjects} from './useProjects'
 
-// Mock dependencies
-vi.mock('@sanity/sdk', () => ({
-  getProjectsState: vi.fn(() => ({
-    getCurrent: vi.fn(() => undefined), // Mocking getCurrent to satisfy the call within shouldSuspend
-  })),
-  resolveProjects: vi.fn(),
-}))
-vi.mock('../helpers/createStateSourceHook', () => ({
-  createStateSourceHook: vi.fn(),
-}))
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...original, projects: {getState: vi.fn(), resolveState: vi.fn(), refetch: vi.fn()}}
+})
+
+const stateSource = (current: Project[] | undefined): StateSource<FetcherSnapshot<Project[]>> => {
+  const snapshot = current
+    ? {status: 'success', data: current, error: undefined, isFetching: false, dataUpdatedAt: 1}
+    : {
+        status: 'pending',
+        data: undefined,
+        error: undefined,
+        isFetching: true,
+        dataUpdatedAt: undefined,
+      }
+  return {
+    getCurrent: vi.fn(() => snapshot),
+    subscribe: vi.fn(() => () => {}),
+    get observable(): Observable<unknown> {
+      throw new Error('Not implemented')
+    },
+  } as unknown as StateSource<FetcherSnapshot<Project[]>>
+}
+
+const sanityInstance = expect.objectContaining({config: expect.any(Object)})
 
 describe('useProjects', () => {
-  // Use beforeEach to reset modules and ensure mocks are fresh for each test
   beforeEach(() => {
-    vi.resetModules()
-    // Re-mock dependencies for each test after resetModules
-    vi.mock('@sanity/sdk', () => ({
-      getProjectsState: vi.fn(() => ({
-        getCurrent: vi.fn(() => undefined),
-      })),
-      resolveProjects: vi.fn(),
-    }))
-    vi.mock('../helpers/createStateSourceHook', () => ({
-      createStateSourceHook: vi.fn(),
-    }))
-  })
-
-  it('should call createStateSourceHook with correct arguments on import', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
-    await import('./useProjects')
-
-    // Check if createStateSourceHook was called during the module evaluation (import)
-    expect(createStateSourceHook).toHaveBeenCalled()
-    expect(createStateSourceHook).toHaveBeenCalledWith(
-      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
-        // Note: getConfig is not used in useProjects
-      }),
-    )
+    vi.clearAllMocks()
+    vi.mocked(projects.getState).mockReturnValue(stateSource([{id: 'a'}] as unknown as Project[]))
   })
 
-  it('shouldSuspend should call getProjectsState and getCurrent', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
-    await import('./useProjects')
-
-    // Get the arguments passed to createStateSourceHook
-    const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
-    expect(mockCreateStateSourceHook.mock.calls.length).toBeGreaterThan(0)
-    const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
-    const shouldSuspend = createStateSourceHookArgs.shouldSuspend
-
-    // Mock instance for the test call
-    const mockInstance = {} as SanityInstance // Use specific type
-
-    // Call the shouldSuspend function with both required parameters
-    const result = shouldSuspend(mockInstance, undefined) // Pass undefined for options
-
-    // Assert that getProjectsState was called with the correct arguments
-    const mockGetProjectsState = getProjectsState as ReturnType<typeof vi.fn>
-    expect(mockGetProjectsState).toHaveBeenCalledWith(mockInstance, undefined)
-
-    // Assert that getCurrent was called on the result of getProjectsState
-    expect(mockGetProjectsState.mock.results.length).toBeGreaterThan(0)
-    const getProjectsStateMockResult = mockGetProjectsState.mock.results[0].value
-    expect(getProjectsStateMockResult.getCurrent).toHaveBeenCalled()
-
-    // Assert the result of shouldSuspend based on the mocked getCurrent value
-    expect(result).toBe(true) // Since getCurrent is mocked to return undefined
+  it('reads the projects fetcher with the passed options', () => {
+    renderHook(() => useProjects({organizationId: 'org123'}))
+    expect(projects.getState).toHaveBeenCalledWith(sanityInstance, {organizationId: 'org123'})
   })
 
-  it('should call createStateSourceHook with correct getState function signature', async () => {
-    await import('./useProjects')
-
-    const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
-    expect(mockCreateStateSourceHook).toHaveBeenCalled()
-
-    const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
-    const getState = createStateSourceHookArgs.getState
-
-    // Test that getState can handle the new options parameter
-    const mockInstance = {} as SanityInstance
-    const mockOptions = {organizationId: 'org123', includeMembers: false}
-
-    // This should not throw
-    expect(() => getState(mockInstance, mockOptions)).not.toThrow()
+  it('returns the fetcher data in the result envelope', () => {
+    const {result} = renderHook(() => useProjects())
+    expect(result.current.data).toEqual([{id: 'a'}])
+    expect(result.current.isFetching).toBe(false)
+    expect(typeof result.current.refetch).toBe('function')
   })
 
-  it('should handle different parameter combinations in shouldSuspend', async () => {
-    await import('./useProjects')
-
-    const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
-    const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
-    const shouldSuspend = createStateSourceHookArgs.shouldSuspend
-
-    const mockInstance = {} as SanityInstance
-
-    // Test with different options
-    expect(() => shouldSuspend(mockInstance, undefined)).not.toThrow()
-    expect(() => shouldSuspend(mockInstance, {organizationId: 'org123'})).not.toThrow()
-    expect(() => shouldSuspend(mockInstance, {includeMembers: false})).not.toThrow()
-    expect(() =>
-      shouldSuspend(mockInstance, {organizationId: 'org123', includeMembers: false}),
-    ).not.toThrow()
+  it('suspends via the projects fetcher until data is available', () => {
+    vi.mocked(projects.getState).mockReturnValue(stateSource(undefined))
+    vi.mocked(projects.resolveState).mockReturnValue(new Promise(() => {}))
+    renderHook(() => useProjects())
+    expect(projects.resolveState).toHaveBeenCalled()
   })
 })

package/src/hooks/projects/useProjects.ts

@@ -1,33 +1,18 @@
-import {type SanityProject} from '@sanity/client'
-import {getProjectsState, resolveProjects, type SanityInstance, type StateSource} from '@sanity/sdk'
+import {type Project, projects, type ProjectsOptions} from '@sanity/sdk'
 
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
-
-/**
- * @public
- * @category Types
- * @interface
- */
-export type ProjectWithoutMembers = Omit<SanityProject, 'members'>
-
-/**
- * @public
- * @category Types
- */
-type UseProjects = <TIncludeMembers extends boolean = false>(options?: {
-  organizationId?: string
-  includeMembers?: TIncludeMembers
-}) => TIncludeMembers extends true ? SanityProject[] : ProjectWithoutMembers[]
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
 
 /**
  * Returns metadata for each project you have access to.
  *
  * @category Projects
  * @param options - Configuration options
- * @returns An array of project metadata. If includeMembers is true, returns full SanityProject objects. Otherwise, returns ProjectWithoutMembers objects.
+ * @returns A {@link FetcherHookResult} whose `data` is an array of project
+ *   metadata. `members` is included only when `includeMembers: true`; `features`
+ *   is included unless `includeFeatures: false`.
  * @example
  * ```tsx
- * const projects = useProjects()
+ * const {data: projects} = useProjects()
  *
  * return (
  *   <select>
@@ -39,18 +24,18 @@ type UseProjects = <TIncludeMembers extends boolean = false>(options?: {
  * ```
  * @example
  * ```tsx
- * const projectsWithMembers = useProjects({ includeMembers: true })
- * const projectsWithoutMembers = useProjects({ includeMembers: false })
+ * const {data: projects} = useProjects()
+ * const {data: projectsWithFeatures} = useProjects()
+ * const {data: projectsWithMembers} = useProjects({includeMembers: true})
+ * const {data: projectsWithoutMembers} = useProjects({includeMembers: false})
+ * const {data: projectsWithoutFeatures} = useProjects({includeFeatures: false})
  * ```
  * @public
  * @function
  */
-export const useProjects: UseProjects = createStateSourceHook({
-  getState: getProjectsState as (
-    instance: SanityInstance,
-    options?: {organizationId?: string; includeMembers?: boolean},
-  ) => StateSource<SanityProject[] | ProjectWithoutMembers[]>,
-  shouldSuspend: (instance, options) =>
-    getProjectsState(instance, options).getCurrent() === undefined,
-  suspender: resolveProjects,
-}) as UseProjects
+export const useProjects = createFetcherHook(projects) as <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = true,
+>(
+  options?: ProjectsOptions<IncludeMembers, IncludeFeatures>,
+) => FetcherHookResult<Project<IncludeMembers, IncludeFeatures>[]>

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

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

package/src/hooks/query/useQuery.ts

@@ -1,25 +1,99 @@
-import {
-  getQueryKey,
-  getQueryState,
-  parseQueryKey,
-  type QueryOptions,
-  resolveQuery,
-} from '@sanity/sdk'
+import {getQueryState, type QueryOptions, resolveQuery} from '@sanity/sdk'
+import {getQueryKey, parseQueryKey} from '@sanity/sdk/_internal'
+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 +117,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 +137,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)
@@ -81,7 +157,7 @@ export function useQuery(options: ReactQueryOptions): {
   const [isPending, startTransition] = useTransition()
 
   // Get the unique key for this query and its options (using normalized options)
-  const queryKey = getQueryKey(normalized)
+  const queryKey = getQueryKey(instance, normalized)
   // Use a deferred state to avoid immediate re-renders when the query changes
   const [deferredQueryKey, setDeferredQueryKey] = useState(queryKey)
 
@@ -123,11 +199,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

@@ -1,4 +1,5 @@
 import {
+  type DatasetHandle,
   type DocumentResource,
   getActiveReleasesState,
   type ReleaseDocument,
@@ -7,18 +8,38 @@ import {
 } 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<DatasetHandle> | 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()
+  })
+})