@sanity/sdk 2.9.0 → 2.11.0

package/src/projects/projects.ts

@@ -1,35 +1,95 @@
 import {switchMap} from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
+import {type Project} from '../project/project'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
 import {createFetcherStore} from '../utils/createFetcherStore'
 
 const API_VERSION = 'v2025-02-19'
 
+/** @public */
+export interface ProjectsOptions<
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = true,
+> {
+  organizationId?: string
+  includeMembers?: IncludeMembers
+  includeFeatures?: IncludeFeatures
+  onlyExplicitMembership?: boolean
+}
+
+function normalizeProjectsOptions(options?: ProjectsOptions<boolean, boolean>) {
+  return {
+    organizationId: options?.organizationId,
+    includeMembers: options?.includeMembers ?? false,
+    includeFeatures: options?.includeFeatures ?? true,
+    onlyExplicitMembership: options?.onlyExplicitMembership ?? false,
+  }
+}
+
+/** @internal */
+export function getProjectsCacheKey(
+  _instance: SanityInstance,
+  options?: ProjectsOptions<boolean, boolean>,
+): string {
+  const {organizationId, includeMembers, includeFeatures, onlyExplicitMembership} =
+    normalizeProjectsOptions(options)
+  const orgKey = organizationId ? `:org:${organizationId}` : ''
+  const membersKey = includeMembers ? ':members' : ''
+  const featuresKey = includeFeatures ? ':features' : ''
+  const explicitKey = onlyExplicitMembership ? ':explicit' : ''
+  return `projects${orgKey}${membersKey}${featuresKey}${explicitKey}`
+}
+
 const projects = createFetcherStore({
   name: 'Projects',
-  getKey: (_instance, options?: {organizationId?: string; includeMembers?: boolean}) => {
-    const orgKey = options?.organizationId ? `:org:${options.organizationId}` : ''
-    const membersKey = options?.includeMembers === false ? ':no-members' : ''
-    return `projects${orgKey}${membersKey}`
-  },
-  fetcher: (instance) => (options?: {organizationId?: string; includeMembers?: boolean}) =>
+  getKey: getProjectsCacheKey,
+  fetcher: (instance) => (options?: ProjectsOptions<boolean, boolean>) =>
     getClientState(instance, {
       apiVersion: API_VERSION,
       scope: 'global',
-      requestTagPrefix: 'sanity.sdk.projects',
     }).observable.pipe(
       switchMap((client) => {
-        const organizationId = options?.organizationId
-        return client.observable.projects.list({
-          // client method has a type that expects false | undefined
-          includeMembers: !options?.includeMembers ? false : undefined,
-          organizationId,
+        const normalized = normalizeProjectsOptions(options)
+        const query = Object.fromEntries(
+          Object.entries(normalized)
+            .filter(([, value]) => value !== undefined)
+            .map(([key, value]) => [key, String(value)]),
+        )
+
+        return client.observable.request({
+          uri: '/projects',
+          query,
+          tag: 'projects.get',
         })
       }),
     ),
 })
 
+/**
+ * Public signature for the projects state source. The conditional generics
+ * cannot flow through `BoundStoreAction`, so we declare the signature here
+ * and assign the (already-correct) runtime function to it.
+ */
+type GetProjectsState = <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = true,
+>(
+  instance: SanityInstance,
+  options?: ProjectsOptions<IncludeMembers, IncludeFeatures>,
+) => StateSource<Project<IncludeMembers, IncludeFeatures>[] | undefined>
+
+type ResolveProjects = <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = true,
+>(
+  instance: SanityInstance,
+  options?: ProjectsOptions<IncludeMembers, IncludeFeatures>,
+) => Promise<Project<IncludeMembers, IncludeFeatures>[]>
+
 /** @public */
-export const getProjectsState = projects.getState
+export const getProjectsState: GetProjectsState = projects.getState
+
 /** @public */
-export const resolveProjects = projects.resolveState
+export const resolveProjects: ResolveProjects = projects.resolveState

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'
@@ -448,21 +448,21 @@ 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 state = getQueryState(instance, {query, source: mediaLibrarySource})
+    const state = getQueryState(instance, {query, resource: mediaLibrarySource})
     const unsubscribe = state.subscribe()
 
     await 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({
-        source: expect.objectContaining({
+        resource: expect.objectContaining({
           mediaLibraryId: 'ml123',
         }),
       }),
@@ -471,22 +471,22 @@ 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 state = getQueryState(instance, {query, source: canvasSource})
+    const state = getQueryState(instance, {query, resource: canvasSource})
     const unsubscribe = state.subscribe()
 
     await 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]) =>
-        isCanvasSource(options.source!) && options.source.canvasId === 'canvas456',
+        isCanvasResource(options.resource!) && options.resource.canvasId === 'canvas456',
     )
     expect(liveClientCall).toBeDefined()
 

package/src/query/queryStore.ts

@@ -24,7 +24,7 @@ import {
 } from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
-import {type DatasetHandle, isDatasetSource} from '../config/sanityConfig'
+import {type DatasetHandle} 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 +35,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,
@@ -117,7 +117,7 @@ function normalizeOptionsWithPerspective(
   }
 }
 
