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

package/src/query/queryStore.test.ts

@@ -3,10 +3,9 @@ import {delay, filter, firstValueFrom, Observable, of, Subject} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {getClientState} from '../client/clientStore'
-import {createSanityInstance} from '../instance/sanityInstance'
-import {getOrCreateResource} from '../resources/createResource'
-import {type StateSource} from '../resources/createStateSourceAction'
-import {errorHandler, getQueryState, queryStore, resolveQuery} from './queryStore'
+import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
+import {type StateSource} from '../store/createStateSourceAction'
+import {getQueryState, resolveQuery} from './queryStore'
 
 vi.mock('./queryStoreConstants', async (importOriginal) => ({
   ...(await importOriginal<typeof import('./queryStoreConstants')>()),
@@ -18,6 +17,7 @@ vi.mock('../client/clientStore', () => ({
 }))
 
 describe('queryStore', () => {
+  let instance: SanityInstance
   let liveEvents: Subject<LiveEvent>
   let fetch: SanityClient['observable']['fetch']
   // Mock data for testing
@@ -29,6 +29,8 @@ describe('queryStore', () => {
   }
 
   beforeEach(() => {
+    instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+
     fetch = vi
       .fn()
       .mockReturnValue(
@@ -50,8 +52,11 @@ describe('queryStore', () => {
     } as StateSource<SanityClient>)
   })
 
+  afterEach(() => {
+    instance.dispose()
+  })
+
   it('initializes query state and cleans up after unsubscribe', async () => {
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
     const state = getQueryState(instance, query)
 
@@ -78,12 +83,9 @@ describe('queryStore', () => {
 
     // Verify state is cleared
     expect(state.getCurrent()).toBeUndefined()
-
-    instance.dispose()
   })
 
   it('maintains state when multiple subscribers exist', async () => {
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
     const state = getQueryState(instance, query)
 
@@ -117,12 +119,9 @@ describe('queryStore', () => {
 
     // Verify state is cleared after all subscribers are gone
     expect(state.getCurrent()).toBeUndefined()
-
-    instance.dispose()
   })
 
   it('resolveQuery works without affecting subscriber cleanup', async () => {
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
 
     const state = getQueryState(instance, query)
@@ -151,12 +150,9 @@ describe('queryStore', () => {
     unsubscribe()
     await new Promise((resolve) => setTimeout(resolve, 20))
     expect(state.getCurrent()).toBeUndefined()
-
-    instance.dispose()
   })
 
   it('handles abort signal in resolveQuery', async () => {
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
     const abortController = new AbortController()
 
@@ -171,8 +167,6 @@ describe('queryStore', () => {
 
     // Verify state is cleared after abort
     expect(getQueryState(instance, query).getCurrent()).toBeUndefined()
-
-    instance.dispose()
   })
 
   it('refetches query when receiving live event with matching sync tag', async () => {
@@ -190,7 +184,6 @@ describe('queryStore', () => {
       ),
     )
 
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
     const state = getQueryState<{_id: string; _type: string; title: string}[]>(instance, query)
 
@@ -214,7 +207,6 @@ describe('queryStore', () => {
     expect(result).toContainEqual(updatedMovie)
 
     unsubscribe()
-    instance.dispose()
   })
 
   it('does not refetch for non-matching sync tags', async () => {
@@ -223,7 +215,6 @@ describe('queryStore', () => {
       of({result: mockData.movies, syncTags: mockSyncTags, ms: 0}).pipe(delay(0)),
     )
 
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
     const state = getQueryState(instance, query)
 
@@ -243,7 +234,6 @@ describe('queryStore', () => {
     expect(fetch).toHaveBeenCalledTimes(1)
 
     unsubscribe()
-    instance.dispose()
   })
 
   it('handles multiple live events with same sync tag', async () => {
@@ -258,7 +248,6 @@ describe('queryStore', () => {
       of({result: mockData.movies, syncTags: mockSyncTags, ms: 0}).pipe(delay(0)),
     )
 
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
     const state = getQueryState(instance, query)
 
@@ -284,11 +273,9 @@ describe('queryStore', () => {
     expect(vi.mocked(fetch).mock.calls[2][2]?.lastLiveEventId).toBe('event2')
 
     unsubscribe()
-    instance.dispose()
   })
 
   it('handles errors in query fetching', async () => {
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const errorMessage = 'Query failed'
 
     // Override fetch to simulate error
@@ -306,29 +293,9 @@ describe('queryStore', () => {
     expect(() => state.getCurrent()).toThrow(errorMessage)
 
     unsubscribe()
-    instance.dispose()
-  })
-
-  it('throws an error if an errorHandler has been called', () => {
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
-    const query = '*[_type == "movie"]'
-    const state = getQueryState(instance, query)
-
-    const resource = getOrCreateResource(instance, queryStore)
-
-    // Create an error and call the error handler
-    const testError = new Error('Global error from error handler')
-    const handler = errorHandler({state: resource.state, instance})
-    handler(testError)
-
-    // Verify the error is thrown when accessing state
-    expect(() => state.getCurrent()).toThrow('Global error from error handler')
-
-    instance.dispose()
   })
 
   it('delays query state removal after unsubscribe', async () => {
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
     const state = getQueryState(instance, query)
     const unsubscribe = state.subscribe()
@@ -342,12 +309,9 @@ describe('queryStore', () => {
     // Wait for the cleanup delay and then state should be removed
     await new Promise((resolve) => setTimeout(resolve, 20))
     expect(state.getCurrent()).toBeUndefined()
-
-    instance.dispose()
   })
 
   it('preserves query state if a new subscriber subscribes before cleanup delay', async () => {
-    const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
     const query = '*[_type == "movie"]'
     const state = getQueryState(instance, query)
     const unsubscribe1 = state.subscribe()
@@ -374,6 +338,5 @@ describe('queryStore', () => {
       {_id: 'movie2', _type: 'movie', title: 'Movie 2'},
     ])
     unsubscribe2()
-    instance.dispose()
   })
 })

package/src/query/queryStore.ts

@@ -20,13 +20,19 @@ import {
   tap,
 } from 'rxjs'
 
-import {type ClientOptions, getClientState} from '../client/clientStore'
-import {type SanityInstance} from '../instance/types'
-import {type ActionContext, createAction, createInternalAction} from '../resources/createAction'
-import {createResource} from '../resources/createResource'
-import {createStateSourceAction, type StateSource} from '../resources/createStateSourceAction'
+import {getClientState} from '../client/clientStore'
+import {type DatasetHandle} from '../config/sanityConfig'
+import {bindActionByDataset} from '../store/createActionBinder'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {
+  createStateSourceAction,
+  type SelectorContext,
+  type StateSource,
+} from '../store/createStateSourceAction'
+import {type StoreState} from '../store/createStoreState'
+import {defineStore, type StoreContext} from '../store/defineStore'
 import {insecureRandomId} from '../utils/ids'
-import {QUERY_STATE_CLEAR_DELAY} from './queryStoreConstants'
+import {QUERY_STATE_CLEAR_DELAY, QUERY_STORE_API_VERSION} from './queryStoreConstants'
 import {
   addSubscriber,
   cancelQuery,
@@ -42,8 +48,11 @@ import {
  * @beta
  */
 export interface QueryOptions
-  extends Pick<ResponseQueryOptions, 'perspective' | 'useCdn' | 'cache' | 'next' | 'cacheMode'>,
-    Pick<ClientOptions, 'scope' | 'resourceId'> {
+  extends Pick<
+      ResponseQueryOptions,
+      'perspective' | 'useCdn' | 'cache' | 'next' | 'cacheMode' | 'tag'
+    >,
+    DatasetHandle {
   params?: Record<string, unknown>
 }
 
@@ -63,13 +72,13 @@ export const getQueryKey = (query: string, options: QueryOptions = {}): string =
 export const parseQueryKey = (key: string): {query: string; options: QueryOptions} =>
   JSON.parse(key)
 
-export const queryStore = createResource<QueryStoreState>({
+const queryStore = defineStore<QueryStoreState>({
   name: 'QueryStore',
   getInitialState: () => ({queries: {}}),
-  initialize() {
+  initialize(context) {
     const subscriptions = [
-      listenForNewSubscribersAndFetch(this),
-      listenToLiveClientAndSetLastLiveEventIds(this),
+      listenForNewSubscribersAndFetch(context),
+      listenToLiveClientAndSetLastLiveEventIds(context),
     ]
 
     return () => {
@@ -80,106 +89,107 @@ export const queryStore = createResource<QueryStoreState>({
   },
 })
 
-export const errorHandler = createInternalAction(({state}: ActionContext<{error?: unknown}>) => {
-  return function () {
-    return (error: unknown) => state.set('setError', {error})
-  }
-})
-
-const listenForNewSubscribersAndFetch = createInternalAction(
-  ({state, instance}: ActionContext<QueryStoreState>) => {
-    return function () {
-      return state.observable
-        .pipe(
-          map((s) => new Set(Object.keys(s.queries))),
-          distinctUntilChanged((curr, next) => {
-            if (curr.size !== next.size) return false
-            return Array.from(next).every((i) => curr.has(i))
-          }),
-          startWith(new Set<string>()),
-          pairwise(),
-          mergeMap(([curr, next]) => {
-            const added = Array.from(next).filter((i) => !curr.has(i))
-            const removed = Array.from(curr).filter((i) => !next.has(i))
-
-            return [
-              ...added.map((key) => ({key, added: true})),
-              ...removed.map((key) => ({key, added: false})),
-            ]
-          }),
-          groupBy((i) => i.key),
-          mergeMap((group$) =>
-            group$.pipe(
-              switchMap((e) => {
-                if (!e.added) return EMPTY
+const errorHandler = (state: StoreState<{error?: unknown}>) => {
+  return (error: unknown): void => state.set('setError', {error})
+}
 
-                const lastLiveEventId$ = state.observable.pipe(
-                  map((s) => s.queries[group$.key]?.lastLiveEventId),
-                  distinctUntilChanged(),
-                )
-                const {query, options: {params, scope, ...options} = {}} = parseQueryKey(group$.key)
-                const client$ = getClientState(instance, {apiVersion: 'vX', scope}).observable
+const listenForNewSubscribersAndFetch = ({state, instance}: StoreContext<QueryStoreState>) => {
+  return state.observable
+    .pipe(
+      map((s) => new Set(Object.keys(s.queries))),
+      distinctUntilChanged((curr, next) => {
+        if (curr.size !== next.size) return false
+        return Array.from(next).every((i) => curr.has(i))
+      }),
+      startWith(new Set<string>()),
+      pairwise(),
+      mergeMap(([curr, next]) => {
+        const added = Array.from(next).filter((i) => !curr.has(i))
+        const removed = Array.from(curr).filter((i) => !next.has(i))
 
-                return combineLatest([lastLiveEventId$, client$]).pipe(
-                  switchMap(([lastLiveEventId, client]) =>
-                    client.observable.fetch(query, params, {
-                      ...options,
-                      filterResponse: false,
-                      returnQuery: false,
-                      lastLiveEventId,
-                    }),
-                  ),
-                )
-              }),
-              catchError((error) => {
-                state.set('setQueryError', setQueryError(group$.key, error))
-                return EMPTY
-              }),
-              tap(({result, syncTags}) => {
-                state.set('setQueryData', setQueryData(group$.key, result, syncTags))
-              }),
-            ),
-          ),
-        )
-        .subscribe({error: errorHandler(this)})
-    }
-  },
-)
+        return [
+          ...added.map((key) => ({key, added: true})),
+          ...removed.map((key) => ({key, added: false})),
+        ]
+      }),
+      groupBy((i) => i.key),
+      mergeMap((group$) =>
+        group$.pipe(
+          switchMap((e) => {
+            if (!e.added) return EMPTY
 
-const listenToLiveClientAndSetLastLiveEventIds = createInternalAction(
-  ({state, instance}: ActionContext<QueryStoreState>) => {
-    return function () {
-      const liveMessages$ = getClientState(instance, {apiVersion: 'vX'}).observable.pipe(
-        switchMap((client) =>
-          client.live.events({includeDrafts: !!client.config().token, tag: 'query-store'}),
-        ),
-        share(),
-        filter((e) => e.type === 'message'),
-      )
-
-      return state.observable
-        .pipe(
-          mergeMap((s) => Object.entries(s.queries)),
-          groupBy(([key]) => key),
-          mergeMap((group$) => {
-            const syncTags$ = group$.pipe(
-              map(([, queryState]) => queryState),
-              map((i) => i?.syncTags ?? EMPTY_ARRAY),
+            const lastLiveEventId$ = state.observable.pipe(
+              map((s) => s.queries[group$.key]?.lastLiveEventId),
               distinctUntilChanged(),
             )
+            const {query, options: {params, projectId, dataset, tag, ...options} = {}} =
+              parseQueryKey(group$.key)
+            const client$ = getClientState(instance, {
+              apiVersion: QUERY_STORE_API_VERSION,
+              projectId,
+              dataset,
+            }).observable
 
-            return combineLatest([liveMessages$, syncTags$]).pipe(
-              filter(([message, syncTags]) => message.tags.some((tag) => syncTags.includes(tag))),
-              tap(([message]) => {
-                state.set('setLastLiveEventId', setLastLiveEventId(group$.key, message.id))
-              }),
+            return combineLatest([lastLiveEventId$, client$]).pipe(
+              switchMap(([lastLiveEventId, client]) =>
+                client.observable.fetch(query, params, {
+                  ...options,
+                  filterResponse: false,
+                  returnQuery: false,
+                  lastLiveEventId,
+                  tag,
+                }),
+              ),
             )
           }),
+          catchError((error) => {
+            state.set('setQueryError', setQueryError(group$.key, error))
+            return EMPTY
+          }),
+          tap(({result, syncTags}) => {
+            state.set('setQueryData', setQueryData(group$.key, result, syncTags))
+          }),
+        ),
+      ),
+    )
+    .subscribe({error: errorHandler(state)})
+}
+
+const listenToLiveClientAndSetLastLiveEventIds = ({
+  state,
+  instance,
+}: StoreContext<QueryStoreState>) => {
+  const liveMessages$ = getClientState(instance, {
+    apiVersion: QUERY_STORE_API_VERSION,
+  }).observable.pipe(
+    switchMap((client) =>
+      client.live.events({includeDrafts: !!client.config().token, tag: 'query-store'}),
+    ),
+    share(),
+    filter((e) => e.type === 'message'),
+  )
+
+  return state.observable
+    .pipe(
+      mergeMap((s) => Object.entries(s.queries)),
+      groupBy(([key]) => key),
+      mergeMap((group$) => {
+        const syncTags$ = group$.pipe(
+          map(([, queryState]) => queryState),
+          map((i) => i?.syncTags ?? EMPTY_ARRAY),
+          distinctUntilChanged(),
+        )
+
+        return combineLatest([liveMessages$, syncTags$]).pipe(
+          filter(([message, syncTags]) => message.tags.some((tag) => syncTags.includes(tag))),
+          tap(([message]) => {
+            state.set('setLastLiveEventId', setLastLiveEventId(group$.key, message.id))
+          }),
         )
-        .subscribe({error: errorHandler(this)})
-    }
-  },
-)
+      }),
+    )
+    .subscribe({error: errorHandler(state)})
+}
 
 /**
  * Returns the state source for a query.
@@ -198,13 +208,13 @@ const listenToLiveClientAndSetLastLiveEventIds = createInternalAction(
  * @beta
  */
 export function getQueryState<T>(
-  instance: SanityInstance | ActionContext<QueryStoreState>,
+  instance: SanityInstance,
   query: string,
   options?: QueryOptions,
 ): StateSource<T | undefined>
 /** @beta */
 export function getQueryState(
-  instance: SanityInstance | ActionContext<QueryStoreState>,
+  instance: SanityInstance,
   query: string,
   options?: QueryOptions,
 ): StateSource<unknown>
@@ -212,29 +222,36 @@ export function getQueryState(
 export function getQueryState(...args: Parameters<typeof _getQueryState>): StateSource<unknown> {
   return _getQueryState(...args)
 }
-const _getQueryState = createStateSourceAction(queryStore, {
-  selector: (state: QueryStoreState, query: string, options?: QueryOptions) => {
-    if (state.error) throw state.error
-    const key = getQueryKey(query, options)
-    const queryState = state.queries[key]
-    if (queryState?.error) throw queryState.error
-    return queryState?.result
-  },
-  onSubscribe: ({state}, query, options?: QueryOptions) => {
-    const subscriptionId = insecureRandomId()
-    const key = getQueryKey(query, options)
+const _getQueryState = bindActionByDataset(
+  queryStore,
+  createStateSourceAction({
+    selector: (
+      {state}: SelectorContext<QueryStoreState>,
+      query: string,
+      options?: QueryOptions,
+    ) => {
+      if (state.error) throw state.error
+      const key = getQueryKey(query, options)
+      const queryState = state.queries[key]
+      if (queryState?.error) throw queryState.error
+      return queryState?.result
+    },
+    onSubscribe: ({state}, query, options?: QueryOptions) => {
+      const subscriptionId = insecureRandomId()
+      const key = getQueryKey(query, options)
 
-    state.set('addSubscriber', addSubscriber(key, subscriptionId))
+      state.set('addSubscriber', addSubscriber(key, subscriptionId))
 
-    return () => {
-      // this runs on unsubscribe
-      setTimeout(
-        () => state.set('removeSubscriber', removeSubscriber(key, subscriptionId)),
-        QUERY_STATE_CLEAR_DELAY,
-      )
-    }
-  },
-})
+      return () => {
+        // this runs on unsubscribe
+        setTimeout(
+          () => state.set('removeSubscriber', removeSubscriber(key, subscriptionId)),
+          QUERY_STATE_CLEAR_DELAY,
+        )
+      }
+    },
+  }),
+)
 
 /**
  * Resolves the result of a query without registering a lasting subscriber.
@@ -251,13 +268,13 @@ const _getQueryState = createStateSourceAction(queryStore, {
  * @beta
  */
 export function resolveQuery<T>(
-  instance: SanityInstance | ActionContext<QueryStoreState>,
+  instance: SanityInstance,
   query: string,
   options?: ResolveQueryOptions,
 ): Promise<T>
 /** @beta */
 export function resolveQuery(
-  instance: SanityInstance | ActionContext<QueryStoreState>,
+  instance: SanityInstance,
   query: string,
   options?: ResolveQueryOptions,
 ): Promise<unknown>
@@ -265,9 +282,10 @@ export function resolveQuery(
 export function resolveQuery(...args: Parameters<typeof _resolveQuery>): Promise<unknown> {
   return _resolveQuery(...args)
 }
-const _resolveQuery = createAction(queryStore, ({state}) => {
-  return function (query: string, {signal, ...options}: ResolveQueryOptions = {}) {
-    const {getCurrent} = getQueryState(this, query, options)
+const _resolveQuery = bindActionByDataset(
+  queryStore,
+  ({state, instance}, query: string, {signal, ...options}: ResolveQueryOptions = {}) => {
+    const {getCurrent} = getQueryState(instance, query, options)
     const key = getQueryKey(query, options)
 
     const aborted$ = signal
@@ -302,5 +320,5 @@ const _resolveQuery = createAction(queryStore, ({state}) => {
     )
 
     return firstValueFrom(race([resolved$, aborted$]))
-  }
-})
+  },
+)

package/src/query/queryStoreConstants.ts

@@ -6,3 +6,5 @@
  * different views quickly.
  */
 export const QUERY_STATE_CLEAR_DELAY = 1000
+// NOTE: Have to use vX for the text::query groq function
+export const QUERY_STORE_API_VERSION = 'vX'