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

package/src/preview/subscribeToStateAndFetchBatches.test.ts

@@ -1,51 +1,38 @@
-import {SanityClient, type SyncTag} from '@sanity/client'
-import {Observable, of, Subject} from 'rxjs'
-import {describe, expect, it, type Mock, vi} from 'vitest'
-
-import {getClientState} from '../client/clientStore'
-import {createSanityInstance} from '../instance/sanityInstance'
-import {createResourceState, type ResourceState} from '../resources/createResource'
-import {type StateSource} from '../resources/createStateSourceAction'
+import {NEVER, Observable, type Observer} from 'rxjs'
+import {describe, expect, it, vi} from 'vitest'
+
+import {getQueryState, resolveQuery} from '../query/queryStore'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {createStoreState, type StoreState} from '../store/createStoreState'
 import {type PreviewQueryResult, type PreviewStoreState} from './previewStore'
 import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
+import {PREVIEW_PERSPECTIVE, PREVIEW_TAG} from './util'
 
-vi.mock('../client/clientStore')
-
-vi.mock('../resources/createResource', async (importOriginal) => {
-  const original = await importOriginal<typeof import('../resources/createResource')>()
-  return {...original, getOrCreateResource: vi.fn()}
-})
+vi.mock('../query/queryStore')
 
 describe('subscribeToStateAndFetchBatches', () => {
-  const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
-
-  let state: ResourceState<PreviewStoreState>
-  let fetchResults: Subject<{result: PreviewQueryResult[]; syncTags: SyncTag[]}>
-  let mockFetch: Mock
+  let instance: SanityInstance
+  let state: StoreState<PreviewStoreState>
 
   beforeEach(() => {
-    state = createResourceState<PreviewStoreState>({
-      documentTypes: {},
-      lastLiveEventId: null,
+    vi.clearAllMocks()
+    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+    state = createStoreState<PreviewStoreState>({
       subscriptions: {},
-      syncTags: {},
       values: {},
     })
-    fetchResults = new Subject()
-
-    mockFetch = vi.fn().mockImplementation(
-      () =>
-        new Observable((subscriber) => {
-          const subscription = fetchResults.subscribe({
-            next: (val) => subscriber.next(val),
-            complete: () => subscriber.complete(),
-          })
-          return () => subscription.unsubscribe()
-        }),
-    )
-    vi.mocked(getClientState).mockReturnValue({
-      observable: of({observable: {fetch: mockFetch}} as unknown as SanityClient),
-    } as StateSource<SanityClient>)
+
+    vi.mocked(getQueryState).mockReturnValue({
+      getCurrent: () => undefined,
+      observable: NEVER as Observable<PreviewQueryResult[] | undefined>,
+    } as StateSource<PreviewQueryResult[] | undefined>)
+
+    vi.mocked(resolveQuery).mockResolvedValue(undefined)
+  })
+
+  afterEach(() => {
+    instance.dispose()
   })
 
   it('batches rapid subscription changes into single requests', async () => {
@@ -53,55 +40,88 @@ describe('subscribeToStateAndFetchBatches', () => {
 
     // Add multiple subscriptions rapidly
     state.set('addSubscription1', {
-      documentTypes: {doc1: 'test'},
       subscriptions: {doc1: {sub1: true}},
     })
 
     state.set('addSubscription2', (prev) => ({
-      documentTypes: {...prev.documentTypes, doc2: 'test'},
       subscriptions: {...prev.subscriptions, doc2: {sub2: true}},
     }))
 
     // Wait for debounce
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(mockFetch).toHaveBeenCalledTimes(1)
-    expect(mockFetch.mock.calls[0][1]).toMatchObject({
-      __ids_0d8f6ec5: ['doc1', 'drafts.doc1', 'doc2', 'drafts.doc2'],
-    })
+    expect(getQueryState).toHaveBeenCalledTimes(1)
+    expect(getQueryState).toHaveBeenCalledWith(
+      instance,
+      expect.any(String),
+      expect.objectContaining({
+        params: expect.objectContaining({
+          __ids_71322c7a: ['doc1', 'drafts.doc1', 'doc2', 'drafts.doc2'],
+        }),
+        perspective: PREVIEW_PERSPECTIVE,
+        tag: PREVIEW_TAG,
+      }),
+    )
 
     subscription.unsubscribe()
   })
 
-  it('always uses latest client/schema/eventId state when fetching', async () => {
+  it('processes query results and updates state with resolved values', async () => {
+    const teardown = vi.fn()
+    const subscriber = vi
+      .fn<(observer: Observer<PreviewQueryResult[] | undefined>) => () => void>()
+      .mockReturnValue(teardown)
+
+    vi.mocked(getQueryState).mockReturnValue({
+      getCurrent: () => undefined,
+      observable: new Observable(subscriber),
+    } as StateSource<PreviewQueryResult[] | undefined>)
+
     const subscription = subscribeToStateAndFetchBatches({instance, state})
 
+    expect(subscriber).not.toHaveBeenCalled()
+
     // Add a subscription
     state.set('addSubscription', {
-      documentTypes: {doc1: 'test'},
       subscriptions: {doc1: {sub1: true}},
     })
 
-    // Update lastLiveEventId
-    state.set('updateEventId', {lastLiveEventId: 'event1'})
+    expect(subscriber).not.toHaveBeenCalled()
 
     // Wait for debounce
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(mockFetch).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.any(Object),
-      expect.objectContaining({
-        lastLiveEventId: 'event1',
+    expect(subscriber).toHaveBeenCalled()
+    expect(teardown).not.toHaveBeenCalled()
+
+    const [observer] = subscriber.mock.lastCall!
+
+    const timestamp = new Date().toISOString()
+
+    observer.next([
+      {
+        _id: 'doc1',
+        _type: 'test',
+        _updatedAt: timestamp,
+        titleCandidates: {title: 'Test Document'},
+        subtitleCandidates: {description: 'Test Description'},
+      },
+    ])
+
+    const {values} = state.get()
+    expect(values['doc1']).toEqual({
+      isPending: false,
+      data: expect.objectContaining({
+        title: 'Test Document',
       }),
-    )
+    })
 
     subscription.unsubscribe()
+    expect(teardown).toHaveBeenCalled()
   })
 
   it('handles new subscriptions optimistically with pending states', async () => {
     state.set('initializeValues', {
-      documentTypes: {doc1: 'test', doc2: 'test'},
       values: {doc1: {data: {title: 'Doc 1'}, isPending: false}},
       subscriptions: {doc1: {sub1: true}},
     })
@@ -131,11 +151,11 @@ describe('subscribeToStateAndFetchBatches', () => {
   })
 
   it('cancels and restarts fetches when subscription set changes', async () => {
+    const abortSpy = vi.spyOn(AbortController.prototype, 'abort')
     const subscription = subscribeToStateAndFetchBatches({instance, state})
 
     // Add initial subscription
     state.set('addSubscription1', {
-      documentTypes: {doc1: 'test'},
       subscriptions: {doc1: {sub1: true}},
     })
 
@@ -143,64 +163,47 @@ describe('subscribeToStateAndFetchBatches', () => {
 
     // Add another subscription before first fetch completes
     state.set('addSubscription2', (prev) => ({
-      documentTypes: {...prev.documentTypes, doc2: 'test'},
       subscriptions: {...prev.subscriptions, doc2: {sub2: true}},
     }))
 
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(mockFetch).toHaveBeenCalledTimes(2)
+    expect(getQueryState).toHaveBeenCalledTimes(2)
+    expect(abortSpy).toHaveBeenCalled()
 
     subscription.unsubscribe()
   })
 
-  it('only refetches when actually needed due to distinctUntilChanged() usage', async () => {
-    const subscription = subscribeToStateAndFetchBatches({instance, state})
-
-    // Add a subscription
-    state.set('addSubscription', {
-      documentTypes: {doc1: 'test'},
-      subscriptions: {doc1: {sub1: true}},
-    })
-
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    // Update state but don't change subscriptions
-    state.set('unrelatedChange', {
-      syncTags: {'s1:tag1': true},
-    })
-
-    await new Promise((resolve) => setTimeout(resolve, 100))
-
-    expect(mockFetch).toHaveBeenCalledTimes(1)
+  it('processes and applies fetch results correctly', async () => {
+    const subscriber = vi.fn<(observer: Observer<PreviewQueryResult[] | undefined>) => () => void>()
 
-    subscription.unsubscribe()
-  })
+    vi.mocked(getQueryState).mockReturnValue({
+      getCurrent: () => undefined,
+      observable: new Observable(subscriber),
+    } as StateSource<PreviewQueryResult[] | undefined>)
 
-  it('processes and applies fetch results correctly', async () => {
     const subscription = subscribeToStateAndFetchBatches({instance, state})
 
     // Add a subscription
     state.set('addSubscription', {
-      documentTypes: {doc1: 'test'},
       subscriptions: {doc1: {sub1: true}},
     })
 
     await new Promise((resolve) => setTimeout(resolve, 100))
 
+    expect(subscriber).toHaveBeenCalled()
+    const [observer] = subscriber.mock.lastCall!
+
     // Emit fetch results
-    fetchResults.next({
-      result: [
-        {
-          _id: 'doc1',
-          _type: 'test',
-          _updatedAt: '2024-01-01T00:00:00Z',
-          titleCandidates: {title: 'Test Document'},
-          subtitleCandidates: {description: 'Test Description'},
-        },
-      ],
-      syncTags: ['s1:tag1', 's1:tag2'],
-    })
+    observer.next([
+      {
+        _id: 'doc1',
+        _type: 'test',
+        _updatedAt: '2024-01-01T00:00:00Z',
+        titleCandidates: {title: 'Test Document'},
+        subtitleCandidates: {description: 'Test Description'},
+      },
+    ])
 
     // Check that the state was updated
     expect(state.get().values['doc1']).toEqual({
@@ -209,10 +212,6 @@ describe('subscribeToStateAndFetchBatches', () => {
       }),
       isPending: false,
     })
-    expect(state.get().syncTags).toEqual({
-      's1:tag1': true,
-      's1:tag2': true,
-    })
 
     subscription.unsubscribe()
   })

package/src/preview/subscribeToStateAndFetchBatches.ts

@@ -1,100 +1,104 @@
-import {type SyncTag} from '@sanity/client'
 import {
-  combineLatest,
   debounceTime,
+  defer,
   distinctUntilChanged,
   EMPTY,
+  filter,
+  from,
   map,
+  Observable,
   pairwise,
   startWith,
+  Subscription,
   switchMap,
   tap,
-  withLatestFrom,
 } from 'rxjs'
 
-import {getClientState} from '../client/clientStore'
-import {type ActionContext, createInternalAction} from '../resources/createAction'
+import {getQueryState, resolveQuery} from '../query/queryStore'
+import {type StoreContext} from '../store/defineStore'
 import {createPreviewQuery, processPreviewQuery} from './previewQuery'
 import {type PreviewQueryResult, type PreviewStoreState} from './previewStore'
-import {PREVIEW_TAG} from './util'
+import {PREVIEW_PERSPECTIVE, PREVIEW_TAG} from './util'
 
 const BATCH_DEBOUNCE_TIME = 50
 
-export const subscribeToStateAndFetchBatches = createInternalAction(
-  ({state, instance}: ActionContext<PreviewStoreState>) => {
-    return function () {
-      const client$ = getClientState(instance, {apiVersion: 'vX'}).observable
-      const documentTypes$ = state.observable.pipe(
-        map((i) => i.documentTypes),
-        distinctUntilChanged(),
-      )
-      const lastLiveEventId$ = state.observable.pipe(
-        map((i) => i.lastLiveEventId),
-        distinctUntilChanged(),
-      )
+const isSetEqual = <T>(a: Set<T>, b: Set<T>) =>
+  a.size === b.size && Array.from(a).every((i) => b.has(i))
 
-      const newSubscriberIds$ = state.observable.pipe(
-        map(({subscriptions}) => new Set(Object.keys(subscriptions))),
-        distinctUntilChanged((a, b) =>
-          a.size !== b.size ? false : Array.from(a).every((i) => b.has(i)),
-        ),
-        debounceTime(BATCH_DEBOUNCE_TIME),
-        startWith(new Set<string>()),
-        pairwise(),
-        tap(([prevIds, currIds]) => {
-          // for all new subscriptions, set their values to pending
-          const newIds = [...currIds].filter((element) => !prevIds.has(element))
-          state.set('updatingPending', (prev) => {
-            const pendingValues = newIds.reduce<PreviewStoreState['values']>((acc, id) => {
-              const prevValue = prev.values[id]
-              const value = prevValue?.data ? prevValue.data : null
-              acc[id] = {data: value, isPending: true}
-              return acc
-            }, {})
-            return {values: {...prev.values, ...pendingValues}}
-          })
-        }),
-        withLatestFrom(documentTypes$),
-        map(([[, ids], documentTypes]) => ({ids, documentTypes})),
-      )
+export const subscribeToStateAndFetchBatches = ({
+  state,
+  instance,
+}: StoreContext<PreviewStoreState>): Subscription => {
+  const newSubscriberIds$ = state.observable.pipe(
+    map(({subscriptions}) => new Set(Object.keys(subscriptions))),
+    distinctUntilChanged(isSetEqual),
+    debounceTime(BATCH_DEBOUNCE_TIME),
+    startWith(new Set<string>()),
+    pairwise(),
+    tap(([prevIds, currIds]) => {
+      // for all new subscriptions, set their values to pending
+      const newIds = [...currIds].filter((element) => !prevIds.has(element))
+      state.set('updatingPending', (prev) => {
+        const pendingValues = newIds.reduce<PreviewStoreState['values']>((acc, id) => {
+          const prevValue = prev.values[id]
+          const value = prevValue?.data ? prevValue.data : null
+          acc[id] = {data: value, isPending: true}
+          return acc
+        }, {})
+        return {values: {...prev.values, ...pendingValues}}
+      })
+    }),
+    map(([, ids]) => ids),
+    distinctUntilChanged(isSetEqual),
+  )
 
-      return combineLatest([newSubscriberIds$, lastLiveEventId$, client$])
-        .pipe(
-          switchMap(([{ids}, lastLiveEventId, client]) => {
-            if (!ids.size) return EMPTY
-            const {query, params} = createPreviewQuery(ids)
+  return newSubscriberIds$
+    .pipe(
+      switchMap((ids) => {
+        if (!ids.size) return EMPTY
+        const {query, params} = createPreviewQuery(ids)
+        const controller = new AbortController()
+        return new Observable<PreviewQueryResult[]>((observer) => {
+          const {getCurrent, observable} = getQueryState<PreviewQueryResult[]>(instance, query, {
+            params,
+            tag: PREVIEW_TAG,
+            perspective: PREVIEW_PERSPECTIVE,
+          })
+          const source$ = defer(() => {
+            if (getCurrent() === undefined) {
+              return from(
+                resolveQuery<PreviewQueryResult[]>(instance, query, {
+                  params,
+                  tag: PREVIEW_TAG,
+                  perspective: PREVIEW_PERSPECTIVE,
+                  signal: controller.signal,
+                }),
+              ).pipe(switchMap(() => observable))
+            }
+            return observable
+          }).pipe(filter((result) => result !== undefined))
+          const subscription = source$.subscribe(observer)
+          return () => {
+            if (!controller.signal.aborted) {
+              controller.abort()
+            }
 
-            return client.observable
-              .fetch<PreviewQueryResult[]>(query, params, {
-                filterResponse: false,
-                returnQuery: false,
-                perspective: 'drafts',
-                tag: PREVIEW_TAG,
-                lastLiveEventId,
-              })
-              .pipe(map((response) => ({...response, ids})))
-          }),
-          map(({ids, result, syncTags}) => ({
-            syncTags,
-            values: processPreviewQuery({
-              projectId: instance.identity.projectId,
-              dataset: instance.identity.dataset,
-              ids,
-              results: result,
-            }),
-          })),
-        )
-        .subscribe({
-          next: ({syncTags = [], values}) => {
-            state.set('updateResult', (prev) => ({
-              values: {...prev.values, ...values},
-              syncTags: syncTags.reduce<Record<SyncTag, true>>((acc, next) => {
-                acc[next] = true
-                return acc
-              }, {}),
-            }))
-          },
-        })
-    }
-  },
-)
+            subscription.unsubscribe()
+          }
+        }).pipe(map((data) => ({data, ids})))
+      }),
+      map(({ids, data}) => ({
+        values: processPreviewQuery({
+          projectId: instance.config.projectId!,
+          dataset: instance.config.dataset!,
+          ids,
+          results: data,
+        }),
+      })),
+    )
+    .subscribe({
+      next: ({values}) => {
+        state.set('updateResult', (prev) => ({values: {...prev.values, ...values}}))
+      },
+    })
+}

package/src/preview/util.ts

@@ -2,6 +2,7 @@ import {getEnv} from '../utils/getEnv'
 import {type PreviewValue, type ValuePending} from './previewStore'
 
 export const PREVIEW_TAG = 'preview'
+export const PREVIEW_PERSPECTIVE = 'drafts'
 export const STABLE_EMPTY_PREVIEW: ValuePending<PreviewValue> = {data: null, isPending: false}
 export const STABLE_ERROR_PREVIEW: ValuePending<PreviewValue> = {
   data: {

package/src/project/project.test.ts

@@ -3,8 +3,8 @@ import {of} from 'rxjs'
 import {describe, it} from 'vitest'
 
 import {getClientState} from '../client/clientStore'
-import {createSanityInstance} from '../instance/sanityInstance'
-import {type StateSource} from '../resources/createStateSourceAction'
+import {createSanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
 import {resolveProject} from './project'
 
 vi.mock('../client/clientStore')
@@ -26,7 +26,7 @@ describe('project', () => {
       observable: of(mockClient),
     } as StateSource<SanityClient>)
 
-    const result = await resolveProject(instance, 'a')
+    const result = await resolveProject(instance, {projectId: 'a'})
     expect(result).toEqual(project)
     expect(getById).toHaveBeenCalledWith('a')
   })

package/src/project/project.ts

@@ -1,15 +1,38 @@
 import {switchMap} from 'rxjs'
 
 import {getClientState} from '../client/clientStore'
+import {type ProjectHandle} from '../config/sanityConfig'
 import {createFetcherStore} from '../utils/createFetcherStore'
 
+const API_VERSION = 'v2025-02-19'
+
 const project = createFetcherStore({
   name: 'Project',
-  getKey: (projectId: string) => projectId,
-  fetcher: (instance) => (projectId: string) =>
-    getClientState(instance, {apiVersion: 'vX', scope: 'global'}).observable.pipe(
-      switchMap((client) => client.observable.projects.getById(projectId)),
-    ),
+  getKey: (instance, options?: ProjectHandle) => {
+    const projectId = options?.projectId ?? instance.config.projectId
+    if (!projectId) {
+      throw new Error('A projectId is required to use the project API.')
+    }
+    return projectId
+  },
+  fetcher:
+    (instance) =>
+    (options: ProjectHandle = {}) => {
+      const projectId = options.projectId ?? instance.config.projectId
+
+      return getClientState(instance, {
+        apiVersion: API_VERSION,
+        scope: 'global',
+        projectId,
+      }).observable.pipe(
+        switchMap((client) =>
+          client.observable.projects.getById(
+            // non-null assertion is fine with the above throwing
+            (projectId ?? instance.config.projectId)!,
+          ),
+        ),
+      )
+    },
 })
 
 /** @public */