@sanity/sdk 0.0.0-alpha.21 → 0.0.0-alpha.23

package/src/preview/getPreviewState.ts

@@ -1,8 +1,13 @@
 import {omit} from 'lodash-es'
 
-import {type DocumentHandle} from '../document/patchOperations'
-import {createAction} from '../resources/createAction'
-import {createStateSourceAction, type StateSource} from '../resources/createStateSourceAction'
+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,
@@ -15,65 +20,72 @@ import {STABLE_EMPTY_PREVIEW} from './util'
 /**
  * @beta
  */
-export interface GetPreviewStateOptions {
-  document: DocumentHandle
-}
-
-const _getPreviewState = createStateSourceAction(
-  previewStore,
-  (state, {document}: GetPreviewStateOptions) => state.values[document._id] ?? STABLE_EMPTY_PREVIEW,
-)
+export type GetPreviewStateOptions = DocumentHandle
 
 /**
  * @beta
  */
-export const getPreviewState = createAction(previewStore, ({state}) => {
-  return function ({document}: GetPreviewStateOptions): StateSource<ValuePending<PreviewValue>> {
-    const {_id, _type: documentType} = document
-    const documentId = getPublishedId(_id)
-    const previewState = _getPreviewState(this, {document})
+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)
+}
 
-    return {
-      ...previewState,
-      subscribe: (subscriber) => {
-        const subscriptionId = insecureRandomId()
+/**
+ * @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) => ({
-          documentTypes: {
-            ...prev.documentTypes,
-            [documentId]: documentType,
-          },
-          subscriptions: {
-            ...prev.subscriptions,
-            [documentId]: {
-              ...prev.subscriptions[documentId],
-              [subscriptionId]: true,
-            },
+      state.set('addSubscription', (prev) => ({
+        subscriptions: {
+          ...prev.subscriptions,
+          [documentId]: {
+            ...prev.subscriptions[documentId],
+            [subscriptionId]: true,
           },
-        }))
-
-        const unsubscribe = previewState.subscribe(subscriber)
+        },
+      }))
 
-        return () => {
-          unsubscribe()
+      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
 
-          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}},
-            }
-          })
-        }
-      },
-    }
-  }
-})
+          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/previewConstants.ts

@@ -0,0 +1,43 @@
+/**
+ * The fields to check for a title.
+ * The order of the items in the array defines the priority.
+ *
+ * @internal
+ */
+export const TITLE_CANDIDATES = ['title', 'name', 'label', 'heading', 'header', 'caption']
+
+/**
+ * The fields to check for a subtitle.
+ * The order of the items in the array defines the priority.
+ *
+ * @internal
+ */
+export const SUBTITLE_CANDIDATES = ['description', 'subtitle', ...TITLE_CANDIDATES]
+
+/**
+ * Generates a GROQ projection for preview data without requiring a schema.
+ * Uses common field names to make educated guesses about which fields to use.
+ *
+ * @internal
+ */
+export const PREVIEW_PROJECTION = `{
+  // Get all potential title fields
+  "titleCandidates": {
+    ${TITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(',\n      ')}
+  },
+  // Get all potential subtitle fields
+  "subtitleCandidates": {
+    ${SUBTITLE_CANDIDATES.map((field) => `"${field}": ${field}`).join(',\n      ')}
+  },
+  "media": coalesce(
+    select(
+      defined(asset) => {"type": "image-asset", "_ref": asset._ref},
+      defined(image.asset) => {"type": "image-asset", "_ref": image.asset._ref},
+      defined(mainImage.asset) => {"type": "image-asset", "_ref": mainImage.asset._ref},
+      null
+    )
+  ),
+  _type,
+  _id,
+  _updatedAt
+}`

package/src/preview/previewQuery.test.ts

@@ -1,6 +1,6 @@
 import {describe, expect, it} from 'vitest'
 
-import {SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './getPreviewProjection'
+import {SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './previewConstants'
 import {createPreviewQuery, normalizeMedia, processPreviewQuery} from './previewQuery'
 import {STABLE_EMPTY_PREVIEW} from './util'
 

package/src/preview/previewQuery.ts

@@ -1,8 +1,8 @@
 import {isObject} from 'lodash-es'
 
-import {hashString} from '../common/util'
+import {hashString} from '../utils/hashString'
 import {getDraftId, getPublishedId} from '../utils/ids'
-import {getPreviewProjection, SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './getPreviewProjection'
+import {PREVIEW_PROJECTION, SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './previewConstants'
 import {
   type PreviewQueryResult,
   type PreviewStoreState,
@@ -142,11 +142,10 @@ interface CreatePreviewQueryResult {
 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 projection = getPreviewProjection()
-  const queryHash = hashString(projection)
+  const queryHash = hashString(PREVIEW_PROJECTION)
 
   return {
-    query: `*[_id in $__ids_${queryHash}]${projection}`,
+    query: `*[_id in $__ids_${queryHash}]${PREVIEW_PROJECTION}`,
     params: {
       [`__ids_${queryHash}`]: allIds,
     },

package/src/preview/previewStore.test.ts

@@ -1,73 +1,28 @@
-import {type Subscription} from 'rxjs'
-import {describe, expect, it, type Mock, vi} from 'vitest'
+import {Observable} from 'rxjs'
+import {describe, it, vi} from 'vitest'
 
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createResourceState} from '../resources/createResource'
+import {createSanityInstance} from '../store/createSanityInstance'
+import {createStoreInstance} from '../store/createStoreInstance'
 import {previewStore} from './previewStore'
 import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
-import {PREVIEW_TAG} from './util'
 
-// Mock the module with a factory function
-vi.mock('../common/createLiveEventSubscriber', () => {
-  const mockLiveSubscriber = vi.fn()
-  return {
-    createLiveEventSubscriber: vi.fn(() => mockLiveSubscriber),
-  }
-})
-
-vi.mock('./subscribeToStateAndFetchBatches', () => ({
-  subscribeToStateAndFetchBatches: vi.fn(),
-}))
+vi.mock('./subscribeToStateAndFetchBatches')
 
 describe('previewStore', () => {
   it('is a resource that initializes with state and subscriptions', async () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-    const initialState = previewStore.getInitialState(instance)
-
-    expect(initialState).toEqual({
-      documentTypes: {},
-      lastLiveEventId: null,
-      subscriptions: {},
-      syncTags: {},
-      values: {},
-    })
-    const liveUnsubscribe = vi.fn()
-    const stateUnsubscribe = vi.fn()
-
-    const {createLiveEventSubscriber} = vi.mocked(
-      await import('../common/createLiveEventSubscriber'),
+    const teardown = vi.fn()
+    const subscriber = vi.fn().mockReturnValue(teardown)
+    vi.mocked(subscribeToStateAndFetchBatches).mockReturnValue(
+      new Observable(subscriber).subscribe(),
     )
-    const mockLiveSubscriber = vi.mocked(createLiveEventSubscriber(PREVIEW_TAG)).mockReturnValue({
-      unsubscribe: liveUnsubscribe,
-    } as unknown as Subscription)
 
-    ;(subscribeToStateAndFetchBatches as Mock).mockImplementation(() => ({
-      unsubscribe: stateUnsubscribe,
-    }))
-
-    const dispose = previewStore.initialize!.call(
-      {
-        instance,
-        state: createResourceState(initialState),
-      },
-      instance,
-    )
-
-    // Verify the factory was called with the correct tag
-    expect(createLiveEventSubscriber).toHaveBeenCalledWith(PREVIEW_TAG)
+    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 
-    // Verify the subscriber was called with the correct context
-    expect(mockLiveSubscriber).toHaveBeenCalledWith({
-      instance,
-      state: expect.any(Object),
-    })
-    expect(mockLiveSubscriber).toHaveBeenCalledOnce()
+    const {state, dispose} = createStoreInstance(instance, previewStore)
 
-    expect(subscribeToStateAndFetchBatches).toHaveBeenCalledOnce()
+    expect(subscribeToStateAndFetchBatches).toHaveBeenCalledWith({instance, state})
 
     dispose()
-
-    expect(liveUnsubscribe).toHaveBeenCalledOnce()
-    expect(stateUnsubscribe).toHaveBeenCalledOnce()
+    instance.dispose()
   })
 })

package/src/preview/previewStore.ts

@@ -1,8 +1,5 @@
-import {createLiveEventSubscriber} from '../common/createLiveEventSubscriber'
-import {type LiveEventAwareState} from '../common/types'
-import {createResource} from '../resources/createResource'
+import {defineStore} from '../store/defineStore'
 import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
-import {PREVIEW_TAG} from './util'
 
 export interface PreviewQueryResult {
   _id: string
@@ -27,7 +24,7 @@ export interface PreviewMedia {
 /**
  * Represents the set of values displayed as a preview for a given Sanity document.
  * This includes a primary title, a secondary subtitle, an optional piece of media associated
- * with the document, and the document’s status.
+ * with the document, and the document's status.
  *
  * @public
  */
@@ -77,32 +74,21 @@ export type ValuePending<T> = {
 /**
  * @public
  */
-export interface PreviewStoreState extends LiveEventAwareState {
+export interface PreviewStoreState {
   values: {[TDocumentId in string]?: ValuePending<PreviewValue>}
-  documentTypes: {[TDocumentId in string]?: string}
   subscriptions: {[TDocumentId in string]?: {[TSubscriptionId in string]?: true}}
 }
 
-export const previewStore = createResource<PreviewStoreState>({
+export const previewStore = defineStore<PreviewStoreState>({
   name: 'Preview',
   getInitialState() {
     return {
-      documentTypes: {},
-      lastLiveEventId: null,
       subscriptions: {},
-      syncTags: {},
       values: {},
     }
   },
-  initialize() {
-    const subscribeToLiveAndSetLastLiveEventId =
-      createLiveEventSubscriber<PreviewStoreState>(PREVIEW_TAG)
-    const stateSubscriptionForBatches = subscribeToStateAndFetchBatches(this)
-    const liveSubscription = subscribeToLiveAndSetLastLiveEventId(this)
-
-    return () => {
-      stateSubscriptionForBatches.unsubscribe()
-      liveSubscription.unsubscribe()
-    }
+  initialize: (context) => {
+    const subscription = subscribeToStateAndFetchBatches(context)
+    return () => subscription.unsubscribe
   },
 })

package/src/preview/resolvePreview.test.ts

@@ -1,119 +1,48 @@
-import {describe, it, type Mock} from 'vitest'
-
-import {createSanityInstance} from '../instance/sanityInstance'
-import {
-  createResourceState,
-  getOrCreateResource,
-  type InitializedResource,
-  type ResourceState,
-} from '../resources/createResource'
-import {insecureRandomId} from '../utils/ids'
-import {
-  previewStore,
-  type PreviewStoreState,
-  type PreviewValue,
-  type ValuePending,
-} from './previewStore'
+import {type SanityDocumentLike} from '@sanity/types'
+import {of} from 'rxjs'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {type DocumentHandle} from '../config/sanityConfig'
+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('../utils/ids', async (importOriginal) => {
-  const util = await importOriginal<typeof import('../utils/ids')>()
-  return {...util, insecureRandomId: vi.fn(util.insecureRandomId)}
-})
-
-vi.mock('../resources/createResource', async (importOriginal) => {
-  const original = await importOriginal<typeof import('../resources/createResource')>()
-  return {...original, getOrCreateResource: vi.fn()}
-})
+vi.mock('./getPreviewState')
 
 describe('resolvePreview', () => {
-  const instance = createSanityInstance({projectId: 'exampleProject', dataset: 'exampleDataset'})
-  const document = {_id: 'exampleId', _type: 'exampleType'}
-  const initialState: PreviewStoreState = {
-    documentTypes: {},
-    lastLiveEventId: null,
-    subscriptions: {},
-    syncTags: {},
-    values: {},
-  }
-  let state: ResourceState<PreviewStoreState>
+  let instance: SanityInstance
 
   beforeEach(() => {
-    state = createResourceState(initialState)
+    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'})
   })
 
-  it('subscribes and resolves when the preview value is non-null', async () => {
-    expect(state.get().subscriptions).toEqual({})
-    ;(insecureRandomId as Mock).mockImplementationOnce(() => 'pseudoRandomId')
-
-    const previewPromise = resolvePreview({state, instance}, {document})
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-
-    state.set('updateDifferentDocument', (prev) => ({
-      values: {
-        ...prev.values,
-        differentId: {data: {title: 'Different Document'}, isPending: false},
-      },
-    }))
-
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-
-    state.set('updateCorrectDocumentButNull', (prev) => ({
-      values: {...prev.values, exampleId: {data: null, isPending: true}},
-    }))
-
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-
-    state.set('updateCorrectDocument', (prev) => ({
-      values: {...prev.values, exampleId: {data: {title: 'Correct Document'}, isPending: false}},
-    }))
-
-    const preview = await previewPromise
-    expect(preview).toEqual({data: {title: 'Correct Document'}, isPending: false})
-
-    // subscription is removed after
-    expect(state.get().subscriptions).toEqual({})
+  afterEach(() => {
+    instance.dispose()
   })
 
-  it('resolves with the next emitted state (not current state)', async () => {
-    const currentValue: ValuePending<PreviewValue> = {
-      data: {title: 'Correct Document'},
-      isPending: false,
+  it('resolves a preview and returns the first emitted value with results', async () => {
+    const docHandle: DocumentHandle<SanityDocumentLike> = {
+      documentId: 'doc123',
+      documentType: 'movie',
     }
-    state.set('setInitialDocument', (prev) => ({
-      values: {...prev.values, exampleId: currentValue},
-    }))
-    vi.mocked(insecureRandomId).mockImplementationOnce(() => 'pseudoRandomId')
-    expect(state.get().subscriptions).toEqual({})
-
-    const previewPromise = resolvePreview({state, instance}, {document})
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
-
-    state.set('updateDifferentDocument', (prev) => ({
-      values: {
-        ...prev.values,
-        differentId: {data: {title: 'Different Document'}, isPending: false},
-      },
-    }))
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
 
-    state.set('updateWithCurrentValue', (prev) => ({
-      values: {...prev.values, exampleId: currentValue},
-    }))
-    expect(state.get().subscriptions).toEqual({exampleId: {pseudoRandomId: true}})
+    const result = await resolvePreview(instance, docHandle)
 
-    state.set('updateWithNewValue', (prev) => ({
-      values: {...prev.values, exampleId: {data: {title: 'New Value'}, isPending: false}},
-    }))
-    expect(state.get().subscriptions).toEqual({})
-
-    const preview = await previewPromise
-    expect(preview).toEqual({data: {title: 'New Value'}, isPending: false})
-  })
-
-  it('calls getOrCreateResource if no state is provided', () => {
-    vi.mocked(getOrCreateResource).mockReturnValue({state} as InitializedResource<unknown>)
-    resolvePreview(instance, {document})
-    expect(getOrCreateResource).toHaveBeenCalledWith(instance, previewStore)
+    expect(getPreviewState).toHaveBeenCalledWith(instance, docHandle)
+    expect(result).toEqual({
+      data: {title: 'test'},
+      isPending: false,
+    })
   })
 })

package/src/preview/resolvePreview.ts

@@ -1,30 +1,20 @@
-import {type DocumentHandle} from '../document/patchOperations'
-import {createAction} from '../resources/createAction'
+import {filter, firstValueFrom} from 'rxjs'
+
+import {type DocumentHandle} from '../config/sanityConfig'
+import {bindActionByDataset} from '../store/createActionBinder'
 import {getPreviewState} from './getPreviewState'
-import {previewStore, type PreviewValue, type ValuePending} from './previewStore'
+import {previewStore} from './previewStore'
 
 /**
  * @beta
  */
-export interface ResolvePreviewOptions {
-  document: DocumentHandle
-}
+export type ResolvePreviewOptions = DocumentHandle
 
 /**
  * @beta
  */
-export const resolvePreview = createAction(previewStore, () => {
-  return function ({document}: ResolvePreviewOptions) {
-    const {getCurrent, subscribe} = getPreviewState(this, {document})
-
-    return new Promise<ValuePending<PreviewValue>>((resolve) => {
-      const unsubscribe = subscribe(() => {
-        const current = getCurrent()
-        if (current?.data) {
-          resolve(current)
-          unsubscribe()
-        }
-      })
-    })
-  }
-})
+export const resolvePreview = bindActionByDataset(
+  previewStore,
+  ({instance}, docHandle: ResolvePreviewOptions) =>
+    firstValueFrom(getPreviewState(instance, docHandle).observable.pipe(filter((i) => !!i.data))),
+)