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

package/src/projection/resolveProjection.ts

@@ -1,36 +1,23 @@
-import {type DocumentHandle} from '../document/patchOperations'
-import {type ActionContext, createAction} from '../resources/createAction'
+import {filter, firstValueFrom} from 'rxjs'
+
+import {type DocumentHandle} from '../config/sanityConfig'
+import {bindActionByDataset} from '../store/createActionBinder'
 import {getProjectionState} from './getProjectionState'
-import {
-  projectionStore,
-  type ProjectionStoreState,
-  type ProjectionValuePending,
-  type ValidProjection,
-} from './projectionStore'
+import {projectionStore, type ValidProjection} from './projectionStore'
 
-interface ResolveProjectionOptions {
-  document: DocumentHandle
+interface ResolveProjectionOptions extends DocumentHandle {
   projection: ValidProjection
 }
 
 /**
  * @beta
  */
-export const resolveProjection = createAction(projectionStore, () => {
-  return function <TResult extends Record<string, unknown> = Record<string, unknown>>(
-    this: ActionContext<ProjectionStoreState>,
-    {document, projection}: ResolveProjectionOptions,
-  ): Promise<ProjectionValuePending<TResult>> {
-    const {getCurrent, subscribe} = getProjectionState<TResult>(this, {document, projection})
-
-    return new Promise<ProjectionValuePending<TResult>>((resolve) => {
-      const unsubscribe = subscribe(() => {
-        const current = getCurrent()
-        if (current?.data) {
-          resolve(current)
-          unsubscribe()
-        }
-      })
-    })
-  }
-})
+export const resolveProjection = bindActionByDataset(
+  projectionStore,
+  ({instance}, {projection, ...docHandle}: ResolveProjectionOptions) =>
+    firstValueFrom(
+      getProjectionState(instance, {...docHandle, projection}).observable.pipe(
+        filter((i) => !!i.data),
+      ),
+    ),
+)

package/src/projection/subscribeToStateAndFetchBatches.test.ts

@@ -1,51 +1,39 @@
-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 {hashString} from '../common/util'
-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 {hashString} from '../utils/hashString'
 import {type ProjectionQueryResult, type ProjectionStoreState} from './projectionStore'
 import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
 
-vi.mock('../client/clientStore.ts', () => ({getClientState: vi.fn()}))
-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<ProjectionStoreState>
-  let fetchResults: Subject<{result: ProjectionQueryResult[]; syncTags: SyncTag[]}>
-  let mockFetch: Mock
+  let instance: SanityInstance
+  let state: StoreState<ProjectionStoreState>
 
   beforeEach(() => {
-    state = createResourceState<ProjectionStoreState>({
+    vi.clearAllMocks()
+    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+    state = createStoreState<ProjectionStoreState>({
       documentProjections: {},
-      lastLiveEventId: null,
       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<ProjectionQueryResult[] | undefined>,
+    } as StateSource<ProjectionQueryResult[] | undefined>)
+
+    vi.mocked(resolveQuery).mockResolvedValue(undefined)
+  })
+
+  afterEach(() => {
+    instance.dispose()
   })
 
   it('batches rapid subscription changes into single requests', async () => {
@@ -67,38 +55,82 @@ describe('subscribeToStateAndFetchBatches', () => {
     // Wait for debounce
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(mockFetch).toHaveBeenCalledTimes(1)
-    expect(mockFetch.mock.calls[0][1]).toMatchObject({
-      [`__ids_${projectionHash}`]: ['doc1', 'drafts.doc1', 'doc2', 'drafts.doc2'],
-    })
+    expect(getQueryState).toHaveBeenCalledTimes(1)
+    expect(getQueryState).toHaveBeenCalledWith(
+      instance,
+      expect.any(String),
+      expect.objectContaining({
+        params: {
+          [`__ids_${projectionHash}`]: ['doc1', 'drafts.doc1', 'doc2', 'drafts.doc2'],
+        },
+      }),
+    )
 
     subscription.unsubscribe()
   })
 
-  it('always uses latest client/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<ProjectionQueryResult[] | undefined>) => () => void>()
+      .mockReturnValue(teardown)
+
+    vi.mocked(getQueryState).mockReturnValue({
+      getCurrent: () => undefined,
+      observable: new Observable(subscriber),
+    } as StateSource<ProjectionQueryResult[] | undefined>)
+
     const subscription = subscribeToStateAndFetchBatches({instance, state})
 
+    expect(subscriber).not.toHaveBeenCalled()
+
     // Add a subscription
     state.set('addSubscription', {
-      documentProjections: {doc1: '{title, description}'},
+      documentProjections: {doc1: '{title}'},
       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: 'doc',
+        _updatedAt: timestamp,
+        result: {title: 'resolved'},
+      },
+      {
+        _id: 'drafts.doc1',
+        _type: 'doc',
+        _updatedAt: timestamp,
+        result: {title: 'resolved'},
+      },
+    ])
+
+    const {values} = state.get()
+    expect(values['doc1']).toEqual({
+      isPending: false,
+      data: {
+        title: 'resolved',
+        status: {
+          lastEditedDraftAt: timestamp,
+          lastEditedPublishedAt: timestamp,
+        },
+      },
+    })
 
     subscription.unsubscribe()
+    expect(teardown).toHaveBeenCalled()
   })
 
   it('handles new subscriptions optimistically with pending states', async () => {
@@ -133,6 +165,7 @@ 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
@@ -151,35 +184,21 @@ describe('subscribeToStateAndFetchBatches', () => {
 
     await new Promise((resolve) => setTimeout(resolve, 100))
 
-    expect(mockFetch).toHaveBeenCalledTimes(2)
+    expect(getQueryState).toHaveBeenCalledTimes(3)
+    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', {
-      documentProjections: {doc1: '{title, description}'},
-      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<ProjectionQueryResult[] | undefined>) => () => void>()
 
-    subscription.unsubscribe()
-  })
+    vi.mocked(getQueryState).mockReturnValue({
+      getCurrent: () => undefined,
+      observable: new Observable(subscriber),
+    } as StateSource<ProjectionQueryResult[] | undefined>)
 
-  it('processes and applies fetch results correctly', async () => {
     const subscription = subscribeToStateAndFetchBatches({instance, state})
 
     // Add a subscription
@@ -190,18 +209,18 @@ describe('subscribeToStateAndFetchBatches', () => {
 
     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',
-          result: {title: 'Test Document', description: 'Test Description'},
-        },
-      ],
-      syncTags: ['s1:tag1', 's1:tag2'],
-    })
+    observer.next([
+      {
+        _id: 'doc1',
+        _type: 'test',
+        _updatedAt: '2024-01-01T00:00:00Z',
+        result: {title: 'Test Document', description: 'Test Description'},
+      },
+    ])
 
     // Check that the state was updated
     expect(state.get().values['doc1']).toEqual({
@@ -214,10 +233,6 @@ describe('subscribeToStateAndFetchBatches', () => {
       }),
       isPending: false,
     })
-    expect(state.get().syncTags).toEqual({
-      's1:tag1': true,
-      's1:tag2': true,
-    })
 
     subscription.unsubscribe()
   })

package/src/projection/subscribeToStateAndFetchBatches.ts

@@ -1,104 +1,117 @@
-import {type SanityClient, type SyncTag} from '@sanity/client'
+import {isEqual} from 'lodash-es'
 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 {createProjectionQuery, processProjectionQuery} from './projectionQuery'
 import {type ProjectionQueryResult, type ProjectionStoreState} from './projectionStore'
-import {PROJECTION_TAG} from './util'
+import {PROJECTION_PERSPECTIVE, PROJECTION_TAG} from './util'
 
 const BATCH_DEBOUNCE_TIME = 50
 
-export const subscribeToStateAndFetchBatches = createInternalAction(
-  ({state, instance}: ActionContext<ProjectionStoreState>) => {
-    return function () {
-      const client$ = new Observable<SanityClient>((observer) =>
-        getClientState(instance, {apiVersion: 'vX'}).observable.subscribe(observer),
-      )
+const isSetEqual = <T>(a: Set<T>, b: Set<T>) =>
+  a.size === b.size && Array.from(a).every((i) => b.has(i))
 
-      const documentProjections$ = state.observable.pipe(
-        map((i) => i.documentProjections),
-        distinctUntilChanged(),
-      )
-      const lastLiveEventId$ = state.observable.pipe(
-        map((i) => i.lastLiveEventId),
-        distinctUntilChanged(),
-      )
+export const subscribeToStateAndFetchBatches = ({
+  state,
+  instance,
+}: StoreContext<ProjectionStoreState>): Subscription => {
+  const documentProjections$ = state.observable.pipe(
+    map((i) => i.documentProjections),
+    distinctUntilChanged(),
+  )
 
-      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<ProjectionStoreState['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}}
+  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<ProjectionStoreState['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$, documentProjections$])
+    .pipe(
+      distinctUntilChanged(isEqual),
+      switchMap(([ids, documentProjections]) => {
+        if (!ids.size) return EMPTY
+        const {query, params} = createProjectionQuery(ids, documentProjections)
+        const controller = new AbortController()
+
+        return new Observable<ProjectionQueryResult[]>((observer) => {
+          const {getCurrent, observable} = getQueryState<ProjectionQueryResult[]>(instance, query, {
+            params,
+            tag: PROJECTION_TAG,
+            perspective: PROJECTION_PERSPECTIVE,
           })
-        }),
-        withLatestFrom(documentProjections$),
-        map(([[, ids], documentProjections]) => ({ids, documentProjections})),
-      )
 
-      return combineLatest([newSubscriberIds$, lastLiveEventId$, client$])
-        .pipe(
-          switchMap(([{ids, documentProjections}, lastLiveEventId, client]) => {
-            if (!ids.size) return EMPTY
-            const {query, params} = createProjectionQuery(ids, documentProjections)
+          const source$ = defer(() => {
+            if (getCurrent() === undefined) {
+              return from(
+                resolveQuery<ProjectionQueryResult[]>(instance, query, {
+                  params,
+                  tag: PROJECTION_TAG,
+                  perspective: PROJECTION_PERSPECTIVE,
+                  signal: controller.signal,
+                }),
+              ).pipe(switchMap(() => observable))
+            }
+            return observable
+          }).pipe(filter((result) => result !== undefined))
 
-            return client.observable
-              .fetch<ProjectionQueryResult[]>(query, params, {
-                filterResponse: false,
-                returnQuery: false,
-                perspective: 'drafts',
-                tag: PROJECTION_TAG,
-                lastLiveEventId,
-              })
-              .pipe(map((response) => ({...response, ids})))
-          }),
-          map(({ids, result, syncTags}) => ({
-            syncTags,
-            values: processProjectionQuery({
-              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
-              }, {}),
-            }))
-          },
-        })
-    }
-  },
-)
+          const subscription = source$.subscribe(observer)
+
+          return () => {
+            if (!controller.signal.aborted) {
+              controller.abort()
+            }
+            subscription.unsubscribe()
+          }
+        }).pipe(map((data) => ({data, ids})))
+      }),
+      map(({ids, data}) => ({
+        values: processProjectionQuery({
+          projectId: instance.config.projectId!,
+          dataset: instance.config.dataset!,
+          ids,
+          results: data,
+        }),
+      })),
+    )
+    .subscribe({
+      next: ({values}) => {
+        state.set('updateResult', (prev) => ({
+          values: {...prev.values, ...values},
+        }))
+      },
+    })
+}

