@sanity/sdk 2.8.0 → 2.10.0

package/src/preview/previewProjectionUtils.test.ts

@@ -0,0 +1,179 @@
+import {type SanityClient} from '@sanity/client'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {createSanityInstance} from '../store/createSanityInstance'
+import {normalizeMedia, transformProjectionToPreview} from './previewProjectionUtils'
+import {type PreviewQueryResult} from './types'
+
+// Mock the getClient function
+vi.mock('../client/clientStore', () => ({
+  getClient: vi.fn(),
+}))
+
+const mockClient = {
+  config: () => ({projectId: 'test-project', dataset: 'test-dataset'}),
+} as unknown as SanityClient
+
+describe('normalizeMedia', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks()
+  })
+
+  it('returns null if media is null or undefined', () => {
+    expect(normalizeMedia(null, mockClient)).toBeNull()
+    expect(normalizeMedia(undefined, mockClient)).toBeNull()
+  })
+
+  it('returns null if media does not have a valid asset', () => {
+    const invalidMedia1 = {media: {_ref: 'image-abc123-200x200-png'}} // Missing `asset` property
+    const invalidMedia2 = {asset: {ref: 'image-abc123-200x200-png'}} // Incorrect property name `ref`
+    expect(normalizeMedia(invalidMedia1, mockClient)).toBeNull()
+    expect(normalizeMedia(invalidMedia2, mockClient)).toBeNull()
+  })
+
+  it('returns null if media is not an object', () => {
+    expect(normalizeMedia(123, mockClient)).toBeNull()
+    expect(normalizeMedia('invalid', mockClient)).toBeNull()
+  })
+
+  it('returns a normalized URL for valid image asset objects', () => {
+    const validMedia = {type: 'image-asset', _ref: 'image-abc123-200x200-png'}
+    const result = normalizeMedia(validMedia, mockClient)
+    expect(result).toEqual({
+      type: 'image-asset',
+      _ref: 'image-abc123-200x200-png',
+      url: 'https://cdn.sanity.io/images/test-project/test-dataset/abc123-200x200.png',
+    })
+  })
+
+  it('handles image assets with expected URL format', () => {
+    const media = {type: 'image-asset', _ref: 'image-xyz456-400x400-jpg'}
+    const result = normalizeMedia(media, mockClient)
+    expect(result).toEqual({
+      type: 'image-asset',
+      _ref: 'image-xyz456-400x400-jpg',
+      url: 'https://cdn.sanity.io/images/test-project/test-dataset/xyz456-400x400.jpg',
+    })
+  })
+})
+
+describe('transformProjectionToPreview', () => {
+  const instance = createSanityInstance({
+    projectId: 'test-project',
+    dataset: 'test-dataset',
+  })
+
+  beforeEach(async () => {
+    vi.clearAllMocks()
+
+    // Mock getClient to return our mock client
+    const {getClient} = await import('../client/clientStore')
+    vi.mocked(getClient).mockReturnValue(mockClient)
+  })
+
+  it('transforms projection result with title and subtitle', () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {title: 'My Title'},
+      subtitleCandidates: {description: 'My Description'},
+      media: null,
+    }
+
+    const result = transformProjectionToPreview(instance, projectionResult)
+
+    expect(result).toEqual({
+      title: 'My Title',
+      subtitle: 'My Description',
+      media: null,
+    })
+  })
+
+  it('uses fallback title when no title candidates exist', () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {},
+      subtitleCandidates: {},
+      media: null,
+    }
+
+    const result = transformProjectionToPreview(instance, projectionResult)
+
+    expect(result.title).toBe('article: doc1')
+    expect(result.subtitle).toBeUndefined()
+  })
+
+  it('transforms projection result with media', () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {title: 'My Title'},
+      subtitleCandidates: {},
+      media: {type: 'image-asset', _ref: 'image-abc123-200x200-png', url: ''},
+    }
+
+    const result = transformProjectionToPreview(instance, projectionResult)
+
+    expect(result).toEqual({
+      title: 'My Title',
+      subtitle: undefined,
+      media: {
+        type: 'image-asset',
+        _ref: 'image-abc123-200x200-png',
+        url: 'https://cdn.sanity.io/images/test-project/test-dataset/abc123-200x200.png',
+      },
+    })
+  })
+
+  it('includes status when provided', () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {title: 'My Title'},
+      subtitleCandidates: {},
+      media: null,
+      _status: {
+        lastEditedPublishedAt: '2026-01-01',
+        lastEditedDraftAt: '2026-01-02',
+      },
+    }
+
+    const result = transformProjectionToPreview(instance, projectionResult)
+
+    expect(result).toEqual({
+      title: 'My Title',
+      subtitle: undefined,
+      media: null,
+      _status: {
+        lastEditedPublishedAt: '2026-01-01',
+        lastEditedDraftAt: '2026-01-02',
+      },
+    })
+  })
+
+  it('calls getClient with the provided resource', async () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {title: 'My Title'},
+      subtitleCandidates: {},
+      media: null,
+    }
+
+    const resource = {mediaLibraryId: 'test-library'}
+
+    transformProjectionToPreview(instance, projectionResult, resource)
+
+    const {getClient} = await import('../client/clientStore')
+    expect(getClient).toHaveBeenCalledWith(instance, {
+      apiVersion: 'v2025-05-06',
+      resource,
+    })
+  })
+})

