@sanity/sdk 2.9.0 → 2.10.0

package/src/projection/resolveProjection.ts

@@ -1,7 +1,7 @@
 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'
@@ -38,7 +38,7 @@ export function resolveProjection(
 /**
  * @beta
  */
-const _resolveProjection = bindActionBySourceAndPerspective(
+const _resolveProjection = bindActionByResourceAndPerspective(
   projectionStore,
   (
     {instance}: {instance: SanityInstance},

package/src/projection/subscribeToStateAndFetchBatches.test.ts

@@ -17,7 +17,7 @@ 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,
   }
 

package/src/projection/subscribeToStateAndFetchBatches.ts

@@ -1,4 +1,4 @@
-import {isEqual} from 'lodash-es'
+import {DocumentId} from '@sanity/id-utils'
 import {
   combineLatest,
   debounceTime,
@@ -16,10 +16,11 @@ import {
   tap,
 } from 'rxjs'
 
-import {isDatasetSource} from '../config/sanityConfig'
+import {isDatasetResource} from '../config/sanityConfig'
 import {getQueryState, resolveQuery} from '../query/queryStore'
 import {type BoundPerspectiveKey} from '../store/createActionBinder'
 import {type StoreContext} from '../store/defineStore'
+import {isDeepEqual} from '../utils/object'
 import {
   createProjectionQuery,
   processProjectionQuery,
@@ -42,22 +43,22 @@ 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),
-    distinctUntilChanged(isEqual),
+    distinctUntilChanged(isDeepEqual),
   )
 
   const activeDocumentIds$ = state.observable.pipe(
-    map(({subscriptions}) => new Set(Object.keys(subscriptions))),
+    map(({subscriptions}) => new Set(Object.keys(subscriptions).map((id) => DocumentId(id)))),
     distinctUntilChanged(isSetEqual),
   )
 
   const pendingUpdateSubscription = activeDocumentIds$
     .pipe(
       debounceTime(BATCH_DEBOUNCE_TIME),
-      startWith(new Set<string>()),
+      startWith(new Set<DocumentId>()),
       pairwise(),
       tap(([prevIds, currIds]) => {
         const newIds = [...currIds].filter((id) => !prevIds.has(id))
@@ -89,7 +90,7 @@ export const subscribeToStateAndFetchBatches = ({
 
   const queryTrigger$ = combineLatest([activeDocumentIds$, documentProjections$]).pipe(
     debounceTime(BATCH_DEBOUNCE_TIME),
-    distinctUntilChanged(isEqual),
+    distinctUntilChanged(isDeepEqual),
   )
 
   const queryExecutionSubscription = queryTrigger$
@@ -113,7 +114,7 @@ export const subscribeToStateAndFetchBatches = ({
               perspective,
             },
             // temporary guard here until we're ready for everything to be queried via global API
-            ...(source && !isDatasetSource(source) ? {source} : {}),
+            ...(resource && !isDatasetResource(resource) ? {resource} : {}),
           })
 
           const querySource$ = defer(() => {
@@ -128,7 +129,7 @@ export const subscribeToStateAndFetchBatches = ({
                     perspective,
                   },
                   // temporary guard here until we're ready for everything to be queried via global API in v3
-                  ...(source && !isDatasetSource(source) ? {source} : {}),
+                  ...(resource && !isDatasetResource(resource) ? {resource} : {}),
                 }),
               ).pipe(switchMap(() => observable))
             }
@@ -154,7 +155,7 @@ export const subscribeToStateAndFetchBatches = ({
               perspective: 'raw',
             },
             // temporary guard here until we're ready for everything to be queried via global API
-            ...(source && !isDatasetSource(source) ? {source} : {}),
+            ...(resource && !isDatasetResource(resource) ? {resource} : {}),
           })
 
           const statusQuerySource$ = defer(() => {
@@ -169,7 +170,7 @@ export const subscribeToStateAndFetchBatches = ({
                     perspective: 'raw',
                   },
                   // temporary guard here until we're ready for everything to be queried via global API
-                  ...(source && !isDatasetSource(source) ? {source} : {}),
+                  ...(resource && !isDatasetResource(resource) ? {resource} : {}),
                 }),
               ).pipe(switchMap(() => observable))
             }

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, isDatasetResource} 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,12 @@ 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 && !isDatasetResource(resource) ? {resource} : {}),
   }).observable.pipe(
     switchMap((client) =>
       defer(() =>
@@ -316,7 +316,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 +375,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,7 +39,7 @@ describe('releasesStore', () => {
       expect.objectContaining({
         query: 'releases::all()',
         perspective: 'raw',
-        source: undefined,
+        resource: undefined,
         tag: 'releases',
       }),
     )
@@ -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, isDatasetResource} 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: resource && !isDatasetResource(resource) ? resource : undefined,
     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',