feat(core): allow a userId option for the user store (#580)

* feat(core): allow a userId option for the user store

---------

Co-authored-by: Carolina Gonzalez <[email protected]>

Author: ryanbonial

knip.config.ts

@@ -12,7 +12,7 @@ const baseConfig = {
         config: 'tsconfig.tsdoc.json',
       },
       // Knip doesn't support pnpm version
-      ignoreBinaries: ['version', 'sed'],
+      ignoreBinaries: ['version', 'sed', 'open'],
       entry: ['package.config.ts', 'vitest.config.mts'],
     },
     'scripts/*': {

package.json

@@ -34,6 +34,7 @@
     "prepare": "husky",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
+    "test:coverage:open": "open coverage/index.html",
     "test:e2e": "turbo run test:e2e",
     "test:watch": "vitest watch",
     "ts:check": "turbo run ts:check --filter='./packages/*' --filter='./apps/*'",

packages/core/src/_exports/index.ts

@@ -127,13 +127,24 @@ export {createSanityInstance, type SanityInstance} from '../store/createSanityIn
 export {type Selector, type StateSource} from '../store/createStateSourceAction'
 export {getUsersKey, parseUsersKey} from '../users/reducers'
 export {
+  type GetUserOptions,
   type GetUsersOptions,
   type Membership,
+  type ResolveUserOptions,
   type ResolveUsersOptions,
   type SanityUser,
+  type SanityUserResponse,
   type UserProfile,
+  type UsersGroupState,
+  type UsersStoreState,
 } from '../users/types'
-export {getUsersState, loadMoreUsers, resolveUsers} from '../users/usersStore'
+export {
+  getUsersState,
+  getUserState,
+  loadMoreUsers,
+  resolveUser,
+  resolveUsers,
+} from '../users/usersStore'
 export {type FetcherStore, type FetcherStoreState} from '../utils/createFetcherStore'
 export {createGroqSearchFilter} from '../utils/createGroqSearchFilter'
 export {CORE_SDK_VERSION} from '../version'

packages/core/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 =

packages/core/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
+}

packages/core/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

packages/core/src/users/usersStore.test.ts

@@ -1,12 +1,12 @@
-import {type SanityClient} from '@sanity/client'
+import {type SanityClient, type SanityUser as SanityUserFromClient} 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, resolveUser, resolveUsers} from './usersStore'
 
 vi.mock('./usersConstants', async (importOriginal) => ({
   ...(await importOriginal<typeof import('./usersConstants')>()),
@@ -64,13 +64,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 +397,108 @@ 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: SanityUserFromClient = {
+        id: 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,
+      }
+
+      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: '',
+          provider: '',
+        },
+        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: '[email protected]',
+          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()
+    })
+  })
 })