@sanity/sdk-react 2.14.1 → 2.16.0

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
-  })
-})