@sanity/sdk 2.1.2 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "private": false,
   "description": "Sanity SDK",
   "keywords": [
@@ -43,7 +43,7 @@
   "prettier": "@sanity/prettier-config",
   "dependencies": {
     "@sanity/bifur-client": "^0.4.1",
-    "@sanity/client": "^7.2.1",
+    "@sanity/client": "^7.10.0",
     "@sanity/comlink": "^3.0.4",
     "@sanity/diff-match-patch": "^3.2.0",
     "@sanity/diff-patch": "^6.0.0",
@@ -73,8 +73,8 @@
     "@repo/config-eslint": "0.0.0",
     "@repo/config-test": "0.0.1",
     "@repo/package.config": "0.0.1",
-    "@repo/tsconfig": "0.0.1",
-    "@repo/package.bundle": "3.82.0"
+    "@repo/package.bundle": "3.82.0",
+    "@repo/tsconfig": "0.0.1"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/projects/projects.test.ts

@@ -36,6 +36,41 @@ describe('projects', () => {
 
     const result = await resolveProjects(instance)
     expect(result).toEqual(projects)
-    expect(list).toHaveBeenCalledWith({includeMembers: false})
+    expect(list).toHaveBeenCalledWith({includeMembers: false, organizationId: undefined})
+  })
+})
+
+describe('projects cache key generation', () => {
+  it('generates correct cache keys for different parameter combinations', async () => {
+    // Test the getKey function directly by creating a mock store
+    const mockGetKey = (
+      _instance: SanityInstance,
+      options?: {organizationId?: string; includeMembers?: boolean},
+    ) => {
+      const orgKey = options?.organizationId ? `:org:${options.organizationId}` : ''
+      const membersKey = options?.includeMembers === false ? ':no-members' : ''
+      return `projects${orgKey}${membersKey}`
+    }
+
+    const mockInstance = {} as SanityInstance
+
+    // Test default behavior (no options)
+    const defaultKey = mockGetKey(mockInstance)
+    expect(defaultKey).toBe('projects')
+
+    // Test with organizationId only
+    const orgKey = mockGetKey(mockInstance, {organizationId: 'org123'})
+    expect(orgKey).toBe('projects:org:org123')
+
+    // Test with includeMembers: false only
+    const noMembersKey = mockGetKey(mockInstance, {includeMembers: false})
+    expect(noMembersKey).toBe('projects:no-members')
+
+    // Test with both parameters
+    const bothKey = mockGetKey(mockInstance, {
+      organizationId: 'org123',
+      includeMembers: false,
+    })
+    expect(bothKey).toBe('projects:org:org123:no-members')
   })
 })

package/src/projects/projects.ts

@@ -7,13 +7,25 @@ const API_VERSION = 'v2025-02-19'
 
 const projects = createFetcherStore({
   name: 'Projects',
-  getKey: () => 'projects',
-  fetcher: (instance) => () =>
+  getKey: (_instance, options?: {organizationId?: string; includeMembers?: boolean}) => {
+    const orgKey = options?.organizationId ? `:org:${options.organizationId}` : ''
+    const membersKey = options?.includeMembers === false ? ':no-members' : ''
+    return `projects${orgKey}${membersKey}`
+  },
+  fetcher: (instance) => (options?: {organizationId?: string; includeMembers?: boolean}) =>
     getClientState(instance, {
       apiVersion: API_VERSION,
       scope: 'global',
+      requestTagPrefix: 'sanity.sdk.projects',
     }).observable.pipe(
-      switchMap((client) => client.observable.projects.list({includeMembers: false})),
+      switchMap((client) => {
+        const organizationId = options?.organizationId
+        return client.observable.projects.list({
+          // client method has a type that expects false | undefined
+          includeMembers: !options?.includeMembers ? false : undefined,
+          organizationId,
+        })
+      }),
     ),
 })
 

package/src/query/queryStore.test.ts

@@ -342,4 +342,90 @@ describe('queryStore', () => {
     ])
     unsubscribe2()
   })
