@sanity/sdk 2.8.0 → 2.10.0

package/src/utils/object.ts

@@ -0,0 +1,142 @@
+/**
+ * Returns true when the input is a non-null object.
+ *
+ * @internal
+ */
+export function isObject(value: unknown): value is object {
+  return typeof value === 'object' && value !== null
+}
+
+const hasOwn = (value: object, key: PropertyKey) => Object.prototype.hasOwnProperty.call(value, key)
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (!isObject(value)) return false
+
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
+/**
+ * Creates a shallow copy without the provided property.
+ *
+ * @internal
+ */
+export function omitProperty<T extends object, K extends keyof T>(
+  value: T | null | undefined,
+  key: K,
+): Omit<T, K> {
+  if (!value) return {} as Omit<T, K>
+
+  const {[key]: _omitted, ...rest} = value
+  return rest
+}
+
+/**
+ * Creates a shallow copy containing only the provided properties.
+ *
+ * @internal
+ */
+export function pickProperties<T extends object, K extends keyof T>(
+  value: T,
+  keys: readonly K[],
+): Pick<T, K> {
+  const result = {} as Pick<T, K>
+
+  for (const key of keys) {
+    if (hasOwn(value, key)) {
+      result[key] = value[key]
+    }
+  }
+
+  return result
+}
+
+const areSetsEqual = (left: Set<unknown>, right: Set<unknown>): boolean => {
+  if (left.size !== right.size) return false
+
+  const unmatched = [...right]
+
+  outer: for (const leftValue of left) {
+    for (let index = 0; index < unmatched.length; index++) {
+      if (isDeepEqual(leftValue, unmatched[index])) {
+        unmatched.splice(index, 1)
+        continue outer
+      }
+    }
+
+    return false
+  }
+
+  return unmatched.length === 0
+}
+
+const areMapsEqual = (left: Map<unknown, unknown>, right: Map<unknown, unknown>): boolean => {
+  if (left.size !== right.size) return false
+
+  const unmatched = [...right.entries()]
+
+  outer: for (const [leftKey, leftValue] of left) {
+    for (let index = 0; index < unmatched.length; index++) {
+      const [rightKey, rightValue] = unmatched[index]
+
+      if (isDeepEqual(leftKey, rightKey) && isDeepEqual(leftValue, rightValue)) {
+        unmatched.splice(index, 1)
+        continue outer
+      }
+    }
+
+    return false
+  }
+
+  return unmatched.length === 0
+}
+
+/**
+ * Compares values deeply across the plain object, array, map, and set shapes used by the SDK.
+ * This helper is intended for acyclic SDK data structures and does not guard against circular
+ * references.
+ *
+ * @internal
+ */
+export function isDeepEqual<T>(left: T, right: T): boolean {
+  if (Object.is(left, right)) return true
+
+  if (!isObject(left) || !isObject(right)) return false
+
+  if (left instanceof Date && right instanceof Date) {
+    return left.getTime() === right.getTime()
+  }
+
+  if (left instanceof RegExp && right instanceof RegExp) {
+    return left.source === right.source && left.flags === right.flags
+  }
+
+  if (left instanceof Set && right instanceof Set) {
+    return areSetsEqual(left, right)
+  }
+
+  if (left instanceof Map && right instanceof Map) {
+    return areMapsEqual(left, right)
+  }
+
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false
+
+    return left.every((value, index) => isDeepEqual(value, right[index]))
+  }
+
+  if (!isPlainObject(left) || !isPlainObject(right)) return false
+
+  const leftKeys = Object.keys(left)
+  const rightKeys = Object.keys(right)
+
+  if (leftKeys.length !== rightKeys.length) return false
+
+  for (const key of leftKeys) {
+    if (!hasOwn(right, key) || !isDeepEqual(left[key], right[key])) {
+      return false
+    }
+  }
+
+  return true
+}

package/src/utils/setCleanupTimeout.ts

