@sanity/sdk 2.7.0 → 3.0.0-rc.0

package/src/projection/projectionStore.test.ts

@@ -24,13 +24,13 @@ describe('projectionStore', () => {
       new Observable(subscriber).subscribe(),
     )
 
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    const instance = createSanityInstance()
 
     const {state, dispose} = createStoreInstance(
       instance,
       {
         name: 'p.d',
-        source: {projectId: 'p', dataset: 'd'},
+        resource: {projectId: 'p', dataset: 'd'},
         perspective: 'drafts',
       },
       projectionStore,
@@ -42,7 +42,7 @@ describe('projectionStore', () => {
       state,
       key: {
         name: 'p.d',
-        source: {projectId: 'p', dataset: 'd'},
+        resource: {projectId: 'p', dataset: 'd'},
         perspective: 'drafts',
       },
     })

package/src/projection/resolveProjection.test.ts

@@ -23,7 +23,7 @@ describe('resolveProjection', () => {
       } as ProjectionValuePending<Record<string, unknown>>),
     } as StateSource<ProjectionValuePending<Record<string, unknown>>>)
 
-    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    instance = createSanityInstance()
   })
 
   afterEach(() => {
@@ -34,6 +34,7 @@ describe('resolveProjection', () => {
     const docHandle = createDocumentHandle({
       documentId: 'doc123',
       documentType: 'movie',
+      resource: {projectId: 'p', dataset: 'd'},
     })
     const projection = '{title}'
 

package/src/projection/resolveProjection.ts

@@ -1,27 +1,11 @@
-import {type SanityProjectionResult} from 'groq'
 import {filter, firstValueFrom} from 'rxjs'
 
-import {bindActionBySourceAndPerspective} from '../store/createActionBinder'
+import {bindActionByResourceAndPerspective} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {getProjectionState, type ProjectionOptions} from './getProjectionState'
 import {projectionStore} from './projectionStore'
 import {type ProjectionValuePending} from './types'
 
-/** @beta */
-export function resolveProjection<
-  TProjection extends string = string,
-  TDocumentType extends string = string,
-  TDataset extends string = string,
-  TProjectId extends string = string,
->(
-  instance: SanityInstance,
-  options: ProjectionOptions<TProjection, TDocumentType, TDataset, TProjectId>,
-): Promise<
-  ProjectionValuePending<
-    SanityProjectionResult<TProjection, TDocumentType, `${TProjectId}.${TDataset}`>
-  >
->
-
 /** @beta */
 export function resolveProjection<TData extends object>(
   instance: SanityInstance,
@@ -38,7 +22,7 @@ export function resolveProjection(
 /**
  * @beta
  */
-const _resolveProjection = bindActionBySourceAndPerspective(
+const _resolveProjection = bindActionByResourceAndPerspective(
   projectionStore,
   (
     {instance}: {instance: SanityInstance},

package/src/projection/subscribeToStateAndFetchBatches.test.ts

@@ -17,13 +17,13 @@ describe('subscribeToStateAndFetchBatches', () => {
   let state: StoreState<ProjectionStoreState>
   const key = {
     name: 'test.test:drafts',
-    source: {projectId: 'test', dataset: 'test'},
+    resource: {projectId: 'test', dataset: 'test'},
     perspective: 'drafts' as const,
   }
 
   beforeEach(() => {
     vi.clearAllMocks()
-    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+    instance = createSanityInstance()
     state = createStoreState<ProjectionStoreState>({
       documentProjections: {},
       documentStatuses: {},

package/src/projection/subscribeToStateAndFetchBatches.ts

@@ -16,7 +16,6 @@ import {
   tap,
 } from 'rxjs'
 
-import {isDatasetSource} from '../config/sanityConfig'
 import {getQueryState, resolveQuery} from '../query/queryStore'
 import {type BoundPerspectiveKey} from '../store/createActionBinder'
 import {type StoreContext} from '../store/defineStore'
@@ -42,7 +41,7 @@ interface StatusQueryResult {
 export const subscribeToStateAndFetchBatches = ({
   state,
   instance,
-  key: {source, perspective},
+  key: {resource, perspective},
 }: StoreContext<ProjectionStoreState, BoundPerspectiveKey>): Subscription => {
   const documentProjections$ = state.observable.pipe(
     map((s) => s.documentProjections),
@@ -106,29 +105,23 @@ export const subscribeToStateAndFetchBatches = ({
 
         const projectionQuery$ = new Observable<ProjectionQueryResult[]>((observer) => {
           const {getCurrent, observable} = getQueryState<ProjectionQueryResult[]>(instance, {
-            ...{
-              query,
-              params,
-              tag: PROJECTION_TAG,
-              perspective,
-            },
-            // temporary guard here until we're ready for everything to be queried via global API
-            ...(source && !isDatasetSource(source) ? {source} : {}),
+            query,
+            params,
+            tag: PROJECTION_TAG,
+            perspective,
+            resource,
           })
 
           const querySource$ = defer(() => {
             if (getCurrent() === undefined) {
               return from(
                 resolveQuery<ProjectionQueryResult[]>(instance, {
-                  ...{
-                    query,
-                    params,
-                    tag: PROJECTION_TAG,
-                    signal: controller.signal,
-                    perspective,
-                  },
-                  // temporary guard here until we're ready for everything to be queried via global API in v3
-                  ...(source && !isDatasetSource(source) ? {source} : {}),
+                  query,
+                  params,
+                  tag: PROJECTION_TAG,
+                  signal: controller.signal,
+                  perspective,
+                  resource,
                 }),
               ).pipe(switchMap(() => observable))
             }
@@ -147,29 +140,23 @@ export const subscribeToStateAndFetchBatches = ({
 
         const statusQuery$ = new Observable<StatusQueryResult[]>((observer) => {
           const {getCurrent, observable} = getQueryState<StatusQueryResult[]>(instance, {
-            ...{
-              query: statusQuery,
-              params: statusParams,
-              tag: PROJECTION_TAG,
-              perspective: 'raw',
-            },
-            // temporary guard here until we're ready for everything to be queried via global API
-            ...(source && !isDatasetSource(source) ? {source} : {}),
+            query: statusQuery,
+            params: statusParams,
+            tag: PROJECTION_TAG,
+            perspective: 'raw',
+            resource,
           })
 
           const statusQuerySource$ = defer(() => {
             if (getCurrent() === undefined) {
               return from(
                 resolveQuery<StatusQueryResult[]>(instance, {
-                  ...{
-                    query: statusQuery,
-                    params: statusParams,
-                    tag: PROJECTION_TAG,
-                    signal: controller.signal,
-                    perspective: 'raw',
-                  },
-                  // temporary guard here until we're ready for everything to be queried via global API
-                  ...(source && !isDatasetSource(source) ? {source} : {}),
+                  query: statusQuery,
+                  params: statusParams,
+                  tag: PROJECTION_TAG,
+                  signal: controller.signal,
+                  perspective: 'raw',
+                  resource,
                 }),
               ).pipe(switchMap(() => observable))
             }

package/src/projection/types.ts

@@ -11,14 +11,6 @@ export interface DocumentProjectionValues<TValue extends object = object> {
   [projectionHash: string]: ProjectionValuePending<TValue>
 }
 
-/**
- * @public
- * @deprecated
- * Template literals are a bit too limited, so this type is deprecated.
- * Use `string` instead. Projection strings are validated at runtime.
- */
-export type ValidProjection = string
-
 export interface DocumentProjections {
   [projectionHash: string]: string
 }
@@ -29,7 +21,7 @@ interface DocumentProjectionSubscriptions {
   }
 }
 
-interface DocumentStatus {
+export interface DocumentStatus {
   lastEditedDraftAt?: string
   lastEditedPublishedAt?: string
   lastEditedVersionAt?: string

package/src/projects/projects.test.ts

@@ -13,7 +13,7 @@ describe('projects', () => {
   let instance: SanityInstance
 
   beforeEach(() => {
-    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    instance = createSanityInstance()
   })
 
   afterEach(() => {

package/src/query/queryStore.test.ts

@@ -3,7 +3,7 @@ import {delay, filter, firstValueFrom, Observable, of, Subject} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {getClientState} from '../client/clientStore'
-import {isCanvasSource} from '../config/sanityConfig'
+import {isCanvasResource} from '../config/sanityConfig'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
 import {getQueryState, resolveQuery} from './queryStore'
@@ -48,7 +48,7 @@ describe('queryStore', () => {
   }
 
   beforeEach(() => {
-    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+    instance = createSanityInstance()
 
     fetch = vi
       .fn()
@@ -80,7 +80,7 @@ describe('queryStore', () => {
 
   it('initializes query state and cleans up after unsubscribe', async () => {
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query})
+    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
 
     // Initially undefined before subscription
     expect(state.getCurrent()).toBeUndefined()
@@ -109,7 +109,7 @@ describe('queryStore', () => {
 
   it('maintains state when multiple subscribers exist', async () => {
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query})
+    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
 
     // Add two subscribers
     const unsubscribe1 = state.subscribe()
@@ -146,13 +146,13 @@ describe('queryStore', () => {
   it('resolveQuery works without affecting subscriber cleanup', async () => {
     const query = '*[_type == "movie"]'
 
-    const state = getQueryState(instance, {query})
+    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
 
     // Check that getQueryState starts undefined
     expect(state.getCurrent()).toBeUndefined()
 
     // Use resolveQuery which should not add a subscriber
-    const result = await resolveQuery(instance, {query})
+    const result = await resolveQuery(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
     expect(result).toEqual([
       {_id: 'movie1', _type: 'movie', title: 'Movie 1'},
       {_id: 'movie2', _type: 'movie', title: 'Movie 2'},
@@ -179,7 +179,11 @@ describe('queryStore', () => {
     const abortController = new AbortController()
 
     // Create a promise that will reject when aborted
-    const queryPromise = resolveQuery(instance, {query, signal: abortController.signal})
+    const queryPromise = resolveQuery(instance, {
+      query,
+      resource: {projectId: 'p', dataset: 'd'},
+      signal: abortController.signal,
+    })
 
     // Abort the request
     abortController.abort()
@@ -188,7 +192,9 @@ describe('queryStore', () => {
     await expect(queryPromise).rejects.toThrow('The operation was aborted.')
 
     // Verify state is cleared after abort
-    expect(getQueryState(instance, {query}).getCurrent()).toBeUndefined()
+    expect(
+      getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}}).getCurrent(),
+    ).toBeUndefined()
   })
 
   it('refetches query when receiving live event with matching sync tag', async () => {
@@ -207,7 +213,10 @@ describe('queryStore', () => {
     )
 
     const query = '*[_type == "movie"]'
-    const state = getQueryState<{_id: string; _type: string; title: string}[]>(instance, {query})
+    const state = getQueryState<{_id: string; _type: string; title: string}[]>(instance, {
+      query,
+      resource: {projectId: 'p', dataset: 'd'},
+    })
 
     const unsubscribe = state.subscribe()
     await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
@@ -238,7 +247,7 @@ describe('queryStore', () => {
     )
 
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query})
+    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
 
     const unsubscribe = state.subscribe()
     await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
@@ -271,7 +280,7 @@ describe('queryStore', () => {
     )
 
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query})
+    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
 
     const unsubscribe = state.subscribe()
     await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
@@ -308,7 +317,7 @@ describe('queryStore', () => {
     )
 
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query})
+    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
     const unsubscribe = state.subscribe()
 
     // Verify error is thrown when accessing state
@@ -319,7 +328,7 @@ describe('queryStore', () => {
 
   it('delays query state removal after unsubscribe', async () => {
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query})
+    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
     const unsubscribe = state.subscribe()
 
     await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
@@ -335,7 +344,7 @@ describe('queryStore', () => {
 
   it('preserves query state if a new subscriber subscribes before cleanup delay', async () => {
     const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, {query})
+    const state = getQueryState(instance, {query, resource: {projectId: 'p', dataset: 'd'}})
     const unsubscribe1 = state.subscribe()
 
     await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
@@ -373,20 +382,20 @@ 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"]'})
+    const sDrafts = getQueryState<{_id: string}[]>(draftsInstance, {
+      query: '*[_type == "movie"]',
+      resource: {projectId: 'p', dataset: 'd'},
+    })
     const sPublished = getQueryState<{_id: string}[]>(publishedInstance, {
       query: '*[_type == "movie"]',
+      resource: {projectId: 'p', dataset: 'd'},
     })
 
     const unsubDrafts = sDrafts.subscribe()
@@ -418,15 +427,17 @@ describe('queryStore', () => {
       >
     }) as SanityClient['observable']['fetch'])
 
-    const base = createSanityInstance({projectId: 'test', dataset: 'test'})
+    const base = createSanityInstance()
 
     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()
@@ -448,11 +459,11 @@ describe('queryStore', () => {
     base.dispose()
   })
 
-  it('uses source from params when passed in query options (listenForNewSubscribersAndFetch)', async () => {
+  it('uses resource from params when passed in query options (listenForNewSubscribersAndFetch)', async () => {
     const query = '*[_type == "movie"]'
-    const mediaLibrarySource = {mediaLibraryId: 'ml123'}
+    const mediaLibraryResource = {mediaLibraryId: 'ml123'}
 
-    const state = getQueryState(instance, {query, source: mediaLibrarySource})
+    const state = getQueryState(instance, {query, resource: mediaLibraryResource})
     const unsubscribe = state.subscribe()
 
     await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
@@ -462,7 +473,7 @@ describe('queryStore', () => {
     expect(getClientState).toHaveBeenCalledWith(
       instance,
       expect.objectContaining({
-        source: expect.objectContaining({
+        resource: expect.objectContaining({
           mediaLibraryId: 'ml123',
         }),
       }),
@@ -471,11 +482,11 @@ describe('queryStore', () => {
     unsubscribe()
   })
 
-  it('uses source from store context key when not a dataset source (listenToLiveClientAndSetLastLiveEventIds)', async () => {
+  it('uses resource from store context key when not a dataset resource (listenToLiveClientAndSetLastLiveEventIds)', async () => {
     const query = '*[_type == "movie"]'
-    const canvasSource = {canvasId: 'canvas456'}
+    const canvasResource = {canvasId: 'canvas456'}
 
-    const state = getQueryState(instance, {query, source: canvasSource})
+    const state = getQueryState(instance, {query, resource: canvasResource})
     const unsubscribe = state.subscribe()
 
     await firstValueFrom(state.observable.pipe(filter((i) => i !== undefined)))
@@ -486,10 +497,57 @@ describe('queryStore', () => {
     const calls = vi.mocked(getClientState).mock.calls
     const liveClientCall = calls.find(
       ([_instance, options]) =>
-        isCanvasSource(options.source!) && options.source.canvasId === 'canvas456',
+        isCanvasResource(options.resource!) && options.resource.canvasId === 'canvas456',
     )
     expect(liveClientCall).toBeDefined()
 
     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()
+  })
 })

package/src/query/queryStore.ts

@@ -1,5 +1,4 @@
 import {CorsOriginError, type ResponseQueryOptions} from '@sanity/client'
-import {type SanityQueryResult} from 'groq'
 import {
   catchError,
   combineLatest,
@@ -24,7 +23,7 @@ import {
 } from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
-import {type DatasetHandle, isDatasetSource} from '../config/sanityConfig'
+import {type ResourceHandle} from '../config/sanityConfig'
 /*
  * Although this is an import dependency cycle, it is not a logical cycle:
  * 1. queryStore uses getPerspectiveState when resolving release perspectives
@@ -35,7 +34,7 @@ import {type DatasetHandle, isDatasetSource} from '../config/sanityConfig'
 // eslint-disable-next-line import/no-cycle
 import {getPerspectiveState} from '../releases/getPerspectiveState'
 import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
-import {bindActionBySource, type BoundSourceKey} from '../store/createActionBinder'
+import {bindActionByResource, type BoundResourceKey} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {
   createStateSourceAction,
@@ -71,7 +70,7 @@ export interface QueryOptions<
 >
   extends
     Pick<ResponseQueryOptions, 'useCdn' | 'cache' | 'next' | 'cacheMode' | 'tag'>,
-    DatasetHandle<TDataset, TProjectId> {
+    ResourceHandle<TDataset, TProjectId> {
   query: TQuery
   params?: Record<string, unknown>
 }
@@ -116,7 +115,7 @@ function normalizeOptionsWithPerspective(
   }
 }
 
-const queryStore = defineStore<QueryStoreState, BoundSourceKey>({
+const queryStore = defineStore<QueryStoreState, BoundResourceKey>({
   name: 'QueryStore',
   getInitialState: () => ({queries: {}}),
   initialize(context) {
@@ -137,7 +136,11 @@ const errorHandler = (state: StoreState<{error?: unknown}>) => {
   return (error: unknown): void => state.set('setError', {error})
 }
 
-const listenForNewSubscribersAndFetch = ({state, instance}: StoreContext<QueryStoreState>) => {
+const listenForNewSubscribersAndFetch = ({
+  state,
+  instance,
+  key: {resource: boundResource},
+}: StoreContext<QueryStoreState, BoundResourceKey>) => {
   return state.observable
     .pipe(
       map((s) => new Set(Object.keys(s.queries))),
@@ -169,10 +172,8 @@ const listenForNewSubscribersAndFetch = ({state, instance}: StoreContext<QuerySt
             const {
               query,
               params,
-              projectId,
-              dataset,
               tag,
-              source,
+              resource,
               perspective: perspectiveFromOptions,
               ...restOptions
             } = parseQueryKey(group$.key)
@@ -182,14 +183,19 @@ const listenForNewSubscribersAndFetch = ({state, instance}: StoreContext<QuerySt
             const perspective$ = isReleasePerspective(perspectiveFromOptions)
               ? getPerspectiveState(instance, {
                   perspective: perspectiveFromOptions,
+                  resource: resource ?? boundResource,
                 }).observable.pipe(filter(Boolean))
               : of(perspectiveFromOptions ?? QUERY_STORE_DEFAULT_PERSPECTIVE)
 
+            // Use the store's bound resource as fallback when the query key
+            // doesn't include an explicit resource. The store is scoped to a
+            // specific resource via bindActionByResource, but the captured
+            // `instance` may have a different default resource (e.g. when the
+            // store was first created by a caller that passed an explicit
+            // resource while using the root app instance).
             const client$ = getClientState(instance, {
               apiVersion: QUERY_STORE_API_VERSION,
-              projectId,
-              dataset,
-              source,
+              resource: resource ?? boundResource,
             }).observable
 
             return combineLatest({
@@ -225,12 +231,11 @@ const listenForNewSubscribersAndFetch = ({state, instance}: StoreContext<QuerySt
 const listenToLiveClientAndSetLastLiveEventIds = ({
   state,
   instance,
-  key: {source},
-}: StoreContext<QueryStoreState, BoundSourceKey>) => {
+  key: {resource},
+}: StoreContext<QueryStoreState, BoundResourceKey>) => {
   const liveMessages$ = getClientState(instance, {
     apiVersion: QUERY_STORE_API_VERSION,
-    // temporary guard here until we're ready for everything to be queried via global api
-    ...(source && !isDatasetSource(source) ? {source} : {}),
+    resource,
   }).observable.pipe(
     switchMap((client) =>
       defer(() =>
@@ -288,16 +293,6 @@ const listenToLiveClientAndSetLastLiveEventIds = ({
  *
  * @beta
  */
-export function getQueryState<
-  TQuery extends string = string,
-  TDataset extends string = string,
-  TProjectId extends string = string,
->(
-  instance: SanityInstance,
-  queryOptions: QueryOptions<TQuery, TDataset, TProjectId>,
-): StateSource<SanityQueryResult<TQuery, `${TProjectId}.${TDataset}`> | undefined>
-
-/** @beta */
 export function getQueryState<TData>(
   instance: SanityInstance,
   queryOptions: QueryOptions,
@@ -315,7 +310,7 @@ export function getQueryState(
 ): ReturnType<typeof _getQueryState> {
   return _getQueryState(...args)
 }
-const _getQueryState = bindActionBySource(
+const _getQueryState = bindActionByResource(
   queryStore,
   createStateSourceAction({
     selector: ({state, instance}: SelectorContext<QueryStoreState>, options: QueryOptions) => {
@@ -356,16 +351,6 @@ const _getQueryState = bindActionBySource(
  *
  * @beta
  */
-export function resolveQuery<
-  TQuery extends string = string,
-  TDataset extends string = string,
-  TProjectId extends string = string,
->(
-  instance: SanityInstance,
-  queryOptions: ResolveQueryOptions<TQuery, TDataset, TProjectId>,
-): Promise<SanityQueryResult<TQuery, `${TProjectId}.${TDataset}`>>
-
-/** @beta */
 export function resolveQuery<TData>(
   instance: SanityInstance,
   queryOptions: ResolveQueryOptions,
@@ -374,7 +359,7 @@ export function resolveQuery<TData>(
 export function resolveQuery(...args: Parameters<typeof _resolveQuery>): Promise<unknown> {
   return _resolveQuery(...args)
 }
-const _resolveQuery = bindActionBySource(
+const _resolveQuery = bindActionByResource(
   queryStore,
   ({state, instance}, {signal, ...options}: ResolveQueryOptions) => {
     const normalized = normalizeOptionsWithPerspective(instance, options)