package/src/projection/util.ts

@@ -1,6 +1,8 @@
 import {type ValidProjection} from './projectionStore'
 
 export const PROJECTION_TAG = 'sdk.projection'
+export const PROJECTION_PERSPECTIVE = 'drafts'
+export const PROJECTION_STATE_CLEAR_DELAY = 1000
 
 export const STABLE_EMPTY_PROJECTION = {
   data: null,

package/src/projects/projects.test.ts

@@ -1,17 +1,26 @@
 import {type SanityClient} from '@sanity/client'
 import {of} from 'rxjs'
-import {describe, it} from 'vitest'
+import {afterEach, beforeEach, describe, it} from 'vitest'
 
 import {getClientState} from '../client/clientStore'
-import {createSanityInstance} from '../instance/sanityInstance'
-import {type StateSource} from '../resources/createStateSourceAction'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
 import {resolveProjects} from './projects'
 
 vi.mock('../client/clientStore')
 
 describe('projects', () => {
+  let instance: SanityInstance
+
+  beforeEach(() => {
+    instance = createSanityInstance({projectId: 'p', dataset: 'd'})
+  })
+
+  afterEach(() => {
+    instance.dispose()
+  })
+
   it('calls the `client.observable.projects.list` method on the client and returns the result', async () => {
-    const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
     const projects = [{id: 'a'}, {id: 'b'}]
     const list = vi.fn().mockReturnValue(of(projects))
 

package/src/projects/projects.ts

@@ -3,11 +3,16 @@ import {switchMap} from 'rxjs'
 import {getClientState} from '../client/clientStore'
 import {createFetcherStore} from '../utils/createFetcherStore'
 
+const API_VERSION = 'v2025-02-19'
+
 const projects = createFetcherStore({
   name: 'Projects',
   getKey: () => 'projects',
   fetcher: (instance) => () =>
-    getClientState(instance, {apiVersion: 'vX', scope: 'global'}).observable.pipe(
+    getClientState(instance, {
+      apiVersion: API_VERSION,
+      scope: 'global',
+    }).observable.pipe(
       switchMap((client) => client.observable.projects.list({includeMembers: false})),
     ),
 })