@sanity/sdk 2.6.0 → 2.7.0

package/src/projection/getProjectionState.ts

@@ -1,8 +1,9 @@
+import {DocumentId, getPublishedId} from '@sanity/id-utils'
 import {type SanityProjectionResult} from 'groq'
 import {omit} from 'lodash-es'
 
 import {type DocumentHandle} from '../config/sanityConfig'
-import {bindActionByDataset} from '../store/createActionBinder'
+import {bindActionBySourceAndPerspective} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {
   createStateSourceAction,
@@ -10,7 +11,7 @@ import {
   type StateSource,
 } from '../store/createStateSourceAction'
 import {hashString} from '../utils/hashString'
-import {getPublishedId, insecureRandomId} from '../utils/ids'
+import {insecureRandomId} from '../utils/ids'
 import {projectionStore} from './projectionStore'
 import {type ProjectionStoreState, type ProjectionValuePending} from './types'
 import {PROJECTION_STATE_CLEAR_DELAY, STABLE_EMPTY_PROJECTION, validateProjection} from './util'
@@ -70,21 +71,21 @@ export function getProjectionState(
 /**
  * @beta
  */
-export const _getProjectionState = bindActionByDataset(
+export const _getProjectionState = bindActionBySourceAndPerspective(
   projectionStore,
   createStateSourceAction({
     selector: (
       {state}: SelectorContext<ProjectionStoreState>,
       options: ProjectionOptions<string, string, string, string>,
     ): ProjectionValuePending<object> | undefined => {
-      const documentId = getPublishedId(options.documentId)
+      const documentId = getPublishedId(DocumentId(options.documentId))
       const projectionHash = hashString(options.projection)
       return state.values[documentId]?.[projectionHash] ?? STABLE_EMPTY_PROJECTION
     },
     onSubscribe: ({state}, options: ProjectionOptions<string, string, string, string>) => {
       const {projection, ...docHandle} = options
       const subscriptionId = insecureRandomId()
-      const documentId = getPublishedId(docHandle.documentId)
+      const documentId = getPublishedId(DocumentId(docHandle.documentId))
       const validProjection = validateProjection(projection)
       const projectionHash = hashString(validProjection)
 

package/src/projection/projectionQuery.test.ts

@@ -1,10 +1,11 @@
+import {DocumentId} from '@sanity/id-utils'
 import {describe, expect, it} from 'vitest'
 
 import {createProjectionQuery, processProjectionQuery} from './projectionQuery'
 
 describe('createProjectionQuery', () => {
   it('creates a query and params for given ids and projections', () => {
-    const ids = new Set(['doc1', 'doc2'])
+    const ids = new Set(['doc1', 'doc2'].map(DocumentId))
     const projectionHash = '{title, description}'
     const documentProjections = {
       doc1: {[projectionHash]: projectionHash},
@@ -15,11 +16,11 @@ describe('createProjectionQuery', () => {
     expect(query).toMatch(/.*_id in \$__ids_.*/)
     expect(Object.keys(params)).toHaveLength(1)
     expect(params[`__ids_${projectionHash}`]).toBeDefined()
-    expect(params[`__ids_${projectionHash}`]).toHaveLength(4)
+    expect(params[`__ids_${projectionHash}`]).toHaveLength(2)
   })
 
   it('handles multiple different projections', () => {
-    const ids = new Set(['doc1', 'doc2'])
+    const ids = new Set(['doc1', 'doc2'].map(DocumentId))
     const projectionHash1 = '{title, description}'
     const projectionHash2 = '{name, age}'
     const documentProjections = {
@@ -31,13 +32,13 @@ describe('createProjectionQuery', () => {
     expect(query).toMatch(/.*_id in \$__ids_.*/)
     expect(Object.keys(params)).toHaveLength(2)
     expect(params[`__ids_${projectionHash1}`]).toBeDefined()
-    expect(params[`__ids_${projectionHash1}`]).toHaveLength(2)
+    expect(params[`__ids_${projectionHash1}`]).toHaveLength(1)
     expect(params[`__ids_${projectionHash2}`]).toBeDefined()
-    expect(params[`__ids_${projectionHash2}`]).toHaveLength(2)
+    expect(params[`__ids_${projectionHash2}`]).toHaveLength(1)
   })
 
   it('filters out ids without projections', () => {
-    const ids = new Set(['doc1', 'doc2', 'doc3'])
+    const ids = new Set(['doc1', 'doc2', 'doc3'].map(DocumentId))
     const projectionHash1 = '{title}'
     // projectionHash2 missing intentionally
     const projectionHash3 = '{name}'
@@ -51,9 +52,9 @@ describe('createProjectionQuery', () => {
     expect(query).toMatch(/.*_id in \$__ids_.*/)
     expect(Object.keys(params)).toHaveLength(2)
     expect(params[`__ids_${projectionHash1}`]).toBeDefined()
-    expect(params[`__ids_${projectionHash1}`]).toHaveLength(2)
+    expect(params[`__ids_${projectionHash1}`]).toHaveLength(1)
     expect(params[`__ids_${projectionHash3}`]).toBeDefined()
-    expect(params[`__ids_${projectionHash3}`]).toHaveLength(2)
+    expect(params[`__ids_${projectionHash3}`]).toHaveLength(1)
   })
 })
 
@@ -63,10 +64,9 @@ describe('processProjectionQuery', () => {
   it('returns structure with empty object if no results found', () => {
     const ids = new Set(['doc1'])
     const result = processProjectionQuery({
-      projectId: 'p',
-      dataset: 'd',
       ids,
       results: [], // no results
+      perspective: 'published',
     })
 
     expect(result['doc1']).toEqual({})
@@ -85,10 +85,14 @@ describe('processProjectionQuery', () => {
     ]
 
     const processed = processProjectionQuery({
-      projectId: 'p',
-      dataset: 'd',
       ids,
       results,
+      perspective: 'published',
+      documentStatuses: {
+        doc1: {
+          lastEditedPublishedAt: '2021-01-01',
+        },
+      },
     })
 
     expect(processed['doc1']?.[testProjectionHash]).toEqual({
@@ -116,10 +120,14 @@ describe('processProjectionQuery', () => {
     ]
 
     const processed = processProjectionQuery({
-      projectId: 'p',
-      dataset: 'd',
       ids: new Set(['doc1']),
       results,
+      perspective: 'published',
+      documentStatuses: {
+        doc1: {
+          lastEditedPublishedAt: '2021-01-01',
+        },
+      },
     })
 
     expect(processed['doc1']?.[testProjectionHash]).toEqual({
@@ -134,66 +142,37 @@ describe('processProjectionQuery', () => {
     })
   })
 
-  it('handles both draft and published documents', () => {
+  it('handles release perspective with all three status fields', () => {
     const results = [
-      {
-        _id: 'drafts.doc1',
-        _type: 'document',
-        _updatedAt: '2021-01-02',
-        result: {title: 'Draft'},
-        __projectionHash: testProjectionHash,
-      },
       {
         _id: 'doc1',
         _type: 'document',
-        _updatedAt: '2021-01-01',
-        result: {title: 'Published'},
+        _updatedAt: '2021-01-03',
+        result: {title: 'Version'},
         __projectionHash: testProjectionHash,
       },
     ]
 
     const processed = processProjectionQuery({
-      projectId: 'p',
-      dataset: 'd',
       ids: new Set(['doc1']),
       results,
-    })
-
-    expect(processed['doc1']?.[testProjectionHash]).toEqual({
-      data: {
-        title: 'Draft',
-        _status: {
+      perspective: {releaseName: 'release1'},
+      documentStatuses: {
+        doc1: {
           lastEditedDraftAt: '2021-01-02',
           lastEditedPublishedAt: '2021-01-01',
+          lastEditedVersionAt: '2021-01-03',
         },
       },
-      isPending: false,
-    })
-  })
-
-  it('uses published result when no draft exists', () => {
-    const results = [
-      {
-        _id: 'doc1',
-        _type: 'document',
-        _updatedAt: '2021-01-01',
-        result: {title: 'Published'},
-        __projectionHash: testProjectionHash,
-      },
-    ]
-
-    const processed = processProjectionQuery({
-      projectId: 'p',
-      dataset: 'd',
-      ids: new Set(['doc1']),
-      results,
     })
 
     expect(processed['doc1']?.[testProjectionHash]).toEqual({
       data: {
-        title: 'Published',
+        title: 'Version',
         _status: {
+          lastEditedDraftAt: '2021-01-02',
           lastEditedPublishedAt: '2021-01-01',
+          lastEditedVersionAt: '2021-01-03',
         },
       },
       isPending: false,
@@ -221,10 +200,14 @@ describe('processProjectionQuery', () => {
     ]
 
     const processed = processProjectionQuery({
-      projectId: 'p',
-      dataset: 'd',
       ids: new Set(['doc1']),
       results,
+      perspective: 'published',
+      documentStatuses: {
+        doc1: {
+          lastEditedPublishedAt: '2021-01-01',
+        },
+      },
     })
 
     expect(processed['doc1']?.[hash1]).toEqual({

package/src/projection/projectionQuery.ts

@@ -1,5 +1,13 @@
-import {getDraftId, getPublishedId} from '../utils/ids'
-import {type DocumentProjections, type DocumentProjectionValues} from './types'
+import {type ClientPerspective} from '@sanity/client'
+import {DocumentId} from '@sanity/id-utils'
+
+import {type ReleasePerspective} from '../config/sanityConfig'
+import {getPublishedId} from '../utils/ids'
+import {
+  type DocumentProjections,
+  type DocumentProjectionValues,
+  type ProjectionStoreState,
+} from './types'
 import {validateProjection} from './util'
 
 export type ProjectionQueryResult = {
@@ -18,8 +26,8 @@ interface CreateProjectionQueryResult {
 type ProjectionMap = Record<string, {projection: string; documentIds: Set<string>}>
 
 export function createProjectionQuery(
-  documentIds: Set<string>,
-  documentProjections: {[TDocumentId in string]?: DocumentProjections},
+  documentIds: Set<DocumentId>,
+  documentProjections: {[TDocumentId in DocumentId]?: DocumentProjections},
 ): CreateProjectionQueryResult {
   const projections = Array.from(documentIds)
     .flatMap((id) => {
@@ -48,11 +56,7 @@ export function createProjectionQuery(
 
   const params = Object.fromEntries(
     Object.entries(projections).map(([projectionHash, value]) => {
-      const idsInProjection = Array.from(value.documentIds).flatMap((id) => [
-        getPublishedId(id),
-        getDraftId(id),
-      ])
-
+      const idsInProjection = Array.from(value.documentIds).flatMap((id) => DocumentId(id))
       return [`__ids_${projectionHash}`, Array.from(idsInProjection)]
     }),
   )
@@ -61,28 +65,28 @@ export function createProjectionQuery(
 }
 
 interface ProcessProjectionQueryOptions {
-  projectId: string
-  dataset: string
   ids: Set<string>
   results: ProjectionQueryResult[]
+  documentStatuses?: ProjectionStoreState['documentStatuses']
+  perspective: ClientPerspective | ReleasePerspective
 }
 
-export function processProjectionQuery({ids, results}: ProcessProjectionQueryOptions): {
+export function processProjectionQuery({
+  ids,
+  results,
+  documentStatuses,
+}: ProcessProjectionQueryOptions): {
   [TDocumentId in string]?: DocumentProjectionValues<Record<string, unknown>>
 } {
   const groupedResults: {
     [docId: string]: {
-      [hash: string]: {
-        draft?: ProjectionQueryResult
-        published?: ProjectionQueryResult
-      }
+      [hash: string]: ProjectionQueryResult | undefined
     }
   } = {}
 
   for (const result of results) {
     const originalId = getPublishedId(result._id)
     const hash = result.__projectionHash
-    const isDraft = result._id.startsWith('drafts.')
 
     if (!ids.has(originalId)) continue
 
@@ -90,14 +94,10 @@ export function processProjectionQuery({ids, results}: ProcessProjectionQueryOpt
       groupedResults[originalId] = {}
     }
     if (!groupedResults[originalId][hash]) {
-      groupedResults[originalId][hash] = {}
+      groupedResults[originalId][hash] = undefined
     }
 
-    if (isDraft) {
-      groupedResults[originalId][hash].draft = result
-    } else {
-      groupedResults[originalId][hash].published = result
-    }
+    groupedResults[originalId][hash] = result
   }
 
   const finalValues: {
@@ -111,22 +111,18 @@ export function processProjectionQuery({ids, results}: ProcessProjectionQueryOpt
     if (!projectionsForDoc) continue
 
     for (const hash in projectionsForDoc) {
-      const {draft, published} = projectionsForDoc[hash]
-
-      const projectionResultData = draft?.result ?? published?.result
+      const projectionResult = projectionsForDoc[hash]
+      const projectionResultData = projectionResult?.result
 
       if (!projectionResultData) {
         finalValues[originalId][hash] = {data: null, isPending: false}
         continue
       }
 
-      const _status = {
-        ...(draft?._updatedAt && {lastEditedDraftAt: draft._updatedAt}),
-        ...(published?._updatedAt && {lastEditedPublishedAt: published._updatedAt}),
-      }
+      const statusFromStore = documentStatuses?.[originalId]
 
       finalValues[originalId][hash] = {
-        data: {...projectionResultData, _status},
+        data: {...projectionResultData, _status: statusFromStore},
         isPending: false,
       }
     }

package/src/projection/projectionStore.test.ts

@@ -30,8 +30,8 @@ describe('projectionStore', () => {
       instance,
       {
         name: 'p.d',
-        projectId: 'p',
-        dataset: 'd',
+        source: {projectId: 'p', dataset: 'd'},
+        perspective: 'drafts',
       },
       projectionStore,
     )
@@ -42,8 +42,8 @@ describe('projectionStore', () => {
       state,
       key: {
         name: 'p.d',
-        projectId: 'p',
-        dataset: 'd',
+        source: {projectId: 'p', dataset: 'd'},
+        perspective: 'drafts',
       },
     })
 

package/src/projection/projectionStore.ts

@@ -1,15 +1,16 @@
-import {type BoundDatasetKey} from '../store/createActionBinder'
+import {type BoundPerspectiveKey} from '../store/createActionBinder'
 import {defineStore} from '../store/defineStore'
 import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
 import {type ProjectionStoreState} from './types'
 
-export const projectionStore = defineStore<ProjectionStoreState, BoundDatasetKey>({
+export const projectionStore = defineStore<ProjectionStoreState, BoundPerspectiveKey>({
   name: 'Projection',
   getInitialState() {
     return {
       values: {},
       documentProjections: {},
       subscriptions: {},
+      documentStatuses: {},
     }
   },
   initialize(context) {

package/src/projection/resolveProjection.ts

@@ -1,7 +1,7 @@
 import {type SanityProjectionResult} from 'groq'
 import {filter, firstValueFrom} from 'rxjs'
 
-import {bindActionByDataset} from '../store/createActionBinder'
+import {bindActionBySourceAndPerspective} 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 = bindActionByDataset(
+const _resolveProjection = bindActionBySourceAndPerspective(
   projectionStore,
   (
     {instance}: {instance: SanityInstance},

package/src/projection/statusQuery.test.ts

@@ -0,0 +1,35 @@
+import {DocumentId, getVersionId} from '@sanity/id-utils'
+import {describe, expect, it} from 'vitest'
+
+import {buildStatusQueryIds, processStatusQueryResults} from './statusQuery'
+
+describe('buildStatusQueryIds', () => {
+  it('includes draft and published ids only when perspective is not a release', () => {
+    const ids = new Set(['doc1'].map(DocumentId))
+    const result = buildStatusQueryIds(ids, 'published')
+    expect(result).toContain('drafts.doc1')
+    expect(result).toContain('doc1')
+    expect(result).toHaveLength(2)
+  })
+
+  it('includes version ids when perspective is a release', () => {
+    const ids = new Set(['doc1'].map(DocumentId))
+    const perspective = {releaseName: 'myRelease'}
+    const result = buildStatusQueryIds(ids, perspective)
+    expect(result).toContain('drafts.doc1')
+    expect(result).toContain('doc1')
+    expect(result).toContain(getVersionId(DocumentId('doc1'), 'myRelease'))
+    expect(result).toHaveLength(3)
+  })
+})
+
+describe('processStatusQueryResults', () => {
+  it('sets lastEditedVersionAt when result _id is a version id', () => {
+    const versionId = getVersionId(DocumentId('doc1'), 'myRelease')
+    const results = [{_id: versionId, _updatedAt: '2025-01-01T12:00:00Z'}]
+    const documentStatuses = processStatusQueryResults(results)
+    expect(documentStatuses['doc1']).toEqual({
+      lastEditedVersionAt: '2025-01-01T12:00:00Z',
+    })
+  })
+})

package/src/projection/statusQuery.ts

@@ -0,0 +1,71 @@
+import {
+  DocumentId,
+  getDraftId,
+  getPublishedId,
+  getVersionId,
+  isDraftId,
+  isPublishedId,
+  isVersionId,
+} from '@sanity/id-utils'
+
+import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
+import {type BoundPerspectiveKey} from '../store/createActionBinder'
+import {type ProjectionStoreState} from './types'
+
+interface StatusQueryResult {
+  _id: string
+  _updatedAt: string
+}
+
+/**
+ * Builds an array of document IDs to query for status information using the "raw" perspective.
+ * Includes draft, published, and version IDs as needed.
+ */
+export function buildStatusQueryIds(
+  documentIds: Set<string>,
+  perspective: BoundPerspectiveKey['perspective'],
+): string[] {
+  const ids: string[] = []
+  const releaseName = isReleasePerspective(perspective) ? perspective.releaseName : null
+
+  for (const id of documentIds) {
+    const publishedId = getPublishedId(DocumentId(id))
+    const draftId = getDraftId(publishedId)
+
+    // Always query for draft and published versions
+    ids.push(draftId, publishedId)
+
+    // If it's a release perspective, also query for the version
+    if (releaseName) {
+      ids.push(getVersionId(publishedId, releaseName))
+    }
+  }
+
+  return ids
+}
+
+/**
+ * Processes status query results into documentStatuses (same shape as _status returned to users).
+ */
+export function processStatusQueryResults(
+  results: StatusQueryResult[],
+): ProjectionStoreState['documentStatuses'] {
+  const documentStatuses: ProjectionStoreState['documentStatuses'] = {}
+
+  for (const result of results) {
+    const id = DocumentId(result._id)
+    const updatedAt = result._updatedAt
+    const publishedId = getPublishedId(id)
+    const statusData = documentStatuses[publishedId] ?? {}
+    if (isDraftId(id)) {
+      statusData.lastEditedDraftAt = updatedAt
+    } else if (isVersionId(id)) {
+      statusData.lastEditedVersionAt = updatedAt
+    } else if (isPublishedId(id)) {
+      statusData.lastEditedPublishedAt = updatedAt
+    }
+    documentStatuses[publishedId] = statusData
+  }
+
+  return documentStatuses
+}