@sanity/sdk 2.6.0 → 2.7.0

package/src/releases/getPerspectiveState.test.ts

@@ -2,14 +2,13 @@ import {filter, firstValueFrom, of, Subject, take} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
 
 import {type PerspectiveHandle, type ReleasePerspective} from '../config/sanityConfig'
+import {getQueryState} from '../query/queryStore'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {listenQuery as mockListenQuery} from '../utils/listenQuery'
+import {type StateSource} from '../store/createStateSourceAction'
 import {getPerspectiveState} from './getPerspectiveState'
 import {type ReleaseDocument} from './releasesStore'
 
-vi.mock('../utils/listenQuery', () => ({
-  listenQuery: vi.fn(),
-}))
+vi.mock('../query/queryStore')
 
 vi.mock('../client/clientStore', () => ({
   getClientState: vi.fn(() => ({
@@ -21,7 +20,7 @@ vi.mock('../client/clientStore', () => ({
 
 describe('getPerspectiveState', () => {
   let instance: SanityInstance
-  let mockReleasesQuerySubject: Subject<ReleaseDocument[]>
+  let mockReleasesQuerySubject: Subject<ReleaseDocument[] | undefined>
 
   const release1 = {
     _id: 'release-1',
@@ -44,8 +43,12 @@ describe('getPerspectiveState', () => {
   beforeEach(() => {
     instance = createSanityInstance({projectId: 'test', dataset: 'test'})
 
-    mockReleasesQuerySubject = new Subject<ReleaseDocument[]>()
-    vi.mocked(mockListenQuery).mockReturnValue(mockReleasesQuerySubject.asObservable())
+    mockReleasesQuerySubject = new Subject<ReleaseDocument[] | undefined>()
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: mockReleasesQuerySubject.asObservable(),
+    } as StateSource<ReleaseDocument[] | undefined>)
   })
 
   afterEach(() => {
@@ -95,7 +98,7 @@ describe('getPerspectiveState', () => {
         take(1),
       ),
     )
-    expect(perspective).toEqual(['drafts', 'release1'])
+    expect(perspective).toEqual(['release1', 'drafts'])
   })
 
   it('should calculate perspective including multiple releases up to the specified releaseName', async () => {
@@ -108,13 +111,13 @@ describe('getPerspectiveState', () => {
         take(1),
       ),
     )
-    expect(perspective).toEqual(['drafts', 'release1', 'release2'])
+    expect(perspective).toEqual(['release2', 'release1', 'drafts'])
   })
 
   it('should filter excluded perspectives', async () => {
     const perspectiveConfig: ReleasePerspective = {
       releaseName: 'release2',
-      excludedPerspectives: ['drafts', 'release1'],
+      excludedPerspectives: ['release1', 'drafts'],
     }
     const options: PerspectiveHandle = {perspective: perspectiveConfig}
     const state = getPerspectiveState(instance, options)
@@ -159,7 +162,7 @@ describe('getPerspectiveState', () => {
     const state2 = getPerspectiveState(instance, options2)
     const perspective2 = state2.getCurrent()
 
-    expect(perspective2).toEqual(['drafts', 'release1'])
+    expect(perspective2).toEqual(['release1', 'drafts'])
   })
 
   it('should handle changes in activeReleases (cache test)', async () => {
@@ -173,7 +176,7 @@ describe('getPerspectiveState', () => {
         take(1),
       ),
     )
-    expect(perspective1).toEqual(['drafts', 'release1'])
+    expect(perspective1).toEqual(['release1', 'drafts'])
 
     const updatedActiveReleases = [release1]
     mockReleasesQuerySubject.next(updatedActiveReleases)
@@ -184,10 +187,10 @@ describe('getPerspectiveState', () => {
         take(1),
       ),
     )
-    expect(perspectiveAfterUpdate).toEqual(['drafts', 'release1'])
+    expect(perspectiveAfterUpdate).toEqual(['release1', 'drafts'])
 
     const state2 = getPerspectiveState(instance, options)
     const perspectiveNewCall = state2.getCurrent()
-    expect(perspectiveNewCall).toEqual(['drafts', 'release1'])
+    expect(perspectiveNewCall).toEqual(['release1', 'drafts'])
   })
 })

package/src/releases/getPerspectiveState.ts

@@ -1,17 +1,20 @@
 import {createSelector} from 'reselect'
 
-import {type PerspectiveHandle, type ReleasePerspective} from '../config/sanityConfig'
-import {bindActionByDataset} from '../store/createActionBinder'
+import {type PerspectiveHandle} from '../config/sanityConfig'
+import {bindActionByDataset, type BoundStoreAction} from '../store/createActionBinder'
 import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
+/*
+ * Although this is an import dependency cycle, it is not a logical cycle:
+ * 1. getPerspectiveState uses releasesStore as a data source
+ * 2. releasesStore uses queryStore as a data source
+ * 3. queryStore calls getPerspectiveState for computing release perspectives
+ * 4. however, queryStore does not use getPerspectiveState for the perspective used in releasesStore ("raw")
+ */
+// eslint-disable-next-line import/no-cycle
 import {releasesStore, type ReleasesStoreState} from './releasesStore'
+import {isReleasePerspective} from './utils/isReleasePerspective'
 import {sortReleases} from './utils/sortReleases'
 
-function isReleasePerspective(
-  perspective: PerspectiveHandle['perspective'],
-): perspective is ReleasePerspective {
-  return typeof perspective === 'object' && perspective !== null && 'releaseName' in perspective
-}
-
 const DEFAULT_PERSPECTIVE = 'drafts'
 
 // Cache for options
@@ -50,6 +53,44 @@ const memoizedOptionsSelector = createSelector(
   },
 )
 
+// Lazily bind the action itself to avoid circular import initialization issues with `releasesStore`
+const _getPerspectiveStateSelector = createStateSourceAction({
+  selector: createSelector(
+    [selectInstancePerspective, selectActiveReleases, memoizedOptionsSelector],
+    (instancePerspective, activeReleases, memoizedOptions) => {
+      const perspective = memoizedOptions?.perspective ?? instancePerspective ?? DEFAULT_PERSPECTIVE
+
+      if (!isReleasePerspective(perspective)) return perspective
+
+      // if there are no active releases we can't compute the release perspective
+      if (!activeReleases || activeReleases.length === 0) return undefined
+
+      const releaseNames = sortReleases(activeReleases).map((release) => release.name)
+      const index = releaseNames.findIndex((name) => name === perspective.releaseName)
+
+      if (index < 0) {
+        throw new Error(`Release "${perspective.releaseName}" not found in active releases`)
+      }
+
+      const filteredReleases = releaseNames.slice(0, index + 1) // Include the release itself
+
+      return ['drafts', ...filteredReleases]
+        .filter((name) => !perspective.excludedPerspectives?.includes(name))
+        .reverse()
+    },
+  ),
+})
+
+type OmitFirst<T extends unknown[]> = T extends [unknown, ...infer R] ? R : never
+type SelectorParams = OmitFirst<Parameters<typeof _getPerspectiveStateSelector>>
+type BoundGetPerspectiveState = BoundStoreAction<
+  ReleasesStoreState,
+  SelectorParams,
+  ReturnType<typeof _getPerspectiveStateSelector>
+>
+
+let _boundGetPerspectiveState: BoundGetPerspectiveState | undefined
+
 /**
  * Provides a subscribable state source for a "perspective" for the Sanity client,
  * which is used to fetch documents as though certain Content Releases are active.
@@ -62,33 +103,12 @@ const memoizedOptionsSelector = createSelector(
  *
  * @public
  */
-export const getPerspectiveState = bindActionByDataset(
-  releasesStore,
-  createStateSourceAction({
-    selector: createSelector(
-      [selectInstancePerspective, selectActiveReleases, memoizedOptionsSelector],
-      (instancePerspective, activeReleases, memoizedOptions) => {
-        const perspective =
-          memoizedOptions?.perspective ?? instancePerspective ?? DEFAULT_PERSPECTIVE
-
-        if (!isReleasePerspective(perspective)) return perspective
-
-        // if there are no active releases we can't compute the release perspective
-        if (!activeReleases || activeReleases.length === 0) return undefined
-
-        const releaseNames = sortReleases(activeReleases).map((release) => release.name)
-        const index = releaseNames.findIndex((name) => name === perspective.releaseName)
-
-        if (index < 0) {
-          throw new Error(`Release "${perspective.releaseName}" not found in active releases`)
-        }
-
-        const filteredReleases = releaseNames.slice(0, index + 1) // Include the release itself
-
-        return ['drafts', ...filteredReleases].filter(
-          (name) => !perspective.excludedPerspectives?.includes(name),
-        )
-      },
-    ),
-  }),
-)
+export const getPerspectiveState: BoundGetPerspectiveState = (...args) => {
+  if (!_boundGetPerspectiveState) {
+    _boundGetPerspectiveState = bindActionByDataset(
+      releasesStore,
+      _getPerspectiveStateSelector,
+    ) as BoundGetPerspectiveState
+  }
+  return _boundGetPerspectiveState(...args)
+}

package/src/releases/releasesStore.test.ts

@@ -1,45 +1,47 @@
-import {type SanityClient} from '@sanity/client'
-import {of, Subject} from 'rxjs'
+import {NEVER, Observable, type Observer, of, Subject} from 'rxjs'
 import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {getClientState} from '../client/clientStore'
+import {getQueryState, resolveQuery} from '../query/queryStore'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
-import {listenQuery} from '../utils/listenQuery'
 import {getActiveReleasesState, type ReleaseDocument} from './releasesStore'
 
 // Mock dependencies
-vi.mock('../client/clientStore', () => ({
-  getClientState: vi.fn(),
-}))
-vi.mock('../utils/listenQuery', () => ({
-  listenQuery: vi.fn(),
-}))
-
-// Mock console.error to prevent test runner noise and allow verification
-let consoleErrorSpy: ReturnType<typeof vi.spyOn>
+vi.mock('../query/queryStore')
 
 describe('releasesStore', () => {
   let instance: SanityInstance
-  const mockClient = {} as SanityClient
 
   beforeEach(() => {
-    vi.resetAllMocks()
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    vi.clearAllMocks()
 
     instance = createSanityInstance({projectId: 'test', dataset: 'test'})
 
-    vi.mocked(getClientState).mockReturnValue({
-      observable: of(mockClient),
-    } as StateSource<SanityClient>)
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: NEVER as Observable<ReleaseDocument[] | undefined>,
+    } as StateSource<ReleaseDocument[] | undefined>)
+
+    vi.mocked(resolveQuery).mockResolvedValue(undefined)
   })
 
   afterEach(() => {
     instance.dispose()
-    consoleErrorSpy.mockRestore()
   })
 
-  it('should set active releases state when listenQuery succeeds', async () => {
+  it('should set active releases state when the releases query emits', async () => {
+    const teardown = vi.fn()
+    const subscriber = vi
+      .fn<(observer: Observer<ReleaseDocument[] | undefined>) => () => void>()
+      .mockReturnValue(teardown)
+
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: new Observable(subscriber),
+    } as StateSource<ReleaseDocument[] | undefined>)
+
     // note that the order of the releases is important here -- they get sorted
     const mockReleases: ReleaseDocument[] = [
       {
@@ -56,21 +58,24 @@ describe('releasesStore', () => {
       } as ReleaseDocument,
     ]
 
-    vi.mocked(listenQuery).mockReturnValue(of(mockReleases))
-
     const state = getActiveReleasesState(instance)
 
+    const [observer] = subscriber.mock.lastCall!
+
+    observer.next(mockReleases)
+
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     expect(state.getCurrent()).toEqual(mockReleases.reverse())
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
-
-    vi.useRealTimers()
   })
 
-  it('should update active releases state when listenQuery emits new data', async () => {
+  it('should update active releases state when the query emits new data', async () => {
     const releasesSubject = new Subject<ReleaseDocument[]>()
-    vi.mocked(listenQuery).mockReturnValue(releasesSubject.asObservable())
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: releasesSubject.asObservable(),
+    } as StateSource<ReleaseDocument[] | undefined>)
 
     const state = getActiveReleasesState(instance)
 
@@ -109,65 +114,58 @@ describe('releasesStore', () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     expect(state.getCurrent()).toEqual(updatedReleases.reverse())
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
   })
 
-  it('should handle empty array from listenQuery', async () => {
-    // Configure listenQuery to return an empty array
-    vi.mocked(listenQuery).mockReturnValue(of([]))
+  it('should handle empty array from the query', async () => {
+    // Configure query to return an empty array
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => [],
+      observable: of([]),
+    } as StateSource<ReleaseDocument[] | undefined>)
 
     const state = getActiveReleasesState(instance)
 
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     expect(state.getCurrent()).toEqual([]) // Should be set to empty array
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
   })
 
-  it('should handle null/undefined from listenQuery by defaulting to empty array', async () => {
+  it('should handle null/undefined from the query by defaulting to empty array', async () => {
     // Test null case
-    vi.mocked(listenQuery).mockReturnValue(of(null))
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => null as unknown as ReleaseDocument[] | undefined,
+      observable: of(null as unknown as ReleaseDocument[] | undefined),
+    } as StateSource<ReleaseDocument[] | undefined>)
     const state = getActiveReleasesState(instance)
     await new Promise((resolve) => setTimeout(resolve, 0))
     expect(state.getCurrent()).toEqual([])
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
 
     // Test undefined case
-    vi.mocked(listenQuery).mockReturnValue(of(undefined))
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: of(undefined),
+    } as StateSource<ReleaseDocument[] | undefined>)
     await new Promise((resolve) => setTimeout(resolve, 0))
     expect(state.getCurrent()).toEqual([])
-    expect(consoleErrorSpy).not.toHaveBeenCalled()
   })
 
-  it('should handle errors from listenQuery by retrying and eventually setting error state', async () => {
-    vi.useFakeTimers()
-    const error = new Error('Query failed')
+  it('should not crash when the releases query errors', async () => {
     const subject = new Subject<ReleaseDocument[]>()
-    vi.mocked(listenQuery).mockReturnValue(subject.asObservable())
+    vi.mocked(getQueryState).mockReturnValue({
+      subscribe: () => () => {},
+      getCurrent: () => undefined,
+      observable: subject.asObservable(),
+    } as StateSource<ReleaseDocument[] | undefined>)
 
-    // initialize the store
     const state = getActiveReleasesState(instance)
 
-    // Error the subject
-    subject.error(error)
-
-    // Advance enough to cover the retry attempts (exponential backoff: 1s, 2s, 4s)
-    for (let i = 0; i < 3; i++) {
-      const delay = Math.pow(2, i) * 1000
-      await vi.advanceTimersByTimeAsync(delay)
-    }
+    subject.error(new Error('Query failed'))
 
-    // Verify error was logged at least once during retries
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      '[releases] Error in subscription:',
-      error,
-      'Retry count:',
-      expect.any(Number),
-    )
+    await new Promise((resolve) => setTimeout(resolve, 0))
 
-    // not sure how to test state.setError()
     expect(state.getCurrent()).toEqual(undefined)
-
-    vi.useRealTimers()
   })
 })

package/src/releases/releasesStore.ts

@@ -1,15 +1,22 @@
-import {type SanityClient} from '@sanity/client'
 import {type SanityDocument} from '@sanity/types'
-import {catchError, EMPTY, retry, switchMap, timer} from 'rxjs'
+import {map} from 'rxjs'
 
-import {getClientState} from '../client/clientStore'
+/*
+ * Although this is an import dependency cycle, it is not a logical cycle:
+ * 1. releasesStore uses queryStore as a data source
+ * 2. queryStore calls getPerspectiveState for computing release perspectives
+ * 3. getPerspectiveState uses releasesStore as a data source
+ * 4. however, queryStore does not use getPerspectiveState for the perspective used in releasesStore ("raw")
+ */
+// eslint-disable-next-line import/no-cycle
+import {getQueryState} from '../query/queryStore'
 import {bindActionByDataset, type BoundDatasetKey} from '../store/createActionBinder'
 import {createStateSourceAction} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
-import {listenQuery} from '../utils/listenQuery'
 import {sortReleases} from './utils/sortReleases'
 
 const ARCHIVED_RELEASE_STATES = ['archived', 'published']
+const STABLE_EMPTY_RELEASES: ReleaseDocument[] = []
 
 /**
  * Represents a document in a Sanity dataset that represents release options.
@@ -55,51 +62,30 @@ export const getActiveReleasesState = bindActionByDataset(
 )
 
 const RELEASES_QUERY = 'releases::all()'
-const QUERY_PARAMS = {}
 
 const subscribeToReleases = ({
   instance,
   state,
   key: {projectId, dataset},
 }: StoreContext<ReleasesStoreState, BoundDatasetKey>) => {
-  return getClientState(instance, {
-    apiVersion: '2025-04-10',
+  const {observable: releases$} = getQueryState<ReleaseDocument[]>(instance, {
+    query: RELEASES_QUERY,
     perspective: 'raw',
     projectId,
     dataset,
+    tag: 'releases',
   })
-    .observable.pipe(
-      switchMap((client: SanityClient) =>
-        // releases are system documents, and are not supported by useQueryState
-        listenQuery<ReleaseDocument[]>(client, RELEASES_QUERY, QUERY_PARAMS, {
-          tag: 'releases-listener',
-          throttleTime: 1000,
-          transitions: ['update', 'appear', 'disappear'],
-        }).pipe(
-          retry({
-            count: 3,
-            delay: (error, retryCount) => {
-              // eslint-disable-next-line no-console
-              console.error('[releases] Error in subscription:', error, 'Retry count:', retryCount)
-              return timer(Math.min(1000 * Math.pow(2, retryCount), 10000))
-            },
-          }),
-          catchError((error) => {
-            state.set('setError', {error})
-            return EMPTY
-          }),
-        ),
-      ),
-    )
-    .subscribe({
-      next: (releases) => {
+  return releases$
+    .pipe(
+      map((releases) => {
         // logic here mirrors that of studio:
         // https://github.com/sanity-io/sanity/blob/156e8fa482703d99219f08da7bacb384517f1513/packages/sanity/src/core/releases/store/useActiveReleases.ts#L29
         state.set('setActiveReleases', {
-          activeReleases: sortReleases(releases ?? [])
+          activeReleases: sortReleases(releases ?? STABLE_EMPTY_RELEASES)
             .filter((release) => !ARCHIVED_RELEASE_STATES.includes(release.state))
             .reverse(),
         })
-      },
-    })
+      }),
+    )
+    .subscribe({error: (error) => state.set('setError', {error})})
 }

package/src/releases/utils/isReleasePerspective.ts

@@ -0,0 +1,7 @@
+import {type PerspectiveHandle, type ReleasePerspective} from '../../config/sanityConfig'
+
+export const isReleasePerspective = (
+  perspective: PerspectiveHandle['perspective'],
+): perspective is ReleasePerspective => {
+  return typeof perspective === 'object' && perspective !== null && 'releaseName' in perspective
+}