@sanity/sdk 2.1.0 → 2.1.1

package/src/presence/presenceStore.ts

@@ -0,0 +1,163 @@
+import {type SanityClient} from '@sanity/client'
+import {createSelector} from 'reselect'
+import {combineLatest, distinctUntilChanged, filter, map, of, Subscription, switchMap} from 'rxjs'
+
+import {getTokenState} from '../auth/authStore'
+import {getClient} from '../client/clientStore'
+import {bindActionByDataset} from '../store/createActionBinder'
+import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
+import {defineStore, type StoreContext} from '../store/defineStore'
+import {type SanityUser} from '../users/types'
+import {getUserState} from '../users/usersStore'
+import {createBifurTransport} from './bifurTransport'
+import {type PresenceLocation, type TransportEvent, type UserPresence} from './types'
+
+type PresenceStoreState = {
+  locations: Map<string, {userId: string; locations: PresenceLocation[]}>
+  users: Record<string, SanityUser | undefined>
+}
+
+const getInitialState = (): PresenceStoreState => ({
+  locations: new Map<string, {userId: string; locations: PresenceLocation[]}>(),
+  users: {},
+})
+
+/** @public */
+export const presenceStore = defineStore<PresenceStoreState>({
+  name: 'presence',
+  getInitialState,
+  initialize: (context: StoreContext<PresenceStoreState>) => {
+    const {instance, state} = context
+    const sessionId = crypto.randomUUID()
+
+    const client = getClient(instance, {
+      apiVersion: '2022-06-30',
+    })
+
+    const token$ = getTokenState(instance).observable.pipe(distinctUntilChanged())
+
+    const [incomingEvents$, dispatch] = createBifurTransport({
+      client: client as SanityClient,
+      token$,
+      sessionId,
+    })
+
+    const subscription = new Subscription()
+
+    subscription.add(
+      incomingEvents$.subscribe((event: TransportEvent) => {
+        if ('sessionId' in event && event.sessionId === sessionId) {
+          return
+        }
+
+        if (event.type === 'state') {
+          state.set('presence/state', (prevState: PresenceStoreState) => {
+            const newLocations = new Map(prevState.locations)
+            newLocations.set(event.sessionId, {
+              userId: event.userId,
+              locations: event.locations,
+            })
+
+            return {
+              ...prevState,
+              locations: newLocations,
+            }
+          })
+        } else if (event.type === 'disconnect') {
+          state.set('presence/disconnect', (prevState: PresenceStoreState) => {
+            const newLocations = new Map(prevState.locations)
+            newLocations.delete(event.sessionId)
+            return {...prevState, locations: newLocations}
+          })
+        }
+      }),
+    )
+
+    dispatch({type: 'rollCall'}).subscribe()
+
+    return () => {
+      dispatch({type: 'disconnect'}).subscribe()
+      subscription.unsubscribe()
+    }
+  },
+})
+
+const selectLocations = (state: PresenceStoreState) => state.locations
+const selectUsers = (state: PresenceStoreState) => state.users
+
+const selectPresence = createSelector(
+  selectLocations,
+  selectUsers,
+  (locations, users): UserPresence[] => {
+    return Array.from(locations.entries()).map(([sessionId, {userId, locations: locs}]) => {
+      const user = users[userId]
+
+      return {
+        user:
+          user ||
+          ({
+            id: userId,
+            displayName: 'Unknown user',
+            name: 'Unknown user',
+            email: '',
+          } as unknown as SanityUser),
+        sessionId,
+        locations: locs,
+      }
+    })
+  },
+)
+
+/** @public */
+export const getPresence = bindActionByDataset(
+  presenceStore,
+  createStateSourceAction({
+    selector: (context: SelectorContext<PresenceStoreState>): UserPresence[] =>
+      selectPresence(context.state),
+    onSubscribe: (context) => {
+      const userIds$ = context.state.observable.pipe(
+        map((state) =>
+          Array.from(state.locations.values())
+            .map((l) => l.userId)
+            .filter((id): id is string => !!id),
+        ),
+        distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i])),
+      )
+
+      const subscription = userIds$
+        .pipe(
+          switchMap((userIds) => {
+            if (userIds.length === 0) {
+              return of([])
+            }
+            const userObservables = userIds.map((userId) =>
+              getUserState(context.instance, {
+                userId,
+                resourceType: 'project',
+                projectId: context.instance.config.projectId,
+              }).pipe(filter((v): v is NonNullable<typeof v> => !!v)),
+            )
+            return combineLatest(userObservables)
+          }),
+        )
+        .subscribe((users) => {
+          if (!users) {
+            return
+          }
+          context.state.set('presence/users', (prevState) => ({
+            ...prevState,
+            users: {
+              ...prevState.users,
+              ...users.reduce<Record<string, SanityUser>>((acc, user) => {
+                if (user) {
+                  acc[user.profile.id] = user
+                }
+                return acc
+              }, {}),
+            },
+          }))
+        })
+      return () => subscription.unsubscribe()
+    },
+  }),
+)