-const queryStore = defineStore<QueryStoreState, BoundSourceKey>({
+const queryStore = defineStore<QueryStoreState, BoundResourceKey>({
   name: 'QueryStore',
   getInitialState: () => ({queries: {}}),
   initialize(context) {
@@ -173,7 +173,7 @@ const listenForNewSubscribersAndFetch = ({state, instance}: StoreContext<QuerySt
               projectId,
               dataset,
               tag,
-              source,
+              resource,
               perspective: perspectiveFromOptions,
               ...restOptions
             } = parseQueryKey(group$.key)
@@ -190,7 +190,7 @@ const listenForNewSubscribersAndFetch = ({state, instance}: StoreContext<QuerySt
               apiVersion: QUERY_STORE_API_VERSION,
               projectId,
               dataset,
-              source,
+              resource,
             }).observable
 
             return combineLatest({
@@ -226,12 +226,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(() =>
@@ -316,7 +315,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) => {
@@ -375,7 +374,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)

package/src/query/reducers.ts

@@ -1,4 +1,4 @@
-import {omit} from 'lodash-es'
+import {omitProperty} from '../utils/object'
 
 interface QueryState {
   syncTags?: string[]
@@ -54,7 +54,7 @@ export const removeSubscriber =
     const prevQuery = prev.queries[key]
     if (!prevQuery) return prev
     const subscribers = prevQuery.subscribers.filter((id) => id !== subscriptionId)
-    if (!subscribers.length) return {...prev, queries: omit(prev.queries, key)}
+    if (!subscribers.length) return {...prev, queries: omitProperty(prev.queries, key)}
     return {...prev, queries: {...prev.queries, [key]: {...prevQuery, subscribers}}}
   }
 
@@ -64,7 +64,7 @@ export const cancelQuery =
     const prevQuery = prev.queries[key]
     if (!prevQuery) return prev
     if (prevQuery.subscribers.length) return prev
-    return {...prev, queries: omit(prev.queries, key)}
+    return {...prev, queries: omitProperty(prev.queries, key)}
   }
 
 export const initializeQuery =

package/src/releases/getPerspectiveState.ts

@@ -1,7 +1,7 @@
 import {createSelector} from 'reselect'
 
-import {type DocumentSource, type PerspectiveHandle} from '../config/sanityConfig'
-import {bindActionBySource, type BoundStoreAction} from '../store/createActionBinder'
+import {type DocumentResource, type PerspectiveHandle} from '../config/sanityConfig'
+import {bindActionByResource, 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:
@@ -26,7 +26,7 @@ const selectActiveReleases = (context: SelectorContext<ReleasesStoreState>) =>
   context.state.activeReleases
 const selectOptions = (
   _context: SelectorContext<ReleasesStoreState>,
-  options: PerspectiveHandle & {projectId?: string; dataset?: string; source?: DocumentSource},
+  options: PerspectiveHandle & {projectId?: string; dataset?: string; resource?: DocumentResource},
 ) => options
 
 const memoizedOptionsSelector = createSelector(
@@ -105,11 +105,11 @@ let _boundGetPerspectiveState: BoundGetPerspectiveState | undefined
  */
 export const getPerspectiveState: BoundGetPerspectiveState = (instance, ...rest) => {
   if (!_boundGetPerspectiveState) {
-    _boundGetPerspectiveState = bindActionBySource(
+    _boundGetPerspectiveState = bindActionByResource(
       releasesStore,
       _getPerspectiveStateSelector,
     ) as BoundGetPerspectiveState
   }
-  // bindActionBySource keyFn destructures { source } from the first param, so pass {} when no options
+  // bindActionByResource keyFn destructures { resource } from the first param, so pass {} when no options
   return _boundGetPerspectiveState(instance, ...(rest.length ? rest : [{}]))
 }

package/src/releases/releasesStore.test.ts

@@ -39,8 +39,8 @@ describe('releasesStore', () => {
       expect.objectContaining({
         query: 'releases::all()',
         perspective: 'raw',
-        source: undefined,
         tag: 'releases',
+        resource: {dataset: 'test', projectId: 'test'},
       }),
     )
   })
@@ -73,7 +73,7 @@ describe('releasesStore', () => {
       } as ReleaseDocument,
     ]
 
-    const state = getActiveReleasesState(instance, {source: {projectId: 'test', dataset: 'test'}})
+    const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
 
     const [observer] = subscriber.mock.lastCall!
 
@@ -92,7 +92,7 @@ describe('releasesStore', () => {
       observable: releasesSubject.asObservable(),
     } as StateSource<ReleaseDocument[] | undefined>)
 
-    const state = getActiveReleasesState(instance, {source: {projectId: 'test', dataset: 'test'}})
+    const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
 
     // Initial state should be default
     expect(state.getCurrent()).toBeUndefined() // Default initial state
@@ -139,7 +139,7 @@ describe('releasesStore', () => {
       observable: of([]),
     } as StateSource<ReleaseDocument[] | undefined>)
 
-    const state = getActiveReleasesState(instance, {source: {projectId: 'test', dataset: 'test'}})
+    const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
 
     await new Promise((resolve) => setTimeout(resolve, 0))
 
@@ -153,7 +153,7 @@ describe('releasesStore', () => {
       getCurrent: () => null as unknown as ReleaseDocument[] | undefined,
       observable: of(null as unknown as ReleaseDocument[] | undefined),
     } as StateSource<ReleaseDocument[] | undefined>)
-    const state = getActiveReleasesState(instance, {source: {projectId: 'test', dataset: 'test'}})
+    const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
     await new Promise((resolve) => setTimeout(resolve, 0))
     expect(state.getCurrent()).toEqual([])
 
@@ -175,7 +175,7 @@ describe('releasesStore', () => {
       observable: subject.asObservable(),
     } as StateSource<ReleaseDocument[] | undefined>)
 
-    const state = getActiveReleasesState(instance, {source: {projectId: 'test', dataset: 'test'}})
+    const state = getActiveReleasesState(instance, {resource: {projectId: 'test', dataset: 'test'}})
 
     subject.error(new Error('Query failed'))
 

package/src/releases/releasesStore.ts

@@ -1,7 +1,7 @@
 import {type SanityDocument} from '@sanity/types'
 import {map} from 'rxjs'
 
-import {type DocumentSource, isDatasetSource} from '../config/sanityConfig'
+import {type DocumentResource} from '../config/sanityConfig'
 /*
  * Although this is an import dependency cycle, it is not a logical cycle:
  * 1. releasesStore uses queryStore as a data source
@@ -11,7 +11,7 @@ import {type DocumentSource, isDatasetSource} from '../config/sanityConfig'
  */
 // eslint-disable-next-line import/no-cycle
 import {getQueryState} from '../query/queryStore'
-import {bindActionBySource, type BoundSourceKey} from '../store/createActionBinder'
+import {bindActionByResource, type BoundResourceKey} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {createStateSourceAction, type StateSource} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
@@ -41,7 +41,7 @@ export interface ReleasesStoreState {
   error?: unknown
 }
 
-export const releasesStore = defineStore<ReleasesStoreState, BoundSourceKey>({
+export const releasesStore = defineStore<ReleasesStoreState, BoundResourceKey>({
   name: 'Releases',
   getInitialState: (): ReleasesStoreState => ({
     activeReleases: undefined,
@@ -56,7 +56,7 @@ export const releasesStore = defineStore<ReleasesStoreState, BoundSourceKey>({
  * Get the active releases from the store.
  * @internal
  */
-const _getActiveReleasesState = bindActionBySource(
+const _getActiveReleasesState = bindActionByResource(
   releasesStore,
   createStateSourceAction({
     selector: ({state}, _?) => state.activeReleases,
@@ -69,9 +69,9 @@ const _getActiveReleasesState = bindActionBySource(
  */
 export const getActiveReleasesState = (
   instance: SanityInstance,
-  options?: {source?: DocumentSource},
+  options?: {resource?: DocumentResource},
 ): StateSource<ReleaseDocument[] | undefined> =>
-  // bindActionBySource keyFn destructures { source } from the first param, so pass {} when no options
+  // bindActionByResource keyFn destructures { resource } from the first param, so pass {} when no options
   _getActiveReleasesState(instance, options ?? {})
 
 const RELEASES_QUERY = 'releases::all()'
@@ -79,12 +79,12 @@ const RELEASES_QUERY = 'releases::all()'
 const subscribeToReleases = ({
   instance,
   state,
-  key: {source},
-}: StoreContext<ReleasesStoreState, BoundSourceKey>) => {
+  key: {resource},
+}: StoreContext<ReleasesStoreState, BoundResourceKey>) => {
   const {observable: releases$} = getQueryState<ReleaseDocument[]>(instance, {
     query: RELEASES_QUERY,
     perspective: 'raw',
-    source: source && !isDatasetSource(source) ? source : undefined,
+    resource,
     tag: 'releases',
   })
   return releases$

package/src/store/createActionBinder.test.ts

@@ -1,10 +1,10 @@
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {type DocumentSource} from '../config/sanityConfig'
+import {type DocumentResource} from '../config/sanityConfig'
 import {
   bindActionByDataset,
-  bindActionBySource,
-  bindActionBySourceAndPerspective,
+  bindActionByResource,
+  bindActionByResourceAndPerspective,
   bindActionGlobally,
   createActionBinder,
 } from './createActionBinder'
@@ -161,28 +161,28 @@ describe('bindActionGlobally', () => {
   })
 })
 
-describe('bindActionBySource', () => {
-  it('should throw an error when provided an invalid source', () => {
+describe('bindActionByResource', () => {
+  it('should throw an error when provided an invalid resource', () => {
     const storeDefinition = {
       name: 'SourceStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionBySource(storeDefinition, action)
+    const boundAction = bindActionByResource(storeDefinition, action)
     const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     expect(() =>
-      boundAction(instance, {source: {invalid: 'source'} as unknown as DocumentSource}),
-    ).toThrow('Received invalid source:')
+      boundAction(instance, {resource: {invalid: 'resource'} as unknown as DocumentResource}),
+    ).toThrow('Received invalid resource:')
   })
 
-  it('should throw an error when no source provided and projectId/dataset are missing', () => {
+  it('should throw an error when no resource provided and projectId/dataset are missing', () => {
     const storeDefinition = {
       name: 'SourceStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionBySource(storeDefinition, action)
+    const boundAction = bindActionByResource(storeDefinition, action)
     const instance = createSanityInstance({projectId: '', dataset: ''})
 
     expect(() => boundAction(instance, {})).toThrow(
@@ -190,47 +190,47 @@ describe('bindActionBySource', () => {
     )
   })
 
-  it('should work correctly with a valid dataset source', () => {
+  it('should work correctly with a valid dataset resource', () => {
     const storeDefinition = {
       name: 'SourceStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionBySource(storeDefinition, action)
+    const boundAction = bindActionByResource(storeDefinition, action)
     const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     const result = boundAction(instance, {
-      source: {projectId: 'proj2', dataset: 'ds2'},
+      resource: {projectId: 'proj2', dataset: 'ds2'},
     })
     expect(result).toBe('success')
   })
 })
 
-describe('bindActionBySourceAndPerspective', () => {
-  it('should throw an error when provided an invalid source', () => {
+describe('bindActionByResourceAndPerspective', () => {
+  it('should throw an error when provided an invalid resource', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     expect(() =>
       boundAction(instance, {
-        source: {invalid: 'source'} as unknown as DocumentSource,
+        resource: {invalid: 'resource'} as unknown as DocumentResource,
         perspective: 'drafts',
       }),
-    ).toThrow('Received invalid source:')
+    ).toThrow('Received invalid resource:')
   })
 
-  it('should throw an error when no source provided and projectId/dataset are missing', () => {
+  it('should throw an error when no resource provided and projectId/dataset are missing', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     const instance = createSanityInstance({projectId: '', dataset: ''})
 
     expect(() => boundAction(instance, {perspective: 'drafts'})).toThrow(
@@ -238,33 +238,33 @@ describe('bindActionBySourceAndPerspective', () => {
     )
   })
 
-  it('should work correctly with a valid dataset source and explicit perspective', () => {
+  it('should work correctly with a valid dataset resource and explicit perspective', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     const result = boundAction(instance, {
-      source: {projectId: 'proj2', dataset: 'ds2'},
+      resource: {projectId: 'proj2', dataset: 'ds2'},
       perspective: 'drafts',
     })
     expect(result).toBe('success')
   })
 
-  it('should work correctly with valid dataset source and no perspective (falls back to drafts)', () => {
+  it('should work correctly with valid dataset resource and no perspective (falls back to drafts)', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     const result = boundAction(instance, {
-      source: {projectId: 'proj1', dataset: 'ds1'},
+      resource: {projectId: 'proj1', dataset: 'ds1'},
     })
     expect(result).toBe('success')
   })
@@ -275,7 +275,7 @@ describe('bindActionBySourceAndPerspective', () => {
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((context) => context.key)
-    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     const instance = createSanityInstance({
       projectId: 'proj1',
       dataset: 'ds1',
@@ -300,7 +300,7 @@ describe('bindActionBySourceAndPerspective', () => {
       context.state.counter += increment
       return context.state.counter
     })
-    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     // Use unique project/dataset so we don't reuse stores from other tests
     const instance = createSanityInstance({
       projectId: 'perspective-isolation',
@@ -322,7 +322,7 @@ describe('bindActionBySourceAndPerspective', () => {
       getInitialState: () => ({counter: 0}),
     }
     const action = vi.fn((_context) => 'success')
-    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     const instance = createSanityInstance({projectId: 'proj1', dataset: 'ds1'})
 
     const result = boundAction(instance, {
@@ -339,7 +339,7 @@ describe('bindActionBySourceAndPerspective', () => {
     )
   })
 
-  it('should reuse same store when same source and perspective are used', () => {
+  it('should reuse same store when same resource and perspective are used', () => {
     const storeDefinition = {
       name: 'PerspectiveStore',
       getInitialState: () => ({counter: 0}),
@@ -348,7 +348,7 @@ describe('bindActionBySourceAndPerspective', () => {
       context.state.counter += increment
       return context.state.counter
     })
-    const boundAction = bindActionBySourceAndPerspective(storeDefinition, action)
+    const boundAction = bindActionByResourceAndPerspective(storeDefinition, action)
     // Use unique project/dataset so we don't reuse stores from other tests
     const instance = createSanityInstance({
       projectId: 'perspective-reuse',