@sanity/sdk 2.4.0 → 2.6.0

package/src/document/documentStore.ts

@@ -28,7 +28,11 @@ import {
 
 import {getClientState} from '../client/clientStore'
 import {type DocumentHandle} from '../config/sanityConfig'
-import {bindActionByDataset, type StoreAction} from '../store/createActionBinder'
+import {
+  bindActionByDataset,
+  type BoundDatasetKey,
+  type StoreAction,
+} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {createStateSourceAction, type StateSource} from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
@@ -103,7 +107,7 @@ export interface DocumentState {
   unverifiedRevisions?: {[TTransactionId in string]?: UnverifiedDocumentRevision}
 }
 
-export const documentStore = defineStore<DocumentStoreState>({
+export const documentStore = defineStore<DocumentStoreState, BoundDatasetKey>({
   name: 'Document',
   getInitialState: (instance) => ({
     documentStates: {},
@@ -183,8 +187,21 @@ const _getDocumentState = bindActionByDataset(
   documentStore,
   createStateSourceAction({
     selector: ({state: {error, documentStates}}, options: DocumentOptions<string | undefined>) => {
-      const {documentId, path} = options
+      const {documentId, path, liveEdit} = options
       if (error) throw error
+
+      if (liveEdit) {
+        // For liveEdit documents, only look at the single document
+        const document = documentStates[documentId]?.local
+        if (document === undefined) return undefined
+        if (!path) return document
+        const result = jsonMatch(document, path).next()
+        if (result.done) return undefined
+        const {value} = result.value
+        return value
+      }
+
+      // Standard draft/published logic
       const draftId = getDraftId(documentId)
       const publishedId = getPublishedId(documentId)
       const draft = documentStates[draftId]?.local
@@ -200,7 +217,7 @@ const _getDocumentState = bindActionByDataset(
       return value
     },
     onSubscribe: (context, options: DocumentOptions<string | undefined>) =>
-      manageSubscriberIds(context, options.documentId),
+      manageSubscriberIds(context, options.documentId, {expandDraftPublished: !options.liveEdit}),
   }),
 )
 
@@ -246,6 +263,15 @@ export const getDocumentSyncStatus = bindActionByDataset(
     ) => {
       const documentId = typeof doc === 'string' ? doc : doc.documentId
       if (error) throw error
+
+      if (doc.liveEdit) {
+        // For liveEdit documents, only check the single document
+        const document = documents[documentId]
+        if (document === undefined) return undefined
+        return !queued.length && !applied.length && !outgoing
+      }
+
+      // Standard draft/published logic
       const draftId = getDraftId(documentId)
       const publishedId = getPublishedId(documentId)
 
@@ -259,16 +285,20 @@ export const getDocumentSyncStatus = bindActionByDataset(
   }),
 )
 
+type PermissionsStateOptions = {
+  actions: DocumentAction[]
+}
+
 /** @beta */
 export const getPermissionsState = bindActionByDataset(
   documentStore,
   createStateSourceAction({
     selector: calculatePermissions,
-    onSubscribe: (context, actions) =>
+    onSubscribe: (context, {actions}: PermissionsStateOptions) =>
       manageSubscriberIds(context, getDocumentIdsFromActions(actions)),
   }) as StoreAction<
     DocumentStoreState,
-    [DocumentAction | DocumentAction[]],
+    [PermissionsStateOptions],
     StateSource<ReturnType<typeof calculatePermissions>>
   >,
 )
@@ -276,9 +306,9 @@ export const getPermissionsState = bindActionByDataset(
 /** @beta */
 export const resolvePermissions = bindActionByDataset(
   documentStore,
-  ({instance}, actions: DocumentAction | DocumentAction[]) => {
+  ({instance}, options: PermissionsStateOptions) => {
     return firstValueFrom(
-      getPermissionsState(instance, actions).observable.pipe(filter((i) => i !== undefined)),
+      getPermissionsState(instance, options).observable.pipe(filter((i) => i !== undefined)),
     )
   },
 )
@@ -439,8 +469,8 @@ const subscribeToSubscriptionsAndListenToDocuments = (
 const subscribeToClientAndFetchDatasetAcl = ({
   instance,
   state,
-}: StoreContext<DocumentStoreState>) => {
-  const {projectId, dataset} = instance.config
+  key: {projectId, dataset},
+}: StoreContext<DocumentStoreState, BoundDatasetKey>) => {
   return getClientState(instance, {apiVersion: API_VERSION})
     .observable.pipe(
       switchMap((client) =>

package/src/document/permissions.test.ts

@@ -75,7 +75,7 @@ describe('calculatePermissions', () => {
     const actions: DocumentAction[] = [
       {documentId: 'doc1', type: 'document.create', documentType: 'article'},
     ]
-    const result = calculatePermissions({instance, state}, actions)
+    const result = calculatePermissions({instance, state}, {actions})
     expect(result).toEqual({allowed: true})
   })
 
@@ -91,7 +91,7 @@ describe('calculatePermissions', () => {
     const actions: DocumentAction[] = [
       {documentId: 'doc1', type: 'document.create', documentType: 'article'},
     ]
-    expect(calculatePermissions({instance, state}, actions)).toBeUndefined()
+    expect(calculatePermissions({instance, state}, {actions})).toBeUndefined()
   })
 
   it('should catch PermissionActionError from processActions and return allowed false with a reason', () => {
@@ -107,7 +107,7 @@ describe('calculatePermissions', () => {
     const actions: DocumentAction[] = [
       {documentId: 'doc1', type: 'document.create', documentType: 'article'},
     ]
-    const result = calculatePermissions({instance, state}, actions)
+    const result = calculatePermissions({instance, state}, {actions})
     expect(result).toBeDefined()
     expect(result?.allowed).toBe(false)
     expect(result?.reasons).toEqual(
@@ -135,7 +135,7 @@ describe('calculatePermissions', () => {
     const actions: DocumentAction[] = [
       {documentId: 'doc1', documentType: 'book', type: 'document.edit'},
     ]
-    const result = calculatePermissions({instance, state}, actions)
+    const result = calculatePermissions({instance, state}, {actions})
     expect(result).toBeDefined()
     expect(result?.allowed).toBe(false)
     expect(result?.reasons).toEqual(
@@ -161,7 +161,7 @@ describe('calculatePermissions', () => {
     const actions: DocumentAction[] = [
       {documentId: 'doc1', documentType: 'book', type: 'document.edit'},
     ]
-    const result = calculatePermissions({instance, state}, actions)
+    const result = calculatePermissions({instance, state}, {actions})
     expect(result).toBeDefined()
     expect(result?.allowed).toBe(false)
     expect(result?.reasons).toEqual(
@@ -185,7 +185,7 @@ describe('calculatePermissions', () => {
     const actions: DocumentAction[] = [
       {documentId: 'doc1', type: 'document.create', documentType: 'article'},
     ]
-    expect(calculatePermissions({instance, state}, actions)).toBeUndefined()
+    expect(calculatePermissions({instance, state}, {actions})).toBeUndefined()
   })
 
   it('should catch ActionError from processActions and return a precondition error reason', () => {
@@ -200,7 +200,7 @@ describe('calculatePermissions', () => {
     const actions: DocumentAction[] = [
       {documentId: 'doc1', documentType: 'book', type: 'document.delete'},
     ]
-    const result = calculatePermissions({instance, state}, actions)
+    const result = calculatePermissions({instance, state}, {actions})
     expect(result).toBeDefined()
     expect(result?.allowed).toBe(false)
     expect(result?.reasons).toEqual(
@@ -228,8 +228,8 @@ describe('calculatePermissions', () => {
       documentType: 'article',
     }
     // notice how the action is a copy
-    const result1 = calculatePermissions({instance, state}, [{...action}])
-    const result2 = calculatePermissions({instance, state}, [{...action}])
+    const result1 = calculatePermissions({instance, state}, {actions: [{...action}]})
+    const result2 = calculatePermissions({instance, state}, {actions: [{...action}]})
     expect(result1).toBe(result2)
   })
 })

package/src/document/permissions.ts

@@ -58,15 +58,22 @@ const nullReplacer: object = {}
 const documentsSelector = createSelector(
   [
     ({state: {documentStates}}: SelectorContext<SyncTransactionState>) => documentStates,
-    (_context: SelectorContext<SyncTransactionState>, actions: DocumentAction | DocumentAction[]) =>
+    (_context: SelectorContext<SyncTransactionState>, {actions}: {actions: DocumentAction[]}) =>
       actions,
   ],
   (documentStates, actions) => {
+    // Collect all document IDs needed for permission checks.
+    // Important: liveEdit documents don't have drafts, so we only fetch the single document to avoid waiting for non-existent draft documents.
     const documentIds = new Set(
-      (Array.isArray(actions) ? actions : [actions])
-        .map((i) => i.documentId)
-        .filter((i) => typeof i === 'string')
-        .flatMap((documentId) => [getPublishedId(documentId), getDraftId(documentId)]),
+      actions
+        .map((action) => {
+          if (typeof action.documentId !== 'string') return []
+          // For liveEdit documents, only fetch the single document
+          if (action.liveEdit) return [action.documentId]
+          // For standard documents, fetch both draft and published
+          return [getPublishedId(action.documentId), getDraftId(action.documentId)]
+        })
+        .flat(),
     )
 
     const documents: DocumentSet = {}
@@ -99,7 +106,7 @@ const documentsSelector = createSelector(
 const memoizedActionsSelector = createSelector(
   [
     documentsSelector,
-    (_state: SelectorContext<SyncTransactionState>, actions: DocumentAction | DocumentAction[]) =>
+    (_state: SelectorContext<SyncTransactionState>, {actions}: {actions: DocumentAction[]}) =>
       actions,
   ],
   (documents, actions) => {
@@ -203,7 +210,10 @@ const _calculatePermissions = createSelector(
       // Check edit actions with no patches
       if (action.type === 'document.edit' && !action.patches?.length) {
         const docId = action.documentId
-        const doc = documents[getDraftId(docId)] ?? documents[getPublishedId(docId)]
+        // For liveEdit documents, only check the single document
+        const doc = action.liveEdit
+          ? documents[docId]
+          : (documents[getDraftId(docId)] ?? documents[getPublishedId(docId)])
         if (!doc) {
           reasons.push({
             type: 'precondition',

package/src/document/processActions.test.ts

@@ -29,6 +29,16 @@ const defaultGrants = {
 const transactionId = 'txn-123'
 const timestamp = '2025-02-02T00:00:00.000Z'
 
+// Helper: Create a sample liveEdit document
+const createLiveEditDoc = (id: string, title: string, rev: string = 'initial'): SanityDocument => ({
+  _id: id,
+  _type: 'liveArticle',
+  _createdAt: '2025-01-01T00:00:00.000Z',
+  _updatedAt: '2025-01-01T00:00:00.000Z',
+  _rev: rev,
+  title,
+})
+
 describe('processActions', () => {
   describe('document.create', () => {
     it('should create a new draft document from a published document', () => {
@@ -845,4 +855,242 @@ describe('processActions', () => {
       ).toThrow(/Unknown action type: "document.unrecognizedAction"/)
     })
   })
+
+  describe('liveEdit documents', () => {
+    describe('document.create', () => {
+      it('should create a liveEdit document directly without draft logic', () => {
+        const base: DocumentSet = {}
+        const working: DocumentSet = {}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.create',
+            documentType: 'liveArticle',
+            liveEdit: true,
+          },
+        ]
+
+        const result = processActions({
+          actions,
+          transactionId,
+          base,
+          working,
+          timestamp,
+          grants: defaultGrants,
+        })
+
+        const doc = result.working['live1']
+        expect(doc).toBeDefined()
+        expect(doc?._id).toBe('live1')
+        expect(doc?._type).toBe('liveArticle')
+        expect(doc?._rev).toBe(transactionId)
+
+        // Should use document.create action, not version.create
+        expect(result.outgoingActions).toHaveLength(1)
+        const action = result.outgoingActions[0]
+        expect(action.actionType).toBe('sanity.action.document.create')
+        if ('attributes' in action && 'publishedId' in action) {
+          expect(action.publishedId).toBe('live1')
+          expect(action.attributes._id).toBe('live1')
+          expect(action.attributes._type).toBe('liveArticle')
+        } else {
+          throw new Error('Expected action to have attributes and publishedId')
+        }
+      })
+
+      it('should throw an error if liveEdit document already exists', () => {
+        const existingDoc = createLiveEditDoc('live1', 'Existing')
+        const base: DocumentSet = {live1: existingDoc}
+        const working: DocumentSet = {live1: existingDoc}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.create',
+            documentType: 'liveArticle',
+            liveEdit: true,
+          },
+        ]
+
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('This document already exists')
+      })
+    })
+
+    describe('document.edit', () => {
+      it('should edit a liveEdit document directly', () => {
+        const doc = createLiveEditDoc('live1', 'Original Title')
+        const base: DocumentSet = {live1: doc}
+        const working: DocumentSet = {live1: doc}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.edit',
+            documentType: 'liveArticle',
+            liveEdit: true,
+            patches: [{set: {title: 'Updated Title'}}],
+          },
+        ]
+
+        const result = processActions({
+          actions,
+          transactionId,
+          base,
+          working,
+          timestamp,
+          grants: defaultGrants,
+        })
+
+        const editedDoc = result.working['live1']
+        expect(editedDoc).toBeDefined()
+        expect(editedDoc?.['title']).toBe('Updated Title')
+        expect(editedDoc?._id).toBe('live1')
+
+        // Should use document.edit action with draftId prefixed (for server validation) but publishedId as the actual doc
+        expect(result.outgoingActions[0]).toMatchObject({
+          actionType: 'sanity.action.document.edit',
+          draftId: 'drafts.live1',
+          publishedId: 'live1',
+        })
+      })
+
+      it('should throw an error if liveEdit document does not exist', () => {
+        const base: DocumentSet = {}
+        const working: DocumentSet = {}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.edit',
+            documentType: 'liveArticle',
+            liveEdit: true,
+            patches: [{set: {title: 'New Title'}}],
+          },
+        ]
+
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('Cannot edit document because it does not exist')
+      })
+    })
+
+    describe('document.delete', () => {
+      it('should delete a liveEdit document directly', () => {
+        const doc = createLiveEditDoc('live1', 'To Delete')
+        const base: DocumentSet = {live1: doc}
+        const working: DocumentSet = {live1: doc}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.delete',
+            documentType: 'liveArticle',
+            liveEdit: true,
+          },
+        ]
+
+        const result = processActions({
+          actions,
+          transactionId,
+          base,
+          working,
+          timestamp,
+          grants: defaultGrants,
+        })
+
+        expect(result.working['live1']).toBeNull()
+
+        expect(result.outgoingActions).toEqual([
+          {
+            actionType: 'sanity.action.document.delete',
+            publishedId: 'live1',
+          },
+        ])
+      })
+
+      it('should throw an error if liveEdit document does not exist', () => {
+        const base: DocumentSet = {}
+        const working: DocumentSet = {}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.delete',
+            documentType: 'liveArticle',
+            liveEdit: true,
+          },
+        ]
+
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('The document you are trying to delete does not exist')
+      })
+    })
+
+    describe('document.publish', () => {
+      it('should throw an error for liveEdit documents', () => {
+        const doc = createLiveEditDoc('live1', 'Title')
+        const base: DocumentSet = {live1: doc}
+        const working: DocumentSet = {live1: doc}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.publish',
+            documentType: 'liveArticle',
+            liveEdit: true,
+          },
+        ]
+
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('Cannot publish liveEdit document')
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('LiveEdit documents do not support drafts or publishing')
+      })
+    })
+
+    describe('document.unpublish', () => {
+      it('should throw an error for liveEdit documents', () => {
+        const doc = createLiveEditDoc('live1', 'Title')
+        const base: DocumentSet = {live1: doc}
+        const working: DocumentSet = {live1: doc}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.unpublish',
+            documentType: 'liveArticle',
+            liveEdit: true,
+          },
+        ]
+
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('Cannot unpublish liveEdit document')
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('LiveEdit documents do not support drafts or publishing')
+      })
+    })
+
+    describe('document.discard', () => {
+      it('should throw an error for liveEdit documents', () => {
+        const doc = createLiveEditDoc('live1', 'Title')
+        const base: DocumentSet = {live1: doc}
+        const working: DocumentSet = {live1: doc}
+        const actions: DocumentAction[] = [
+          {
+            documentId: 'live1',
+            type: 'document.discard',
+            documentType: 'liveArticle',
+            liveEdit: true,
+          },
+        ]
+
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('Cannot discard changes for liveEdit document')
+        expect(() =>
+          processActions({actions, transactionId, base, working, timestamp, grants: defaultGrants}),
+        ).toThrow('LiveEdit documents do not support drafts')
+      })
+    })
+  })
 })