package/src/presence/types.ts

@@ -0,0 +1,70 @@
+import {type SanityClient} from '@sanity/client'
+import {type Observable} from 'rxjs'
+
+import {type SanityUser} from '../users/types'
+
+/** @public */
+export interface PresenceLocation {
+  type: 'document'
+  documentId: string
+  path: string[]
+  lastActiveAt: string
+}
+
+/** @public */
+export interface UserPresence {
+  user: SanityUser
+  locations: PresenceLocation[]
+  sessionId: string
+}
+
+/** @public */
+export type PresenceTransport = [
+  incomingEvents$: Observable<TransportEvent>,
+  dispatchMessage: (message: TransportMessage) => Observable<void>,
+]
+
+/** @public */
+export type TransportEvent = RollCallEvent | StateEvent | DisconnectEvent
+
+/** @public */
+export interface RollCallEvent {
+  type: 'rollCall'
+  userId: string
+  sessionId: string
+}
+
+/** @public */
+export interface StateEvent {
+  type: 'state'
+  userId: string
+  sessionId: string
+  timestamp: string
+  locations: PresenceLocation[]
+}
+
+/** @public */
+export interface DisconnectEvent {
+  type: 'disconnect'
+  userId: string
+  sessionId: string
+  timestamp: string
+}
+
+/** @public */
+export type TransportMessage =
+  | {type: 'rollCall'}
+  | {type: 'state'; locations: PresenceLocation[]}
+  | {type: 'disconnect'}
+
+/** @public */
+export interface BifurTransportOptions {
+  client: SanityClient
+  token$: Observable<string | null>
+  sessionId: string
+}
+
+/** @public */
+export interface PresenceStore {
+  locations$: Observable<PresenceLocation[]>
+}

package/src/query/queryStore.test.ts

