@sanity/sdk 2.8.0 → 2.10.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 {omitProperty} from '../utils/object'
+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)
@@ -383,7 +392,7 @@ export function revertOutgoingTransaction(prev: SyncTransactionState): SyncTrans
             local: documentId in working ? working[documentId] : local,
             unverifiedRevisions:
               prev.outgoing && prev.outgoing.transactionId in unverifiedRevisions
-                ? omit(unverifiedRevisions, prev.outgoing.transactionId)
+                ? omitProperty(unverifiedRevisions, prev.outgoing.transactionId)
                 : unverifiedRevisions,
           }
           return [documentId, next] as const
@@ -411,7 +420,7 @@ export function applyRemoteDocument(
   const revisionToVerify = revision ? prevUnverifiedRevisions?.[revision] : undefined
   let unverifiedRevisions = prevUnverifiedRevisions ?? EMPTY_REVISIONS
   if (revision && revisionToVerify) {
-    unverifiedRevisions = omit(prevUnverifiedRevisions, revision)
+    unverifiedRevisions = omitProperty(prevUnverifiedRevisions, revision)
   }
 
   // if this remote document is from a `'sync'` event (meaning that the whole
@@ -538,7 +547,7 @@ export function removeSubscriptionIdFromDocument(
 
   if (!prevDocState) return prev
   if (!subscriptions.length) {
-    return {...prev, documentStates: omit(prev.documentStates, documentId)}
+    return {...prev, documentStates: omitProperty(prev.documentStates, documentId)}
   }
   return {
     ...prev,
@@ -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 DocumentResource, isDatasetResource} 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,
+  resource?: DocumentResource,
+): 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 resource
+    resource: resource && !isDatasetResource(resource) ? resource : 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, resource?: DocumentResource) {
   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 resource
+      resource: resource && !isDatasetResource(resource) ? resource : 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.test.ts

@@ -45,16 +45,18 @@ describe('createBifurTransport', () => {
 
   beforeEach(() => {
     vi.useFakeTimers()
+    vi.clearAllMocks()
     mockBifurClient = {
       listen: vi.fn(() => new Subject<never>()),
       request: vi.fn(() => of(undefined)),
     }
     fromUrlMock.mockReturnValue(mockBifurClient)
 
+    // Default mock is a dataset client using project hostname
     mockSanityClient = {
       config: () => ({
         dataset: 'test-dataset',
-        url: 'http://localhost:3333',
+        url: 'https://test-project.api.sanity.io/v2022-06-30',
         requestTagPrefix: 'test-tag',
       }),
       withConfig: vi.fn().mockReturnThis(),
@@ -63,7 +65,7 @@ describe('createBifurTransport', () => {
     token$ = new Subject<string | null>()
   })
 
-  it('constructs the bifur client with the correct URL', () => {
+  it('constructs the bifur client URL for a dataset resource', () => {
     createBifurTransport({
       client: mockSanityClient,
       token$,
@@ -71,13 +73,51 @@ describe('createBifurTransport', () => {
     })
 
     expect(fromUrlMock).toHaveBeenCalledWith(
-      'ws://localhost:3333/socket/test-dataset?tag=test-tag',
-      {
-        token$,
-      },
+      'wss://test-project.api.sanity.io/v2022-06-30/socket/test-dataset?tag=test-tag',
+      {token$},
+    )
+  })
+
+  it('constructs the bifur client URL for a canvas resource', () => {
+    const canvasClient = {
+      config: () => ({
+        resource: {type: 'canvas', id: 'canvas-123'},
+        url: 'https://api.sanity.io/v2022-06-30',
+        requestTagPrefix: 'test-tag',
+      }),
+      withConfig: vi.fn().mockReturnThis(),
+    } as unknown as SanityClient
+
+    createBifurTransport({
+      client: canvasClient,
+      token$,
+      sessionId: 'session-id-123',
+    })
+
+    expect(fromUrlMock).toHaveBeenCalledWith(
+      'wss://api.sanity.io/v2022-06-30/socket/canvases/canvas-123?tag=test-tag',
+      {token$},
     )
   })
 
+  it('throws when no canvas resource or dataset is configured', () => {
+    const invalidClient = {
+      config: () => ({
+        url: 'https://api.sanity.io/v2022-06-30',
+        requestTagPrefix: 'test-tag',
+      }),
+      withConfig: vi.fn().mockReturnThis(),
+    } as unknown as SanityClient
+
+    expect(() =>
+      createBifurTransport({
+        client: invalidClient,
+        token$,
+        sessionId: 'session-id-123',
+      }),
+    ).toThrow('Unable to determine presence URL')
+  })
+
   it('handles incoming rollCall events', () => {
     const incomingBifurEvents$ = new Subject<IncomingBifurEvent>()
     mockBifurClient.listen.mockReturnValue(incomingBifurEvents$)

package/src/presence/bifurTransport.ts

@@ -36,8 +36,25 @@ 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 url = `${baseUrl.replace(/\/+$/, '')}/socket/${dataset}`.replace(/^http/, 'ws')
+  const {
+    resource,
+    dataset,
+    url: baseUrl,
+    requestTagPrefix = 'sanity.sdk.presence',
+  } = bifurVersionedClient.config()
+
+  let resourcePath: string
+  if (resource?.type === 'canvas') {
+    resourcePath = `canvases/${resource.id}`
+  } else if (dataset) {
+    // Dataset clients use project hostname — dataset name alone is the socket path
+    resourcePath = dataset
+  } else {
+    throw new Error(`Unable to determine presence URL: no canvas resource or dataset configured`)
+  }
+
+  const url = `${baseUrl}/socket/${resourcePath}`.replace(/^http/, 'ws')
+
   const urlWithTag = `${url}?tag=${requestTagPrefix}`
 
   return fromUrl(urlWithTag, {token$})

package/src/presence/presenceStore.test.ts

@@ -48,6 +48,9 @@ describe('presenceStore', () => {
 
     mockClient = {
       withConfig: vi.fn().mockReturnThis(),
+      observable: {
+        request: vi.fn(() => of({organizationId: 'test-org-id'})),
+      },
     } as unknown as SanityClient
 
     mockTokenState = new Subject<string | null>()
@@ -243,5 +246,98 @@ describe('presenceStore', () => {
 
       unsubscribe()
     })
+
+    it('should throw an error when initialized with a media library resource', () => {
+      const mediaLibraryResource = {mediaLibraryId: 'ml123'}
+
+      expect(() => {
+        getPresence(instance, {resource: mediaLibraryResource})
+      }).toThrow('Presence is not supported for media library resources.')
+    })
+
+    it('should work with a dataset resource', () => {
+      const datasetResource = {projectId: 'test-project', dataset: 'test-dataset'}
+
+      expect(() => {
+        getPresence(instance, {resource: datasetResource})
+      }).not.toThrow()
+    })
+
+    it('should work with a canvas resource', () => {
+      const canvasResource = {canvasId: 'canvas123'}
+
+      expect(() => {
+        getPresence(instance, {resource: canvasResource})
+      }).not.toThrow()
+    })
+
+    it('creates a project-hostname client for dataset resources', () => {
+      getPresence(instance, {resource: {projectId: 'my-project', dataset: 'my-dataset'}})
+
+      expect(getClient).toHaveBeenCalledWith(instance, {
+        apiVersion: '2026-03-30',
+        projectId: 'my-project',
+        dataset: 'my-dataset',
+        useProjectHostname: true,
+      })
+    })
+
+    it('creates a resource client for canvas resources', () => {
+      const canvasResource = {canvasId: 'canvas123'}
+      getPresence(instance, {resource: canvasResource})
+
+      expect(getClient).toHaveBeenCalledWith(instance, {
+        apiVersion: '2026-03-30',
+        resource: canvasResource,
+      })
+    })
+
+    it('fetches organizationId from canvas endpoint for canvas resources', () => {
+      const canvasResource = {canvasId: 'canvas123'}
+      getPresence(instance, {resource: canvasResource})
+
+      expect(mockClient.observable.request).toHaveBeenCalledWith({
+        uri: '/canvases/canvas123',
+        tag: 'canvases.get',
+      })
+    })
+
+    it('does not fetch organizationId for dataset resources', () => {
+      getPresence(instance, {resource: {projectId: 'my-project', dataset: 'my-dataset'}})
+
+      expect(mockClient.observable.request).not.toHaveBeenCalled()
+    })
+
+    it('fetches user data for canvas users', async () => {
+      const source = getPresence(instance, {resource: {canvasId: 'canvas123'}})
+      const unsubscribe = source.subscribe(() => {})
+
+      await firstValueFrom(of(null).pipe(delay(10)))
+
+      mockIncomingEvents.next({
+        type: 'state',
+        userId: 'user-1',
+        sessionId: 'other-session',
+        timestamp: '2023-01-01T12:00:00Z',
+        locations: [
+          {
+            type: 'document',
+            documentId: 'doc-1',
+            path: ['title'],
+            lastActiveAt: '2023-01-01T12:00:00Z',
+          },
+        ],
+      })
+
+      await firstValueFrom(of(null).pipe(delay(50)))
+
+      expect(getUserState).toHaveBeenCalledWith(instance, {
+        userId: 'user-1',
+        resourceType: 'organization',
+        organizationId: 'test-org-id',
+      })
+
+      unsubscribe()
+    })
   })
 })