@sanity/sdk 3.0.0-rc.0 → 3.0.0-rc.1

package/src/document/applyDocumentActions.test.ts

@@ -1,11 +1,9 @@
-// applyDocumentActions.test.ts
 import {type SanityDocument} from '@sanity/types'
 import {Subject} from 'rxjs'
 import {describe, expect, it} from 'vitest'
 
 import {bindActionByResource} from '../store/createActionBinder'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {} from '../store/createStateSourceAction'
 import {createStoreState, type StoreState} from '../store/createStoreState'
 import {type DocumentAction} from './actions'
 import {type DocumentStoreState} from './documentStore'
@@ -47,7 +45,7 @@ describe('applyDocumentActions', () => {
       events: eventsSubject,
     }
     state = createStoreState(initialState)
-    instance = createSanityInstance()
+    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
     const key = {name: 'p.d', resource: {projectId: 'p', dataset: 'd'}}
 
     vi.mocked(bindActionByResource).mockImplementation(
@@ -69,7 +67,6 @@ describe('applyDocumentActions', () => {
       documentId: 'doc1',
       documentType: 'example',
       patches: [{set: {foo: 'bar'}}],
-      resource: {projectId: 'p', dataset: 'd'},
     }
 
     // Call applyDocumentActions with a fixed transactionId for reproducibility.
@@ -128,7 +125,6 @@ describe('applyDocumentActions', () => {
       documentId: 'doc1',
       documentType: 'example',
       patches: [{set: {foo: 'error'}}],
-      resource: {projectId: 'p', dataset: 'd'},
     }
 
     // Call applyDocumentActions with a fixed transactionId.
@@ -150,18 +146,23 @@ describe('applyDocumentActions', () => {
     await expect(applyPromise).rejects.toThrow('Simulated error')
   })
 
-  it('uses explicit resource even when instance default differs', async () => {
-    const otherInstance = createSanityInstance({
-      defaultResource: {projectId: 'child-p', dataset: 'child-d'},
-    })
+  it('matches parent instance via child when action projectId and dataset do not match child config', async () => {
+    // Create a parent instance
+    const parentInstance = createSanityInstance({projectId: 'p', dataset: 'd'})
+    // Create a child instance with different config
+    const childInstance = parentInstance.createChild({projectId: 'child-p', dataset: 'child-d'})
+    // Use the child instance in context
+    // Create an action that refers to the parent's configuration
     const action: DocumentAction = {
       type: 'document.edit',
       documentId: 'doc1',
       documentType: 'example',
       patches: [{set: {foo: 'childTest'}}],
-      resource: {projectId: 'p', dataset: 'd'},
+      projectId: 'p',
+      dataset: 'd',
     }
-    const applyPromise = applyDocumentActions(instance, {
+    // Call applyDocumentActions with the context using childInstance, but with action requiring parent's config
+    const applyPromise = applyDocumentActions(childInstance, {
       actions: [action],
       transactionId: 'txn-child-match',
       resource: {projectId: 'p', dataset: 'd'},
@@ -198,6 +199,31 @@ describe('applyDocumentActions', () => {
     const submittedResult = await result.submitted()
     expect(submittedResult).toEqual(acceptedResult)
 
-    otherInstance.dispose()
+    childInstance.dispose()
+    parentInstance.dispose()
+  })
+
+  it('normalizes actions for the bound resource before queueing', async () => {
+    // A plain edit action with no `liveEdit` flag. Canvas forces liveEdit, so
+    // the queued action should come back with `liveEdit: true` — proving that
+    // `applyDocumentActions` runs `normalizeActionsForResource`.
+    const action: DocumentAction = {
+      type: 'document.edit',
+      documentId: 'doc1',
+      documentType: 'sanity.canvas.document',
+      patches: [{set: {foo: 'bar'}}],
+    }
+
+    // Don't await — we only need to inspect the synchronously-queued transaction.
+    applyDocumentActions(instance, {
+      actions: [action],
+      transactionId: 'txn-normalize',
+      resource: {canvasId: 'c'},
+    })
+
+    const queued = state.get().queued.find((t) => t.transactionId === 'txn-normalize')
+    expect(queued).toBeDefined()
+    const [queuedAction] = queued!.actions
+    expect(queuedAction).toMatchObject({type: 'document.edit', liveEdit: true})
   })
 })

package/src/document/applyDocumentActions.ts

@@ -1,15 +1,16 @@
-import {type SanityClient} from '@sanity/client'
-import {type SanityDocument} from '@sanity/types'
+import {type SanityDocument} from 'groq'
 import {distinctUntilChanged, filter, first, firstValueFrom, map, race} from 'rxjs'
 
 import {type DocumentResource} from '../config/sanityConfig'
 import {bindActionByResource} from '../store/createActionBinder'
 import {type SanityInstance} from '../store/createSanityInstance'
 import {type StoreContext} from '../store/defineStore'
-import {type DocumentAction} from './actions'
+import {type Action} from './actions'
 import {documentStore, type DocumentStoreState} from './documentStore'
+import {type DocumentTransactionSubmissionResult} from './events'
 import {type DocumentSet} from './processMutations'
 import {type AppliedTransaction, type QueuedTransaction, queueTransaction} from './reducers'
+import {normalizeActionsForResource} from './resourceRules'
 
 /** @beta */
 export interface ActionsResult<TDocument extends SanityDocument = SanityDocument> {
@@ -20,20 +21,21 @@ export interface ActionsResult<TDocument extends SanityDocument = SanityDocument
   appeared: string[]
   updated: string[]
   disappeared: string[]
-  submitted: () => ReturnType<SanityClient['action']>
+  submitted: () => Promise<DocumentTransactionSubmissionResult>
 }
 
 /** @beta */
 export interface ApplyDocumentActionsOptions {
   /**
-   * List of actions to apply.
+   * List of actions to apply. Accepts both document actions and release
+   * lifecycle actions because they share the same transaction pipeline.
    */
-  actions: DocumentAction[]
+  actions: Action[]
 
   /**
    * The resource to which the documents being acted on belong.
    */
-  resource: DocumentResource
+  resource?: DocumentResource
 
   /**
    * Optionally provide an ID to be used as this transaction ID
@@ -45,6 +47,15 @@ export interface ApplyDocumentActionsOptions {
   disableBatching?: boolean
 }
 
+/** @beta */
+export function applyDocumentActions<
+  TDocumentType extends string = string,
+  TDataset extends string = string,
+  TProjectId extends string = string,
+>(
+  instance: SanityInstance,
+  options: ApplyDocumentActionsOptions,
+): Promise<ActionsResult<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
 /** @beta */
 export function applyDocumentActions(
   instance: SanityInstance,
@@ -63,13 +74,23 @@ const boundApplyDocumentActions = bindActionByResource(documentStore, _applyDocu
 /** @internal */
 async function _applyDocumentActions(
   {state}: StoreContext<DocumentStoreState>,
-  {actions, transactionId = crypto.randomUUID(), disableBatching}: ApplyDocumentActionsOptions,
+  {
+    actions,
+    resource,
+    transactionId = crypto.randomUUID(),
+    disableBatching,
+  }: ApplyDocumentActionsOptions,
 ): Promise<ActionsResult> {
   const {events} = state.get()
 
+  // Rewrite edit actions to match the bound resource's editing model (e.g.
+  // forcing liveEdit for Canvas, stripping unsupported release perspectives).
+  // Non-edit and release actions pass through unchanged.
+  const normalizedActions = normalizeActionsForResource(actions, resource)
+
   const transaction: QueuedTransaction = {
     transactionId,
-    actions,
+    actions: normalizedActions,
     ...(disableBatching && {disableBatching}),
   }
 

package/src/document/documentConstants.ts

@@ -8,3 +8,10 @@
 export const DOCUMENT_STATE_CLEAR_DELAY = 1000
 export const INITIAL_OUTGOING_THROTTLE_TIME = 1000
 export const API_VERSION = 'v2025-05-06'
+
+/**
+ * Base delay (ms) before retrying a document listener after an `OutOfSyncError`.
+ * Backoff doubles on each successive retry, capped at {@link OUT_OF_SYNC_RETRY_MAX_DELAY}.
+ */
+export const OUT_OF_SYNC_RETRY_BASE_DELAY = 500
+export const OUT_OF_SYNC_RETRY_MAX_DELAY = 10_000