@sanity/sdk 0.0.0-alpha.21 → 0.0.0-alpha.23

package/src/document/applyDocumentActions.ts

@@ -2,8 +2,9 @@ import {type SanityClient} from '@sanity/client'
 import {type SanityDocument} from '@sanity/types'
 import {distinctUntilChanged, filter, first, firstValueFrom, map, race} from 'rxjs'
 
-import {type SanityInstance} from '../instance/types'
-import {type ActionContext, createAction} from '../resources/createAction'
+import {bindActionByDataset} from '../store/createActionBinder'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {type StoreContext} from '../store/defineStore'
 import {type DocumentAction} from './actions'
 import {documentStore, type DocumentStoreState} from './documentStore'
 import {type DocumentSet} from './processMutations'
@@ -35,120 +36,160 @@ export interface ApplyDocumentActionsOptions {
 
 /** @beta */
 export function applyDocumentActions<TDocument extends SanityDocument>(
-  instance: SanityInstance | ActionContext<DocumentStoreState>,
+  instance: SanityInstance,
   action: DocumentAction<TDocument> | DocumentAction<TDocument>[],
   options?: ApplyDocumentActionsOptions,
 ): Promise<ActionsResult<TDocument>>
 /** @beta */
 export function applyDocumentActions(
-  instance: SanityInstance | ActionContext<DocumentStoreState>,
+  instance: SanityInstance,
   action: DocumentAction | DocumentAction[],
   options?: ApplyDocumentActionsOptions,
 ): Promise<ActionsResult>
 /** @beta */
 export function applyDocumentActions(
-  ...args: Parameters<typeof _applyDocumentActions>
-): ReturnType<typeof _applyDocumentActions> {
-  return _applyDocumentActions(...args)
+  ...args: Parameters<typeof boundApplyDocumentActions>
+): ReturnType<typeof boundApplyDocumentActions> {
+  return boundApplyDocumentActions(...args)
 }
 
-const _applyDocumentActions = createAction(documentStore, ({state}) => {
-  const {events} = state.get()
-
-  return async function (
-    action: DocumentAction | DocumentAction[],
-    {transactionId = crypto.randomUUID(), disableBatching}: ApplyDocumentActionsOptions = {},
-  ): Promise<ActionsResult> {
-    const actions = Array.isArray(action) ? action : [action]
-
-    const transaction: QueuedTransaction = {
-      transactionId,
-      actions,
-      ...(disableBatching && {disableBatching}),
-    }
+const boundApplyDocumentActions = bindActionByDataset(documentStore, _applyDocumentActions)
+
+/** @internal */
+async function _applyDocumentActions(
+  {instance, state}: StoreContext<DocumentStoreState>,
+  actionOrActions: DocumentAction | DocumentAction[],
+  {transactionId = crypto.randomUUID(), disableBatching}: ApplyDocumentActionsOptions = {},
+): Promise<ActionsResult> {
+  const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]
+
+  let projectId
+  let dataset
+  for (const action of actions) {
+    if (action.projectId) {
+      if (!projectId) projectId = action.projectId
+      if (action.projectId !== projectId) {
+        throw new Error(
+          `Mismatched project IDs found in actions. All actions must belong to the same project. Found "${action.projectId}" but expected "${projectId}".`,
+        )
+      }
 
-    const fatalError$ = state.observable.pipe(
-      map((s) => s.error),
-      first(Boolean),
-      map((error) => ({type: 'error', error}) as const),
-    )
-
-    const transactionError$ = events.pipe(
-      filter((e) => e.type === 'error'),
-      first((e) => e.transactionId === transactionId),
-    )
-
-    const appliedTransaction$ = state.observable.pipe(
-      map((s) => s.applied),
-      distinctUntilChanged(),
-      map((applied) => applied.find((t) => t.transactionId === transactionId)),
-      first(Boolean),
-    )
-
-    const successfulTransaction$ = events.pipe(
-      filter((e) => e.type === 'accepted'),
-      first((e) => e.outgoing.batchedTransactionIds.includes(transactionId)),
-    )
-
-    const rejectedTransaction$ = events.pipe(
-      filter((e) => e.type === 'reverted'),
-      first((e) => e.outgoing.batchedTransactionIds.includes(transactionId)),
-    )
-
-    const appliedTransactionOrError = firstValueFrom(
-      race([fatalError$, transactionError$, appliedTransaction$]),
-    )
-    const acceptedOrRejectedTransaction = firstValueFrom(
-      race([successfulTransaction$, rejectedTransaction$, transactionError$]),
-    )
-
-    state.set('queueTransaction', (prev) => queueTransaction(prev, transaction))
-
-    const result = await appliedTransactionOrError
-    if ('type' in result && result.type === 'error') throw result.error
-
-    const {working: documents, previous, previousRevs} = result as AppliedTransaction
-    const existingIds = new Set(
-      Object.entries(previous)
-        .filter(([, value]) => !!value)
-        .map(([key]) => key),
-    )
-    const resultingIds = new Set(
-      Object.entries(documents)
-        .filter(([, value]) => !!value)
-        .map(([key]) => key),
-    )
-    const allIds = new Set([...existingIds, ...resultingIds])
-
-    const updated: string[] = []
-    const appeared: string[] = []
-    const disappeared: string[] = []
-
-    for (const id of allIds) {
-      if (existingIds.has(id) && resultingIds.has(id)) {
-        updated.push(id)
-      } else if (!existingIds.has(id) && resultingIds.has(id)) {
-        appeared.push(id)
-      } else if (!resultingIds.has(id) && existingIds.has(id)) {
-        disappeared.push(id)
+      if (action.dataset) {
+        if (!dataset) dataset = action.dataset
+        if (action.dataset !== dataset) {
+          throw new Error(
+            `Mismatched datasets found in actions. All actions must belong to the same dataset. Found "${action.dataset}" but expected "${dataset}".`,
+          )
+        }
       }
     }
+  }
 
-    async function submitted() {
-      const raceResult = await acceptedOrRejectedTransaction
-      if (raceResult.type !== 'accepted') throw raceResult.error
-      return raceResult.result
+  if (
+    (projectId && projectId !== instance.config.projectId) ||
+    (dataset && dataset !== instance.config.dataset)
+  ) {
+    const matchedInstance = instance.match({projectId, dataset})
+    if (!matchedInstance) {
+      throw new Error(
+        `Could not find a matching instance for projectId: "${projectId}" and dataset: "${dataset}"`,
+      )
     }
-
-    return {
+    return boundApplyDocumentActions(matchedInstance, actionOrActions, {
+      disableBatching,
       transactionId,
-      documents,
-      previous,
-      previousRevs,
-      appeared,
-      updated,
-      disappeared,
-      submitted,
+    })
+  }
+
+  const {events} = state.get()
+
+  const transaction: QueuedTransaction = {
+    transactionId,
+    actions,
+    ...(disableBatching && {disableBatching}),
+  }
+
+  const fatalError$ = state.observable.pipe(
+    map((s) => s.error),
+    first(Boolean),
+    map((error) => ({type: 'error', error}) as const),
+  )
+
+  const transactionError$ = events.pipe(
+    filter((e) => e.type === 'error'),
+    first((e) => e.transactionId === transactionId),
+  )
+
+  const appliedTransaction$ = state.observable.pipe(
+    map((s) => s.applied),
+    distinctUntilChanged(),
+    map((applied) => applied.find((t) => t.transactionId === transactionId)),
+    first(Boolean),
+  )
+
+  const successfulTransaction$ = events.pipe(
+    filter((e) => e.type === 'accepted'),
+    first((e) => e.outgoing.batchedTransactionIds.includes(transactionId)),
+  )
+
+  const rejectedTransaction$ = events.pipe(
+    filter((e) => e.type === 'reverted'),
+    first((e) => e.outgoing.batchedTransactionIds.includes(transactionId)),
+  )
+
+  const appliedTransactionOrError = firstValueFrom(
+    race([fatalError$, transactionError$, appliedTransaction$]),
+  )
+  const acceptedOrRejectedTransaction = firstValueFrom(
+    race([successfulTransaction$, rejectedTransaction$, transactionError$]),
+  )
+
+  state.set('queueTransaction', (prev) => queueTransaction(prev, transaction))
+
+  const result = await appliedTransactionOrError
+  if ('type' in result && result.type === 'error') throw result.error
+
+  const {working: documents, previous, previousRevs} = result as AppliedTransaction
+  const existingIds = new Set(
+    Object.entries(previous)
+      .filter(([, value]) => !!value)
+      .map(([key]) => key),
+  )
+  const resultingIds = new Set(
+    Object.entries(documents)
+      .filter(([, value]) => !!value)
+      .map(([key]) => key),
+  )
+  const allIds = new Set([...existingIds, ...resultingIds])
+
+  const updated: string[] = []
+  const appeared: string[] = []
+  const disappeared: string[] = []
+
+  for (const id of allIds) {
+    if (existingIds.has(id) && resultingIds.has(id)) {
+      updated.push(id)
+    } else if (!existingIds.has(id) && resultingIds.has(id)) {
+      appeared.push(id)
+    } else if (!resultingIds.has(id) && existingIds.has(id)) {
+      disappeared.push(id)
     }
   }
-})
+
+  async function submitted() {
+    const raceResult = await acceptedOrRejectedTransaction
+    if (raceResult.type !== 'accepted') throw raceResult.error
+    return raceResult.result
+  }
+
+  return {
+    transactionId,
+    documents,
+    previous,
+    previousRevs,
+    appeared,
+    updated,
+    disappeared,
+    submitted,
+  }
+}