@sanity/sdk 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "private": false,
   "description": "Sanity SDK",
   "keywords": [
@@ -45,10 +45,10 @@
     "@sanity/client": "^7.2.1",
     "@sanity/comlink": "^3.0.4",
     "@sanity/diff-match-patch": "^3.2.0",
+    "@sanity/diff-patch": "^6.0.0",
     "@sanity/message-protocol": "^0.12.0",
     "@sanity/mutate": "^0.12.4",
     "@sanity/types": "^3.83.0",
-    "@types/lodash-es": "^4.17.12",
     "groq": "3.88.1-typegen-experimental.0",
     "lodash-es": "^4.17.21",
     "reselect": "^5.1.1",
@@ -59,6 +59,7 @@
     "@sanity/browserslist-config": "^1.0.5",
     "@sanity/pkg-utils": "^7.2.2",
     "@sanity/prettier-config": "^1.0.3",
+    "@types/lodash-es": "^4.17.12",
     "@vitest/coverage-v8": "3.1.2",
     "eslint": "^9.22.0",
     "groq-js": "^1.16.1",
@@ -67,11 +68,11 @@
     "typescript": "^5.8.3",
     "vite": "^6.3.4",
     "vitest": "^3.1.2",
-    "@repo/config-eslint": "0.0.0",
-    "@repo/config-test": "0.0.1",
     "@repo/package.bundle": "3.82.0",
+    "@repo/config-eslint": "0.0.0",
     "@repo/package.config": "0.0.1",
-    "@repo/tsconfig": "0.0.1"
+    "@repo/tsconfig": "0.0.1",
+    "@repo/config-test": "0.0.1"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/_exports/index.ts

@@ -13,11 +13,13 @@ export {
   getAuthState,
   getCurrentUserState,
   getDashboardOrganizationId,
+  getIsInDashboardState,
   getLoginUrlState,
   getTokenState,
   type LoggedInAuthState,
   type LoggedOutAuthState,
   type LoggingInAuthState,
+  setAuthToken,
 } from '../auth/authStore'
 export {observeOrganizationVerificationState} from '../auth/getOrganizationVerificationState'
 export {handleAuthCallback} from '../auth/handleAuthCallback'
@@ -32,8 +34,14 @@ export {
   releaseChannel,
 } from '../comlink/controller/comlinkControllerStore'
 export type {ComlinkNodeState} from '../comlink/node/comlinkNodeStore'
+export {getOrCreateNode, releaseNode} from '../comlink/node/comlinkNodeStore'
 export {getNodeState, type NodeState} from '../comlink/node/getNodeState'
-export {type FrameMessage, type WindowMessage} from '../comlink/types'
+export {
+  type FrameMessage,
+  type NewTokenResponseMessage,
+  type RequestNewTokenMessage,
+  type WindowMessage,
+} from '../comlink/types'
 export {type AuthConfig, type AuthProvider} from '../config/authConfig'
 export {
   createDatasetHandle,

package/src/auth/authStore.ts

@@ -280,3 +280,48 @@ export const getDashboardOrganizationId = bindActionGlobally(
   authStore,
   createStateSourceAction(({state: {dashboardContext}}) => dashboardContext?.orgId),
 )
+
+/**
+ * Returns a state source indicating if the SDK is running within a dashboard context.
+ * @public
+ */
+export const getIsInDashboardState = bindActionGlobally(
+  authStore,
+  createStateSourceAction(
+    ({state: {dashboardContext}}) =>
+      // Check if dashboardContext exists and is not empty
+      !!dashboardContext && Object.keys(dashboardContext).length > 0,
+  ),
+)
+
+/**
+ * Action to explicitly set the authentication token.
+ * Used internally by the Comlink token refresh.
+ * @internal
+ */
+export const setAuthToken = bindActionGlobally(authStore, ({state}, token: string | null) => {
+  const currentAuthState = state.get().authState
+  if (token) {
+    // Update state only if the new token is different or currently logged out
+    if (currentAuthState.type !== AuthStateType.LOGGED_IN || currentAuthState.token !== token) {
+      // This state update structure should trigger listeners in clientStore
+      state.set('setToken', {
+        authState: {
+          type: AuthStateType.LOGGED_IN,
+          token: token,
+          // Keep existing user or set to null? Setting to null forces refetch.
+          // Keep existing user to avoid unnecessary refetches if user data is still valid.
+          currentUser:
+            currentAuthState.type === AuthStateType.LOGGED_IN ? currentAuthState.currentUser : null,
+        },
+      })
+    }
+  } else {
+    // Handle setting token to null (logging out)
+    if (currentAuthState.type !== AuthStateType.LOGGED_OUT) {
+      state.set('setToken', {
+        authState: {type: AuthStateType.LOGGED_OUT, isDestroyingSession: false},
+      })
+    }
+  }
+})

package/src/comlink/types.ts

@@ -11,3 +11,21 @@ export type FrameMessage = Message
  * @public
  */
 export type WindowMessage = Message
+
+/**
+ * Message from SDK (iframe) to Parent (dashboard) to request a new token
+ * @internal
+ */
+export type RequestNewTokenMessage = {
+  type: 'dashboard/v1/auth/tokens/create'
+  payload?: undefined
+}
+
+/**
+ * Message from Parent (dashboard) to SDK (iframe) with the new token
+ * @internal
+ */
+export type NewTokenResponseMessage = {
+  type: 'dashboard/v1/auth/tokens/create'
+  payload: {token: string | null; error?: string}
+}

package/src/document/documentStore.test.ts

@@ -11,6 +11,7 @@ import {
   type UnfilteredResponseQueryOptions,
   type WelcomeEvent,
 } from '@sanity/client'
+import {diffValue} from '@sanity/diff-patch'
 import {type Mutation, type SanityDocument} from '@sanity/types'
 import {evaluate, parse} from 'groq-js'
 import {delay, first, firstValueFrom, from, Observable, of, ReplaySubject, Subject} from 'rxjs'
@@ -30,7 +31,6 @@ import {
   unpublishDocument,
 } from './actions'
 import {applyDocumentActions} from './applyDocumentActions'
-import {diffPatch} from './diffPatch'
 import {
   getDocumentState,
   getDocumentSyncStatus,
@@ -980,7 +980,7 @@ beforeEach(() => {
             documentId: id,
             eventId: `${transactionId}#${id}`,
             identity: 'example-user',
-            mutations: diffPatch(prevDoc, nextDoc).map(
+            mutations: diffValue(prevDoc, nextDoc).map(
               (patch): Mutation => ({patch: {...patch, id}}),
             ),
             timestamp,

package/src/document/documentStore.ts

@@ -189,8 +189,9 @@ const _getDocumentState = bindActionByDataset(
       const draft = documentStates[draftId]?.local
       const published = documentStates[publishedId]?.local
 
+      // wait for draft and published to be loaded before returning a value
+      if (draft === undefined || published === undefined) return undefined
       const document = draft ?? published
-      if (document === undefined) return undefined
       if (path) return jsonMatch(document, path).at(0)?.value
       return document
     },

package/src/document/patchOperations.test.ts

@@ -301,7 +301,7 @@ describe('jsonMatch', () => {
   it('matches an element in an array by keyed segment', () => {
     const input = [{_key: 'bar'}, {_key: 'foo'}, {_key: 'baz'}]
     const result = jsonMatch(input, '[_key=="foo"]')
-    expect(result).toEqual([{value: {_key: 'foo'}, path: [1]}])
+    expect(result).toEqual([{value: {_key: 'foo'}, path: [{_key: 'foo'}]}])
   })
 
   it('returns no match for a keyed segment when the input is not an array', () => {
@@ -668,7 +668,7 @@ describe('unset', () => {
   it('unsets multiple array elements when using a range', () => {
     const input = {items: [1, 2, 3, 4, 5]}
     const output = unset(input, ['items[1:3]'])
-    expect(output).toEqual({items: [1, 3, 5]})
+    expect(output).toEqual({items: [1, 4, 5]})
   })
 
   it('leaves input unchanged if no path expression matches', () => {
@@ -758,10 +758,10 @@ describe('insert', () => {
     expect(output).toEqual({some: {array: ['a', '!', 'b', 'c']}})
   })
 
-  it('interprets a negative index for "before" as append', () => {
+  it('interprets a negative index for "before"', () => {
     const input = {some: {array: ['a', 'b', 'c']}}
     const output = insert(input, {before: 'some.array[-1]', items: ['!']})
-    expect(output).toEqual({some: {array: ['a', 'b', 'c', '!']}})
+    expect(output).toEqual({some: {array: ['a', 'b', '!', 'c']}})
   })
 
   it('inserts items after a given positive index ("after" operation)', () => {
@@ -793,10 +793,10 @@ describe('insert', () => {
     })
   })
 
-  it('inserts items after a negative index ("after" operation with negative index interpreted as prepend)', () => {
+  it('inserts items after a negative index ("after" operation with negative index interpreted as append)', () => {
     const input = {some: {array: ['a', 'b', 'c']}}
     const output = insert(input, {after: 'some.array[-1]', items: ['!']})
-    expect(output).toEqual({some: {array: ['!', 'a', 'b', 'c']}})
+    expect(output).toEqual({some: {array: ['a', 'b', 'c', '!']}})
   })
 
   it('replaces a single matched element ("replace" operation, single match)', () => {

package/src/document/patchOperations.ts

@@ -325,17 +325,9 @@ function matchRecursive(value: unknown, path: Path, currentPath: SingleValuePath
     const endIndex = end === '' ? value.length : end
 
     // We'll accumulate all matches from each index in the range
-    let results: MatchEntry[] = []
-
-    // Decide whether the range is exclusive or inclusive. The example in
-    // the doc says "array[1:9]" => element 1 through 9 (non-inclusive?).
-    // Typically, in slice terms, that is `array.slice(1, 9)` → includes
-    // indices 1..8. If that's your intention, do i < endIndex.
-    for (let i = startIndex; i < endIndex; i++) {
-      results = results.concat(matchRecursive(value[i], rest, [...currentPath, i]))
-    }
-
-    return results
+    return value
+      .slice(startIndex, endIndex)
+      .flatMap((item, i) => matchRecursive(item, rest, [...currentPath, i + startIndex]))
   }
 
   // 4) Keyed segment => find index in array
@@ -347,7 +339,7 @@ function matchRecursive(value: unknown, path: Path, currentPath: SingleValuePath
   }
 
   const nextVal = value[arrIndex]
-  return matchRecursive(nextVal, rest, [...currentPath, arrIndex])
+  return matchRecursive(nextVal, rest, [...currentPath, {_key: keyed._key}])
 }
 
 // this is a similar array key to the studio:
@@ -492,14 +484,14 @@ export function unset<R>(input: unknown, pathExpressions: string[]): R
 export function unset(input: unknown, pathExpressions: string[]): unknown {
   const result = pathExpressions
     .flatMap((pathExpression) => jsonMatch(input, pathExpression))
+    // ensure that we remove in the reverse order the paths were found in
+    // this is necessary for array unsets so the indexes don't change as we unset
+    .reverse()
     .reduce((acc, {path}) => unsetDeep(acc, path), input)
 
   return ensureArrayKeysDeep(result)
 }
 
-const operations = ['before', 'after', 'replace'] as const
-type Operation = (typeof operations)[number]
-
 /**
  * Given an input object, a path expression (inside the insert patch object), and an array of items,
  * this function will insert or replace the matched items.
@@ -579,105 +571,138 @@ type Operation = (typeof operations)[number]
  * ```
  */
 export function insert<R>(input: unknown, insertPatch: InsertPatch): R
-export function insert(input: unknown, insertPatch: InsertPatch): unknown {
-  const operation = operations.find((op) => op in insertPatch)
+export function insert(input: unknown, {items, ...insertPatch}: InsertPatch): unknown {
+  let operation
+  let pathExpression
+
+  // behavior observed from content-lake when inserting:
+  // 1. if the operation is before, out of all the matches, it will use the
+  //    insert the items before the first match that appears in the array
+  // 2. if the operation is after, it will insert the items after the first
+  //    match that appears in the array
+  // 3. if the operation is replace, then insert the items before the first
+  //    match and then delete the rest
+  if ('before' in insertPatch) {
+    operation = 'before' as const
+    pathExpression = insertPatch.before
+  } else if ('after' in insertPatch) {
+    operation = 'after' as const
+    pathExpression = insertPatch.after
+  } else if ('replace' in insertPatch) {
+    operation = 'replace' as const
+    pathExpression = insertPatch.replace
+  }
   if (!operation) return input
-
-  const {items} = insertPatch
-  const pathExpression = (insertPatch as {[K in Operation]?: string} & {items: unknown})[operation]
   if (typeof pathExpression !== 'string') return input
 
-  // Helper to normalize a matched index given the parent array's length.
-  function normalizeIndex(index: number, parentLength: number): number {
-    switch (operation) {
-      case 'before':
-        // A negative index means "append" (i.e. insert before a hypothetical element
-        // beyond the end of the array).
-        return index < 0 ? parentLength : index
-      case 'after':
-        // For "after", if the matched index is negative, we treat it as "prepend":
-        // by convention, we convert it to -1 so that later adding 1 produces 0.
-        return index < 0 ? -1 : index
-      default: // default to 'replace'
-        // For replace, convert a negative index to the corresponding positive one.
-        return index < 0 ? parentLength + index : index
-    }
-  }
+  const parsedPath = parsePath(pathExpression)
+  // in order to do an insert patch, you need to provide at least one path segment
+  if (!parsedPath.length) return input
 
-  // Group the matched array entries by their parent array.
-  interface GroupEntry {
-    array: unknown[]
-    pathToArray: SingleValuePath
-    indexes: number[]
-  }
-  const grouped = new Map<unknown, GroupEntry>()
-  jsonMatch(input, pathExpression)
-    .map(({path}) => {
-      const segment = path[path.length - 1]
-      let index: number | undefined
-      if (isKeySegment(segment)) {
-        index = getIndexForKey(input, segment._key)
-      } else if (typeof segment === 'number') {
-        index = segment
-      }
-      if (typeof index !== 'number') return null
+  const arrayPath = stringifyPath(parsedPath.slice(0, -1))
+  const positionPath = stringifyPath(parsedPath.slice(-1))
 
-      const parentPath = path.slice(0, path.length - 1)
-      const parent = getDeep(input, parentPath)
-      if (!Array.isArray(parent)) return null
+  const arrayMatches = jsonMatch<unknown[]>(input, arrayPath)
 
-      const normalizedIndex = normalizeIndex(index, parent.length)
-      return {parent, parentPath, normalizedIndex}
-    })
-    .filter(isNonNullable)
-    .forEach(({parent, parentPath, normalizedIndex}) => {
-      if (grouped.has(parent)) {
-        grouped.get(parent)!.indexes.push(normalizedIndex)
-      } else {
-        grouped.set(parent, {array: parent, pathToArray: parentPath, indexes: [normalizedIndex]})
-      }
-    })
+  let result = input
 
-  // Sort the indexes for each grouped entry.
-  const groupEntries = Array.from(grouped.values()).map((entry) => ({
-    ...entry,
-    indexes: entry.indexes.sort((a, b) => a - b),
-  }))
+  for (const {path, value} of arrayMatches) {
+    if (!Array.isArray(value)) continue
+    let arr = value
 
-  // For each group, update the parent array using setDeep.
-  const result = groupEntries.reduce<unknown>((acc, {array, indexes, pathToArray}) => {
     switch (operation) {
+      case 'replace': {
+        const indexesToRemove = new Set<number>()
+        let position = Infinity
+
+        for (const itemMatch of jsonMatch(arr, positionPath)) {
+          // there should only be one path segment for an insert patch, invalid otherwise
+          if (itemMatch.path.length !== 1) continue
+          const [segment] = itemMatch.path
+          if (typeof segment === 'string') continue
+
+          let index
+
+          if (typeof segment === 'number') index = segment
+          if (typeof index === 'number' && index < 0) index = arr.length + index
+          if (isKeySegment(segment)) index = getIndexForKey(arr, segment._key)
+          if (typeof index !== 'number') continue
+          if (index < 0) index = arr.length + index
+
+          indexesToRemove.add(index)
+          if (index < position) position = index
+        }
+
+        if (position === Infinity) continue
+
+        // remove all other indexes
+        arr = arr
+          .map((item, index) => ({item, index}))
+          .filter(({index}) => !indexesToRemove.has(index))
+          .map(({item}) => item)
+
+        // insert at the min index
+        arr = [...arr.slice(0, position), ...items, ...arr.slice(position, arr.length)]
+
+        break
+      }
       case 'before': {
-        // Insert items before the first matched index.
-        const firstIndex = indexes[0]
-        return setDeep(acc, pathToArray, [
-          ...array.slice(0, firstIndex),
-          ...items,
-          ...array.slice(firstIndex),
-        ])
+        let position = Infinity
+
+        for (const itemMatch of jsonMatch(arr, positionPath)) {
+          if (itemMatch.path.length !== 1) continue
+          const [segment] = itemMatch.path
+
+          if (typeof segment === 'string') continue
+
+          let index
+
+          if (typeof segment === 'number') index = segment
+          if (typeof index === 'number' && index < 0) index = arr.length + index
+          if (isKeySegment(segment)) index = getIndexForKey(arr, segment._key)
+          if (typeof index !== 'number') continue
+          if (index < 0) index = arr.length - index
+          if (index < position) position = index
+        }
+
+        if (position === Infinity) continue
+
+        arr = [...arr.slice(0, position), ...items, ...arr.slice(position, arr.length)]
+
+        break
       }
       case 'after': {
-        // Insert items after the last matched index.
-        const lastIndex = indexes[indexes.length - 1] + 1
-        return setDeep(acc, pathToArray, [
-          ...array.slice(0, lastIndex),
-          ...items,
-          ...array.slice(lastIndex),
-        ])
+        let position = -Infinity
+
+        for (const itemMatch of jsonMatch(arr, positionPath)) {
+          if (itemMatch.path.length !== 1) continue
+          const [segment] = itemMatch.path
+
+          if (typeof segment === 'string') continue
+
+          let index
+
+          if (typeof segment === 'number') index = segment
+          if (typeof index === 'number' && index < 0) index = arr.length + index
+          if (isKeySegment(segment)) index = getIndexForKey(arr, segment._key)
+          if (typeof index !== 'number') continue
+          if (index > position) position = index
+        }
+
+        if (position === -Infinity) continue
+
+        arr = [...arr.slice(0, position + 1), ...items, ...arr.slice(position + 1, arr.length)]
+
+        break
       }
-      // default to 'replace' behavior
+
       default: {
-        // Remove all matched items then insert the new items at the first match.
-        const firstIndex = indexes[0]
-        const indexSet = new Set(indexes)
-        return setDeep(acc, pathToArray, [
-          ...array.slice(0, firstIndex),
-          ...items,
-          ...array.slice(firstIndex).filter((_, idx) => !indexSet.has(idx + firstIndex)),
-        ])
+        continue
       }
     }
-  }, input)
+
+    result = setDeep(result, path, arr)
+  }
 
   return ensureArrayKeysDeep(result)
 }
@@ -807,10 +832,6 @@ export function ifRevisionID(input: unknown, revisionId: string): unknown {
   return input
 }
 
-function isNonNullable<T>(t: T): t is NonNullable<T> {
-  return t !== null && t !== undefined
-}
-
 const indexCache = new WeakMap<KeyedSegment[], Record<string, number | undefined>>()
 export function getIndexForKey(input: unknown, key: string): number | undefined {
   if (!Array.isArray(input)) return undefined

package/src/document/processActions.ts

@@ -1,3 +1,4 @@
+import {diffValue} from '@sanity/diff-patch'
 import {
   type Mutation,
   type PatchOperations,
@@ -10,7 +11,6 @@ import {isEqual} from 'lodash-es'
 import {getDraftId, getPublishedId} from '../utils/ids'
 import {evaluateSync} from './_synchronous-groq-js.mjs'
 import {type DocumentAction} from './actions'
-import {diffPatch} from './diffPatch'
 import {type Grant} from './permissions'
 import {type DocumentSet, getId, processMutations} from './processMutations'
 import {type HttpAction} from './reducers'
@@ -300,11 +300,7 @@ export function processActions({
         // this one will always be defined because a patch mutation will never
         // delete an input document
         const baseAfter = base[draftId] as SanityDocument
-
-        // TODO: consider replacing with `sanity-diff-patch`. There seems to be
-        // bug in `sanity-diff-patch` where differing strings are not creating
-        // diff-match patches.
-        const patches = diffPatch(baseBefore, baseAfter)
+        const patches = diffValue(baseBefore, baseAfter)
 
         const workingMutations: Mutation[] = []
         if (!working[draftId] && working[publishedId]) {

package/src/document/processMutations.ts

@@ -26,7 +26,7 @@ export type DocumentSet<TDocument extends SanityDocument = SanityDocument> = {
   [TDocumentId in string]?: TDocument | null
 }
 
-type SupportPatchOperation = Exclude<keyof PatchOperations, 'merge'>
+type SupportedPatchOperation = Exclude<keyof PatchOperations, 'merge'>
 
 // > If multiple patches are included, then the order of execution is as follows:
 // > - set, setIfMissing, unset, inc, dec, insert.
@@ -41,7 +41,7 @@ const patchOperations = {
   insert,
   diffMatchPatch,
 } satisfies {
-  [K in SupportPatchOperation]: (
+  [K in SupportedPatchOperation]: (
     input: unknown,
     pathExpressions: NonNullable<PatchOperations[K]>,
   ) => unknown