@sanity/sdk 2.7.0 → 3.0.0-rc.0

package/src/preview/getPreviewState.test.ts

@@ -1,120 +0,0 @@
-import {NEVER} from 'rxjs'
-import {describe, it} from 'vitest'
-
-import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {type StoreState} from '../store/createStoreState'
-import {insecureRandomId} from '../utils/ids'
-import {getPreviewState} from './getPreviewState'
-import {type PreviewStoreState} from './previewStore'
-import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
-import {STABLE_EMPTY_PREVIEW} from './util'
-
-vi.mock('../utils/ids', async (importOriginal) => {
-  const util = await importOriginal<typeof import('../utils/ids')>()
-  return {...util, insecureRandomId: vi.fn(util.insecureRandomId)}
-})
-
-vi.mock('./subscribeToStateAndFetchBatches.ts')
-
-describe('getPreviewState', () => {
-  let instance: SanityInstance
-  const docHandle = {documentId: 'exampleId', documentType: 'exampleType'}
-  let state: StoreState<PreviewStoreState & {extra?: unknown}>
-
-  beforeEach(() => {
-    // capture state
-    vi.mocked(subscribeToStateAndFetchBatches).mockImplementation((context) => {
-      state = context.state
-      return NEVER.subscribe()
-    })
-
-    instance = createSanityInstance({projectId: 'exampleProject', dataset: 'exampleDataset'})
-  })
-
-  afterEach(() => {
-    instance.dispose()
-  })
-
-  it('returns a state source that emits when the preview value changes', () => {
-    const previewState = getPreviewState(instance, docHandle)
-    expect(previewState.getCurrent()).toBe(STABLE_EMPTY_PREVIEW)
-
-    const subscriber = vi.fn()
-    previewState.subscribe(subscriber)
-
-    // emit unrelated state changes
-    state.set('updateLastLiveEventId', {extra: 'unrelated change'})
-    expect(subscriber).toHaveBeenCalledTimes(0)
-
-    state.set('relatedChange', (prev) => ({
-      values: {...prev.values, exampleId: {data: {title: 'Changed!'}, isPending: false}},
-    }))
-    expect(subscriber).toHaveBeenCalledTimes(1)
-
-    state.set('unrelatedChange', (prev) => ({
-      values: {
-        ...prev.values,
-        unrelatedId: {data: {title: 'Unrelated Document'}, isPending: false},
-      },
-    }))
-    expect(subscriber).toHaveBeenCalledTimes(1)
-
-    state.set('relatedChange', (prev) => ({
-      values: {...prev.values, exampleId: {data: {title: 'Changed again!'}, isPending: false}},
-    }))
-    expect(subscriber).toHaveBeenCalledTimes(2)
-  })
-
-  it('adds a subscription ID and document type to the state on subscription', () => {
-    const previewState = getPreviewState(instance, docHandle)
-
-    expect(state.get().subscriptions).toEqual({})
-    vi.mocked(insecureRandomId)
-      .mockImplementationOnce(() => 'pseudoRandomId1')
-      .mockImplementationOnce(() => 'pseudoRandomId2')
-
-    const unsubscribe1 = previewState.subscribe(vi.fn())
-    const unsubscribe2 = previewState.subscribe(vi.fn())
-
-    expect(state.get().subscriptions).toEqual({
-      exampleId: {pseudoRandomId1: true, pseudoRandomId2: true},
-    })
-
-    unsubscribe2()
-    expect(state.get().subscriptions).toEqual({
-      exampleId: {pseudoRandomId1: true},
-    })
-
-    unsubscribe1()
-    expect(state.get().subscriptions).toEqual({})
-  })
-
-  it('resets to pending false on unsubscribe if the subscription is the last one', () => {
-    const previewState = getPreviewState(instance, docHandle)
-
-    state.set('presetValueToPending', (prev) => ({
-      values: {...prev.values, [docHandle.documentId]: {data: {title: 'Foo'}, isPending: true}},
-    }))
-
-    const unsubscribe1 = previewState.subscribe(vi.fn())
-    const unsubscribe2 = previewState.subscribe(vi.fn())
-
-    expect(state.get().values[docHandle.documentId]).toEqual({
-      data: {title: 'Foo'},
-      isPending: true,
-    })
-
-    unsubscribe1()
-    expect(state.get().values[docHandle.documentId]).toEqual({
-      data: {title: 'Foo'},
-      isPending: true,
-    })
-
-    unsubscribe2()
-    expect(state.get().subscriptions).toEqual({})
-    expect(state.get().values[docHandle.documentId]).toEqual({
-      data: {title: 'Foo'},
-      isPending: false,
-    })
-  })
-})

