@sanity/sdk-react 2.15.0 → 2.16.0

package/src/hooks/projects/useProject.ts

@@ -1,7 +1,14 @@
 import {getProjectState, type Project, type ProjectOptions, resolveProject} from '@sanity/sdk'
-import {identity} from 'rxjs'
 
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {useResolvedProjectId} from '../helpers/useResolvedProjectId'
+
+const useProjectBase = createStateSourceHook({
+  getState: getProjectState,
+  shouldSuspend: (instance, ...params) =>
+    getProjectState(instance, ...params).getCurrent() === undefined,
+  suspender: resolveProject,
+})
 
 /**
  * Returns metadata for a given project.
@@ -29,15 +36,18 @@ import {createStateSourceHook} from '../helpers/createStateSourceHook'
  * const projectWithoutMembers = useProject({projectId, includeMembers: false})
  * const projectWithoutFeatures = useProject({projectId, includeFeatures: false})
  * ```
+ * @remarks
+ * The `projectId` is resolved in order from:
+ * 1. an explicit `projectId` option
+ * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
+ * 3. The active resource (`ResourceProvider`/`SDKProvider`)
+ * 4. `instance.config`.
  * @public
  * @function
  */
-export const useProject = createStateSourceHook({
-  getState: getProjectState,
-  shouldSuspend: (instance, ...params) =>
-    getProjectState(instance, ...params).getCurrent() === undefined,
-  suspender: resolveProject,
-  getConfig: identity,
+export const useProject = ((options?: ProjectOptions<boolean, boolean>) => {
+  const projectId = useResolvedProjectId(options)
+  return useProjectBase(projectId ? {...options, projectId} : options)
 }) as <IncludeMembers extends boolean = true, IncludeFeatures extends boolean = true>(
   options?: ProjectOptions<IncludeMembers, IncludeFeatures>,
 ) => Project<IncludeMembers, IncludeFeatures>

package/src/hooks/users/useUsers.test.tsx

@@ -1,4 +1,5 @@
 import {
+  createSanityInstance,
   getUsersState,
   loadMoreUsers,
   resolveUsers,
@@ -6,12 +7,14 @@ import {
   type StateSource,
   type UserProfile,
 } from '@sanity/sdk'
-import {act, fireEvent, render, screen} from '@testing-library/react'
-import {useState} from 'react'
+import {act, fireEvent, render, renderHook, screen} from '@testing-library/react'
+import {type ReactNode, useState} from 'react'
 import {type Observable, Subject} from 'rxjs'
 import {describe, expect, it, vi} from 'vitest'
 
 import {ResourceProvider} from '../../context/ResourceProvider'
+import {SanityInstanceContext} from '../../context/SanityInstanceContext'
+import {useSanityInstance} from '../context/useSanityInstance'
 import {useUsers} from './useUsers'
 
 // Mock the functions from '@sanity/sdk'
@@ -335,4 +338,100 @@ describe('useUsers', () => {
       },
     )
   })
+
+  it('resolves the projectId from the default resource for a project-scoped query', () => {
+    vi.mocked(getUsersState).mockReturnValue({
+      getCurrent: vi.fn().mockReturnValue({data: mockUsers, hasMore: false, totalCount: 2}),
+      subscribe: vi.fn(),
+      get observable(): Observable<unknown> {
+        throw new Error('Not implemented')
+      },
+    } as unknown as StateSource<
+      {data: SanityUser[]; totalCount: number; hasMore: boolean} | undefined
+    >)
+
+    const {
+      result: {current: instance},
+    } = renderHook(
+      () => {
+        useUsers({resourceType: 'project'})
+        return useSanityInstance()
+      },
+      {
+        wrapper: ({children}: {children: ReactNode}) => (
+          <ResourceProvider
+            resource={{projectId: 'resource-project', dataset: 'production'}}
+            fallback={null}
+          >
+            {children}
+          </ResourceProvider>
+        ),
+      },
+    )
+
+    expect(getUsersState).toHaveBeenLastCalledWith(
+      instance,
+      expect.objectContaining({projectId: 'resource-project', resourceType: 'project'}),
+    )
+  })
+
+  it('does not inject a projectId for an organization-scoped query', () => {
+    vi.mocked(getUsersState).mockReturnValue({
+      getCurrent: vi.fn().mockReturnValue({data: mockUsers, hasMore: false, totalCount: 2}),
+      subscribe: vi.fn(),
+      get observable(): Observable<unknown> {
+        throw new Error('Not implemented')
+      },
+    } as unknown as StateSource<
+      {data: SanityUser[]; totalCount: number; hasMore: boolean} | undefined
+    >)
+
+    function TestComponent() {
+      useUsers({resourceType: 'organization', organizationId: 'test-org'})
+      return null
+    }
+
+    render(
+      <ResourceProvider
+        resource={{projectId: 'resource-project', dataset: 'production'}}
+        fallback={null}
+      >
+        <TestComponent />
+      </ResourceProvider>,
+    )
+
+    // Organization queries key off organizationId; the ambient project resource
+    // must not leak in as a projectId.
+    expect(vi.mocked(getUsersState).mock.lastCall?.[1]).not.toHaveProperty('projectId')
+  })
+
+  it('resolves a bare projectId from a ResourceProvider when the parent instance has no config', () => {
+    vi.mocked(getUsersState).mockReturnValue({
+      getCurrent: vi.fn().mockReturnValue({data: mockUsers, hasMore: false, totalCount: 2}),
+      subscribe: vi.fn(),
+      get observable(): Observable<unknown> {
+        throw new Error('Not implemented')
+      },
+    } as unknown as StateSource<
+      {data: SanityUser[]; totalCount: number; hasMore: boolean} | undefined
+    >)
+
+    // An instance with no project/dataset config, then a
+    // projectId-only ResourceProvider.
+    const emptyInstance = createSanityInstance({})
+    renderHook(() => useUsers(), {
+      wrapper: ({children}: {children: ReactNode}) => (
+        <SanityInstanceContext.Provider value={emptyInstance}>
+          <ResourceProvider projectId="bare-project" fallback={null}>
+            {children}
+          </ResourceProvider>
+        </SanityInstanceContext.Provider>
+      ),
+    })
+
+    expect(getUsersState).toHaveBeenLastCalledWith(
+      emptyInstance,
+      expect.objectContaining({projectId: 'bare-project'}),
+    )
+  })
 })

