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

package/src/query/queryStore.test.ts

@@ -1,17 +1,21 @@
-import {type LiveEvent, type SanityClient, type SyncTag} from '@sanity/client'
+import {
+  ConnectionFailedError,
+  CorsOriginError,
+  DisconnectError,
+  type LiveEvent,
+  type SanityClient,
+  type SyncTag,
+} from '@sanity/client'
 import {delay, filter, firstValueFrom, Observable, of, Subject} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {getClientState} from '../client/clientStore'
+import {LIVE_EVENTS_RETRY_DELAY} from '../client/liveEvents'
 import {isCanvasResource} from '../config/sanityConfig'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
 import {getQueryState, resolveQuery} from './queryStore'
-
-vi.mock('./queryStoreConstants', async (importOriginal) => ({
-  ...(await importOriginal<typeof import('./queryStoreConstants')>()),
-  QUERY_STATE_CLEAR_DELAY: 10,
-}))
+import {QUERY_STATE_CLEAR_DELAY} from './queryStoreConstants'
 
 vi.mock('../client/clientStore', () => ({
   getClientState: vi.fn(),
@@ -34,6 +38,14 @@ vi.mock('../releases/getPerspectiveState', async () => {
   }
 })
 
+// With fake timers, an emission gated on a pending rxjs delay or cleanup
+// timeout never arrives on its own: create the promise first, advance the
+// clock, then await it.
+async function advanceAndAwait<T>(promise: Promise<T>, ms = 0): Promise<T> {
+  await vi.advanceTimersByTimeAsync(ms)
+  return promise
+}
+
 describe('queryStore', () => {
   let instance: SanityInstance
   let liveEvents: Subject<LiveEvent>
@@ -48,7 +60,8 @@ describe('queryStore', () => {
   }
 
   beforeEach(() => {
-    instance = createSanityInstance()
+    vi.useFakeTimers()
+    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
 
     fetch = vi
       .fn()
@@ -76,11 +89,12 @@ describe('queryStore', () => {
   afterEach(() => {
     vi.mocked(getClientState).mockClear()
     instance.dispose()
+    vi.useRealTimers()
   })
 
   it('initializes query state and cleans up after unsubscribe', async () => {
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    const state = getQueryState(instance, {query})
 
     // Initially undefined before subscription
     expect(state.getCurrent()).toBeUndefined()
@@ -89,7 +103,7 @@ describe('queryStore', () => {
     const unsubscribe = state.subscribe()
 
     // Wait for data to be fetched
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
 
     // Verify data is present
     expect(state.getCurrent()).toEqual([
@@ -101,7 +115,7 @@ describe('queryStore', () => {
     unsubscribe()
 
     // Wait for the cleanup delay
-    await new Promise((resolve) => setTimeout(resolve, 20))
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY)
 
     // Verify state is cleared
     expect(state.getCurrent()).toBeUndefined()
@@ -109,14 +123,14 @@ describe('queryStore', () => {
 
   it('maintains state when multiple subscribers exist', async () => {
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    const state = getQueryState(instance, {query})
 
     // Add two subscribers
     const unsubscribe1 = state.subscribe()
     const unsubscribe2 = state.subscribe()
 
     // Wait for data to be fetched
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
 
     // Verify data is present
     expect(state.getCurrent()).toEqual([
@@ -137,7 +151,7 @@ describe('queryStore', () => {
     unsubscribe2()
 
     // Wait for cleanup delay
-    await new Promise((resolve) => setTimeout(resolve, 20))
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY)
 
     // Verify state is cleared after all subscribers are gone
     expect(state.getCurrent()).toBeUndefined()
@@ -146,22 +160,22 @@ describe('queryStore', () => {
   it('resolveQuery works without affecting subscriber cleanup', async () => {
     const query = '*[_type == "movie"]'
 
-    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    const state = getQueryState(instance, {query})
 
     // Check that getQueryState starts undefined
     expect(state.getCurrent()).toBeUndefined()
 
-    // Use resolveQuery which should not add a subscriber
-    const result = await resolveQuery(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    // resolveQuery holds only a temporary subscriber (released after the
+    // clear delay once the promise settles)
+    const result = await advanceAndAwait(resolveQuery(instance, {query}))
     expect(result).toEqual([
       {_id: 'movie1', _type: 'movie', title: 'Movie 1'},
       {_id: 'movie2', _type: 'movie', title: 'Movie 2'},
     ])
 
-    // Check that getQueryState starts resolved now.
-    // Note that this behavior is important for supporting suspense.
-    // `resolveQuery` is the only way to resolve state without adding a
-    // subscriber that can trigger a clean up
+    // Check that getQueryState is resolved now. This behavior is important
+    // for supporting suspense: the resolved state must remain readable while
+    // React re-renders and attaches a lasting subscriber
     expect(state.getCurrent()).toEqual([
       {_id: 'movie1', _type: 'movie', title: 'Movie 1'},
       {_id: 'movie2', _type: 'movie', title: 'Movie 2'},
@@ -170,7 +184,7 @@ describe('queryStore', () => {
     // Subscribing and unsubscribing should nuke the state now
     const unsubscribe = state.subscribe()
     unsubscribe()
-    await new Promise((resolve) => setTimeout(resolve, 20))
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY)
     expect(state.getCurrent()).toBeUndefined()
   })
 
@@ -179,11 +193,7 @@ describe('queryStore', () => {
     const abortController = new AbortController()
 
     // Create a promise that will reject when aborted
-    const queryPromise = resolveQuery(instance, {
-      query,
-      resource: {projectId: 'p', dataset: 'd'},
-      signal: abortController.signal,
-    })
+    const queryPromise = resolveQuery(instance, {query, signal: abortController.signal})
 
     // Abort the request
     abortController.abort()
@@ -192,9 +202,14 @@ describe('queryStore', () => {
     await expect(queryPromise).rejects.toThrow('The operation was aborted.')
 
     // Verify state is cleared after abort
-    expect(
-      getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}}).getCurrent(),
-    ).toBeUndefined()
+    expect(getQueryState(instance, {query}).getCurrent()).toBeUndefined()
+
+    // The key must be removed immediately (not after the clear delay): a new
+    // resolveQuery re-adds it, which only triggers a fresh fetch if the abort
+    // actually released the previous temporary subscriber
+    const callsBefore = vi.mocked(fetch).mock.calls.length
+    await expect(advanceAndAwait(resolveQuery(instance, {query}))).resolves.toEqual(mockData.movies)
+    expect(vi.mocked(fetch).mock.calls.length).toBe(callsBefore + 1)
   })
 
   it('refetches query when receiving live event with matching sync tag', async () => {
@@ -213,13 +228,10 @@ describe('queryStore', () => {
     )
 
     const query = '*[_type == "movie"]'
-    const state = getQueryState<{_id: string; _type: string; title: string}[]>(instance, {
-      query,
-      resource: {projectId: 'p', dataset: 'd'},
-    })
+    const state = getQueryState<{_id: string; _type: string; title: string}[]>(instance, {query})
 
     const unsubscribe = state.subscribe()
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
 
     // Emit live event with matching sync tag
     liveEvents.next({
@@ -231,7 +243,9 @@ describe('queryStore', () => {
     } as LiveEvent)
 
     // Wait for updated data
-    const result = await firstValueFrom(state.observable.pipe(filter((data) => data?.length === 3)))
+    const result = await advanceAndAwait(
+      firstValueFrom(state.observable.pipe(filter((data) => data?.length === 3))),
+    )
 
     expect(fetch).toHaveBeenCalledTimes(2)
     expect(vi.mocked(fetch).mock.calls[1][2]?.lastLiveEventId).toBe('event1')
@@ -247,10 +261,10 @@ describe('queryStore', () => {
     )
 
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    const state = getQueryState(instance, {query})
 
     const unsubscribe = state.subscribe()
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
 
     // Emit event with different tag
     liveEvents.next({
@@ -261,7 +275,7 @@ describe('queryStore', () => {
       event: 'created',
     } as LiveEvent)
 
-    await new Promise((resolve) => setTimeout(resolve, 50)) // Allow time for potential refetch
+    await vi.advanceTimersByTimeAsync(50) // Allow time for potential refetch
     expect(fetch).toHaveBeenCalledTimes(1)
 
     unsubscribe()
@@ -280,10 +294,10 @@ describe('queryStore', () => {
     )
 
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    const state = getQueryState(instance, {query})
 
     const unsubscribe = state.subscribe()
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
 
     // Emit two events with same tag
     liveEvents.next({
@@ -298,7 +312,7 @@ describe('queryStore', () => {
       tags: mockSyncTags,
     })
 
-    await new Promise((resolve) => setTimeout(resolve, 0))
+    await vi.advanceTimersByTimeAsync(0)
     expect(fetch).toHaveBeenCalledTimes(3)
     expect(vi.mocked(fetch).mock.calls[1][2]?.lastLiveEventId).toBe('event1')
     expect(vi.mocked(fetch).mock.calls[2][2]?.lastLiveEventId).toBe('event2')
@@ -317,7 +331,7 @@ describe('queryStore', () => {
     )
 
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    const state = getQueryState(instance, {query})
     const unsubscribe = state.subscribe()
 
     // Verify error is thrown when accessing state
@@ -326,28 +340,199 @@ describe('queryStore', () => {
     unsubscribe()
   })
 
+  it('refetches when a query key is re-added after an error', async () => {
+    // First fetch fails (e.g. transient network failure)
+    vi.mocked(fetch).mockReturnValueOnce(
+      new Observable((observer) => {
+        observer.error(new Error('transient network failure'))
+      }),
+    )
+
+    const query = '*[_type == "movie"]'
+    const state1 = getQueryState(instance, {query})
+    const unsub1 = state1.subscribe()
+    expect(() => state1.getCurrent()).toThrow('transient network failure')
+    unsub1()
+
+    // Wait for the clear delay so the key is fully removed from state
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY)
+
+    // Retry with the same key — must trigger a fresh fetch
+    const state2 = getQueryState(instance, {query})
+    const unsub2 = state2.subscribe()
+
+    await vi.advanceTimersByTimeAsync(0)
+    expect(vi.mocked(fetch)).toHaveBeenCalledTimes(2)
+
+    const result = await advanceAndAwait(
+      firstValueFrom(state2.observable.pipe(filter((i) => i !== undefined))),
+    )
+    expect(result).toEqual(mockData.movies)
+    unsub2()
+  })
+
+  it('releases an errored key created by resolveQuery so a retry can refetch', async () => {
+    vi.mocked(fetch).mockReturnValueOnce(
+      new Observable((observer) => {
+        observer.error(new Error('network down'))
+      }),
+    )
+
+    const query = '*[_type == "movie"]'
+    // This is how React drives a suspended query: resolveQuery creates the
+    // key without any subscriber (the component never commits when it throws)
+    await expect(resolveQuery(instance, {query})).rejects.toThrow('network down')
+
+    // While the errored key exists, the error surfaces to error boundaries
+    const state = getQueryState(instance, {query})
+    expect(() => state.getCurrent()).toThrow('network down')
+
+    // After the clear delay, the errored key must be released — otherwise it
+    // has no subscribers, nothing ever removes it, and every future mount
+    // rethrows the stored error without ever fetching
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY)
+    expect(state.getCurrent()).toBeUndefined()
+
+    // A retry now creates a fresh key and fetches
+    await expect(advanceAndAwait(resolveQuery(instance, {query}))).resolves.toEqual(mockData.movies)
+  })
+
+  it('stops live updates without retrying or erroring on a 4xx connection rejection', async () => {
+    const query = '*[_type == "movie"]'
+    const state = getQueryState(instance, {query})
+    const unsub = state.subscribe()
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
+
+    const clientState = vi.mocked(getClientState).mock.results[0]
+      ?.value as StateSource<SanityClient>
+    const client = await firstValueFrom(clientState.observable)
+    const eventsMock = vi.mocked(client.live.events)
+    const callsBefore = eventsMock.mock.calls.length
+
+    // The server rejected the connection with a 401 (e.g. expired token). The
+    // client surfaces this as a fatal ConnectionFailedError with the status —
+    // retrying would reconnect once per second forever against a server that
+    // keeps rejecting
+    liveEvents.error(new ConnectionFailedError('EventSource connection failed', {status: 401}))
+    await vi.advanceTimersByTimeAsync(LIVE_EVENTS_RETRY_DELAY * 5)
+
+    expect(() => state.getCurrent()).not.toThrow()
+    expect(eventsMock.mock.calls.length).toBe(callsBefore)
+    unsub()
+  })
+
+  it('retries a connection failure without a status (transient network failure)', async () => {
+    const query = '*[_type == "movie"]'
+    const state = getQueryState(instance, {query})
+    const unsub = state.subscribe()
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
+
+    const clientState = vi.mocked(getClientState).mock.results[0]
+      ?.value as StateSource<SanityClient>
+    const client = await firstValueFrom(clientState.observable)
+    const eventsMock = vi.mocked(client.live.events)
+    const callsBefore = eventsMock.mock.calls.length
+
+    // No status means the failure could be transient (native EventSource
+    // exposes no status) — reconnecting is correct here
+    liveEvents.error(new ConnectionFailedError('EventSource connection failed'))
+    await vi.advanceTimersByTimeAsync(LIVE_EVENTS_RETRY_DELAY * 2)
+
+    expect(() => state.getCurrent()).not.toThrow()
+    expect(eventsMock.mock.calls.length).toBeGreaterThan(callsBefore)
+    unsub()
+  })
+
+  it('surfaces CORS errors on the live connection as a store-wide error', async () => {
+    const query = '*[_type == "movie"]'
+    const state = getQueryState(instance, {query})
+    const unsub = state.subscribe()
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
+
+    liveEvents.error(new CorsOriginError({projectId: 'test'}))
+    await vi.advanceTimersByTimeAsync(0)
+
+    // the swallowed CORS error is recorded as store state so the query
+    // selector rethrows it (handled by the Cors Error component)
+    expect(() => state.getCurrent()).toThrow(CorsOriginError)
+    unsub()
+  })
+
+  it('stops live updates without retrying or erroring on DisconnectError', async () => {
+    const query = '*[_type == "movie"]'
+    const state = getQueryState(instance, {query})
+    const unsub = state.subscribe()
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
+
+    // Grab the live events factory from the client the store is subscribed to
+    const clientState = vi.mocked(getClientState).mock.results[0]
+      ?.value as StateSource<SanityClient>
+    const client = await firstValueFrom(clientState.observable)
+    const eventsMock = vi.mocked(client.live.events)
+    const callsBefore = eventsMock.mock.calls.length
+
+    // The server instructed the client to stop reconnecting
+    liveEvents.error(new DisconnectError('Server disconnected client'))
+    // Advance past several retry delays
+    await vi.advanceTimersByTimeAsync(LIVE_EVENTS_RETRY_DELAY * 5)
+
+    // No store-wide error, and no reconnect attempts (a retry would call
+    // live.events again)
+    expect(() => state.getCurrent()).not.toThrow()
+    expect(eventsMock.mock.calls.length).toBe(callsBefore)
+    unsub()
+  })
+
+  it('keeps queries working after the live events connection errors', async () => {
+    const query = '*[_type == "movie"]'
+    const state = getQueryState(instance, {query})
+    const unsub = state.subscribe()
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
+
+    // The live connection drops (e.g. network goes offline)
+    liveEvents.error(new Error('live connection lost'))
+    await vi.advanceTimersByTimeAsync(0)
+
+    // Existing query state must remain readable — a lost live connection must
+    // not poison the whole store
+    expect(() => state.getCurrent()).not.toThrow()
+    expect(state.getCurrent()).toEqual(mockData.movies)
+    unsub()
+
+    // Wait for the clear delay so the key is fully removed, then re-add it —
+    // fetching must still work
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY)
+    const state2 = getQueryState(instance, {query})
+    const unsub2 = state2.subscribe()
+    const result = await advanceAndAwait(
+      firstValueFrom(state2.observable.pipe(filter((i) => i !== undefined))),
+    )
+    expect(result).toEqual(mockData.movies)
+    unsub2()
+  })
+
   it('delays query state removal after unsubscribe', async () => {
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    const state = getQueryState(instance, {query})
     const unsubscribe = state.subscribe()
 
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
 
     unsubscribe()
     // Immediately after unsubscription, state should still be present due to delay
     expect(state.getCurrent()).not.toBeUndefined()
 
     // Wait for the cleanup delay and then state should be removed
-    await new Promise((resolve) => setTimeout(resolve, 20))
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY)
     expect(state.getCurrent()).toBeUndefined()
   })
 
   it('preserves query state if a new subscriber subscribes before cleanup delay', async () => {
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
+    const state = getQueryState(instance, {query})
     const unsubscribe1 = state.subscribe()
 
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
     expect(state.getCurrent()).toEqual([
       {_id: 'movie1', _type: 'movie', title: 'Movie 1'},
       {_id: 'movie2', _type: 'movie', title: 'Movie 2'},
@@ -355,13 +540,13 @@ describe('queryStore', () => {
 
     unsubscribe1()
     // Wait less than the cleanup delay
-    await new Promise((resolve) => setTimeout(resolve, 5))
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY / 2)
 
     // Subscribe again before cleanup occurs
     const unsubscribe2 = state.subscribe()
 
     // Wait for cleanup delay to pass
-    await new Promise((resolve) => setTimeout(resolve, 20))
+    await vi.advanceTimersByTimeAsync(QUERY_STATE_CLEAR_DELAY)
 
     // Since a subscriber now exists, state should still be present
     expect(state.getCurrent()).toEqual([
@@ -382,30 +567,30 @@ describe('queryStore', () => {
     }) as SanityClient['observable']['fetch'])
 
     const draftsInstance = createSanityInstance({
+      projectId: 'test',
+      dataset: 'test',
       perspective: 'drafts',
     })
     const publishedInstance = createSanityInstance({
+      projectId: 'test',
+      dataset: 'test',
       perspective: 'published',
     })
 
     // Same query/options, different implicit perspectives via instance.config
-    const sDrafts = getQueryState<{_id: string}[]>(draftsInstance, {
-      query: '*[_type == "movie"]',
-      resource: {projectId: 'p', dataset: 'd'},
-    })
+    const sDrafts = getQueryState<{_id: string}[]>(draftsInstance, {query: '*[_type == "movie"]'})
     const sPublished = getQueryState<{_id: string}[]>(publishedInstance, {
       query: '*[_type == "movie"]',
-      resource: {projectId: 'p', dataset: 'd'},
     })
 
     const unsubDrafts = sDrafts.subscribe()
     const unsubPublished = sPublished.subscribe()
 
-    const draftsResult = await firstValueFrom(
-      sDrafts.observable.pipe(filter((i) => i !== undefined)),
+    const draftsResult = await advanceAndAwait(
+      firstValueFrom(sDrafts.observable.pipe(filter((i) => i !== undefined))),
     )
-    const publishedResult = await firstValueFrom(
-      sPublished.observable.pipe(filter((i) => i !== undefined)),
+    const publishedResult = await advanceAndAwait(
+      firstValueFrom(sPublished.observable.pipe(filter((i) => i !== undefined))),
     )
 
     expect(draftsResult).toEqual([{_id: 'drafts'}])
@@ -427,27 +612,25 @@ describe('queryStore', () => {
       >
     }) as SanityClient['observable']['fetch'])
 
-    const base = createSanityInstance()
+    const base = createSanityInstance({projectId: 'test', dataset: 'test'})
 
     const sDrafts = getQueryState<{_id: string}[]>(base, {
       query: '*[_type == "movie"]',
       perspective: 'drafts',
-      resource: {projectId: 'p', dataset: 'd'},
     })
     const sPublished = getQueryState<{_id: string}[]>(base, {
       query: '*[_type == "movie"]',
       perspective: 'published',
-      resource: {projectId: 'p', dataset: 'd'},
     })
 
     const unsubDrafts = sDrafts.subscribe()
     const unsubPublished = sPublished.subscribe()
 
-    const draftsResult = await firstValueFrom(
-      sDrafts.observable.pipe(filter((i) => i !== undefined)),
+    const draftsResult = await advanceAndAwait(
+      firstValueFrom(sDrafts.observable.pipe(filter((i) => i !== undefined))),
     )
-    const publishedResult = await firstValueFrom(
-      sPublished.observable.pipe(filter((i) => i !== undefined)),
+    const publishedResult = await advanceAndAwait(
+      firstValueFrom(sPublished.observable.pipe(filter((i) => i !== undefined))),
     )
 
     expect(draftsResult).toEqual([{_id: 'drafts'}])
@@ -461,15 +644,15 @@ describe('queryStore', () => {
 
   it('uses resource from params when passed in query options (listenForNewSubscribersAndFetch)', async () => {
     const query = '*[_type == "movie"]'
-    const mediaLibraryResource = {mediaLibraryId: 'ml123'}
+    const mediaLibrarySource = {mediaLibraryId: 'ml123'}
 
-    const state = getQueryState(instance, {query, resource: mediaLibraryResource})
+    const state = getQueryState(instance, {query, resource: mediaLibrarySource})
     const unsubscribe = state.subscribe()
 
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
 
-    // Verify getClientState was called with the source from params in listenForNewSubscribersAndFetch
-    // This call includes projectId, dataset, and source
+    // Verify getClientState was called with the resource from params in listenForNewSubscribersAndFetch
+    // This call includes projectId, dataset, and resource
     expect(getClientState).toHaveBeenCalledWith(
       instance,
       expect.objectContaining({
@@ -484,16 +667,16 @@ describe('queryStore', () => {
 
   it('uses resource from store context key when not a dataset resource (listenToLiveClientAndSetLastLiveEventIds)', async () => {
     const query = '*[_type == "movie"]'
-    const canvasResource = {canvasId: 'canvas456'}
+    const canvasSource = {canvasId: 'canvas456'}
 
-    const state = getQueryState(instance, {query, resource: canvasResource})
+    const state = getQueryState(instance, {query, resource: canvasSource})
     const unsubscribe = state.subscribe()
 
-    await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
+    await advanceAndAwait(firstValueFrom(state.observable.pipe(filter((i) => i !== undefined))))
 
-    // Verify getClientState was called with the canvas source for live events
-    // The source is extracted from the store key and passed when it's not a dataset source
-    // This call only has apiVersion and source (no projectId/dataset)
+    // Verify getClientState was called with the canvas resource for live events
+    // The resource is extracted from the store key and passed when it's not a dataset resource
+    // This call only has apiVersion and resource (no projectId/dataset)
     const calls = vi.mocked(getClientState).mock.calls
     const liveClientCall = calls.find(
       ([_instance, options]) =>
@@ -503,51 +686,4 @@ describe('queryStore', () => {
 
     unsubscribe()
   })
-
-  it('uses bound resource when a shared store receives a query with the same explicit resource', async () => {
-    // Regression test: when a store for source B is first created by an
-    // instance (passing source B explicitly), subsequent queries added to
-    // that store by a different instance (also passing source B explicitly)
-    // must still use resource B for client creation.
-    const projectBSource = {projectId: 'project-b', dataset: 'production'}
-
-    const rootInstance = createSanityInstance()
-
-    // 1. Root instance queries with an explicit source for project B.
-    //    This creates the QueryStore:project-b.production store, whose
-    //    initialize() captures rootInstance in its closure.
-    const stateWithResource = getQueryState(rootInstance, {
-      query: '*[_type == "author"]',
-      resource: projectBSource,
-    })
-    const unsub1 = stateWithResource.subscribe()
-    await firstValueFrom(stateWithResource.observable.pipe(filter((i) => i !== undefined)))
-
-    vi.mocked(getClientState).mockClear()
-
-    // 2. A second instance queries the SAME store (same composite key)
-    //    with the same explicit resource.
-    const secondInstance = createSanityInstance()
-    const stateWithSameResource = getQueryState(secondInstance, {
-      query: '*[_type == "movie"]',
-      resource: projectBSource,
-    })
-    const unsub2 = stateWithSameResource.subscribe()
-    await firstValueFrom(stateWithSameResource.observable.pipe(filter((i) => i !== undefined)))
-
-    // The listener should create a client using the bound source (project B).
-    const fetchCalls = vi.mocked(getClientState).mock.calls
-    const correctCall = fetchCalls.find(
-      ([, options]) =>
-        options.resource &&
-        'projectId' in options.resource &&
-        options.resource.projectId === 'project-b',
-    )
-    expect(correctCall).toBeDefined()
-
-    unsub1()
-    unsub2()
-    secondInstance.dispose()
-    rootInstance.dispose()
-  })
 })