@sanity/sdk 2.8.0 → 2.10.0

package/src/presence/presenceStore.ts

@@ -1,20 +1,45 @@
-import {type SanityClient} from '@sanity/client'
 import {createSelector} from 'reselect'
-import {combineLatest, distinctUntilChanged, filter, map, of, Subscription, switchMap} from 'rxjs'
+import {
+  catchError,
+  combineLatest,
+  distinctUntilChanged,
+  EMPTY,
+  filter,
+  first,
+  map,
+  type Observable,
+  of,
+  Subscription,
+  switchMap,
+} from 'rxjs'
 
 import {getTokenState} from '../auth/authStore'
 import {getClient} from '../client/clientStore'
-import {bindActionByDataset, type BoundDatasetKey} from '../store/createActionBinder'
-import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
+import {
+  type DocumentResource,
+  isCanvasResource,
+  isDatasetResource,
+  isMediaLibraryResource,
+} from '../config/sanityConfig'
+import {bindActionByResource, type BoundResourceKey} from '../store/createActionBinder'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {
+  createStateSourceAction,
+  type SelectorContext,
+  type StateSource,
+} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
 import {type SanityUser} from '../users/types'
 import {getUserState} from '../users/usersStore'
 import {createBifurTransport} from './bifurTransport'
 import {type PresenceLocation, type TransportEvent, type UserPresence} from './types'
 
+const PRESENCE_API_VERSION = '2026-03-30'
+
 type PresenceStoreState = {
   locations: Map<string, {userId: string; locations: PresenceLocation[]}>
   users: Record<string, SanityUser | undefined>
+  organizationId?: string
 }
 
 const getInitialState = (): PresenceStoreState => ({
@@ -23,27 +48,40 @@ const getInitialState = (): PresenceStoreState => ({
 })
 
 /** @public */
-export const presenceStore = defineStore<PresenceStoreState, BoundDatasetKey>({
+export const presenceStore = defineStore<PresenceStoreState, BoundResourceKey>({
   name: 'presence',
   getInitialState,
-  initialize: (context: StoreContext<PresenceStoreState, BoundDatasetKey>) => {
+  initialize: (context: StoreContext<PresenceStoreState, BoundResourceKey>) => {
     const {
       instance,
       state,
-      key: {projectId, dataset},
+      key: {resource},
     } = context
+
+    if (isMediaLibraryResource(resource)) {
+      throw new Error('Presence is not supported for media library resources.')
+    }
+
     const sessionId = crypto.randomUUID()
 
-    const client = getClient(instance, {
-      apiVersion: '2022-06-30',
-      projectId,
-      dataset,
-    })
+    // Dataset resources must use the project hostname so the socket URL is project-specific.
+    // Canvas resources use the global API endpoint via the resource config.
+    const client = isDatasetResource(resource)
+      ? getClient(instance, {
+          apiVersion: PRESENCE_API_VERSION,
+          projectId: resource.projectId,
+          dataset: resource.dataset,
+          useProjectHostname: true,
+        })
+      : getClient(instance, {
+          apiVersion: PRESENCE_API_VERSION,
+          resource,
+        })
 
     const token$ = getTokenState(instance).observable.pipe(distinctUntilChanged())
 
     const [incomingEvents$, dispatch] = createBifurTransport({
-      client: client as SanityClient,
+      client,
       token$,
       sessionId,
     })
@@ -81,6 +119,22 @@ export const presenceStore = defineStore<PresenceStoreState, BoundDatasetKey>({
 
     dispatch({type: 'rollCall'}).subscribe()
 
+    // Canvas resources need the organizationId to resolve users — fetch it once from the canvas endpoint
+    if (isCanvasResource(resource)) {
+      const globalClient = getClient(instance, {apiVersion: PRESENCE_API_VERSION})
+      subscription.add(
+        globalClient.observable
+          .request<{organizationId: string}>({
+            uri: `/canvases/${resource.canvasId}`,
+            tag: 'canvases.get',
+          })
+          .pipe(catchError(() => EMPTY))
+          .subscribe(({organizationId}) => {
+            state.set('presence/organizationId', (prev) => ({...prev, organizationId}))
+          }),
+      )
+    }
+
     return () => {
       dispatch({type: 'disconnect'}).subscribe()
       subscription.unsubscribe()
@@ -114,13 +168,13 @@ const selectPresence = createSelector(
   },
 )
 
-/** @public */
-export const getPresence = bindActionByDataset(
+const _getPresence = bindActionByResource(
   presenceStore,
   createStateSourceAction({
-    selector: (context: SelectorContext<PresenceStoreState>, _?): UserPresence[] =>
+    selector: (context: SelectorContext<PresenceStoreState>): UserPresence[] =>
       selectPresence(context.state),
-    onSubscribe: (context: StoreContext<PresenceStoreState, BoundDatasetKey>, _?) => {
+    onSubscribe: (context: StoreContext<PresenceStoreState, BoundResourceKey>) => {
+      const resource = context.key.resource
       const userIds$ = context.state.observable.pipe(
         map((state) =>
           Array.from(state.locations.values())
@@ -130,26 +184,34 @@ export const getPresence = bindActionByDataset(
         distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i])),
       )
 
-      const subscription = userIds$
+      // For canvas resources, wait for organizationId to be fetched and stored in state.
+      // For dataset resources, emit undefined immediately so the stream isn't blocked.
+      const organizationId$: Observable<string | undefined> = isCanvasResource(resource)
+        ? context.state.observable.pipe(
+            map((s) => s.organizationId),
+            filter((id): id is string => id !== undefined),
+            first(),
+          )
+        : of(undefined)
+
+      const subscription = combineLatest([userIds$, organizationId$])
         .pipe(
-          switchMap((userIds) => {
+          switchMap(([userIds, organizationId]) => {
             if (userIds.length === 0) {
               return of([])
             }
             const userObservables = userIds.map((userId) =>
               getUserState(context.instance, {
                 userId,
-                resourceType: 'project',
-                projectId: context.key.projectId,
+                ...(isDatasetResource(resource)
+                  ? {resourceType: 'project', projectId: resource.projectId}
+                  : {resourceType: 'organization', organizationId}),
               }).pipe(filter((v): v is NonNullable<typeof v> => !!v)),
             )
             return combineLatest(userObservables)
           }),
         )
         .subscribe((users) => {
-          if (!users) {
-            return
-          }
           context.state.set('presence/users', (prevState) => ({
             ...prevState,
             users: {
@@ -167,3 +229,13 @@ export const getPresence = bindActionByDataset(
     },
   }),
 )
+
+/** @beta */
+export function getPresence(
+  instance: SanityInstance,
+  params?: {resource?: DocumentResource},
+): StateSource<UserPresence[]> {
+  // bit of a hack to support the old bound action by dataset
+  // in reality, this will always be passed a resource
+  return _getPresence(instance, params ?? {})
+}

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.resource)
 
-      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)),
+  }
+}