package/src/hooks/users/useUsers.ts

@@ -10,6 +10,7 @@ import {
 import {useCallback, useEffect, useMemo, useState, useSyncExternalStore, useTransition} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
+import {useResolvedProjectId} from '../helpers/useResolvedProjectId'
 import {trackHookUsage} from '../helpers/useTrackHookUsage'
 
 /**
@@ -36,6 +37,23 @@ export interface UsersResult {
   loadMore: () => void
 }
 
+/**
+ * Injects a resolved `projectId` into project-scoped users options. A missing
+ * `projectId` is a no-op, and organization-scoped queries (explicit
+ * `resourceType`/`organizationId`) or options that already carry a `projectId`
+ * are returned unchanged.
+ */
+function withResolvedProjectId(
+  options: GetUsersOptions | undefined,
+  projectId: string | undefined,
+): GetUsersOptions | undefined {
+  if (!projectId) return options
+  if (!options) return {projectId}
+  const isOrgScoped = options.resourceType === 'organization' || !!options.organizationId
+  if (isOrgScoped || options.projectId) return options
+  return {...options, projectId}
+}
+
 /**
  *
  * @public
@@ -67,6 +85,12 @@ export interface UsersResult {
  *   </div>
  * )
  * ```
+ * @remarks
+ * For project-scoped queries the `projectId` is resolved in order from:
+ * 1. an explicit `projectId` option
+ * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
+ * 3. The active resource (`ResourceProvider`/`SDKProvider`)
+ * 4. `instance.config`.
  */
 export function useUsers(options?: GetUsersOptions): UsersResult {
   const instance = useSanityInstance()
@@ -74,8 +98,16 @@ export function useUsers(options?: GetUsersOptions): UsersResult {
   // Use React's useTransition to avoid UI jank when user options change
   const [isPending, startTransition] = useTransition()
 
+  // Resolve the projectId from the ambient project/resource context so a
+  // project-scoped users request can pick it up rather than the top-level config.
+  const resolvedProjectId = useResolvedProjectId(options)
+  const effectiveOptions = useMemo(
+    () => withResolvedProjectId(options, resolvedProjectId),
+    [options, resolvedProjectId],
+  )
+
   // Get the unique key for this users request and its options
-  const key = getUsersKey(instance, options)
+  const key = getUsersKey(instance, effectiveOptions)
   // Use a deferred state to avoid immediate re-renders when the users request changes
   const [deferredKey, setDeferredKey] = useState(key)
   // Parse the deferred users key back into users options
@@ -115,8 +147,8 @@ export function useUsers(options?: GetUsersOptions): UsersResult {
   const {data, hasMore} = useSyncExternalStore(subscribe, getCurrent)!
 
   const loadMore = useCallback(() => {
-    loadMoreUsers(instance, options)
-  }, [instance, options])
+    loadMoreUsers(instance, effectiveOptions)
+  }, [instance, effectiveOptions])
 
   return {data, hasMore, isPending, loadMore}
 }

package/src/utils/resolveOrgResources.test.ts

@@ -0,0 +1,111 @@
+import {type SanityClient} from '@sanity/client'
+import {getClientState, type SanityInstance, type StateSource} from '@sanity/sdk'
+import {firstValueFrom} from 'rxjs'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {resolveOrgResources} from './resolveOrgResources'
+
+vi.mock('@sanity/sdk', () => ({
+  getClientState: vi.fn(),
+}))
+
+vi.mock('rxjs', () => ({
+  firstValueFrom: vi.fn(),
+}))
+
+const mockGetClientState = vi.mocked(getClientState)
+const mockFirstValueFrom = vi.mocked(firstValueFrom)
+
+const mockRequest = vi.fn()
+const mockClient = {request: mockRequest}
+const mockInstance = {} as SanityInstance
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mockGetClientState.mockReturnValue({
+    observable: 'mock-observable',
+  } as unknown as StateSource<SanityClient>)
+  mockFirstValueFrom.mockResolvedValue(mockClient as unknown as SanityClient)
+})
+
+const ORG_ID = 'org-1'
+
+describe('resolveOrgResources', () => {
+  it('returns both mediaLibrary and canvas when both requests succeed', async () => {
+    mockRequest
+      .mockResolvedValueOnce({data: [{id: 'ml-123'}]})
+      .mockResolvedValueOnce({data: [{id: 'canvas-456'}]})
+
+    const result = await resolveOrgResources(mockInstance, ORG_ID)
+
+    expect(result).toEqual({
+      mediaLibrary: {mediaLibraryId: 'ml-123'},
+      canvas: {canvasId: 'canvas-456'},
+    })
+  })
+
+  it('scopes both requests to the organization', async () => {
+    mockRequest
+      .mockResolvedValueOnce({data: [{id: 'ml-123'}]})
+      .mockResolvedValueOnce({data: [{id: 'canvas-456'}]})
+
+    await resolveOrgResources(mockInstance, ORG_ID)
+
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({uri: '/media-libraries', query: {organizationId: ORG_ID}}),
+    )
+    expect(mockRequest).toHaveBeenCalledWith(
+      expect.objectContaining({uri: '/canvases', query: {organizationId: ORG_ID}}),
+    )
+  })
+
+  it('returns only mediaLibrary when canvas request fails', async () => {
+    mockRequest
+      .mockResolvedValueOnce({data: [{id: 'ml-123'}]})
+      .mockRejectedValueOnce(new Error('canvas not found'))
+
+    const result = await resolveOrgResources(mockInstance, ORG_ID)
+
+    expect(result).toEqual({
+      mediaLibrary: {mediaLibraryId: 'ml-123'},
+      canvas: undefined,
+    })
+  })
+
+  it('returns only canvas when mediaLibrary request fails', async () => {
+    mockRequest
+      .mockRejectedValueOnce(new Error('media library not found'))
+      .mockResolvedValueOnce({data: [{id: 'canvas-456'}]})
+
+    const result = await resolveOrgResources(mockInstance, ORG_ID)
+
+    expect(result).toEqual({
+      mediaLibrary: undefined,
+      canvas: {canvasId: 'canvas-456'},
+    })
+  })
+
+  it('returns undefined for both when both requests fail', async () => {
+    mockRequest
+      .mockRejectedValueOnce(new Error('error 1'))
+      .mockRejectedValueOnce(new Error('error 2'))
+
+    const result = await resolveOrgResources(mockInstance, ORG_ID)
+
+    expect(result).toEqual({
+      mediaLibrary: undefined,
+      canvas: undefined,
+    })
+  })
+
+  it('returns undefined for both when data arrays are empty', async () => {
+    mockRequest.mockResolvedValueOnce({data: []}).mockResolvedValueOnce({data: []})
+
+    const result = await resolveOrgResources(mockInstance, ORG_ID)
+
+    expect(result).toEqual({
+      mediaLibrary: undefined,
+      canvas: undefined,
+    })
+  })
+})

