@sanity/sdk 2.0.2 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "private": false,
   "description": "Sanity SDK",
   "keywords": [
@@ -46,6 +46,7 @@
     "@sanity/comlink": "^3.0.4",
     "@sanity/diff-match-patch": "^3.2.0",
     "@sanity/diff-patch": "^6.0.0",
+    "@sanity/json-match": "^1.0.5",
     "@sanity/message-protocol": "^0.12.0",
     "@sanity/mutate": "^0.12.4",
     "@sanity/types": "^3.83.0",
@@ -68,11 +69,11 @@
     "typescript": "^5.8.3",
     "vite": "^6.3.4",
     "vitest": "^3.1.2",
-    "@repo/package.bundle": "3.82.0",
     "@repo/config-eslint": "0.0.0",
+    "@repo/config-test": "0.0.1",
     "@repo/package.config": "0.0.1",
     "@repo/tsconfig": "0.0.1",
-    "@repo/config-test": "0.0.1"
+    "@repo/package.bundle": "3.82.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/_exports/index.ts

@@ -100,7 +100,7 @@ export {
   type TransactionAcceptedEvent,
   type TransactionRevertedEvent,
 } from '../document/events'
-export {type JsonMatch, jsonMatch} from '../document/patchOperations'
+export {type JsonMatch} from '../document/patchOperations'
 export {type DocumentPermissionsResult, type PermissionDeniedReason} from '../document/permissions'
 export type {FavoriteStatusResponse} from '../favorites/favorites'
 export {getFavoritesState, resolveFavoritesState} from '../favorites/favorites'
@@ -137,4 +137,12 @@ export {getUsersState, loadMoreUsers, resolveUsers} from '../users/usersStore'
 export {type FetcherStore, type FetcherStoreState} from '../utils/createFetcherStore'
 export {createGroqSearchFilter} from '../utils/createGroqSearchFilter'
 export {CORE_SDK_VERSION} from '../version'
+export {
+  getIndexForKey,
+  getPathDepth,
+  joinPaths,
+  jsonMatch,
+  slicePath,
+  stringifyPath,
+} from '@sanity/json-match'
 export type {CurrentUser, Role, SanityDocument} from '@sanity/types'

package/src/document/documentStore.ts

@@ -1,5 +1,6 @@
 import {type Action} from '@sanity/client'
 import {getPublishedId} from '@sanity/client/csm'
+import {jsonMatch} from '@sanity/json-match'
 import {type SanityDocument} from 'groq'
 import {type ExprNode} from 'groq-js'
 import {
@@ -36,7 +37,7 @@ import {type DocumentAction} from './actions'
 import {API_VERSION, INITIAL_OUTGOING_THROTTLE_TIME} from './documentConstants'
 import {type DocumentEvent, getDocumentEvents} from './events'
 import {listen, OutOfSyncError} from './listen'
-import {type JsonMatch, jsonMatch} from './patchOperations'
+import {type JsonMatch} from './patchOperations'
 import {calculatePermissions, createGrantsLookup, type DatasetAcl, type Grant} from './permissions'
 import {ActionError} from './processActions'
 import {
@@ -192,8 +193,11 @@ const _getDocumentState = bindActionByDataset(
       // wait for draft and published to be loaded before returning a value
       if (draft === undefined || published === undefined) return undefined
       const document = draft ?? published
-      if (path) return jsonMatch(document, path).at(0)?.value
-      return document
+      if (!path) return document
+      const result = jsonMatch(document, path).next()
+      if (result.done) return undefined
+      const {value} = result.value
+      return value
     },
     onSubscribe: (context, options: DocumentOptions<string | undefined>) =>
       manageSubscriberIds(context, options.documentId),

package/src/document/patchOperations.test.ts

@@ -5,356 +5,16 @@ import {
   diffMatchPatch,
   ensureArrayKeysDeep,
   getDeep,
-  getIndexForKey,
   ifRevisionID,
   inc,
   insert,
-  jsonMatch,
-  parsePath,
   set,
   setDeep,
   setIfMissing,
-  stringifyPath,
   unset,
   unsetDeep,
 } from './patchOperations'
 
-describe('parsePath', () => {
-  it('parses an empty string into an empty path', () => {
-    expect(parsePath('')).toEqual([])
-  })
-
-  it('parses simple dot notation (simple descent)', () => {
-    expect(parsePath('friend.name')).toEqual(['friend', 'name'])
-  })
-
-  it('parses a single property', () => {
-    expect(parsePath('foo')).toEqual(['foo'])
-  })
-
-  it('parses a property with a single numeric index', () => {
-    expect(parsePath('items[0]')).toEqual(['items', 0])
-  })
-
-  it('parses a property with a negative index', () => {
-    expect(parsePath('items[-1]')).toEqual(['items', -1])
-  })
-
-  it('parses a property with a keyed segment using double quotes', () => {
-    expect(parsePath('items[_key=="value"]')).toEqual(['items', {_key: 'value'}])
-  })
-
-  it('parses a property with a keyed segment using single quotes', () => {
-    expect(parsePath("items[_key=='value']")).toEqual(['items', {_key: 'value'}])
-  })
-
-  it('parses an array range that selects the whole thing (e.g. [:])', () => {
-    expect(parsePath('array[:]')).toEqual(['array', ['', '']])
-  })
-
-  it('parses an array range with both start and end (e.g. [1:9])', () => {
-    expect(parsePath('array[1:9]')).toEqual(['array', [1, 9]])
-  })
-
-  it('parses an array range with missing end (e.g. [4:])', () => {
-    expect(parsePath('array[4:]')).toEqual(['array', [4, '']])
-  })
-
-  it('parses an array range with missing start (e.g. [:4])', () => {
-    expect(parsePath('array[:4]')).toEqual(['array', ['', 4]])
-  })
-
-  it('parses multiple bracket expressions in one segment', () => {
-    expect(parsePath('foo[1][_key=="bar"][2:9]')).toEqual(['foo', 1, {_key: 'bar'}, [2, 9]])
-  })
-
-  it('parses segments that mix dot and bracket notation', () => {
-    // "a.b[0].c" splits into: ["a"] + parseSegment("b[0]") + ["c"] → ["a", "b", 0, "c"]
-    expect(parsePath('a.b[0].c')).toEqual(['a', 'b', 0, 'c'])
-  })
-
-  it('parses a segment with text before and after a bracket expression', () => {
-    // "foo[1]bar" → ["foo", 1, "bar"]
-    expect(parsePath('foo[1]bar')).toEqual(['foo', 1, 'bar'])
-  })
-
-  it('parses a segment that is only a bracket expression', () => {
-    expect(parsePath('[0]')).toEqual([0])
-  })
-
-  it('parses a segment that consists solely of bracket expressions', () => {
-    // "[1][_key=="a"]" → [1, { _key: "a" }]
-    expect(parsePath('[1][_key=="a"]')).toEqual([1, {_key: 'a'}])
-  })
-
-  it('ignores a trailing dot', () => {
-    // "foo." → ["foo"]
-    expect(parsePath('foo.')).toEqual(['foo'])
-  })
-
-  it('ignores a leading dot', () => {
-    // ".foo" → ["foo"]
-    expect(parsePath('.foo')).toEqual(['foo'])
-  })
-
-  it('throws an error when a bracket is not closed', () => {
-    expect(() => parsePath('foo[1')).toThrowError('Unmatched "[" in segment: "foo[1"')
-  })
-
-  it('throws an error when bracket content is invalid', () => {
-    expect(() => parsePath('a[invalid]')).toThrowError('Invalid bracket content: "[invalid]"')
-  })
-})
-
-describe('stringifyPath', () => {
-  it('stringifies a single string segment', () => {
-    expect(stringifyPath(['foo'])).toBe('foo')
-  })
-
-  it('stringifies multiple string segments using dot notation', () => {
-    expect(stringifyPath(['friend', 'name'])).toBe('friend.name')
-  })
-
-  it('stringifies a path with a single numeric index', () => {
-    expect(stringifyPath(['items', 0])).toBe('items[0]')
-  })
-
-  it('stringifies a path with a negative index', () => {
-    expect(stringifyPath(['items', -1])).toBe('items[-1]')
-  })
-
-  it('stringifies a keyed segment', () => {
-    expect(stringifyPath(['items', {_key: 'value'}])).toBe('items[_key=="value"]')
-  })
-
-  it('stringifies an array range with both start and end', () => {
-    expect(stringifyPath(['array', [1, 9]])).toBe('array[1:9]')
-  })
-
-  it('stringifies an array range with missing end', () => {
-    expect(stringifyPath(['array', [4, '']])).toBe('array[4:]')
-  })
-
-  it('stringifies an array range with missing start', () => {
-    expect(stringifyPath(['array', ['', 4]])).toBe('array[:4]')
-  })
-
-  it('stringifies an array range with both start and end missing (i.e. ":")', () => {
-    expect(stringifyPath(['array', ['', '']])).toBe('array[:]')
-  })
-
-  it('stringifies a complex combination of segments', () => {
-    // ["foo", 1, { _key: "bar" }, [2, 9]] → "foo[1][_key=="bar"][2:9]"
-    expect(stringifyPath(['foo', 1, {_key: 'bar'}, [2, 9]])).toBe('foo[1][_key=="bar"][2:9]')
-  })
-
-  it('stringifies a path that starts with a non-string segment', () => {
-    // [0, "foo"] → "[0].foo"
-    expect(stringifyPath([0, 'foo'])).toBe('[0].foo')
-  })
-
-  it('stringifies consecutive non-string segments without adding extra dots', () => {
-    // [0, -1] → "[0][-1]"
-    expect(stringifyPath([0, -1])).toBe('[0][-1]')
-  })
-
-  it('stringifies an empty path as an empty string', () => {
-    expect(stringifyPath([])).toBe('')
-  })
-})
-
-describe('getIndexForKey', () => {
-  it('returns undefined when input is not an array', () => {
-    expect(getIndexForKey(null, 'a')).toBeUndefined()
-    expect(getIndexForKey(123, 'a')).toBeUndefined()
-    expect(getIndexForKey('string', 'a')).toBeUndefined()
-    expect(getIndexForKey({}, 'a')).toBeUndefined()
-  })
-
-  it('returns undefined when given an empty array', () => {
-    const arr: unknown[] = []
-    expect(getIndexForKey(arr, 'any')).toBeUndefined()
-  })
-
-  it('returns undefined when array items do not have a _key property', () => {
-    const arr = [{notKey: 'a'}, {foo: 'bar'}]
-    expect(getIndexForKey(arr, 'a')).toBeUndefined()
-  })
-
-  it('returns the correct index for keyed segments', () => {
-    const arr = [{_key: 'a'}, {_key: 'b'}, {_key: 'c'}]
-    expect(getIndexForKey(arr, 'a')).toBe(0)
-    expect(getIndexForKey(arr, 'b')).toBe(1)
-    expect(getIndexForKey(arr, 'c')).toBe(2)
-  })
-
-  it('returns undefined when the key is not found in the array', () => {
-    const arr = [{_key: 'a'}, {_key: 'b'}]
-    expect(getIndexForKey(arr, 'c')).toBeUndefined()
-  })
-
-  it('returns the index for the last occurrence when duplicate keys exist', () => {
-    const arr = [{_key: 'dup'}, {_key: 'dup'}]
-    // Because the lookup overwrites earlier values,
-    // the index for "dup" should be the index of the last occurrence.
-    expect(getIndexForKey(arr, 'dup')).toBe(1)
-  })
-
-  it('ignores items that are not objects or that lack a _key property', () => {
-    const arr = [{_key: 'a'}, 42, 'hello', {_key: 'b'}]
-    expect(getIndexForKey(arr, 'a')).toBe(0)
-    expect(getIndexForKey(arr, 'b')).toBe(3)
-    // Even though 42 and "hello" are in the array, they are ignored.
-    expect(getIndexForKey(arr, '42')).toBeUndefined()
-  })
-
-  it('caches the index lookup even if the array is mutated after the first call', () => {
-    const arr = [{_key: 'a'}, {_key: 'b'}]
-    // First call creates the cache.
-    expect(getIndexForKey(arr, 'a')).toBe(0)
-    // Mutate the array element _key.
-    arr[0]._key = 'changed'
-    // The cache still returns the original index for "a"
-    expect(getIndexForKey(arr, 'a')).toBe(0)
-    // Lookup for the new key is undefined because it was not in the original lookup.
-    expect(getIndexForKey(arr, 'changed')).toBeUndefined()
-  })
-})
-
-describe('jsonMatch', () => {
-  it('returns the input when the path expression is empty', () => {
-    const input = 42
-    const result = jsonMatch(input, '')
-    expect(result).toEqual([{value: 42, path: []}])
-  })
-
-  it('matches object properties (simple descent)', () => {
-    const input = {friend: {name: 'Alice'}}
-    const result = jsonMatch(input, 'friend.name')
-    expect(result).toEqual([{value: 'Alice', path: ['friend', 'name']}])
-  })
-
-  it('returns a match with undefined for a missing property', () => {
-    const input = {friend: {}}
-    const result = jsonMatch(input, 'friend.name')
-    // Even though friend.name does not exist, the match is returned with value undefined.
-    expect(result).toEqual([{value: undefined, path: ['friend', 'name']}])
-  })
-
-  it('matches an array element by a positive numeric index', () => {
-    const input = [10, 20, 30]
-    const result = jsonMatch(input, '[1]')
-    expect(result).toEqual([{value: 20, path: [1]}])
-  })
-
-  it('matches an array element by a negative numeric index', () => {
-    const input = [10, 20, 30]
-    const result = jsonMatch(input, '[-1]')
-    expect(result).toEqual([{value: 30, path: [-1]}])
-  })
-
-  it('returns no match when a numeric index is used on a non-array', () => {
-    const input = {not: 'an array'}
-    const result = jsonMatch(input, '[1]')
-    expect(result).toEqual([])
-  })
-
-  it('matches multiple elements using an index tuple (range) with both start and end', () => {
-    const input = ['a', 'b', 'c', 'd', 'e']
-    const result = jsonMatch(input, '[1:4]')
-    // The range [1:4] will match indices 1, 2, and 3.
-    expect(result).toEqual([
-      {value: 'b', path: [1]},
-      {value: 'c', path: [2]},
-      {value: 'd', path: [3]},
-    ])
-  })
-
-  it('matches a range with a missing start ([:3])', () => {
-    const input = ['a', 'b', 'c', 'd']
-    const result = jsonMatch(input, '[:3]')
-    // Missing start means start at index 0.
-    expect(result).toEqual([
-      {value: 'a', path: [0]},
-      {value: 'b', path: [1]},
-      {value: 'c', path: [2]},
-    ])
-  })
-
-  it('matches a range with a missing end ([2:])', () => {
-    const input = ['a', 'b', 'c', 'd', 'e']
-    const result = jsonMatch(input, '[2:]')
-    // Missing end means go until the end of the array.
-    expect(result).toEqual([
-      {value: 'c', path: [2]},
-      {value: 'd', path: [3]},
-      {value: 'e', path: [4]},
-    ])
-  })
-
-  it('returns no match for an index tuple when the input is not an array', () => {
-    const input = {not: 'an array'}
-    const result = jsonMatch(input, '[1:3]')
-    expect(result).toEqual([])
-  })
-
-  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: [{_key: 'foo'}]}])
-  })
-
-  it('returns no match for a keyed segment when the input is not an array', () => {
-    const input = {_key: 'foo'}
-    const result = jsonMatch(input, '[_key=="foo"]')
-    expect(result).toEqual([])
-  })
-
-  it('returns no match for a keyed segment when the key is not found', () => {
-    const input = [{_key: 'a'}]
-    const result = jsonMatch(input, '[_key=="b"]')
-    expect(result).toEqual([])
-  })
-
-  it('matches a complex nested structure with a range and negative index', () => {
-    const input = {
-      friends: [
-        {name: 'Alice', scores: [10, 20, 30]},
-        {name: 'Bob', scores: [15, 25, 35]},
-        {name: 'Charlie', scores: [20, 30, 40]},
-      ],
-    }
-    const result = jsonMatch(input, 'friends[0:2].scores[-1]')
-    // For friends[0:2], the range selects friend indices 0 and 1.
-    // For each friend, scores[-1] picks the last element in the scores array.
-    expect(result).toEqual([
-      {value: 30, path: ['friends', 0, 'scores', -1]},
-      {value: 35, path: ['friends', 1, 'scores', -1]},
-    ])
-  })
-
-  it('returns no match when trying to access a property on a non-object', () => {
-    const input = {name: 'John'}
-    // Here, "name" is a string so it does not have a property "first"
-    const result = jsonMatch(input, 'name.first')
-    expect(result).toEqual([])
-  })
-
-  it('returns a match with undefined for an out-of-bound numeric index', () => {
-    const input = [1, 2, 3]
-    // Index 5 is out of bounds; .at(5) returns undefined.
-    const result = jsonMatch(input, '[5]')
-    expect(result).toEqual([{value: undefined, path: [5]}])
-  })
-
-  it('returns an empty match for an index tuple with an empty range', () => {
-    const input = ['a', 'b']
-    // A range like [2:2] selects no indices.
-    const result = jsonMatch(input, '[2:2]')
-    expect(result).toEqual([])
-  })
-})
-
 describe('getDeep', () => {
   it('returns the input when the path is empty', () => {
     const input = {a: 1, b: 2}
@@ -608,10 +268,16 @@ describe('set', () => {
     })
   })
 
-  it('leaves input unchanged if the path expression matches nothing', () => {
+  it('allows setting deeper even if the path expression matches nothing currently', () => {
     const input = {a: 1}
     const output = set(input, {'nonexistent.path': 999})
-    expect(output).toEqual({a: 1})
+    expect(output).toEqual({a: 1, nonexistent: {path: 999}})
+  })
+
+  it('creates an item from a key constraint if the key is not present', () => {
+    const input = {items: [{_key: 'item1'}]}
+    const output = set(input, {'items[_key=="item2"]': {_key: 'item2'}})
+    expect(output).toEqual({items: [{_key: 'item1'}, {_key: 'item2'}]})
   })
 })