@@ -0,0 +1,24 @@
+/**
+ * Like `setTimeout`, but calls `.unref()` on the timer when running in Node.js.
+ *
+ * In Node.js, active timers prevent the process from exiting. Cleanup timers
+ * (e.g. deferred subscription removal) should not keep the process alive -
+ * `.unref()` lets the process exit naturally while still firing the timer if
+ * the process happens to still be running.
+ *
+ * In browsers, `setTimeout` returns a number and has no `.unref()` method,
+ * so this is a no-op there.
+ */
+export function setCleanupTimeout(fn: () => void, delay: number): ReturnType<typeof setTimeout> {
+  const timer = setTimeout(fn, delay)
+
+  // In Node.js, setTimeout returns an object with an `unref()` method.
+  // In browsers, it returns a number. We assign to `unknown` and narrow
+  // at runtime so this works in both environments without type assertions.
+  const t: unknown = timer
+  if (typeof t === 'object' && t !== null && 'unref' in t && typeof t.unref === 'function') {
+    t.unref()
+  }
+
+  return timer
+}

package/src/preview/previewQuery.test.ts

@@ -1,236 +0,0 @@
-import {describe, expect, it} from 'vitest'
-
-import {SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './previewConstants'
-import {createPreviewQuery, normalizeMedia, processPreviewQuery} from './previewQuery'
-import {STABLE_EMPTY_PREVIEW} from './util'
-
-describe('createPreviewQuery', () => {
-  it('creates a query and params for given ids and schema', () => {
-    const ids = new Set(['book1', 'book2'])
-    const {query, params} = createPreviewQuery(ids)
-    expect(query).toMatch(/.*_id in \$__ids_.*/)
-    expect(Object.keys(params)).toHaveLength(1)
-  })
-})
-
-describe('processPreviewQuery', () => {
-  it('returns STABLE_EMPTY_PREVIEW if documentType is missing', () => {
-    const ids = new Set(['doc1'])
-    const result = processPreviewQuery({
-      projectId: 'p',
-      dataset: 'd',
-      results: [],
-      ids,
-    })
-
-    expect(result['doc1']).toEqual(STABLE_EMPTY_PREVIEW)
-  })
-
-  it('returns STABLE_EMPTY_PREVIEW if no candidates found', () => {
-    const ids = new Set(['doc1'])
-    const result = processPreviewQuery({
-      projectId: 'p',
-      dataset: 'd',
-      results: [], // no results, so no selectResult
-      ids,
-    })
-
-    expect(result['doc1']).toEqual(STABLE_EMPTY_PREVIEW)
-  })
-
-  // it.only('returns STABLE_ERROR_PREVIEW if an error occurs', () => {
-  //   const ids = new Set(['doc1'])
-  //   const result = processPreviewQuery({
-  //     projectId: 'p',
-  //     dataset: 'd',
-  //     results: [
-  //       {
-  //         _id: 'doc1',
-  //         _type: 'someType',
-  //         _updatedAt: new Date().toISOString(),
-  //         titleCandidates: {title: null},
-  //         subtitleCandidates: {subtitle: null},
-  //       },
-  //     ], // no results, so no selectResult
-  //     ids,
-  //   })
-
-  //   expect(result['doc1']).toEqual(STABLE_ERROR_PREVIEW)
-  // })
-
-  it('processes query results into preview values', () => {
-    const results = [
-      {
-        _id: 'person1',
-        _type: 'person',
-        _updatedAt: '2021-01-01',
-        titleCandidates: {title: 'John'},
-        subtitleCandidates: {subtitle: null},
-      },
-    ]
-
-    const processed = processPreviewQuery({
-      projectId: 'p',
-      dataset: 'd',
-      ids: new Set(['person1']),
-      results,
-    })
-
-    const val = processed['person1']
-    expect(val?.data).toEqual({
-      title: 'John',
-      media: null,
-      _status: {lastEditedPublishedAt: '2021-01-01'},
-    })
-    expect(val?.isPending).toBe(false)
-  })
-
-  it('resolves status preferring draft over published when available', () => {
-    const results = [
-      {
-        _id: 'drafts.article1',
-        _type: 'article',
-        _updatedAt: '2023-12-16T12:00:00Z',
-        titleCandidates: {
-          title: 'Draft Title',
-          name: null,
-        },
-        subtitleCandidates: {
-          title: null,
-          name: null,
-        },
-      },
-      {
-        _id: 'article1',
-        _type: 'article',
-        _updatedAt: '2023-12-15T12:00:00Z',
-        titleCandidates: {
-          title: 'Published Title',
-          name: null,
-        },
-        subtitleCandidates: {
-          title: null,
-          name: null,
-        },
-      },
-    ]
-
-    const processed = processPreviewQuery({
-      projectId: 'p',
-      dataset: 'd',
-      ids: new Set(['article1']),
-      results,
-    })
-
-    const val = processed['article1']
-    expect(val?.data).toEqual({
-      title: 'Draft Title',
-      media: null,
-      _status: {
-        lastEditedDraftAt: '2023-12-16T12:00:00Z',
-        lastEditedPublishedAt: '2023-12-15T12:00:00Z',
-      },
-    })
-    expect(val?.isPending).toBe(false)
-  })
-
-  it('uses the first defined title or subtitle from the candidates', () => {
-    const titleCandidates = {
-      title: 'Draft Title',
-      name: 'Draft Name',
-      label: 'Draft Label',
-      heading: 'Draft Heading',
-      header: 'Draft Header',
-      caption: 'Draft Caption',
-    }
-
-    const subtitleCandidates = {
-      subtitle: 'Draft Subtitle',
-      description: 'Draft Description',
-      name: 'Draft Name',
-      label: 'Draft Label',
-      heading: 'Draft Heading',
-      header: 'Draft Header',
-      caption: 'Draft Caption',
-    }
-
-    const results = [
-      {
-        _id: 'article1',
-        _type: 'article',
-        _updatedAt: '2023-12-15T12:00:00Z',
-        titleCandidates,
-        subtitleCandidates,
-      },
-    ]
-
-    const processed = processPreviewQuery({
-      projectId: 'p',
-      dataset: 'd',
-      ids: new Set(['article1']),
-      results,
-    })
-
-    const val = processed['article1']
-    expect(val?.data).toEqual({
-      title: titleCandidates[TITLE_CANDIDATES[0] as keyof typeof titleCandidates],
-      subtitle: subtitleCandidates[SUBTITLE_CANDIDATES[0] as keyof typeof subtitleCandidates],
-      media: null,
-      _status: {lastEditedPublishedAt: '2023-12-15T12:00:00Z'},
-    })
-    expect(val?.isPending).toBe(false)
-  })
-})
-
-describe('normalizeMedia', () => {
-  it('returns null if media is null or undefined', () => {
-    expect(normalizeMedia(null, 'projectId', 'dataset')).toBeNull()
-    expect(normalizeMedia(undefined, 'projectId', 'dataset')).toBeNull()
-  })
-
-  it('returns null if media does not have a valid asset', () => {
-    const invalidMedia1 = {media: {_ref: 'image-abc123-200x200-png'}} // Missing `asset` property
-    const invalidMedia2 = {asset: {ref: 'image-abc123-200x200-png'}} // Incorrect property name `ref`
-    expect(normalizeMedia(invalidMedia1, 'projectId', 'dataset')).toBeNull()
-    expect(normalizeMedia(invalidMedia2, 'projectId', 'dataset')).toBeNull()
-  })
-
-  it('returns null if media is not an object', () => {
-    expect(normalizeMedia(123, 'projectId', 'dataset')).toBeNull()
-    expect(normalizeMedia('invalid', 'projectId', 'dataset')).toBeNull()
-  })
-
-  it('returns a normalized URL for valid image asset objects', () => {
-    const validMedia = {type: 'image-asset', _ref: 'image-abc123-200x200-png'}
-    const result = normalizeMedia(validMedia, 'projectId', 'dataset')
-    expect(result).toEqual({
-      type: 'image-asset',
-      _ref: 'image-abc123-200x200-png',
-      url: 'https://cdn.sanity.io/images/projectId/dataset/abc123-200x200.png',
-    })
-  })
-
-  it('throws an error for invalid asset IDs in the media', () => {
-    const invalidMedia = {type: 'image-asset', _ref: 'invalid-asset-id'}
-    expect(() => normalizeMedia(invalidMedia, 'projectId', 'dataset')).toThrow(
-      'Invalid asset ID `invalid-asset-id`. Expected: image-{assetName}-{width}x{height}-{format}',
-    )
-  })
-
-  it('handles image assets with expected URL format', () => {
-    const media = {type: 'image-asset', _ref: 'image-xyz456-400x400-jpg'}
-    const result = normalizeMedia(media, 'projectId', 'dataset')
-    expect(result).toEqual({
-      type: 'image-asset',
-      _ref: 'image-xyz456-400x400-jpg',
-      url: 'https://cdn.sanity.io/images/projectId/dataset/xyz456-400x400.jpg',
-    })
-  })
-
-  it('ensures assetIdToUrl throws for asset IDs with missing groups', () => {
-    const invalidMedia = {type: 'image-asset', _ref: 'image-missinggroups'}
-    expect(() => normalizeMedia(invalidMedia, 'projectId', 'dataset')).toThrow(
-      'Invalid asset ID `image-missinggroups`. Expected: image-{assetName}-{width}x{height}-{format}',
-    )
-  })
-})

package/src/preview/previewQuery.ts

@@ -1,153 +0,0 @@
-import {isObject} from 'lodash-es'
-
-import {hashString} from '../utils/hashString'
-import {getDraftId, getPublishedId} from '../utils/ids'
-import {PREVIEW_PROJECTION, SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './previewConstants'
-import {
-  type PreviewQueryResult,
-  type PreviewStoreState,
-  type PreviewValue,
-  type ValuePending,
-} from './previewStore'
-import {STABLE_EMPTY_PREVIEW, STABLE_ERROR_PREVIEW} from './util'
-
-interface ProcessPreviewQueryOptions {
-  projectId: string
-  dataset: string
-  ids: Set<string>
-  results: PreviewQueryResult[]
-}
-
-/**
- * Converts an asset ID to a URL.
- *
- * @internal
- */
-function assetIdToUrl(assetId: string, projectId: string, dataset: string) {
-  const pattern = /^image-(?<assetName>[A-Za-z0-9]+)-(?<dimensions>\d+x\d+)-(?<format>[a-z]+)$/
-  const match = assetId.match(pattern)
-  if (!match?.groups) {
-    throw new Error(
-      `Invalid asset ID \`${assetId}\`. Expected: image-{assetName}-{width}x{height}-{format}`,
-    )
-  }
-
-  const {assetName, dimensions, format} = match.groups
-  return `https://cdn.sanity.io/images/${projectId}/${dataset}/${assetName}-${dimensions}.${format}`
-}
-
-/**
- * Checks if the provided value has `_ref` property that is a string and starts with `image-`
- */
-function hasImageRef<T>(value: unknown): value is T & {_ref: string} {
-  return isObject(value) && '_ref' in value && typeof (value as {_ref: unknown})._ref === 'string'
-}
-
-/**
- * Normalizes a media asset to a preview value.
- * Adds a url to a media asset reference.
- *
- * @internal
- */
-export function normalizeMedia(
-  media: unknown,
-  projectId: string,
-  dataset: string,
-): PreviewValue['media'] {
-  if (!media) return null
-  if (!hasImageRef(media)) return null
-  return {
-    type: 'image-asset',
-    _ref: media._ref,
-    url: assetIdToUrl(media._ref, projectId, dataset),
-  }
-}
-
-/**
- * Finds a single field value from a set of candidates based on a priority list of field names.
- * Returns the first non-empty string value found from the candidates matching the priority list order.
- *
- * @internal
- */
-function findFirstDefined(
-  fieldsToSearch: string[],
-  candidates: Record<string, unknown>,
-  exclude?: unknown,
-): string | undefined {
-  if (!candidates) return undefined
-
-  for (const field of fieldsToSearch) {
-    const value = candidates[field]
-    if (typeof value === 'string' && value.trim() !== '' && value !== exclude) {
-      return value
-    }
-  }
-
-  return undefined
-}
-
-export function processPreviewQuery({
-  projectId,
-  dataset,
-  ids,
-  results,
-}: ProcessPreviewQueryOptions): PreviewStoreState['values'] {
-  const resultMap = results.reduce<{[TDocumentId in string]?: PreviewQueryResult}>((acc, next) => {
-    acc[next._id] = next
-    return acc
-  }, {})
-
-  return Object.fromEntries(
-    Array.from(ids).map((id): [string, ValuePending<PreviewValue>] => {
-      const publishedId = getPublishedId(id)
-      const draftId = getDraftId(id)
-
-      const draftResult = resultMap[draftId]
-      const publishedResult = resultMap[publishedId]
-
-      if (!draftResult && !publishedResult) return [id, STABLE_EMPTY_PREVIEW]
-
-      try {
-        const result = draftResult || publishedResult
-        if (!result) return [id, STABLE_EMPTY_PREVIEW]
-        const title = findFirstDefined(TITLE_CANDIDATES, result.titleCandidates)
-        const subtitle = findFirstDefined(SUBTITLE_CANDIDATES, result.subtitleCandidates, title)
-        const preview: Omit<PreviewValue, 'status'> = {
-          title: String(title || `${result._type}: ${result._id}`),
-          subtitle: subtitle || undefined,
-          media: normalizeMedia(result.media, projectId, dataset),
-        }
-
-        const _status: PreviewValue['_status'] = {
-          ...(draftResult?._updatedAt && {lastEditedDraftAt: draftResult._updatedAt}),
-          ...(publishedResult?._updatedAt && {lastEditedPublishedAt: publishedResult._updatedAt}),
-        }
-
-        return [id, {data: {...preview, _status}, isPending: false}]
-      } catch (e) {
-        // TODO: replace this with bubbling the error
-        // eslint-disable-next-line no-console
-        console.warn(e)
-        return [id, STABLE_ERROR_PREVIEW]
-      }
-    }),
-  )
-}
-
-interface CreatePreviewQueryResult {
-  query: string
-  params: Record<string, string[]>
-}
-
-export function createPreviewQuery(documentIds: Set<string>): CreatePreviewQueryResult {
-  // Create arrays of draft and published IDs
-  const allIds = Array.from(documentIds).flatMap((id) => [getPublishedId(id), getDraftId(id)])
-  const queryHash = hashString(PREVIEW_PROJECTION)
-
-  return {
-    query: `*[_id in $__ids_${queryHash}]${PREVIEW_PROJECTION}`,
-    params: {
-      [`__ids_${queryHash}`]: allIds,
-    },
-  }
-}

package/src/preview/previewStore.test.ts

@@ -1,36 +0,0 @@
-import {Observable} from 'rxjs'
-import {describe, it, vi} from 'vitest'
-
-import {createSanityInstance} from '../store/createSanityInstance'
-import {createStoreInstance} from '../store/createStoreInstance'
-import {previewStore} from './previewStore'
-import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
-
-vi.mock('./subscribeToStateAndFetchBatches')
-
-describe('previewStore', () => {
-  it('is a resource that initializes with state and subscriptions', async () => {
-    const teardown = vi.fn()
-    const subscriber = vi.fn().mockReturnValue(teardown)
-    vi.mocked(subscribeToStateAndFetchBatches).mockReturnValue(
-      new Observable(subscriber).subscribe(),
-    )
-
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-
-    const {state, dispose} = createStoreInstance(
-      instance,
-      {name: 'p.d', projectId: 'p', dataset: 'd'},
-      previewStore,
-    )
-
-    expect(subscribeToStateAndFetchBatches).toHaveBeenCalledWith({
-      instance,
-      state,
-      key: {name: 'p.d', projectId: 'p', dataset: 'd'},
-    })
-
-    dispose()
-    instance.dispose()
-  })
-})