package/src/utils/resolveOrgResources.ts

@@ -0,0 +1,69 @@
+import {
+  type CanvasResource,
+  getClientState,
+  type MediaLibraryResource,
+  type SanityInstance,
+} from '@sanity/sdk'
+import {firstValueFrom} from 'rxjs'
+
+const API_VERSION = 'v2026-07-09'
+
+interface OrgResourcesApiItem {
+  id: string
+}
+
+interface OrgResourcesApiResponse {
+  data: OrgResourcesApiItem[]
+}
+
+interface OrgResources {
+  mediaLibrary?: MediaLibraryResource
+  canvas?: CanvasResource
+}
+
+/**
+ * Gets the id of the first resource from a settled request result. The request
+ * is already scoped to a single organization, so the first item is the one we want.
+ */
+function getFirstResourceId(
+  result: PromiseSettledResult<OrgResourcesApiResponse>,
+): string | undefined {
+  if (result.status !== 'fulfilled') return undefined
+  return result.value.data?.[0]?.id
+}
+
+/**
+ * Fetches the media library and canvas resources for the given organization.
+ * Both requests are scoped to `organizationId` so each response contains only
+ * that org's resources. Each resource is fetched independently — a failure for
+ * one does not prevent the other from resolving.
+ */
+export async function resolveOrgResources(
+  instance: SanityInstance,
+  organizationId: string,
+): Promise<OrgResources> {
+  const client = await firstValueFrom(
+    getClientState(instance, {apiVersion: API_VERSION, scope: 'global'}).observable,
+  )
+
+  const [mediaLibrariesResult, canvasesResult] = await Promise.allSettled([
+    client.request<OrgResourcesApiResponse>({
+      uri: `/media-libraries`,
+      query: {organizationId},
+      tag: 'org-resources.media-libraries',
+    }),
+    client.request<OrgResourcesApiResponse>({
+      uri: `/canvases`,
+      query: {organizationId},
+      tag: 'org-resources.canvases',
+    }),
+  ])
+
+  const mediaLibraryId = getFirstResourceId(mediaLibrariesResult)
+  const canvasId = getFirstResourceId(canvasesResult)
+
+  return {
+    mediaLibrary: mediaLibraryId ? {mediaLibraryId} : undefined,
+    canvas: canvasId ? {canvasId} : undefined,
+  }
+}

