@sanity/sdk 2.4.0 → 2.5.0

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

package/src/document/processActions.ts

@@ -140,6 +140,52 @@ export function processActions({
     switch (action.type) {
       case 'document.create': {
         const documentId = getId(action.documentId)
+
+        if (action.liveEdit) {
+          // For liveEdit documents, create directly without draft/published logic
+          if (working[documentId]) {
+            throw new ActionError({
+              documentId,
+              transactionId,
+              message: `This document already exists.`,
+            })
+          }
+
+          const newDocBase = {_type: action.documentType, _id: documentId}
+          const newDocWorking = {_type: action.documentType, _id: documentId}
+          const mutations: Mutation[] = [{create: newDocWorking}]
+
+          base = processMutations({
+            documents: base,
+            transactionId,
+            mutations: [{create: newDocBase}],
+            timestamp,
+          })
+          working = processMutations({
+            documents: working,
+            transactionId,
+            mutations,
+            timestamp,
+          })
+
+          if (!checkGrant(grants.create, working[documentId] as SanityDocument)) {
+            throw new PermissionActionError({
+              documentId,
+              transactionId,
+              message: `You do not have permission to create document "${documentId}".`,
+            })
+          }
+
+          outgoingMutations.push(...mutations)
+          outgoingActions.push({
+            actionType: 'sanity.action.document.create',
+            publishedId: documentId,
+            attributes: newDocWorking,
+          })
+          continue
+        }
+
+        // Standard draft/published logic
         const draftId = getDraftId(documentId)
         const publishedId = getPublishedId(documentId)
 
@@ -198,6 +244,39 @@ export function processActions({
 
       case 'document.delete': {
         const documentId = action.documentId
+
+        if (action.liveEdit) {
+          // For liveEdit documents, delete directly
+          if (!working[documentId]) {
+            throw new ActionError({
+              documentId,
+              transactionId,
+              message: 'The document you are trying to delete does not exist.',
+            })
+          }
+
+          if (!checkGrant(grants.update, working[documentId])) {
+            throw new PermissionActionError({
+              documentId,
+              transactionId,
+              message: `You do not have permission to delete this document.`,
+            })
+          }
+
+          const mutations: Mutation[] = [{delete: {id: documentId}}]
+
+          base = processMutations({documents: base, transactionId, mutations, timestamp})
+          working = processMutations({documents: working, transactionId, mutations, timestamp})
+
+          outgoingMutations.push(...mutations)
+          outgoingActions.push({
+            actionType: 'sanity.action.document.delete',
+            publishedId: documentId,
+          })
+          continue
+        }
+
+        // Standard draft/published logic
         const draftId = getDraftId(documentId)
         const publishedId = getPublishedId(documentId)
 
@@ -240,6 +319,16 @@ export function processActions({
 
       case 'document.discard': {
         const documentId = getId(action.documentId)
+
+        if (action.liveEdit) {
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: `Cannot discard changes for liveEdit document "${documentId}". LiveEdit documents do not support drafts.`,
+          })
+        }
+
+        // Standard draft/published logic
         const draftId = getDraftId(documentId)
         const mutations: Mutation[] = [{delete: {id: draftId}}]
 
@@ -272,6 +361,70 @@ export function processActions({
 
       case 'document.edit': {
         const documentId = getId(action.documentId)
+
+        if (action.liveEdit) {
+          // For liveEdit documents, edit directly without draft logic
+          const userPatches = action.patches?.map((patch) => ({patch: {id: documentId, ...patch}}))
+
+          // skip this action if there are no associated patches
+          if (!userPatches?.length) continue
+
+          if (!working[documentId] || !base[documentId]) {
+            throw new ActionError({
+              documentId,
+              transactionId,
+              message: `Cannot edit document because it does not exist.`,
+            })
+          }
+
+          const baseBefore = base[documentId] as SanityDocument
+          if (userPatches) {
+            base = processMutations({
+              documents: base,
+              transactionId,
+              mutations: userPatches,
+              timestamp,
+            })
+          }
+
+          const baseAfter = base[documentId] as SanityDocument
+          const patches = diffValue(baseBefore, baseAfter)
+
+          const workingBefore = working[documentId] as SanityDocument
+          if (!checkGrant(grants.update, workingBefore)) {
+            throw new PermissionActionError({
+              documentId,
+              transactionId,
+              message: `You do not have permission to edit document "${documentId}".`,
+            })
+          }
+
+          const workingMutations = patches.map((patch) => ({patch: {id: documentId, ...patch}}))
+
+          working = processMutations({
+            documents: working,
+            transactionId,
+            mutations: workingMutations,
+            timestamp,
+          })
+
+          outgoingMutations.push(...workingMutations)
+          outgoingActions.push(
+            ...patches.map(
+              (patch): HttpAction => ({
+                actionType: 'sanity.action.document.edit',
+                // Server requires draftId to have drafts. prefix for validation, even for liveEdit
+                draftId: getDraftId(documentId),
+                publishedId: documentId,
+                patch: patch as PatchOperations,
+              }),
+            ),
+          )
+
+          continue
+        }
+
+        // Standard draft/published logic
         const draftId = getDraftId(documentId)
         const publishedId = getPublishedId(documentId)
         const userPatches = action.patches?.map((patch) => ({patch: {id: draftId, ...patch}}))
@@ -362,6 +515,16 @@ export function processActions({
 
       case 'document.publish': {
         const documentId = getId(action.documentId)
+
+        if (action.liveEdit) {
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: `Cannot publish liveEdit document "${documentId}". LiveEdit documents do not support drafts or publishing.`,
+          })
+        }
+
+        // Standard draft/published logic
         const draftId = getDraftId(documentId)
         const publishedId = getPublishedId(documentId)
 
@@ -428,6 +591,16 @@ export function processActions({
 
       case 'document.unpublish': {
         const documentId = getId(action.documentId)
+
+        if (action.liveEdit) {
+          throw new ActionError({
+            documentId,
+            transactionId,
+            message: `Cannot unpublish liveEdit document "${documentId}". LiveEdit documents do not support drafts or publishing.`,
+          })
+        }
+
+        // Standard draft/published logic
         const draftId = getDraftId(documentId)
         const publishedId = getPublishedId(documentId)
 

package/src/document/reducers.ts

@@ -20,6 +20,7 @@ export type SyncTransactionState = Pick<
 
 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'
@@ -34,6 +35,7 @@ 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[]}
@@ -550,13 +552,19 @@ export function removeSubscriptionIdFromDocument(
 export function manageSubscriberIds(
   {state}: StoreContext<SyncTransactionState>,
   documentId: string | string[],
+  options?: {expandDraftPublished?: boolean},
 ): () => void {
+  const expandDraftPublished = options?.expandDraftPublished ?? true
   const documentIds = Array.from(
     new Set(
-      (Array.isArray(documentId) ? documentId : [documentId]).flatMap((id) => [
-        getPublishedId(id),
-        getDraftId(id),
-      ]),
+      expandDraftPublished
+        ? (Array.isArray(documentId) ? documentId : [documentId]).flatMap((id) => [
+            getPublishedId(id),
+            getDraftId(id),
+          ])
+        : Array.isArray(documentId)
+          ? documentId
+          : [documentId],
     ),
   )
   const subscriptionId = insecureRandomId()
@@ -579,8 +587,7 @@ export function manageSubscriberIds(
   }
 }
 
-export function getDocumentIdsFromActions(action: DocumentAction | DocumentAction[]): string[] {
-  const actions = Array.isArray(action) ? action : [action]
+export function getDocumentIdsFromActions(actions: DocumentAction[]): string[] {
   return Array.from(
     new Set(
       actions