@sanity/sdk 2.5.0 → 2.7.0

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
+}

package/src/projection/subscribeToStateAndFetchBatches.test.ts

@@ -15,13 +15,18 @@ vi.mock('../query/queryStore')
 describe('subscribeToStateAndFetchBatches', () => {
   let instance: SanityInstance
   let state: StoreState<ProjectionStoreState>
-  const key = {name: 'test.test', projectId: 'test', dataset: 'test'}
+  const key = {
+    name: 'test.test:drafts',
+    source: {projectId: 'test', dataset: 'test'},
+    perspective: 'drafts' as const,
+  }
 
   beforeEach(() => {
     vi.clearAllMocks()
     instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     state = createStoreState<ProjectionStoreState>({
       documentProjections: {},
+      documentStatuses: {},
       subscriptions: {},
       values: {},
     })
@@ -65,19 +70,14 @@ describe('subscribeToStateAndFetchBatches', () => {
     // Wait for debounce
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    // Should still be 1 call because projections are identical
-    expect(getQueryState).toHaveBeenCalledTimes(1)
+    // only 2 calls (one for projection, one for status) even though we added 2 subscriptions
+    expect(getQueryState).toHaveBeenCalledTimes(2)
     expect(getQueryState).toHaveBeenCalledWith(
       instance,
       expect.objectContaining({
-        query: expect.any(String),
+        perspective: 'drafts',
         params: {
-          [`__ids_${projectionHash}`]: expect.arrayContaining([
-            'doc1',
-            'drafts.doc1',
-            'doc2',
-            'drafts.doc2',
-          ]),
+          [`__ids_${projectionHash}`]: expect.arrayContaining(['doc1', 'doc2']),
         },
       }),
     )
@@ -87,47 +87,43 @@ describe('subscribeToStateAndFetchBatches', () => {
 
   it('processes query results and updates state with resolved values', async () => {
     const teardown = vi.fn()
-    const subscriber = vi
-      .fn<(observer: Observer<ProjectionQueryResult[] | undefined>) => () => void>()
-      .mockReturnValue(teardown)
-
-    vi.mocked(getQueryState).mockReturnValue({
-      getCurrent: () => undefined,
-      observable: new Observable(subscriber),
-    } as StateSource<ProjectionQueryResult[] | undefined>)
+    const projectionObservers: Observer<ProjectionQueryResult[] | undefined>[] = []
+    const statusObservers: Observer<{_id: string; _updatedAt: string}[] | undefined>[] = []
+
+    vi.mocked(getQueryState).mockImplementation((_, options) => {
+      const isStatusQuery = options.perspective === 'raw'
+      const observers = isStatusQuery ? statusObservers : projectionObservers
+      const observable = new Observable<unknown>((observer) => {
+        observers.push(observer as Observer<ProjectionQueryResult[] | undefined>)
+        return teardown
+      })
+      return {
+        getCurrent: () => undefined,
+        observable,
+      } as StateSource<ProjectionQueryResult[] | undefined>
+    })
 
     const subscription = subscribeToStateAndFetchBatches({instance, state, key})
     const projection = '{title}'
     const projectionHash = hashString(projection)
 
-    expect(subscriber).not.toHaveBeenCalled()
-
     // Add a subscription
     state.set('addSubscription', {
       documentProjections: {doc1: {[projectionHash]: projection}},
       subscriptions: {doc1: {[projectionHash]: {sub1: true}}},
     })
 
-    expect(subscriber).not.toHaveBeenCalled()
-
-    // Wait for debounce
+    // Wait for debounce (combineLatest subscribes to both projection and status)
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(subscriber).toHaveBeenCalled()
+    expect(projectionObservers.length).toBe(1)
+    expect(statusObservers.length).toBe(1)
     expect(teardown).not.toHaveBeenCalled()
 
-    const [observer] = subscriber.mock.lastCall!
-
     const timestamp = new Date().toISOString()
 
-    observer.next([
-      {
-        _id: 'doc1',
-        _type: 'doc',
-        _updatedAt: timestamp,
-        result: {title: 'resolved'},
-        __projectionHash: projectionHash,
-      },
+    // Emit projection results first
+    projectionObservers[0]!.next([
       {
         _id: 'drafts.doc1',
         _type: 'doc',
@@ -137,6 +133,12 @@ describe('subscribeToStateAndFetchBatches', () => {
       },
     ])
 
+    // Emit status results (raw query returns _id, _updatedAt per document variant)
+    statusObservers[0]!.next([
+      {_id: 'doc1', _updatedAt: timestamp},
+      {_id: 'drafts.doc1', _updatedAt: timestamp},
+    ])
+
     const {values} = state.get()
     expect(values['doc1']?.[projectionHash]).toEqual({
       isPending: false,
@@ -247,11 +249,9 @@ describe('subscribeToStateAndFetchBatches', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    // Expected calls:
-    // 1. Initial fetch (doc1, hash1)
-    // 2. Adding doc2 subscription (optimistic update, no fetch)
-    // 3. Debounced fetch for (doc1, hash1) AND (doc2, hash2)
-    expect(getQueryState).toHaveBeenCalledTimes(initialQueryCallCount + 1)
+    // Expected calls: initial batch has 2 (projection + status). After adding doc2,
+    // debounced fetch triggers 2 more (projection + status for new batch).
+    expect(getQueryState).toHaveBeenCalledTimes(initialQueryCallCount + 2)
     // Abort should have been called because the required projections changed
     expect(abortSpy).toHaveBeenCalled()
 
@@ -259,13 +259,21 @@ describe('subscribeToStateAndFetchBatches', () => {
   })
 
   it('processes and applies fetch results correctly', async () => {
-    const subscriber =
-      vi.fn<(observer: Observer<ProjectionQueryResult[] | undefined>) => () => void>()
-
-    vi.mocked(getQueryState).mockReturnValue({
-      getCurrent: () => undefined,
-      observable: new Observable(subscriber),
-    } as StateSource<ProjectionQueryResult[] | undefined>)
+    const projectionObservers: Observer<ProjectionQueryResult[] | undefined>[] = []
+    const statusObservers: Observer<{_id: string; _updatedAt: string}[] | undefined>[] = []
+
+    vi.mocked(getQueryState).mockImplementation((_, options) => {
+      const isStatusQuery = options.perspective === 'raw'
+      const observers = isStatusQuery ? statusObservers : projectionObservers
+      const observable = new Observable<unknown>((observer) => {
+        observers.push(observer as Observer<ProjectionQueryResult[] | undefined>)
+        return () => {}
+      })
+      return {
+        getCurrent: () => undefined,
+        observable,
+      } as StateSource<ProjectionQueryResult[] | undefined>
+    })
 
     const subscription = subscribeToStateAndFetchBatches({instance, state, key})
     const projection = '{title, description}'
@@ -280,12 +288,12 @@ describe('subscribeToStateAndFetchBatches', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(subscriber).toHaveBeenCalled()
-    const [observer] = subscriber.mock.lastCall!
+    expect(projectionObservers.length).toBe(1)
+    expect(statusObservers.length).toBe(1)
 
     // Emit fetch results
     const timestamp = '2024-01-01T00:00:00Z'
-    observer.next([
+    projectionObservers[0]!.next([
       {
         _id: 'doc1',
         _type: 'test',
@@ -294,13 +302,18 @@ describe('subscribeToStateAndFetchBatches', () => {
         __projectionHash: projectionHash,
       },
     ])
+    statusObservers[0]!.next([
+      {_id: 'doc1', _updatedAt: timestamp},
+      {_id: 'drafts.doc1', _updatedAt: timestamp},
+    ])
 
-    // Check that the state was updated
+    // Check that the state was updated (status query provides both draft and published _updatedAt)
     expect(state.get().values['doc1']?.[projectionHash]).toEqual({
       data: expect.objectContaining({
         title: 'Test Document',
         description: 'Test Description',
         _status: {
+          lastEditedDraftAt: timestamp,
           lastEditedPublishedAt: timestamp,
         },
       }),