@sanity/sdk 2.8.0 → 2.9.0

package/src/document/reducers.ts

@@ -1,9 +1,12 @@
-import {getPublishedId} from '@sanity/client/csm'
+import {DocumentId, getDraftId, getPublishedId, getVersionId} from '@sanity/id-utils'
 import {type Mutation, type PatchOperations, type SanityDocumentLike} from '@sanity/types'
 import {omit} from 'lodash-es'
 
+import {type DocumentHandle} from '../config/sanityConfig'
+import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
 import {type StoreContext} from '../store/defineStore'
-import {getDraftId, insecureRandomId} from '../utils/ids'
+import {insecureRandomId} from '../utils/ids'
+import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {type DocumentAction} from './actions'
 import {DOCUMENT_STATE_CLEAR_DELAY} from './documentConstants'
 import {type DocumentState, type DocumentStoreState} from './documentStore'
@@ -18,9 +21,13 @@ export type SyncTransactionState = Pick<
   'queued' | 'applied' | 'documentStates' | 'outgoing' | 'grants'
 >
 
+type DocumentHandleLike = Pick<DocumentHandle, 'perspective'> & {
+  documentId?: string
+  liveEdit?: boolean
+}
+
 type ActionMap = {
   create: 'sanity.action.document.version.create'
-  createLiveEdit: 'sanity.action.document.create'
   discard: 'sanity.action.document.version.discard'
   unpublish: 'sanity.action.document.unpublish'
   delete: 'sanity.action.document.delete'
@@ -35,7 +42,6 @@ type OptimisticLock = {
 
 export type HttpAction =
   | {actionType: ActionMap['create']; publishedId: string; attributes: SanityDocumentLike}
-  | {actionType: ActionMap['createLiveEdit']; publishedId: string; attributes: SanityDocumentLike}
   | {actionType: ActionMap['discard']; versionId: string; purge?: boolean}
   | {actionType: ActionMap['unpublish']; draftId: string; publishedId: string}
   | {actionType: ActionMap['delete']; publishedId: string; includeDrafts?: string[]}
@@ -115,9 +121,9 @@ export interface AppliedTransaction extends QueuedTransaction {
   outgoingActions: HttpAction[]
 
   /**
-   * similar to `outgoingActions` but comprised of mutations instead of action.
-   * this left here for debugging purposes but could be used to send mutations
-   * to Content Lake instead of actions.
+   * similar to `outgoingActions` but comprised of mutations instead of actions.
+   * Useful for debugging, and is also used by liveEdit documents to send mutations,
+   * since they can't use the Actions API which is pretty dependent on the draft model.
    */
   outgoingMutations: Mutation[]
 }
@@ -145,7 +151,7 @@ export function queueTransaction(
   transaction: QueuedTransaction,
 ): SyncTransactionState {
   const {transactionId, actions} = transaction
-  const prevWithSubscriptionIds = getDocumentIdsFromActions(actions).reduce(
+  const prevWithSubscriptionIds = getDocumentIdsFromHandleLikes(actions).reduce(
     (acc, id) => addSubscriptionIdToDocument(acc, id, transactionId),
     prev,
   )
@@ -163,7 +169,7 @@ export function removeQueuedTransaction(
   const transaction = prev.queued.find((t) => t.transactionId === transactionId)
   if (!transaction) return prev
 
-  const prevWithSubscriptionIds = getDocumentIdsFromActions(transaction.actions).reduce(
+  const prevWithSubscriptionIds = getDocumentIdsFromHandleLikes(transaction.actions).reduce(
     (acc, id) => removeSubscriptionIdFromDocument(acc, id, transactionId),
     prev,
   )
@@ -179,7 +185,7 @@ export function applyFirstQueuedTransaction(prev: SyncTransactionState): SyncTra
   if (!queued) return prev
   if (!prev.grants) return prev
 
-  const ids = getDocumentIdsFromActions(queued.actions)
+  const ids = getDocumentIdsFromHandleLikes(queued.actions)
   // the local value is only ever `undefined` if it has not been loaded yet
   // we can't get the next applied state unless all relevant documents are ready
   if (ids.some((id) => prev.documentStates[id]?.local === undefined)) return prev
@@ -265,6 +271,9 @@ export function batchAppliedTransactions([curr, ...rest]: AppliedTransaction[]):
   if (!next) return undefined
   if (next.disableBatching) return editAction
 
+  // Don't batch a liveEdit edit with a non-liveEdit edit — they route to different APIs
+  if (!!action.liveEdit !== !!next.actions[0]?.liveEdit) return editAction
+
   return {
     disableBatching: false,
     // Use the transactionId from the later (next) transaction.
@@ -337,7 +346,7 @@ export function cleanupOutgoingTransaction(prev: SyncTransactionState): SyncTran
   if (!outgoing) return prev
 
   let next = prev
-  const ids = getDocumentIdsFromActions(outgoing.actions)
+  const ids = getDocumentIdsFromHandleLikes(outgoing.actions)
   for (const transactionId of outgoing.batchedTransactionIds) {
     for (const documentId of ids) {
       next = removeSubscriptionIdFromDocument(next, documentId, transactionId)
@@ -551,22 +560,10 @@ export function removeSubscriptionIdFromDocument(
 
 export function manageSubscriberIds(
   {state}: StoreContext<SyncTransactionState>,
-  documentId: string | string[],
-  options?: {expandDraftPublished?: boolean},
+  handles: DocumentHandleLike[],
 ): () => void {
-  const expandDraftPublished = options?.expandDraftPublished ?? true
-  const documentIds = Array.from(
-    new Set(
-      expandDraftPublished
-        ? (Array.isArray(documentId) ? documentId : [documentId]).flatMap((id) => [
-            getPublishedId(id),
-            getDraftId(id),
-          ])
-        : Array.isArray(documentId)
-          ? documentId
-          : [documentId],
-    ),
-  )
+  const documentIds = getDocumentIdsFromHandleLikes(handles)
+
   const subscriptionId = insecureRandomId()
   state.set('addSubscribers', (prev) =>
     documentIds.reduce(
@@ -576,7 +573,7 @@ export function manageSubscriberIds(
   )
 
   return () => {
-    setTimeout(() => {
+    setCleanupTimeout(() => {
       state.set('removeSubscribers', (prev) =>
         documentIds.reduce(
           (acc, id) => removeSubscriptionIdFromDocument(acc, id, subscriptionId),
@@ -587,13 +584,23 @@ export function manageSubscriberIds(
   }
 }
 
-export function getDocumentIdsFromActions(actions: DocumentAction[]): string[] {
-  return Array.from(
-    new Set(
-      actions
-        .map((i) => i.documentId)
-        .filter((i) => typeof i === 'string')
-        .flatMap((documentId) => [getPublishedId(documentId), getDraftId(documentId)]),
-    ),
-  )
+// document handles are passed in via the public facing API, but we also need to
+// pull the correct document ids from action bodies, which have similar but not
+// identical shapes to the document handles.
+function getDocumentIdsFromHandleLikes(handles: DocumentHandleLike[]): string[] {
+  return handles.flatMap((handle) => {
+    const idsForDocument = []
+    if (!handle.documentId) return []
+    if (handle.liveEdit) {
+      return [handle.documentId]
+    }
+    if (isReleasePerspective(handle.perspective)) {
+      idsForDocument.push(
+        getVersionId(DocumentId(handle.documentId), handle.perspective.releaseName),
+      )
+    }
+    idsForDocument.push(getPublishedId(DocumentId(handle.documentId)))
+    idsForDocument.push(getDraftId(DocumentId(handle.documentId)))
+    return idsForDocument
+  })
 }

package/src/document/sharedListener.ts

@@ -14,6 +14,7 @@ import {
 } from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
+import {type DocumentSource, isDatasetSource} from '../config/sanityConfig'
 import {type SanityInstance} from '../store/createSanityInstance'
 
 const API_VERSION = 'v2025-05-06'
@@ -23,10 +24,15 @@ export interface SharedListener {
   dispose: () => void
 }
 
-export function createSharedListener(instance: SanityInstance): SharedListener {
+export function createSharedListener(
+  instance: SanityInstance,
+  source?: DocumentSource,
+): SharedListener {
   const dispose$ = new Subject<void>()
   const events$ = getClientState(instance, {
     apiVersion: API_VERSION,
+    // TODO: remove in v3 when we're ready for everything to be queried via source
+    source: source && !isDatasetSource(source) ? source : undefined,
   }).observable.pipe(
     switchMap((client) =>
       // TODO: it seems like the client.listen method is not emitting disconnected
@@ -62,13 +68,17 @@ export function createSharedListener(instance: SanityInstance): SharedListener {
   }
 }
 
-export function createFetchDocument(instance: SanityInstance) {
+export function createFetchDocument(instance: SanityInstance, source?: DocumentSource) {
   return function (documentId: string): Observable<SanityDocument | null> {
-    return getClientState(instance, {apiVersion: API_VERSION}).observable.pipe(
+    return getClientState(instance, {
+      apiVersion: API_VERSION,
+      // TODO: remove in v3 when we're ready for everything to be queried via source
+      source: source && !isDatasetSource(source) ? source : undefined,
+    }).observable.pipe(
       switchMap((client) => {
-        // TODO: remove this once the client is updated to v7 the new type is available in @sanity/mutate/_unstable_store
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const loadDocument = createDocumentLoaderFromClient(client as any)
+        // creates a observable request to the /doc/{documentId} endpoint for a given document id
+        // should work across all kinds of document IDs (drafts.**, version.**., etc.)
+        const loadDocument = createDocumentLoaderFromClient(client)
         return loadDocument(documentId)
       }),
       map((result) => {

package/src/document/util.ts

@@ -0,0 +1,14 @@
+import {DocumentId, getPublishedId, getVersionId} from '@sanity/id-utils'
+
+import {type DocumentHandle} from '../config/sanityConfig'
+import {isReleasePerspective} from '../releases/utils/isReleasePerspective'
+
+export function getEffectiveDocumentId(doc: DocumentHandle): string {
+  if (doc.liveEdit) {
+    return doc.documentId
+  } else if (isReleasePerspective(doc.perspective)) {
+    return getVersionId(DocumentId(doc.documentId), doc.perspective.releaseName)
+  } else {
+    return getPublishedId(DocumentId(doc.documentId))
+  }
+}

package/src/favorites/favorites.test.ts

@@ -126,9 +126,15 @@ describe('favoritesStore', () => {
     })
 
     it('handles error and returns default response', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
       setupMockStateSource({fetchImpl: vi.fn().mockRejectedValue(new Error('Failed to fetch'))})
       const result = await resolveFavoritesState(instance!, mockContext)
       expect(result).toEqual({isFavorited: false})
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'Favorites service connection error',
+        expect.any(Error),
+      )
+      consoleErrorSpy.mockRestore()
     })
 
     it('shares observable between multiple subscribers and cleans up', async () => {
@@ -140,8 +146,9 @@ describe('favoritesStore', () => {
       await firstValueFrom(state.observable)
       expect(mockFetch).toHaveBeenCalledTimes(1)
       // Second subscriber should use cached response
-      const sub2 = state.subscribe()
-      await firstValueFrom(state.observable)
+      const state2 = getFavoritesState(instance!, mockContext)
+      const sub2 = state2.subscribe()
+      await firstValueFrom(state2.observable)
       expect(mockFetch).toHaveBeenCalledTimes(1)
       // Cleanup
       sub1()

package/src/presence/bifurTransport.ts

@@ -36,8 +36,13 @@ type IncomingBifurEvent = RollCallEvent | BifurStateMessage | BifurDisconnectMes
 
 function getBifurClient(client: SanityClient, token$: Observable<string | null>): BifurClient {
   const bifurVersionedClient = client.withConfig({apiVersion: '2022-06-30'})
-  const {dataset, url: baseUrl, requestTagPrefix = 'sanity.studio'} = bifurVersionedClient.config()
+  const {
+    dataset,
+    url: baseUrl,
+    requestTagPrefix = 'sanity.sdk.presence',
+  } = bifurVersionedClient.config()
   const url = `${baseUrl.replace(/\/+$/, '')}/socket/${dataset}`.replace(/^http/, 'ws')
+
   const urlWithTag = `${url}?tag=${requestTagPrefix}`
 
   return fromUrl(urlWithTag, {token$})

package/src/preview/getPreviewState.test.ts

@@ -1,120 +1,137 @@
-import {NEVER} from 'rxjs'
-import {describe, it} from 'vitest'
+import {of} from 'rxjs'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {type StoreState} from '../store/createStoreState'
-import {insecureRandomId} from '../utils/ids'
+import {getProjectionState} from '../projection/getProjectionState'
+import {type ProjectionValuePending} from '../projection/types'
+import {createSanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
 import {getPreviewState} from './getPreviewState'
-import {type PreviewStoreState} from './previewStore'
-import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
-import {STABLE_EMPTY_PREVIEW} from './util'
+import {type PreviewQueryResult} from './types'
 
-vi.mock('../utils/ids', async (importOriginal) => {
-  const util = await importOriginal<typeof import('../utils/ids')>()
-  return {...util, insecureRandomId: vi.fn(util.insecureRandomId)}
-})
-
-vi.mock('./subscribeToStateAndFetchBatches.ts')
+vi.mock('../projection/getProjectionState')
 
 describe('getPreviewState', () => {
-  let instance: SanityInstance
-  const docHandle = {documentId: 'exampleId', documentType: 'exampleType'}
-  let state: StoreState<PreviewStoreState & {extra?: unknown}>
-
   beforeEach(() => {
-    // capture state
-    vi.mocked(subscribeToStateAndFetchBatches).mockImplementation((context) => {
-      state = context.state
-      return NEVER.subscribe()
-    })
-
-    instance = createSanityInstance({projectId: 'exampleProject', dataset: 'exampleDataset'})
+    vi.clearAllMocks()
   })
 
-  afterEach(() => {
-    instance.dispose()
-  })
-
-  it('returns a state source that emits when the preview value changes', () => {
-    const previewState = getPreviewState(instance, docHandle)
-    expect(previewState.getCurrent()).toBe(STABLE_EMPTY_PREVIEW)
-
-    const subscriber = vi.fn()
-    previewState.subscribe(subscriber)
-
-    // emit unrelated state changes
-    state.set('updateLastLiveEventId', {extra: 'unrelated change'})
-    expect(subscriber).toHaveBeenCalledTimes(0)
-
-    state.set('relatedChange', (prev) => ({
-      values: {...prev.values, exampleId: {data: {title: 'Changed!'}, isPending: false}},
-    }))
-    expect(subscriber).toHaveBeenCalledTimes(1)
-
-    state.set('unrelatedChange', (prev) => ({
-      values: {
-        ...prev.values,
-        unrelatedId: {data: {title: 'Unrelated Document'}, isPending: false},
-      },
-    }))
-    expect(subscriber).toHaveBeenCalledTimes(1)
-
-    state.set('relatedChange', (prev) => ({
-      values: {...prev.values, exampleId: {data: {title: 'Changed again!'}, isPending: false}},
-    }))
-    expect(subscriber).toHaveBeenCalledTimes(2)
-  })
-
-  it('adds a subscription ID and document type to the state on subscription', () => {
-    const previewState = getPreviewState(instance, docHandle)
-
-    expect(state.get().subscriptions).toEqual({})
-    vi.mocked(insecureRandomId)
-      .mockImplementationOnce(() => 'pseudoRandomId1')
-      .mockImplementationOnce(() => 'pseudoRandomId2')
-
-    const unsubscribe1 = previewState.subscribe(vi.fn())
-    const unsubscribe2 = previewState.subscribe(vi.fn())
-
-    expect(state.get().subscriptions).toEqual({
-      exampleId: {pseudoRandomId1: true, pseudoRandomId2: true},
+  it('transforms projection result to preview format', () => {
+    const mockProjectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2024-01-01',
+      titleCandidates: {title: 'Test Title'},
+      subtitleCandidates: {description: 'Test Description'},
+      media: null,
+    }
+
+    const mockProjectionState = {
+      getCurrent: vi.fn().mockReturnValue({
+        data: mockProjectionResult,
+        isPending: false,
+      } as ProjectionValuePending<PreviewQueryResult>),
+      subscribe: vi.fn(),
+      observable: of({
+        data: mockProjectionResult,
+        isPending: false,
+      } as ProjectionValuePending<PreviewQueryResult>),
+    }
+
+    vi.mocked(getProjectionState).mockReturnValue(
+      mockProjectionState as unknown as StateSource<
+        ProjectionValuePending<Record<string, unknown>> | undefined
+      >,
+    )
+
+    const instance = createSanityInstance({
+      projectId: 'test-project',
+      dataset: 'test-dataset',
     })
-
-    unsubscribe2()
-    expect(state.get().subscriptions).toEqual({
-      exampleId: {pseudoRandomId1: true},
+    const previewState = getPreviewState(instance, {
+      documentId: 'doc1',
+      documentType: 'article',
     })
 
-    unsubscribe1()
-    expect(state.get().subscriptions).toEqual({})
+    const result = previewState.getCurrent()
+
+    expect(result.data).toEqual({
+      title: 'Test Title',
+      subtitle: 'Test Description',
+      media: null,
+    })
+    expect(result.isPending).toBe(false)
   })
 
-  it('resets to pending false on unsubscribe if the subscription is the last one', () => {
-    const previewState = getPreviewState(instance, docHandle)
+  it('returns null data when projection result is null', () => {
+    const mockProjectionState = {
+      getCurrent: vi.fn().mockReturnValue({
+        data: null,
+        isPending: true,
+      }),
+      subscribe: vi.fn(),
+      observable: of({data: null, isPending: true}),
+    }
+
+    vi.mocked(getProjectionState).mockReturnValue(mockProjectionState)
+
+    const instance = createSanityInstance({
+      projectId: 'test-project',
+      dataset: 'test-dataset',
+    })
+    const previewState = getPreviewState(instance, {
+      documentId: 'doc1',
+      documentType: 'article',
+    })
 
-    state.set('presetValueToPending', (prev) => ({
-      values: {...prev.values, [docHandle.documentId]: {data: {title: 'Foo'}, isPending: true}},
-    }))
+    const result = previewState.getCurrent()
 
-    const unsubscribe1 = previewState.subscribe(vi.fn())
-    const unsubscribe2 = previewState.subscribe(vi.fn())
+    expect(result.data).toBeNull()
+    expect(result.isPending).toBe(true)
+  })
 
-    expect(state.get().values[docHandle.documentId]).toEqual({
-      data: {title: 'Foo'},
-      isPending: true,
+  it('uses fallback title when no title candidates exist', () => {
+    const mockProjectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2024-01-01',
+      titleCandidates: {},
+      subtitleCandidates: {},
+      media: null,
+    }
+
+    const mockProjectionState = {
+      getCurrent: vi.fn().mockReturnValue({
+        data: mockProjectionResult,
+        isPending: false,
+      } as ProjectionValuePending<PreviewQueryResult>),
+      subscribe: vi.fn(),
+      observable: of({
+        data: mockProjectionResult,
+        isPending: false,
+      } as ProjectionValuePending<PreviewQueryResult>),
+    }
+
+    vi.mocked(getProjectionState).mockReturnValue(
+      mockProjectionState as unknown as StateSource<
+        ProjectionValuePending<Record<string, unknown>> | undefined
+      >,
+    )
+
+    const instance = createSanityInstance({
+      projectId: 'test-project',
+      dataset: 'test-dataset',
     })
-
-    unsubscribe1()
-    expect(state.get().values[docHandle.documentId]).toEqual({
-      data: {title: 'Foo'},
-      isPending: true,
+    const previewState = getPreviewState(instance, {
+      documentId: 'doc1',
+      documentType: 'article',
     })
 
-    unsubscribe2()
-    expect(state.get().subscriptions).toEqual({})
-    expect(state.get().values[docHandle.documentId]).toEqual({
-      data: {title: 'Foo'},
-      isPending: false,
+    const result = previewState.getCurrent()
+
+    expect(result.data).toEqual({
+      title: 'article: doc1',
+      subtitle: undefined,
+      media: null,
     })
   })
 })

package/src/preview/getPreviewState.ts

@@ -1,29 +1,22 @@
-import {omit} from 'lodash-es'
+import {map} from 'rxjs'
 
 import {type DocumentHandle} from '../config/sanityConfig'
-import {bindActionByDataset} from '../store/createActionBinder'
+import {getProjectionState} from '../projection/getProjectionState'
 import {type SanityInstance} from '../store/createSanityInstance'
-import {
-  createStateSourceAction,
-  type SelectorContext,
-  type StateSource,
-} from '../store/createStateSourceAction'
-import {getPublishedId, insecureRandomId} from '../utils/ids'
-import {
-  previewStore,
-  type PreviewStoreState,
-  type PreviewValue,
-  type ValuePending,
-} from './previewStore'
-import {STABLE_EMPTY_PREVIEW} from './util'
+import {type StateSource} from '../store/createStateSourceAction'
+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 GetPreviewStateOptions = DocumentHandle
 
 /**
  * @beta
+ * @deprecated This function is deprecated and will be removed in a future release.
  */
 export function getPreviewState<TResult extends object>(
   instance: SanityInstance,
@@ -31,6 +24,7 @@ export function getPreviewState<TResult extends object>(
 ): StateSource<ValuePending<TResult>>
 /**
  * @beta
+ * @deprecated This function is deprecated and will be removed in a future release.
  */
 export function getPreviewState(
   instance: SanityInstance,
@@ -38,54 +32,38 @@ export function getPreviewState(
 ): StateSource<ValuePending<PreviewValue>>
 /**
  * @beta
+ * @deprecated This function is deprecated and will be removed in a future release.
  */
 export function getPreviewState(
-  ...args: Parameters<typeof _getPreviewState>
-): StateSource<ValuePending<object>> {
-  return _getPreviewState(...args)
-}
+  instance: SanityInstance,
+  options: GetPreviewStateOptions,
+): StateSource<ValuePending<PreviewValue>> {
+  // Get the projection state
+  const projectionState = getProjectionState<PreviewQueryResult>(instance, {
+    ...options,
+    projection: PREVIEW_PROJECTION,
+  })
 
-/**
- * @beta
- */
-export const _getPreviewState = bindActionByDataset(
-  previewStore,
-  createStateSourceAction({
-    selector: (
-      {state}: SelectorContext<PreviewStoreState>,
-      docHandle: GetPreviewStateOptions,
-    ): ValuePending<object> => state.values[docHandle.documentId] ?? STABLE_EMPTY_PREVIEW,
-    onSubscribe: ({state}, docHandle: GetPreviewStateOptions) => {
-      const subscriptionId = insecureRandomId()
-      const documentId = getPublishedId(docHandle.documentId)
+  // Transform helper to convert projection result to preview format
+  const transformResult = (
+    current: ReturnType<typeof projectionState.getCurrent>,
+  ): ValuePending<PreviewValue> => {
+    if (!current || current.data === null) {
+      return {data: null, isPending: current?.isPending ?? false}
+    }
 
-      state.set('addSubscription', (prev) => ({
-        subscriptions: {
-          ...prev.subscriptions,
-          [documentId]: {
-            ...prev.subscriptions[documentId],
-            [subscriptionId]: true,
-          },
-        },
-      }))
+    const previewValue = transformProjectionToPreview(instance, current.data, options.source)
 
-      return () => {
-        state.set('removeSubscription', (prev): Partial<PreviewStoreState> => {
-          const documentSubscriptions = omit(prev.subscriptions[documentId], subscriptionId)
-          const hasSubscribers = !!Object.keys(documentSubscriptions).length
-          const prevValue = prev.values[documentId]
-          const previewValue = prevValue?.data ? prevValue.data : null
+    return {
+      data: previewValue,
+      isPending: current.isPending,
+    }
+  }
 
-          return {
-            subscriptions: hasSubscribers
-              ? {...prev.subscriptions, [documentId]: documentSubscriptions}
-              : omit(prev.subscriptions, documentId),
-            values: hasSubscribers
-              ? prev.values
-              : {...prev.values, [documentId]: {data: previewValue, isPending: false}},
-          }
-        })
-      }
-    },
-  }),
-)
+  // Wrap the state source to transform projection results to preview format
+  return {
+    getCurrent: () => transformResult(projectionState.getCurrent()),
+    subscribe: (callback) => projectionState.subscribe(callback),
+    observable: projectionState.observable.pipe(map(transformResult)),
+  }
+}