package/src/hooks/datasets/useDatasets.test.ts

@@ -1,80 +0,0 @@
-import {getDatasetsState, type ProjectHandle, type SanityInstance} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
-
-// Mock dependencies
-vi.mock('@sanity/sdk', () => ({
-  getDatasetsState: vi.fn(() => ({
-    getCurrent: vi.fn(() => undefined), // Mocking getCurrent to satisfy the call within shouldSuspend
-  })),
-  resolveDatasets: vi.fn(),
-}))
-vi.mock('../helpers/createStateSourceHook', () => ({
-  createStateSourceHook: vi.fn(),
-}))
-
-describe('useDatasets', () => {
-  // Use beforeEach to reset modules and ensure mocks are fresh for each test
-  beforeEach(() => {
-    vi.resetModules()
-    // Re-mock dependencies for each test after resetModules
-    vi.mock('@sanity/sdk', () => ({
-      getDatasetsState: vi.fn(() => ({
-        getCurrent: vi.fn(() => undefined),
-      })),
-      resolveDatasets: vi.fn(),
-    }))
-    vi.mock('../helpers/createStateSourceHook', () => ({
-      createStateSourceHook: vi.fn(),
-    }))
-  })
-
-  it('should call createStateSourceHook with correct arguments on import', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
-    await import('./useDatasets')
-
-    // Check if createStateSourceHook was called during the module evaluation (import)
-    expect(createStateSourceHook).toHaveBeenCalled()
-    expect(createStateSourceHook).toHaveBeenCalledWith(
-      expect.objectContaining({
-        getState: expect.any(Function),
-        shouldSuspend: expect.any(Function),
-        suspender: expect.any(Function), // Actual function reference doesn't matter here as it's mocked
-        getConfig: expect.any(Function), // Actual function reference doesn't matter here
-      }),
-    )
-  })
-
-  it('shouldSuspend should call getDatasetsState and getCurrent', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
-    await import('./useDatasets')
-
-    // Get the arguments passed to createStateSourceHook
-    // Need to ensure createStateSourceHook mock is correctly typed for access
-    const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
-    expect(mockCreateStateSourceHook.mock.calls.length).toBeGreaterThan(0)
-    const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
-    const shouldSuspend = createStateSourceHookArgs.shouldSuspend
-
-    // Mock instance and projectHandle for the test call
-    const mockInstance = {} as SanityInstance // Use specific type
-    const mockProjectHandle = {} as ProjectHandle // Use specific type
-
-    // Call the shouldSuspend function
-    const result = shouldSuspend(mockInstance, mockProjectHandle)
-
-    // Assert that getDatasetsState was called with the correct arguments
-    // Need to ensure getDatasetsState mock is correctly typed for access
-    const mockGetDatasetsState = getDatasetsState as ReturnType<typeof vi.fn>
-    expect(mockGetDatasetsState).toHaveBeenCalledWith(mockInstance, mockProjectHandle)
-
-    // Assert that getCurrent was called on the result of getDatasetsState
-    expect(mockGetDatasetsState.mock.results.length).toBeGreaterThan(0)
-    const getDatasetsStateMockResult = mockGetDatasetsState.mock.results[0].value
-    expect(getDatasetsStateMockResult.getCurrent).toHaveBeenCalled()
-
-    // Assert the result of shouldSuspend based on the mocked getCurrent value
-    expect(result).toBe(true) // Since getCurrent is mocked to return undefined
-  })
-})

