@sanity/sdk 2.8.0 → 2.9.0

package/src/utils/createFetcherStore.test.ts

@@ -127,8 +127,9 @@ describe('createFetcherStore', () => {
     expect(fetchSpy).toHaveBeenCalledTimes(1)
 
     // Second subscription within throttle interval
-    const sub2 = stateSource.subscribe()
-    await firstValueFrom(stateSource.observable)
+    const stateSource2 = store.getState(instance, 1)
+    const sub2 = stateSource2.subscribe()
+    await firstValueFrom(stateSource2.observable)
     expect(fetchSpy).toHaveBeenCalledTimes(1)
 
     // Advance past throttle interval
@@ -136,8 +137,9 @@ describe('createFetcherStore', () => {
     await vi.advanceTimersByTimeAsync(1000)
 
     // Third subscription after throttle interval
-    const sub3 = stateSource.subscribe()
-    await firstValueFrom(stateSource.observable)
+    const stateSource3 = store.getState(instance, 1)
+    const sub3 = stateSource3.subscribe()
+    await firstValueFrom(stateSource3.observable)
     expect(fetchSpy).toHaveBeenCalledTimes(2)
 
     sub1()

package/src/utils/createFetcherStore.ts

@@ -23,6 +23,7 @@ import {
 } from '../store/createStateSourceAction'
 import {defineStore, type StoreContext} from '../store/defineStore'
 import {insecureRandomId} from '../utils/ids'
+import {setCleanupTimeout} from './setCleanupTimeout'
 
 interface CreateFetcherStoreOptions<TParams extends unknown[], TData> {
   /**
@@ -247,7 +248,7 @@ export function createFetcherStore<TParams extends unknown[], TData>({
         }))
 
         return () => {
-          setTimeout(() => {
+          setCleanupTimeout(() => {
             state.set('removeSubscription', (prev: FetcherStoreState<TParams, TData>) => {
               const entry = prev.stateByParams[key]
               if (!entry) return prev

package/src/utils/getStagingApiHost.test.ts

@@ -0,0 +1,21 @@
+import {describe, expect, it, vi} from 'vitest'
+
+import {getStagingApiHost} from './getStagingApiHost'
+
+describe('getStagingApiHost', () => {
+  it('returns staging host when __SANITY_STAGING__ is true', () => {
+    vi.stubGlobal('__SANITY_STAGING__', true)
+    expect(getStagingApiHost()).toBe('https://api.sanity.work')
+    vi.unstubAllGlobals()
+  })
+
+  it('returns undefined when __SANITY_STAGING__ is false', () => {
+    vi.stubGlobal('__SANITY_STAGING__', false)
+    expect(getStagingApiHost()).toBeUndefined()
+    vi.unstubAllGlobals()
+  })
+
+  it('returns undefined when __SANITY_STAGING__ is not defined', () => {
+    expect(getStagingApiHost()).toBeUndefined()
+  })
+})

package/src/utils/getStagingApiHost.ts

@@ -0,0 +1,14 @@
+declare const __SANITY_STAGING__: boolean | undefined
+
+/**
+ * Returns the staging API host if the `__SANITY_STAGING__` build-time flag is
+ * set to `true` (mirroring how Sanity Studio detects staging builds).
+ *
+ * @internal
+ */
+export function getStagingApiHost(): string | undefined {
+  if (typeof __SANITY_STAGING__ !== 'undefined' && __SANITY_STAGING__ === true) {
+    return 'https://api.sanity.work'
+  }
+  return undefined
+}

package/src/utils/ids.test.ts

@@ -1,34 +1,6 @@
 import {describe, expect, it} from 'vitest'
 
-import {getDraftId, getPublishedId, insecureRandomId} from './ids'
-
-describe('getDraftId', () => {
-  it('should add drafts prefix to non-draft ids', () => {
-    expect(getDraftId('abc123')).toBe('drafts.abc123')
-  })
-
-  it('should not modify ids that already have drafts prefix', () => {
-    expect(getDraftId('drafts.abc123')).toBe('drafts.abc123')
-  })
-
-  it('should handle empty string', () => {
-    expect(getDraftId('')).toBe('drafts.')
-  })
-})
-
-describe('getPublishedId', () => {
-  it('should remove drafts prefix from draft ids', () => {
-    expect(getPublishedId('drafts.abc123')).toBe('abc123')
-  })
-
-  it('should not modify ids that dont have drafts prefix', () => {
-    expect(getPublishedId('abc123')).toBe('abc123')
-  })
-
-  it('should handle empty string', () => {
-    expect(getPublishedId('')).toBe('')
-  })
-})
+import {insecureRandomId} from './ids'
 
 describe('insecureRandomId', () => {
   it('should generate 16-character string', () => {

package/src/utils/ids.ts

@@ -1,13 +1,3 @@
-export function getPublishedId(id: string): string {
-  const draftsPrefix = 'drafts.'
-  return id.startsWith(draftsPrefix) ? id.slice(draftsPrefix.length) : id
-}
-
-export function getDraftId(id: string): string {
-  const draftsPrefix = 'drafts.'
-  return id.startsWith(draftsPrefix) ? id : `${draftsPrefix}${id}`
-}
-
 export function insecureRandomId(): string {
   return Array.from({length: 16}, () => Math.floor(Math.random() * 16).toString(16)).join('')
 }

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