+
+  it('separates cache entries by implicit perspective (instance.config)', async () => {
+    // Mock fetch to return different results based on perspective option
+    vi.mocked(fetch).mockImplementation(((_q, _p, options) => {
+      const perspective = (options as {perspective?: unknown})?.perspective
+      const result = perspective === 'published' ? [{_id: 'pub'}] : [{_id: 'drafts'}]
+      return of({result, syncTags: []}).pipe(delay(0)) as unknown as ReturnType<
+        SanityClient['observable']['fetch']
+      >
+    }) as SanityClient['observable']['fetch'])
+
+    const draftsInstance = createSanityInstance({
+      projectId: 'test',
+      dataset: 'test',
+      perspective: 'drafts',
+    })
+    const publishedInstance = createSanityInstance({
+      projectId: 'test',
+      dataset: 'test',
+      perspective: 'published',
+    })
+
+    // Same query/options, different implicit perspectives via instance.config
+    const sDrafts = getQueryState<{_id: string}[]>(draftsInstance, {query: '*[_type == "movie"]'})
+    const sPublished = getQueryState<{_id: string}[]>(publishedInstance, {
+      query: '*[_type == "movie"]',
+    })
+
+    const unsubDrafts = sDrafts.subscribe()
+    const unsubPublished = sPublished.subscribe()
+
+    const draftsResult = await firstValueFrom(
+      sDrafts.observable.pipe(filter((i) => i !== undefined)),
+    )
+    const publishedResult = await firstValueFrom(
+      sPublished.observable.pipe(filter((i) => i !== undefined)),
+    )
+
+    expect(draftsResult).toEqual([{_id: 'drafts'}])
+    expect(publishedResult).toEqual([{_id: 'pub'}])
+
+    unsubDrafts()
+    unsubPublished()
+
+    draftsInstance.dispose()
+    publishedInstance.dispose()
+  })
+
+  it('separates cache entries by explicit perspective in options', async () => {
+    vi.mocked(fetch).mockImplementation(((_q, _p, options) => {
+      const perspective = (options as {perspective?: unknown})?.perspective
+      const result = perspective === 'published' ? [{_id: 'pub'}] : [{_id: 'drafts'}]
+      return of({result, syncTags: []}).pipe(delay(0)) as unknown as ReturnType<
+        SanityClient['observable']['fetch']
+      >
+    }) as SanityClient['observable']['fetch'])
+
+    const base = createSanityInstance({projectId: 'test', dataset: 'test'})
+
+    const sDrafts = getQueryState<{_id: string}[]>(base, {
+      query: '*[_type == "movie"]',
+      perspective: 'drafts',
+    })
+    const sPublished = getQueryState<{_id: string}[]>(base, {
+      query: '*[_type == "movie"]',
+      perspective: 'published',
+    })
+
+    const unsubDrafts = sDrafts.subscribe()
+    const unsubPublished = sPublished.subscribe()
+
+    const draftsResult = await firstValueFrom(
+      sDrafts.observable.pipe(filter((i) => i !== undefined)),
+    )
+    const publishedResult = await firstValueFrom(
+      sPublished.observable.pipe(filter((i) => i !== undefined)),
+    )
+
+    expect(draftsResult).toEqual([{_id: 'drafts'}])
+    expect(publishedResult).toEqual([{_id: 'pub'}])
+
+    unsubDrafts()
+    unsubPublished()
+
+    base.dispose()
+  })
 })

package/src/query/queryStore.ts

@@ -34,7 +34,11 @@ import {
 import {type StoreState} from '../store/createStoreState'
 import {defineStore, type StoreContext} from '../store/defineStore'
 import {insecureRandomId} from '../utils/ids'
-import {QUERY_STATE_CLEAR_DELAY, QUERY_STORE_API_VERSION} from './queryStoreConstants'
+import {
+  QUERY_STATE_CLEAR_DELAY,
+  QUERY_STORE_API_VERSION,
+  QUERY_STORE_DEFAULT_PERSPECTIVE,
+} from './queryStoreConstants'
 import {
   addSubscriber,
   cancelQuery,
@@ -77,6 +81,28 @@ export const getQueryKey = (options: QueryOptions): string => JSON.stringify(opt
 /** @beta */
 export const parseQueryKey = (key: string): QueryOptions => JSON.parse(key)
 
+/**
+ * Ensures the query key includes an effective perspective so that
+ * implicit differences (e.g. different instance.config.perspective)
+ * don't collide in the dataset-scoped store.
+ *
+ * Since perspectives are unique, we can depend on the release stacks
+ * to be correct when we retrieve the results.
+ *
+ */
+function normalizeOptionsWithPerspective(
+  instance: SanityInstance,
+  options: QueryOptions,
+): QueryOptions {
+  if (options.perspective !== undefined) return options
+  const instancePerspective = instance.config.perspective
+  return {
+    ...options,
+    perspective:
+      instancePerspective !== undefined ? instancePerspective : QUERY_STORE_DEFAULT_PERSPECTIVE,
+  }
+}
+
 const queryStore = defineStore<QueryStoreState>({
   name: 'QueryStore',
   getInitialState: () => ({queries: {}}),
@@ -255,16 +281,16 @@ export function getQueryState(
 const _getQueryState = bindActionByDataset(
   queryStore,
   createStateSourceAction({
-    selector: ({state}: SelectorContext<QueryStoreState>, options: QueryOptions) => {
+    selector: ({state, instance}: SelectorContext<QueryStoreState>, options: QueryOptions) => {
       if (state.error) throw state.error
-      const key = getQueryKey(options)
+      const key = getQueryKey(normalizeOptionsWithPerspective(instance, options))
       const queryState = state.queries[key]
       if (queryState?.error) throw queryState.error
       return queryState?.result
     },
-    onSubscribe: ({state}, options: QueryOptions) => {
+    onSubscribe: ({state, instance}, options: QueryOptions) => {
       const subscriptionId = insecureRandomId()
-      const key = getQueryKey(options)
+      const key = getQueryKey(normalizeOptionsWithPerspective(instance, options))
 
       state.set('addSubscriber', addSubscriber(key, subscriptionId))
 
@@ -314,8 +340,9 @@ export function resolveQuery(...args: Parameters<typeof _resolveQuery>): Promise
 const _resolveQuery = bindActionByDataset(
   queryStore,
   ({state, instance}, {signal, ...options}: ResolveQueryOptions) => {
-    const {getCurrent} = getQueryState(instance, options)
-    const key = getQueryKey(options)
+    const normalized = normalizeOptionsWithPerspective(instance, options)
+    const {getCurrent} = getQueryState(instance, normalized)
+    const key = getQueryKey(normalized)
 
     const aborted$ = signal
       ? new Observable<void>((observer) => {

package/src/query/queryStoreConstants.ts

@@ -7,3 +7,4 @@
  */
 export const QUERY_STATE_CLEAR_DELAY = 1000
 export const QUERY_STORE_API_VERSION = 'v2025-05-06'
+export const QUERY_STORE_DEFAULT_PERSPECTIVE = 'drafts'