@sanity/sdk 2.3.1 → 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', () => {
@@ -138,6 +148,103 @@ describe('processActions', () => {
         processActions({actions, transactionId, base, working, timestamp, grants}),
       ).toThrow(/You do not have permission to create a draft for document "doc1"/)
     })
+
+    it('should create a draft document with initial values', () => {
+      const base: DocumentSet = {}
+      const working: DocumentSet = {}
+      const actions: DocumentAction[] = [
+        {
+          documentId: 'doc1',
+          type: 'document.create',
+          documentType: 'article',
+          initialValue: {
+            title: 'New Article',
+            author: 'John Doe',
+            count: 42,
+          },
+        },
+      ]
+      const result = processActions({
+        actions,
+        transactionId,
+        base,
+        working,
+        timestamp,
+        grants: defaultGrants,
+      })
+
+      const draftId = 'drafts.doc1'
+      const draftDoc = result.working[draftId]
+      expect(draftDoc).toBeDefined()
+      expect(draftDoc?._id).toBe(draftId)
+      expect(draftDoc?._type).toBe('article')
+      expect(draftDoc?._rev).toBe(transactionId)
+      // Should have the initial values:
+      expect(draftDoc?.['title']).toBe('New Article')
+      expect(draftDoc?.['author']).toBe('John Doe')
+      expect(draftDoc?.['count']).toBe(42)
+    })
+
+    it('should create a draft with initial values that override published document values', () => {
+      const published = createDoc('doc1', 'Original Title')
+      const base: DocumentSet = {doc1: published}
+      const working: DocumentSet = {doc1: published}
+      const actions: DocumentAction[] = [
+        {
+          documentId: 'doc1',
+          type: 'document.create',
+          documentType: 'article',
+          initialValue: {
+            title: 'Overridden Title',
+            newField: 'New Value',
+          },
+        },
+      ]
+      const result = processActions({
+        actions,
+        transactionId,
+        base,
+        working,
+        timestamp,
+        grants: defaultGrants,
+      })
+
+      const draftId = 'drafts.doc1'
+      const draftDoc = result.working[draftId]
+      expect(draftDoc).toBeDefined()
+      // Should have the overridden title from initialValue:
+      expect(draftDoc?.['title']).toBe('Overridden Title')
+      // Should have the new field:
+      expect(draftDoc?.['newField']).toBe('New Value')
+    })
+
+    it('should create a draft with empty initial values object', () => {
+      const base: DocumentSet = {}
+      const working: DocumentSet = {}
+      const actions: DocumentAction[] = [
+        {
+          documentId: 'doc1',
+          type: 'document.create',
+          documentType: 'article',
+          initialValue: {},
+        },
+      ]
+      const result = processActions({
+        actions,
+        transactionId,
+        base,
+        working,
+        timestamp,
+        grants: defaultGrants,
+      })
+
+      const draftId = 'drafts.doc1'
+      const draftDoc = result.working[draftId]
+      expect(draftDoc).toBeDefined()
+      expect(draftDoc?._id).toBe(draftId)
+      expect(draftDoc?._type).toBe('article')
+      expect(draftDoc?._rev).toBe(transactionId)
+    })
   })
 
   describe('document.delete', () => {
@@ -748,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')
+      })
+    })
+  })
 })