@sanity/client 6.6.0 → 6.7.1-canary.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/client",
-  "version": "6.6.0",
+  "version": "6.7.1-canary.0",
   "description": "Client for retrieving, creating and patching data from Sanity.io",
   "keywords": [
     "sanity",
@@ -44,6 +44,13 @@
       },
       "default": "./dist/index.js"
     },
+    "./csm": {
+      "types": "./dist/csm.d.ts",
+      "source": "./src/csm/index.ts",
+      "import": "./dist/csm.js",
+      "require": "./dist/csm.cjs",
+      "default": "./dist/csm.js"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.cjs",
@@ -55,6 +62,13 @@
     "./dist/index.js": "./dist/index.browser.js"
   },
   "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "csm": [
+        "./dist/csm.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist",
     "src",
@@ -91,33 +105,33 @@
   },
   "dependencies": {
     "@sanity/eventsource": "^5.0.0",
-    "get-it": "^8.4.3",
+    "get-it": "^8.4.4",
     "rxjs": "^7.0.0"
   },
   "devDependencies": {
-    "@edge-runtime/types": "^2.2.4",
-    "@edge-runtime/vm": "^3.1.4",
-    "@rollup/plugin-commonjs": "^25.0.5",
+    "@edge-runtime/types": "^2.2.6",
+    "@edge-runtime/vm": "^3.1.6",
+    "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@sanity/pkg-utils": "^3.0.0",
-    "@types/node": "^20.8.4",
-    "@typescript-eslint/eslint-plugin": "^6.7.5",
-    "@typescript-eslint/parser": "^6.7.5",
+    "@sanity/pkg-utils": "^3.2.1",
+    "@types/node": "^20.8.8",
+    "@typescript-eslint/eslint-plugin": "^6.9.0",
+    "@typescript-eslint/parser": "^6.9.0",
     "@vitest/coverage-v8": "^0.34.6",
-    "eslint": "^8.51.0",
+    "eslint": "^8.52.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-prettier": "^5.0.1",
     "eslint-plugin-simple-import-sort": "^10.0.0",
     "faucet": "^0.0.4",
-    "happy-dom": "^12.9.1",
+    "happy-dom": "^12.10.1",
     "ls-engines": "^0.9.0",
-    "nock": "^13.3.4",
+    "nock": "^13.3.6",
     "prettier": "^3.0.3",
     "prettier-plugin-packagejson": "^2.4.6",
     "rimraf": "^5.0.1",
-    "rollup": "^4.0.2",
+    "rollup": "^4.1.4",
     "sse-channel": "^4.0.0",
-    "terser": "^5.21.0",
+    "terser": "^5.22.0",
     "typescript": "^5.2.2",
     "vitest": "^0.34.6",
     "vitest-github-actions-reporter": "^0.10.0"

package/src/csm/editIntent.ts

@@ -0,0 +1,42 @@
+import {ContentSourceMapDocument, ContentSourceMapDocuments} from '../types'
+import {parseJsonPath} from './jsonpath'
+import type {PathSegment, StudioUrl} from './types'
+
+/** @alpha */
+export type EditLink = `/intent/edit/id=${string};type=${string};path=${string}`
+
+/** @alpha */
+export interface EditLinkProps {
+  studioUrl: StudioUrl
+  document: ContentSourceMapDocument
+}
+
+/** @alpha */
+export type DefineEditLink = (
+  studioUrl: StudioUrl,
+) => (sourceDocument: ContentSourceMapDocuments[number]) => `${StudioUrl}${EditLink}`
+
+/** @alpha */
+export function defineEditLink(
+  _studioUrl: StudioUrl,
+): (
+  sourceDocument: ContentSourceMapDocuments[number],
+  path: string | PathSegment[],
+) => `${StudioUrl}${EditLink}` {
+  const studioUrl = _studioUrl.replace(/\/$/, '')
+  return ({_id, _type}, path) =>
+    `${studioUrl}/intent/edit/id=${_id};type=${_type};path=${encodeJsonPathToUriComponent(path)}`
+}
+
+/** @alpha */
+export function encodeJsonPathToUriComponent(path: string | PathSegment[]): string {
+  const sourcePath = Array.isArray(path) ? path : parseJsonPath(path)
+  return encodeURIComponent(
+    sourcePath
+      .map((key, i) =>
+        // eslint-disable-next-line no-nested-ternary
+        typeof key === 'number' ? `[${key}]` : i > 0 ? `.${key}` : key,
+      )
+      .join(''),
+  )
+}

package/src/csm/index.ts

@@ -0,0 +1,20 @@
+export type {
+  ContentSourceMap,
+  ContentSourceMapDocument,
+  ContentSourceMapDocumentBase,
+  ContentSourceMapDocuments,
+  ContentSourceMapDocumentValueSource,
+  ContentSourceMapLiteralSource,
+  ContentSourceMapMapping,
+  ContentSourceMapMappings,
+  ContentSourceMapPaths,
+  ContentSourceMapRemoteDocument,
+  ContentSourceMapSource,
+  ContentSourceMapUnknownSource,
+  ContentSourceMapValueMapping,
+} from '../types'
+export {encodeJsonPathToUriComponent} from './editIntent'
+export {jsonPath} from './jsonpath'
+export * from './mapToEditLinks'
+export {resolveMapping, walkMap, type WalkMapFn} from './sourcemap'
+export type * from './types'

package/src/csm/jsonpath.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from 'vitest'
+
+import { jsonPath, parseJsonPath } from './jsonpath'
+
+test('formats normalised JSON Paths', () => {
+  expect(jsonPath(['foo', 'bar', 0, 'baz'])).toBe(
+    "$['foo']['bar'][0]['baz']",
+  )
+})
+
+test('formats normalised JSON Paths with escaped characters', () => {
+  expect(jsonPath(['foo', 'bar', 0, 'baz', "it's a 'test'"])).toBe(
+    "$['foo']['bar'][0]['baz']['it\\'s a \\'test\\'']",
+  )
+})
+
+test('parses normalised JSON Paths', () => {
+  expect(parseJsonPath("$['foo']['bar'][0]['baz']")).toEqual([
+    'foo',
+    'bar',
+    0,
+    'baz',
+  ])
+})
+
+test('parses normalised JSON Paths with escaped characters', () => {
+  expect(
+    parseJsonPath("$['foo']['bar'][0]['baz']['it\\'s a \\'test\\'']"),
+  ).toEqual(['foo', 'bar', 0, 'baz', "it's a 'test'"])
+})
+
+test('parses normalised JSON Paths with key array filter selectors', () => {
+  expect(parseJsonPath("$['foo'][?(@._key=='section-1')][0]['baz'][?(@._key=='section-2')]")).toEqual([
+    'foo',
+    { key: 'section-1', index: -1 },
+    0,
+    'baz',
+    { key: 'section-2', index: -1},
+  ])
+})

package/src/csm/jsonpath.ts

@@ -0,0 +1,89 @@
+import type { PathSegment } from './types'
+
+const ESCAPE: Record<string, string> = {
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t',
+  "'": "\\'",
+  '\\': '\\\\',
+}
+
+const UNESCAPE: Record<string, string> = {
+  '\\f': '\f',
+  '\\n': '\n',
+  '\\r': '\r',
+  '\\t': '\t',
+  "\\'": "'",
+  '\\\\': '\\',
+}
+
+/** @internal */
+export function jsonPath(
+  path: PathSegment[],
+  opts?: {
+    keyArraySelectors: boolean
+  },
+): string {
+  return `$${path
+    .map((segment) => {
+      if (typeof segment === 'string') {
+        const escapedKey = segment.replace(/[\f\n\r\t'\\]/g, (match) => {
+          return ESCAPE[match]
+        })
+        return `['${escapedKey}']`
+      }
+
+      if (typeof segment === 'number') {
+        return `[${segment}]`
+      }
+
+      if (opts?.keyArraySelectors && segment.key !== '') {
+        const escapedKey = segment.key.replace(/['\\]/g, (match) => {
+          return ESCAPE[match]
+        })
+        return `[?(@._key=='${escapedKey}')]`
+      }
+
+      return `[${segment.index}]`
+    })
+    .join('')}`
+}
+
+/** @internal */
+export function parseJsonPath(path: string): PathSegment[] {
+  const parsed: PathSegment[] = []
+
+  const parseRe = /\['(.*?)'\]|\[(\d+)\]|\[\?\(@\._key=='(.*?)'\)\]/g
+  let match: RegExpExecArray | null
+
+  while ((match = parseRe.exec(path)) !== null) {
+    if (match[1] !== undefined) {
+      const key = match[1].replace(/\\(\\|f|n|r|t|')/g, (m) => {
+        return UNESCAPE[m]
+      })
+
+      parsed.push(key)
+      continue
+    }
+
+    if (match[2] !== undefined) {
+      parsed.push(parseInt(match[2], 10))
+      continue
+    }
+
+    if (match[3] !== undefined) {
+      const key = match[3].replace(/\\(\\')/g, (m) => {
+        return UNESCAPE[m]
+      })
+
+      parsed.push({
+        key,
+        index: -1,
+      })
+      continue
+    }
+  }
+
+  return parsed
+}

package/src/csm/mapToEditLinks.test.ts

@@ -0,0 +1,103 @@
+import {expect, test} from 'vitest'
+
+import {ContentSourceMapDocument} from '../types'
+import {mapToEditLinks} from './mapToEditLinks'
+
+const resultEditLinksTestCases = [
+  {
+    name: 'returns links for all strings in the result',
+    queryResult: {
+      result: [
+        {
+          linkMe: 'that',
+          deep: [
+            {
+              linkMe: 'that',
+            },
+          ],
+        },
+      ],
+      resultSourceMap: {
+        documents: [
+          {
+            _id: 'foo',
+            _type: 'foo',
+          },
+        ] satisfies ContentSourceMapDocument[],
+        paths: ["$['linkMe']", "$['deep']"],
+        mappings: {
+          "$[0]['linkMe']": {
+            source: {
+              document: 0,
+              path: 0,
+              type: 'documentValue',
+            },
+            type: 'value',
+          },
+          "$[0]['deep']": {
+            source: {
+              document: 0,
+              path: 1,
+              type: 'documentValue',
+            },
+            type: 'value',
+          },
+        },
+      },
+    },
+    expected: [
+      {
+        linkMe: 'test.sanity.studio/intent/edit/id=foo;type=foo;path=linkMe',
+        deep: [
+          {
+            linkMe: 'test.sanity.studio/intent/edit/id=foo;type=foo;path=deep%5B0%5D.linkMe',
+          },
+        ],
+      },
+    ],
+  },
+  {
+    name: 'results should be unchanged if no compatible types are found',
+    queryResult: {
+      result: [
+        {
+          dontLinkMe: 1,
+        },
+      ],
+      resultSourceMap: {
+        documents: [
+          {
+            _id: 'foo',
+            _type: 'foo',
+          },
+        ] satisfies ContentSourceMapDocument[],
+        paths: ["$['dontLinkMe']"],
+        mappings: {
+          "$[0]['dontLinkMe']": {
+            source: {
+              document: 0,
+              path: 0,
+              type: 'documentValue',
+            },
+            type: 'value',
+          },
+        },
+      },
+    },
+    expected: [
+      {
+        dontLinkMe: 1,
+      },
+    ],
+  },
+]
+
+test.each(resultEditLinksTestCases)('mapToEditLinks $name', ({queryResult, expected}) => {
+  const response = mapToEditLinks(
+    queryResult.result,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    queryResult.resultSourceMap as any,
+    'test.sanity.studio/',
+  )
+  expect(response).toEqual(expected)
+})

package/src/csm/mapToEditLinks.ts

@@ -0,0 +1,11 @@
+import type {ContentSourceMap} from '../types'
+import {defineEditLink} from './editIntent'
+import {encodeIntoResult} from './sourcemap'
+
+/** @alpha */
+export function mapToEditLinks<R>(result: R, csm: ContentSourceMap, studioUrl: string): R {
+  const createEditLink = defineEditLink(studioUrl)
+  return encodeIntoResult(result, csm, (_, sourceDocument, path) => {
+    return createEditLink(sourceDocument, path)
+  }) as R
+}

package/src/csm/sourcemap.test.ts

@@ -0,0 +1,212 @@
+import {expect, test, vi} from 'vitest'
+
+import type {ContentSourceMap} from '../types'
+import {encode} from './sourcemap'
+
+const encodeTestCases: {
+  name: string
+  queryResult: {
+    result: unknown
+    resultSourceMap: ContentSourceMap
+  }
+  options?: {
+    keyArraySelectors: boolean
+  }
+  expected: {
+    encoderCalls: number
+    encoderArgs: unknown[][]
+  }
+}[] = [
+  {
+    name: 'resolves exact mappings to source',
+    queryResult: {
+      result: [
+        {
+          _id: 'foo',
+          this: 'that',
+        },
+      ],
+      resultSourceMap: {
+        documents: [
+          {
+            _id: 'foo',
+            _type: 'bar',
+          },
+        ],
+        paths: ["$['this']"],
+        mappings: {
+          "$[0]['this']": {
+            source: {
+              document: 0,
+              path: 0,
+              type: 'documentValue',
+            },
+            type: 'value',
+          },
+        },
+      },
+    },
+    expected: {
+      encoderCalls: 1,
+      encoderArgs: [['that', {_id: 'foo', _type: 'bar'}, ['this']]],
+    },
+  },
+  {
+    name: 'resolves aggregated mappings to source',
+    queryResult: {
+      result: [
+        {
+          _id: 'foo',
+          nested: {
+            object: {
+              this: 'that',
+            },
+          },
+        },
+      ],
+      resultSourceMap: {
+        documents: [
+          {
+            _id: 'foo',
+            _type: 'bar',
+          },
+        ],
+        paths: ["$['something']['nested']"],
+        mappings: {
+          "$[0]['nested']": {
+            source: {
+              document: 0,
+              path: 0,
+              type: 'documentValue',
+            },
+            type: 'value',
+          },
+        },
+      },
+    },
+    expected: {
+      encoderCalls: 1,
+      encoderArgs: [
+        ['that', {_id: 'foo', _type: 'bar'}, ['something', 'nested', 'object', 'this']],
+      ],
+    },
+  },
+  {
+    name: 'plucks out _key to use as path segment',
+    queryResult: {
+      result: [
+        {
+          _id: 'foo',
+          nested: {
+            arr: [
+              {
+                _key: 'im_a_key',
+                value: 'that',
+              },
+            ],
+          },
+        },
+      ],
+      resultSourceMap: {
+        documents: [
+          {
+            _id: 'foo',
+            _type: 'bar',
+          },
+        ],
+        paths: ["$['projected']['nested']"],
+        mappings: {
+          "$[0]['nested']": {
+            source: {
+              document: 0,
+              path: 0,
+              type: 'documentValue',
+            },
+            type: 'value',
+          },
+        },
+      },
+    },
+    options: {
+      keyArraySelectors: true,
+    },
+    expected: {
+      encoderCalls: 2,
+      encoderArgs: [
+        [
+          'im_a_key',
+          {_id: 'foo', _type: 'bar'},
+          ['projected', 'nested', 'arr', {key: 'im_a_key', index: 0}, '_key'],
+        ],
+        [
+          'that',
+          {_id: 'foo', _type: 'bar'},
+          ['projected', 'nested', 'arr', {key: 'im_a_key', index: 0}, 'value'],
+        ],
+      ],
+    },
+  },
+  {
+    name: 'handles _key array filter selectors in source paths',
+    queryResult: {
+      result: [
+        {
+          _id: 'foo',
+          arr: [
+            {
+              _key: 'im_a_key',
+              value: 'that',
+            },
+          ],
+        },
+      ],
+      resultSourceMap: {
+        documents: [
+          {
+            _id: 'foo',
+            _type: 'bar',
+          },
+        ],
+        paths: ["$['projected'][?(@._key=='fooKey')]"],
+        mappings: {
+          "$[0]['arr']": {
+            source: {
+              document: 0,
+              path: 0,
+              type: 'documentValue',
+            },
+            type: 'value',
+          },
+        },
+      },
+    },
+    options: {
+      keyArraySelectors: true,
+    },
+    expected: {
+      encoderCalls: 2,
+      encoderArgs: [
+        [
+          'im_a_key',
+          {_id: 'foo', _type: 'bar'},
+          ['projected', {key: 'fooKey', index: -1}, {key: 'im_a_key', index: 0}, '_key'],
+        ],
+        [
+          'that',
+          {_id: 'foo', _type: 'bar'},
+          ['projected', {key: 'fooKey', index: -1}, {key: 'im_a_key', index: 0}, 'value'],
+        ],
+      ],
+    },
+  },
+]
+
+test.each(encodeTestCases)('encode $name', ({queryResult, options, expected}) => {
+  const mockTranscoder = vi.fn().mockImplementation((input: string) => input)
+  encode(queryResult.result, queryResult.resultSourceMap, mockTranscoder, options)
+
+  expect(mockTranscoder).toBeCalledTimes(expected.encoderCalls)
+  for (const args of expected.encoderArgs) {
+    expect(mockTranscoder).toBeCalledWith(...args)
+  }
+})