package/src/preview/getPreviewState.ts

@@ -1,91 +0,0 @@
-import {omit} from 'lodash-es'
-
-import {type DocumentHandle} from '../config/sanityConfig'
-import {bindActionByDataset} from '../store/createActionBinder'
-import {type SanityInstance} from '../store/createSanityInstance'
-import {
-  createStateSourceAction,
-  type SelectorContext,
-  type StateSource,
-} from '../store/createStateSourceAction'
-import {getPublishedId, insecureRandomId} from '../utils/ids'
-import {
-  previewStore,
-  type PreviewStoreState,
-  type PreviewValue,
-  type ValuePending,
-} from './previewStore'
-import {STABLE_EMPTY_PREVIEW} from './util'
-
-/**
- * @beta
- */
-export type GetPreviewStateOptions = DocumentHandle
-
-/**
- * @beta
- */
-export function getPreviewState<TResult extends object>(
-  instance: SanityInstance,
-  options: GetPreviewStateOptions,
-): StateSource<ValuePending<TResult>>
-/**
- * @beta
- */
-export function getPreviewState(
-  instance: SanityInstance,
-  options: GetPreviewStateOptions,
-): StateSource<ValuePending<PreviewValue>>
-/**
- * @beta
- */
-export function getPreviewState(
-  ...args: Parameters<typeof _getPreviewState>
-): StateSource<ValuePending<object>> {
-  return _getPreviewState(...args)
-}
-
-/**
- * @beta
- */
-export const _getPreviewState = bindActionByDataset(
-  previewStore,
-  createStateSourceAction({
-    selector: (
-      {state}: SelectorContext<PreviewStoreState>,
-      docHandle: GetPreviewStateOptions,
-    ): ValuePending<object> => state.values[docHandle.documentId] ?? STABLE_EMPTY_PREVIEW,
-    onSubscribe: ({state}, docHandle: GetPreviewStateOptions) => {
-      const subscriptionId = insecureRandomId()
-      const documentId = getPublishedId(docHandle.documentId)
-
-      state.set('addSubscription', (prev) => ({
-        subscriptions: {
-          ...prev.subscriptions,
-          [documentId]: {
-            ...prev.subscriptions[documentId],
-            [subscriptionId]: true,
-          },
-        },
-      }))
-
-      return () => {
-        state.set('removeSubscription', (prev): Partial<PreviewStoreState> => {
-          const documentSubscriptions = omit(prev.subscriptions[documentId], subscriptionId)
-          const hasSubscribers = !!Object.keys(documentSubscriptions).length
-          const prevValue = prev.values[documentId]
-          const previewValue = prevValue?.data ? prevValue.data : null
-
-          return {
-            subscriptions: hasSubscribers
-              ? {...prev.subscriptions, [documentId]: documentSubscriptions}
-              : omit(prev.subscriptions, documentId),
-            values: hasSubscribers
-              ? prev.values
-              : {...prev.values, [documentId]: {data: previewValue, isPending: false}},
-          }
-        })
-      }
-    },
-  }),
-)

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()
-  })
-})

package/src/preview/resolvePreview.test.ts

@@ -1,47 +0,0 @@
-import {of} from 'rxjs'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {createDocumentHandle} from '../config/handles'
-import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {type StateSource} from '../store/createStateSourceAction'
-import {getPreviewState} from './getPreviewState'
-import {type PreviewValue, type ValuePending} from './previewStore'
-import {resolvePreview} from './resolvePreview'
-
-vi.mock('./getPreviewState')
-
-describe('resolvePreview', () => {
-  let instance: SanityInstance
-
-  beforeEach(() => {
-    vi.resetAllMocks()
-    // Create a mock that returns the correct ValuePending type
-    vi.mocked(getPreviewState).mockReturnValue({
-      observable: of({
-        data: {title: 'test'},
-        isPending: false,
-      } as ValuePending<PreviewValue>),
-    } as StateSource<ValuePending<PreviewValue>>)
-
-    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-  })
-
-  afterEach(() => {
-    instance.dispose()
-  })
-
-  it('resolves a preview and returns the first emitted value with results', async () => {
-    const docHandle = createDocumentHandle({
-      documentId: 'doc123',
-      documentType: 'movie',
-    })
-
-    const result = await resolvePreview(instance, docHandle)
-
-    expect(getPreviewState).toHaveBeenCalledWith(instance, docHandle)
-    expect(result).toEqual({
-      data: {title: 'test'},
-      isPending: false,
-    })
-  })
-})