package/src/preview/previewProjectionUtils.ts

@@ -0,0 +1,93 @@
+import {type SanityClient} from '@sanity/client'
+import {createImageUrlBuilder} from '@sanity/image-url'
+
+import {getClient} from '../client/clientStore'
+import {type DocumentResource, isDatasetResource} from '../config/sanityConfig'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {isObject} from '../utils/object'
+import {SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './previewConstants'
+import {type PreviewQueryResult, type PreviewValue} from './types'
+
+const API_VERSION = 'v2025-05-06'
+
+/**
+ * Checks if the provided value has `_ref` property that is a string and starts with `image-`
+ */
+function hasImageRef<T>(value: unknown): value is T & {_ref: string} {
+  return isObject(value) && '_ref' in value && typeof (value as {_ref: unknown})._ref === 'string'
+}
+
+/**
+ * Normalizes a media asset to a preview value.
+ * Adds a url to a media asset reference using `@sanity/image-url`.
+ *
+ * @internal
+ */
+export function normalizeMedia(media: unknown, client: SanityClient): PreviewValue['media'] {
+  if (!media) return null
+  if (!hasImageRef(media)) return null
+
+  const builder = createImageUrlBuilder(client)
+  const url = builder.image({_ref: media._ref}).url()
+
+  return {
+    type: 'image-asset',
+    _ref: media._ref,
+    url,
+  }
+}
+
+/**
+ * Finds a single field value from a set of candidates based on a priority list of field names.
+ * Returns the first non-empty string value found from the candidates matching the priority list order.
+ *
+ * @internal
+ */
+function findFirstDefined(
+  fieldsToSearch: string[],
+  candidates: Record<string, unknown>,
+  exclude?: unknown,
+): string | undefined {
+  if (!candidates) return undefined
+
+  for (const field of fieldsToSearch) {
+    const value = candidates[field]
+    if (typeof value === 'string' && value.trim() !== '' && value !== exclude) {
+      return value
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Transforms a projection result (with titleCandidates, subtitleCandidates, media)
+ * into a PreviewValue (with title, subtitle, media).
+ *
+ * @param projectionResult - The raw projection result from GROQ
+ * @param instance - The Sanity instance to use for client configuration
+ * @param resource - Data resource for the preview
+ * @internal
+ */
+export function transformProjectionToPreview(
+  instance: SanityInstance,
+  projectionResult: PreviewQueryResult,
+  resource?: DocumentResource,
+): PreviewValue {
+  const title = findFirstDefined(TITLE_CANDIDATES, projectionResult.titleCandidates)
+  const subtitle = findFirstDefined(SUBTITLE_CANDIDATES, projectionResult.subtitleCandidates, title)
+
+  // Get a client for the resource (if provided) or use the instance config
+  const client = getClient(instance, {
+    apiVersion: API_VERSION,
+    // TODO: remove in v3 when we're ready for everything to be queried via resource
+    resource: resource && !isDatasetResource(resource) ? resource : undefined,
+  })
+
+  return {
+    title: String(title || `${projectionResult._type}: ${projectionResult._id}`),
+    subtitle: subtitle || undefined,
+    media: normalizeMedia(projectionResult.media, client),
+    ...(projectionResult._status && {_status: projectionResult._status}),
+  }
+}

package/src/preview/resolvePreview.test.ts

@@ -1,28 +1,17 @@
-import {of} from 'rxjs'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {createDocumentHandle} from '../config/handles'
+import {resolveProjection} from '../projection/resolveProjection'
+import {type ProjectionValuePending} from '../projection/types'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {type StateSource} from '../store/createStateSourceAction'
-import {getPreviewState} from './getPreviewState'
-import {type PreviewValue, type ValuePending} from './previewStore'
 import {resolvePreview} from './resolvePreview'
+import {type PreviewQueryResult} from './types'
 
-vi.mock('./getPreviewState')
+vi.mock('../projection/resolveProjection')
 
 describe('resolvePreview', () => {
   let instance: SanityInstance
-
   beforeEach(() => {
-    vi.resetAllMocks()
-    // Create a mock that returns the correct ValuePending type
-    vi.mocked(getPreviewState).mockReturnValue({
-      observable: of({
-        data: {title: 'test'},
-        isPending: false,
-      } as ValuePending<PreviewValue>),
-    } as StateSource<ValuePending<PreviewValue>>)
-
+    vi.clearAllMocks()
     instance = createSanityInstance({projectId: 'p', dataset: 'd'})
   })
 
@@ -30,18 +19,46 @@ describe('resolvePreview', () => {
     instance.dispose()
   })
 
-  it('resolves a preview and returns the first emitted value with results', async () => {
-    const docHandle = createDocumentHandle({
-      documentId: 'doc123',
-      documentType: 'movie',
+  it('resolves and transforms projection result to preview format', async () => {
+    const mockProjectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2024-01-01',
+      titleCandidates: {title: 'Resolved Title'},
+      subtitleCandidates: {description: 'Resolved Description'},
+      media: null,
+    }
+
+    vi.mocked(resolveProjection).mockResolvedValue({
+      data: mockProjectionResult,
+      isPending: false,
+    } as ProjectionValuePending<PreviewQueryResult>)
+
+    const result = await resolvePreview(instance, {
+      documentId: 'doc1',
+      documentType: 'article',
     })
 
-    const result = await resolvePreview(instance, docHandle)
+    expect(result.data).toEqual({
+      title: 'Resolved Title',
+      subtitle: 'Resolved Description',
+      media: null,
+    })
+    expect(result.isPending).toBe(false)
+  })
 
-    expect(getPreviewState).toHaveBeenCalledWith(instance, docHandle)
-    expect(result).toEqual({
-      data: {title: 'test'},
+  it('returns null data when projection resolves with null', async () => {
+    vi.mocked(resolveProjection).mockResolvedValue({
+      data: null,
       isPending: false,
     })
+
+    const result = await resolvePreview(instance, {
+      documentId: 'doc1',
+      documentType: 'article',
+    })
+
+    expect(result.data).toBeNull()
+    expect(result.isPending).toBe(false)
   })
 })

package/src/preview/resolvePreview.ts

@@ -1,20 +1,43 @@
-import {filter, firstValueFrom} from 'rxjs'
-
 import {type DocumentHandle} from '../config/sanityConfig'
-import {bindActionByDataset} from '../store/createActionBinder'
-import {getPreviewState} from './getPreviewState'
-import {previewStore} from './previewStore'
+import {resolveProjection} from '../projection/resolveProjection'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {PREVIEW_PROJECTION} from './previewConstants'
+import {transformProjectionToPreview} from './previewProjectionUtils'
+import {type PreviewQueryResult, type PreviewValue, type ValuePending} from './types'
 
 /**
  * @beta
+ * @deprecated This type is deprecated and will be removed in a future release.
  */
 export type ResolvePreviewOptions = DocumentHandle
 
 /**
  * @beta
+ * @deprecated This function is deprecated and will be removed in a future release.
  */
-export const resolvePreview = bindActionByDataset(
-  previewStore,
-  ({instance}, docHandle: ResolvePreviewOptions) =>
-    firstValueFrom(getPreviewState(instance, docHandle).observable.pipe(filter((i) => !!i.data))),
-)
+export async function resolvePreview(
+  instance: SanityInstance,
+  options: ResolvePreviewOptions,
+): Promise<ValuePending<PreviewValue>> {
+  // Resolve the projection
+  const projectionResult = await resolveProjection<PreviewQueryResult>(instance, {
+    ...options,
+    projection: PREVIEW_PROJECTION,
+  })
+
+  if (!projectionResult.data) {
+    return {data: null, isPending: projectionResult.isPending}
+  }
+
+  // Transform to preview format
+  const previewValue = transformProjectionToPreview(
+    instance,
+    projectionResult.data,
+    options.resource,
+  )
+
+  return {
+    data: previewValue,
+    isPending: projectionResult.isPending,
+  }
+}

package/src/preview/{previewStore.ts → types.ts}

@@ -1,7 +1,9 @@
-import {type BoundDatasetKey} from '../store/createActionBinder'
-import {defineStore} from '../store/defineStore'
-import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
+import {type DocumentStatus} from '../projection/types'
 
+/**
+ *
+ * @internal
+ */
 export interface PreviewQueryResult {
   _id: string
   _type: string
@@ -9,6 +11,7 @@ export interface PreviewQueryResult {
   titleCandidates: Record<string, unknown>
   subtitleCandidates: Record<string, unknown>
   media?: PreviewMedia | null
+  _status?: DocumentStatus
 }
 
 /**
@@ -74,22 +77,10 @@ export type ValuePending<T> = {
 
 /**
  * @public
+ * @deprecated This interface is kept for backwards compatibility but is no longer used internally.
+ * Preview state is now stored in the projection store.
  */
 export interface PreviewStoreState {
   values: {[TDocumentId in string]?: ValuePending<PreviewValue>}
   subscriptions: {[TDocumentId in string]?: {[TSubscriptionId in string]?: true}}
 }
-
-export const previewStore = defineStore<PreviewStoreState, BoundDatasetKey>({
-  name: 'Preview',
-  getInitialState() {
-    return {
-      subscriptions: {},
-      values: {},
-    }
-  },
-  initialize: (context) => {
-    const subscription = subscribeToStateAndFetchBatches(context)
-    return () => subscription.unsubscribe
-  },
-})

package/src/projection/getProjectionState.test.ts

@@ -126,7 +126,7 @@ describe('getProjectionState', () => {
     expect(state.get().subscriptions).toEqual({})
     expect(state.get().documentProjections).toEqual({})
 
-    const unsubscribe1 = projectionState1.subscribe(vi.fn()) // Should use ID 3
+    const unsubscribe1 = projectionState1.subscribe(vi.fn()) // Should use ID 2
     expect(state.get().subscriptions).toEqual({
       [docHandle.documentId]: {[hash1]: {testSubId_2: true}},
     })
@@ -134,7 +134,7 @@ describe('getProjectionState', () => {
       [docHandle.documentId]: {[hash1]: projection1},
     })
 
-    const unsubscribe2 = projectionState2.subscribe(vi.fn()) // Should use ID 4
+    const unsubscribe2 = projectionState2.subscribe(vi.fn()) // Should use ID 3
     expect(state.get().subscriptions).toEqual({
       [docHandle.documentId]: {
         [hash1]: {testSubId_2: true},
@@ -148,10 +148,12 @@ describe('getProjectionState', () => {
       },
     })
 
-    const unsubscribe3 = projectionState1.subscribe(vi.fn()) // Should use ID 5
+    // should share ID 2 from the first subscription -- we only care if ANY subscription exists
+    // so we can include the document / projection in a bulk fetch
+    const unsubscribe3 = projectionState1.subscribe(vi.fn())
     expect(state.get().subscriptions).toEqual({
       [docHandle.documentId]: {
-        [hash1]: {testSubId_2: true, testSubId_4: true},
+        [hash1]: {testSubId_2: true},
         [hash2]: {testSubId_3: true},
       },
     })
@@ -165,23 +167,20 @@ describe('getProjectionState', () => {
     })
 
     // --- Test Unsubscribe ---
-    unsubscribe1() // Unsubscribes ID 3
-    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({
-      testSubId_2: true,
-      testSubId_4: true,
-    })
+    unsubscribe1() // Unsubscribes first subscription consumer
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({testSubId_2: true})
     vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
-    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({testSubId_4: true})
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({testSubId_2: true})
     expect(state.get().documentProjections[docHandle.documentId]?.[hash1]).toEqual(projection1)
 
-    unsubscribe3() // Unsubscribes ID 5
+    unsubscribe3() // Also unsubscibes first projection subscription, should be removed
     vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
     expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toBeUndefined()
     expect(state.get().documentProjections[docHandle.documentId]?.[hash1]).toBeUndefined()
     expect(state.get().subscriptions[docHandle.documentId]?.[hash2]).toEqual({testSubId_3: true})
     expect(state.get().documentProjections[docHandle.documentId]?.[hash2]).toEqual(projection2)
 
-    unsubscribe2() // Unsubscribes ID 4
+    unsubscribe2() // Unsubscribes second projection subscription, should be removed
     vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
     expect(state.get().subscriptions[docHandle.documentId]).toBeUndefined()
     expect(state.get().documentProjections[docHandle.documentId]).toBeUndefined()
@@ -203,14 +202,14 @@ describe('getProjectionState', () => {
     }))
 
     const unsubscribe1 = projectionState.subscribe(vi.fn()) // Should use ID 2
-    const unsubscribe2 = projectionState.subscribe(vi.fn()) // Should use ID 3
+    const unsubscribe2 = projectionState.subscribe(vi.fn()) // Should reuse ID 2
 
     expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
       data: initialData,
       isPending: true,
     })
 
-    unsubscribe1() // Unsubscribes ID 2
+    unsubscribe1() // Unsubscribes first subscription consumer
     vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
     expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
       data: initialData,
@@ -219,9 +218,10 @@ describe('getProjectionState', () => {
     expect(Object.keys(state.get().subscriptions[docHandle.documentId]?.[hash] ?? {}).length).toBe(
       1,
     )
-    expect(state.get().subscriptions[docHandle.documentId]?.[hash]).toEqual({testSubId_3: true})
+    // should still have the same subscription ID since we're not unsubscribing the second consumer
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash]).toEqual({testSubId_2: true})
 
-    unsubscribe2() // Unsubscribes ID 3
+    unsubscribe2() // Unsubscribes second subscription consumer
     expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
       data: initialData,
       isPending: true,

package/src/projection/getProjectionState.ts

@@ -1,9 +1,8 @@
 import {DocumentId, getPublishedId} from '@sanity/id-utils'
 import {type SanityProjectionResult} from 'groq'
-import {omit} from 'lodash-es'
 
 import {type DocumentHandle} from '../config/sanityConfig'
-import {bindActionBySourceAndPerspective} from '../store/createActionBinder'
+import {bindActionByResourceAndPerspective} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {
   createStateSourceAction,
@@ -12,6 +11,8 @@ import {
 } from '../store/createStateSourceAction'
 import {hashString} from '../utils/hashString'
 import {insecureRandomId} from '../utils/ids'
+import {omitProperty} from '../utils/object'
+import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {projectionStore} from './projectionStore'
 import {type ProjectionStoreState, type ProjectionValuePending} from './types'
 import {PROJECTION_STATE_CLEAR_DELAY, STABLE_EMPTY_PROJECTION, validateProjection} from './util'
@@ -71,7 +72,7 @@ export function getProjectionState(
 /**
  * @beta
  */
-export const _getProjectionState = bindActionBySourceAndPerspective(
+export const _getProjectionState = bindActionByResourceAndPerspective(
   projectionStore,
   createStateSourceAction({
     selector: (
@@ -110,9 +111,9 @@ export const _getProjectionState = bindActionBySourceAndPerspective(
       }))
 
       return () => {
-        setTimeout(() => {
+        setCleanupTimeout(() => {
           state.set('removeSubscription', (prev): Partial<ProjectionStoreState> => {
-            const documentSubscriptionsForHash = omit(
+            const documentSubscriptionsForHash = omitProperty(
               prev.subscriptions[documentId]?.[projectionHash],
               subscriptionId,
             )

package/src/projection/projectionQuery.ts

@@ -1,8 +1,7 @@
 import {type ClientPerspective} from '@sanity/client'
-import {DocumentId} from '@sanity/id-utils'
+import {DocumentId, getPublishedId} from '@sanity/id-utils'
 
 import {type ReleasePerspective} from '../config/sanityConfig'
-import {getPublishedId} from '../utils/ids'
 import {
   type DocumentProjections,
   type DocumentProjectionValues,
@@ -85,7 +84,7 @@ export function processProjectionQuery({
   } = {}
 
   for (const result of results) {
-    const originalId = getPublishedId(result._id)
+    const originalId = getPublishedId(DocumentId(result._id))
     const hash = result.__projectionHash
 
     if (!ids.has(originalId)) continue

package/src/projection/projectionStore.test.ts

@@ -30,7 +30,7 @@ describe('projectionStore', () => {
       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.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,
   }