@@ -20,6 +20,7 @@ describe('queryStore', () => {
   let instance: SanityInstance
   let liveEvents: Subject<LiveEvent>
   let fetch: SanityClient['observable']['fetch']
+  let listen: SanityClient['observable']['listen']
   // Mock data for testing
   const mockData = {
     movies: [
@@ -37,6 +38,8 @@ describe('queryStore', () => {
         of({result: mockData.movies, syncTags: []}).pipe(delay(0)),
       ) as SanityClient['observable']['fetch']
 
+    listen = vi.fn().mockReturnValue(of(mockData.movies))
+
     liveEvents = new Subject<LiveEvent>()
 
     const events = vi.fn().mockReturnValue(liveEvents) as SanityClient['live']['events']
@@ -47,7 +50,7 @@ describe('queryStore', () => {
       observable: of({
         config,
         live: {events},
-        observable: {fetch},
+        observable: {fetch, listen},
       } as SanityClient),
     } as StateSource<SanityClient>)
   })

package/src/releases/releasesStore.test.ts

@@ -17,7 +17,7 @@ vi.mock('../utils/listenQuery', () => ({
 }))
 
 // Mock console.error to prevent test runner noise and allow verification
-const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+let consoleErrorSpy: ReturnType<typeof vi.spyOn>
 
 describe('releasesStore', () => {
   let instance: SanityInstance
@@ -25,7 +25,7 @@ describe('releasesStore', () => {
 
   beforeEach(() => {
     vi.resetAllMocks()
-    consoleErrorSpy.mockClear()
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
 
     instance = createSanityInstance({projectId: 'test', dataset: 'test'})
 
@@ -36,6 +36,7 @@ describe('releasesStore', () => {
 
   afterEach(() => {
     instance.dispose()
+    consoleErrorSpy.mockRestore()
   })
 
   it('should set active releases state when listenQuery succeeds', async () => {
@@ -63,6 +64,8 @@ describe('releasesStore', () => {
 
     expect(state.getCurrent()).toEqual(mockReleases.reverse())
     expect(consoleErrorSpy).not.toHaveBeenCalled()
+
+    vi.useRealTimers()
   })
 
   it('should update active releases state when listenQuery emits new data', async () => {

package/src/users/reducers.ts

@@ -12,11 +12,16 @@ export const getUsersKey = (
     organizationId,
     batchSize = DEFAULT_USERS_BATCH_SIZE,
     projectId = instance.config.projectId,
+    userId,
   }: GetUsersOptions = {},
 ): string =>
-  JSON.stringify({resourceType, organizationId, batchSize, projectId} satisfies ReturnType<
-    typeof parseUsersKey
-  >)
+  JSON.stringify({
+    resourceType,
+    organizationId,
+    batchSize,
+    projectId,
+    userId,
+  } satisfies ReturnType<typeof parseUsersKey>)
 
 /** @internal */
 export const parseUsersKey = (
@@ -26,6 +31,7 @@ export const parseUsersKey = (
   resourceType?: 'organization' | 'project'
   projectId?: string
   organizationId?: string
+  userId?: string
 } => JSON.parse(key)
 
 export const addSubscription =

package/src/users/types.ts

@@ -46,6 +46,7 @@ export interface GetUsersOptions extends ProjectHandle {
   resourceType?: 'organization' | 'project'
   batchSize?: number
   organizationId?: string
+  userId?: string
 }
 
 /**
@@ -83,3 +84,19 @@ export interface UsersStoreState {
 export interface ResolveUsersOptions extends GetUsersOptions {
   signal?: AbortSignal
 }
+
+/**
+ * @public
+ */
+export interface GetUserOptions extends ProjectHandle {
+  userId: string
+  resourceType?: 'organization' | 'project'
+  organizationId?: string
+}
+
+/**
+ * @public
+ */
+export interface ResolveUserOptions extends GetUserOptions {
+  signal?: AbortSignal
+}

package/src/users/usersConstants.ts

@@ -1,4 +1,5 @@
 // NOTE: currently this API is only available on vX
 export const API_VERSION = 'vX'
+export const PROJECT_API_VERSION = '2025-07-18'
 export const USERS_STATE_CLEAR_DELAY = 5000
 export const DEFAULT_USERS_BATCH_SIZE = 100

package/src/users/usersStore.test.ts

@@ -2,11 +2,18 @@ import {type SanityClient} from '@sanity/client'
 import {delay, filter, firstValueFrom, Observable, of} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {getClientState} from '../client/clientStore'
+import {getClient, getClientState} from '../client/clientStore'
 import {createSanityInstance} from '../store/createSanityInstance'
 import {type StateSource} from '../store/createStateSourceAction'
 import {type GetUsersOptions, type SanityUser, type SanityUserResponse} from './types'
-import {getUsersState, loadMoreUsers, resolveUsers} from './usersStore'
+import {
+  getUsersState,
+  getUserState,
+  loadMoreUsers,
+  type PatchedSanityUserFromClient,
+  resolveUser,
+  resolveUsers,
+} from './usersStore'
 
 vi.mock('./usersConstants', async (importOriginal) => ({
   ...(await importOriginal<typeof import('./usersConstants')>()),
@@ -64,13 +71,19 @@ describe('usersStore', () => {
   beforeEach(() => {
     request = vi.fn().mockReturnValue(of(mockResponse).pipe(delay(0)))
 
-    vi.mocked(getClientState).mockReturnValue({
-      observable: of({
-        observable: {
-          request,
-        },
-      } as SanityClient),
-    } as StateSource<SanityClient>)
+    vi.mocked(getClientState).mockImplementation(() => {
+      const client = {
+        observable: {request},
+      } as unknown as SanityClient
+      return {
+        observable: of(client),
+      } as StateSource<SanityClient>
+    })
+    vi.mocked(getClient).mockReturnValue({
+      observable: {
+        request,
+      },
+    } as unknown as SanityClient)
   })
 
   it('initializes users state and cleans up after unsubscribe', async () => {
@@ -391,4 +404,111 @@ describe('usersStore', () => {
     unsubscribe2()
     instance.dispose()
   })
+
+  describe('getUserState', () => {
+    beforeEach(() => {
+      // Clear all mocks between tests
+      vi.clearAllMocks()
+    })
+
+    it('fetches a single user with a project-scoped ID', async () => {
+      const instance = createSanityInstance({projectId: 'test', dataset: 'test'})
+      const projectUserId = 'p12345'
+      const mockProjectUser: PatchedSanityUserFromClient = {
+        id: projectUserId,
+        sanityUserId: projectUserId,
+        displayName: 'Project User',
+        createdAt: '2023-01-01T00:00:00Z',
+        updatedAt: '2023-01-01T00:00:00Z',
+        isCurrentUser: false,
+        projectId: 'project1',
+        familyName: null,
+        givenName: null,
+        middleName: null,
+        imageUrl: null,
+        email: 'project@example.com',
+        provider: 'google',
+      }
+
+      const specificRequest = vi.fn().mockReturnValue(of(mockProjectUser).pipe(delay(0)))
+      vi.mocked(getClient).mockReturnValue({
+        observable: {
+          request: specificRequest,
+        },
+      } as unknown as SanityClient)
+
+      const user$ = getUserState(instance, {userId: projectUserId, projectId: 'project1'})
+
+      const result = await firstValueFrom(user$.pipe(filter((i) => i !== undefined)))
+
+      expect(getClient).toHaveBeenCalledWith(
+        instance,
+        expect.objectContaining({
+          projectId: 'project1',
+          useProjectHostname: true,
+        }),
+      )
+      expect(specificRequest).toHaveBeenCalledWith({
+        method: 'GET',
+        uri: `/users/${projectUserId}`,
+      })
+
+      const expectedUser: SanityUser = {
+        sanityUserId: projectUserId,
+        profile: {
+          id: projectUserId,
+          displayName: 'Project User',
+          familyName: undefined,
+          givenName: undefined,
+          middleName: undefined,
+          imageUrl: undefined,
+          createdAt: '2023-01-01T00:00:00Z',
+          updatedAt: '2023-01-01T00:00:00Z',
+          isCurrentUser: false,
+          email: 'project@example.com',
+          provider: 'google',
+        },
+        memberships: [],
+      }
+      expect(result).toEqual(expectedUser)
+
+      instance.dispose()
+    })
+
+    it('fetches a single user with a global-scoped ID', async () => {
+      const instance = createSanityInstance({
+        projectId: 'test',
+        dataset: 'test',
+      })
+      const globalUserId = 'g12345'
+      const mockGlobalUser: SanityUser = {
+        sanityUserId: globalUserId,
+        profile: {
+          id: 'profile-g1',
+          displayName: 'Global User',
+          email: 'global@example.com',
+          provider: 'google',
+          createdAt: '2023-01-01T00:00:00Z',
+        },
+        memberships: [],
+      }
+      const mockGlobalUserResponse: SanityUserResponse = {
+        data: [mockGlobalUser],
+        totalCount: 1,
+        nextCursor: null,
+      }
+
+      // Mock the request to return the global user response
+      vi.mocked(request).mockReturnValue(of(mockGlobalUserResponse))
+
+      const result = await resolveUser(instance, {
+        userId: globalUserId,
+        projectId: 'project1',
+      })
+
+      expect(result).toEqual(mockGlobalUser)
+
+      instance.dispose()
+    })
+  })
 })

package/src/users/usersStore.ts

@@ -1,3 +1,4 @@
+import {type SanityUser as SanityUserFromClient} from '@sanity/client'
 import {createSelector} from 'reselect'
 import {
   catchError,
@@ -24,7 +25,7 @@ import {
 } from 'rxjs'
 
 import {getDashboardOrganizationId} from '../auth/authStore'
-import {getClientState} from '../client/clientStore'
+import {getClient, getClientState} from '../client/clientStore'
 import {bindActionGlobally} from '../store/createActionBinder'
 import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
 import {type StoreState} from '../store/createStoreState'
@@ -42,12 +43,23 @@ import {
   updateLastLoadMoreRequest,
 } from './reducers'
 import {
+  type GetUserOptions,
   type GetUsersOptions,
+  type ResolveUserOptions,
   type ResolveUsersOptions,
+  type SanityUser,
   type SanityUserResponse,
   type UsersStoreState,
 } from './types'
-import {API_VERSION, USERS_STATE_CLEAR_DELAY} from './usersConstants'
+import {API_VERSION, PROJECT_API_VERSION, USERS_STATE_CLEAR_DELAY} from './usersConstants'
+
+/** @internal */
+export type PatchedSanityUserFromClient = Omit<SanityUserFromClient, 'id'> & {
+  id: string
+  sanityUserId: string
+  email: string
+  provider: string
+}
 
 /**
  * The users store resource that manages user data fetching and state.
@@ -100,9 +112,98 @@ const listenForLoadMoreAndFetch = ({state, instance}: StoreContext<UsersStoreSta
         group$.pipe(
           switchMap((e) => {
             if (!e.added) return EMPTY
-            const {batchSize, ...options} = parseUsersKey(group$.key)
+            const {userId, batchSize, ...options} = parseUsersKey(group$.key)
+
+            if (userId) {
+              // In the future we will be able to fetch a user from the global API using the resourceUserId,
+              // but for now we need to use the project subdomain to fetch a user if the userId is a project user (starts with "p")
+              if (userId.startsWith('p')) {
+                const client = getClient(instance, {
+                  apiVersion: PROJECT_API_VERSION,
+                  // this is a global store, so we need to use the projectId from the options when we're fetching
+                  // users from a project subdomain
+                  projectId: options.projectId,
+                  useProjectHostname: true,
+                })
 
-            const projectId = options.projectId ?? instance.config.projectId
+                return client.observable
+                  .request<PatchedSanityUserFromClient>({
+                    method: 'GET',
+                    uri: `/users/${userId}`,
+                  })
+                  .pipe(
+                    map((user) => {
+                      // We need to convert the user to the format we expect
+                      const convertedUser: SanityUser = {
+                        sanityUserId: user.sanityUserId,
+                        profile: {
+                          id: user.id,
+                          displayName: user.displayName,
+                          familyName: user.familyName ?? undefined,
+                          givenName: user.givenName ?? undefined,
+                          middleName: user.middleName ?? undefined,
+                          imageUrl: user.imageUrl ?? undefined,
+                          createdAt: user.createdAt,
+                          updatedAt: user.updatedAt,
+                          isCurrentUser: user.isCurrentUser,
+                          email: user.email,
+                          provider: user.provider,
+                        },
+                        memberships: [],
+                      }
+                      return {
+                        data: [convertedUser],
+                        totalCount: 1,
+                        nextCursor: null,
+                      }
+                    }),
+                    catchError((error) => {
+                      state.set('setUsersError', setUsersError(group$.key, error))
+                      return EMPTY
+                    }),
+                    tap((response) =>
+                      state.set('setUsersData', setUsersData(group$.key, response)),
+                    ),
+                  )
+              }
+
+              // Fetch the user from the global API
+              const scope = userId.startsWith('g') ? 'global' : undefined
+              const client = getClient(instance, {
+                scope,
+                apiVersion: API_VERSION,
+              })
+              const resourceType = options.resourceType || 'project'
+              const resourceId =
+                resourceType === 'organization' ? options.organizationId : options.projectId
+              if (!resourceId) {
+                return throwError(() => new Error('An organizationId or a projectId is required'))
+              }
+              return client.observable
+                .request<SanityUser | SanityUserResponse>({
+                  method: 'GET',
+                  uri: `access/${resourceType}/${resourceId}/users/${userId}`,
+                })
+                .pipe(
+                  map((response) => {
+                    // If the response is a single user object (has sanityUserId), wrap it in the expected format
+                    if ('sanityUserId' in response) {
+                      return {
+                        data: [response],
+                        totalCount: 1,
+                        nextCursor: null,
+                      } as SanityUserResponse
+                    }
+                    return response as SanityUserResponse
+                  }),
+                  catchError((error) => {
+                    state.set('setUsersError', setUsersError(group$.key, error))
+                    return EMPTY
+                  }),
+                  tap((response) => state.set('setUsersData', setUsersData(group$.key, response))),
+                )
+            }
+            const projectId = options.projectId
 
             // the resource type this request will use
             // If resourceType is explicitly provided, use it
@@ -313,3 +414,30 @@ export const loadMoreUsers = bindActionGlobally(
     return await promise
   },
 )
+
+/**
+ * @beta
+ */
+export const getUserState = bindActionGlobally(
+  usersStore,
+  ({instance}, {userId, ...options}: GetUserOptions) => {
+    return getUsersState(instance, {userId, ...options}).observable.pipe(
+      map((res) => res?.data[0]),
+      distinctUntilChanged((a, b) => a?.profile.updatedAt === b?.profile.updatedAt),
+    )
+  },
+)
+
+/**
+ * @beta
+ */
+export const resolveUser = bindActionGlobally(
+  usersStore,
+  async ({instance}, {signal, ...options}: ResolveUserOptions) => {
+    const result = await resolveUsers(instance, {
+      signal,
+      ...options,
+    })
+    return result?.data[0]
+  },
+)