package/src/hooks/projects/useProject.test.ts

@@ -1,80 +0,0 @@
-import {getProjectState, type ProjectHandle, type SanityInstance} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
-
-// Mock dependencies
-vi.mock('@sanity/sdk', () => ({
-  getProjectState: vi.fn(() => ({
-    getCurrent: vi.fn(() => undefined), // Mocking getCurrent to satisfy the call within shouldSuspend
-  })),
-  resolveProject: vi.fn(),
-}))
-vi.mock('../helpers/createStateSourceHook', () => ({
-  createStateSourceHook: vi.fn(),
-}))
-
-describe('useProject', () => {
-  // Use beforeEach to reset modules and ensure mocks are fresh for each test
-  beforeEach(() => {
-    vi.resetModules()
-    // Re-mock dependencies for each test after resetModules
-    vi.mock('@sanity/sdk', () => ({
-      getProjectState: vi.fn(() => ({
-        getCurrent: vi.fn(() => undefined),
-      })),
-      resolveProject: vi.fn(),
-    }))
-    vi.mock('../helpers/createStateSourceHook', () => ({
-      createStateSourceHook: vi.fn(),
-    }))
-  })
-
-  it('should call createStateSourceHook with correct arguments on import', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
-    await import('./useProject')
-
-    // Check if createStateSourceHook was called during the module evaluation (import)
-    expect(createStateSourceHook).toHaveBeenCalled()
-    expect(createStateSourceHook).toHaveBeenCalledWith(
-      expect.objectContaining({
-        getState: expect.any(Function),
-        shouldSuspend: expect.any(Function),
-        suspender: expect.any(Function), // Actual function reference doesn't matter here as it's mocked
-        getConfig: expect.any(Function), // Actual function reference doesn't matter here
-      }),
-    )
-  })
-
-  it('shouldSuspend should call getProjectState and getCurrent', async () => {
-    // Dynamically import the hook *after* mocks are set up and modules reset
-    await import('./useProject')
-
-    // Get the arguments passed to createStateSourceHook
-    // Need to ensure createStateSourceHook mock is correctly typed for access
-    const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
-    expect(mockCreateStateSourceHook.mock.calls.length).toBeGreaterThan(0)
-    const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
-    const shouldSuspend = createStateSourceHookArgs.shouldSuspend
-
-    // Mock instance and projectHandle for the test call
-    const mockInstance = {} as SanityInstance // Use specific type
-    const mockProjectHandle = {} as ProjectHandle // Use specific type
-
-    // Call the shouldSuspend function
-    const result = shouldSuspend(mockInstance, mockProjectHandle)
-
-    // Assert that getProjectState was called with the correct arguments
-    // Need to ensure getProjectState mock is correctly typed for access
-    const mockGetProjectState = getProjectState as ReturnType<typeof vi.fn>
-    expect(mockGetProjectState).toHaveBeenCalledWith(mockInstance, mockProjectHandle)
-
-    // Assert that getCurrent was called on the result of getProjectState
-    expect(mockGetProjectState.mock.results.length).toBeGreaterThan(0)
-    const getProjectStateMockResult = mockGetProjectState.mock.results[0].value
-    expect(getProjectStateMockResult.getCurrent).toHaveBeenCalled()
-
-    // Assert the result of shouldSuspend based on the mocked getCurrent value
-    expect(result).toBe(true) // Since getCurrent is mocked to return undefined
-  })
-})