@sanity/sdk-react 3.0.0-rc.0 → 3.0.0-rc.2

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/context/useDefaultResource.test.tsx

@@ -1,25 +0,0 @@
-import {renderHook} from '@testing-library/react'
-import {describe, expect, it} from 'vitest'
-
-import {ResourceContext} from '../../context/DefaultResourceContext'
-import {useResource} from './useDefaultResource'
-
-describe('useResource', () => {
-  it('returns the resource from context', () => {
-    const resource = {projectId: 'my-project', dataset: 'my-dataset'}
-
-    const {result} = renderHook(() => useResource(), {
-      wrapper: ({children}) => (
-        <ResourceContext.Provider value={resource}>{children}</ResourceContext.Provider>
-      ),
-    })
-
-    expect(result.current).toBe(resource)
-  })
-
-  it('returns undefined when no resource is in context', () => {
-    const {result} = renderHook(() => useResource())
-
-    expect(result.current).toBeUndefined()
-  })
-})

package/src/hooks/context/useDefaultResource.ts

@@ -1,30 +0,0 @@
-import {type DocumentResource} from '@sanity/sdk'
-import {useContext} from 'react'
-
-import {ResourceContext} from '../../context/DefaultResourceContext'
-
-/**
- * Returns the current {@link DocumentResource} from context.
- *
- * @public
- *
- * @category Platform
- * @returns The resource set by the nearest `ResourceProvider`, or `undefined`
- *
- * @remarks
- * With the flat instance model, nested `ResourceProvider`s override the
- * active resource via React context rather than creating child instances.
- * Use this hook when you need the current project/dataset/resource for a
- * subtree instead of reading from `useSanityInstance().config`.
- *
- * @example Get the current resource
- * ```tsx
- * const resource = useResource()
- * if (resource && 'projectId' in resource) {
- *   console.log(resource.projectId, resource.dataset)
- * }
- * ```
- */
-export function useResource(): DocumentResource | undefined {
-  return useContext(ResourceContext)
-}

package/src/hooks/dashboard/useDispatchIntent.test.ts

@@ -1,254 +0,0 @@
-import {type DocumentHandle} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {renderHook} from '../../../test/test-utils'
-import {useDispatchIntent} from './useDispatchIntent'
-
-// Mock the useWindowConnection hook
-const mockSendMessage = vi.fn()
-vi.mock('../comlink/useWindowConnection', () => ({
-  useWindowConnection: vi.fn(() => ({
-    sendMessage: mockSendMessage,
-  })),
-}))
-
-describe('useDispatchIntent', () => {
-  const mockDocumentHandle: DocumentHandle = {
-    documentId: 'test-document-id',
-    documentType: 'test-document-type',
-    resource: {projectId: 'test-project-id', dataset: 'test-dataset'},
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    // Reset mock implementation to default behavior
-    mockSendMessage.mockImplementation(() => {})
-  })
-
-  it('should return dispatchIntent function', () => {
-    const {result} = renderHook(() =>
-      useDispatchIntent({action: 'edit', documentHandle: mockDocumentHandle}),
-    )
-
-    expect(result.current).toEqual({
-      dispatchIntent: expect.any(Function),
-    })
-  })
-
-  it('should throw error when neither action nor intentId is provided', () => {
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const {result} = renderHook(() => useDispatchIntent({documentHandle: mockDocumentHandle}))
-
-    expect(() => result.current.dispatchIntent()).toThrow(
-      'useDispatchIntent: Either `action` or `intentId` must be provided.',
-    )
-    consoleErrorSpy.mockRestore()
-  })
-
-  it('should handle errors gracefully', () => {
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    mockSendMessage.mockImplementation(() => {
-      throw new Error('Test error')
-    })
-
-    const {result} = renderHook(() =>
-      useDispatchIntent({action: 'edit', documentHandle: mockDocumentHandle}),
-    )
-
-    expect(() => result.current.dispatchIntent()).toThrow('Test error')
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Failed to dispatch intent:', expect.any(Error))
-
-    consoleErrorSpy.mockRestore()
-  })
-
-  it('should use memoized dispatchIntent function', () => {
-    const params = {action: 'edit' as const, documentHandle: mockDocumentHandle}
-    const {result, rerender} = renderHook(
-      ({params: hookParams}: {params: typeof params}) => useDispatchIntent(hookParams),
-      {
-        initialProps: {params},
-      },
-    )
-
-    const firstDispatchIntent = result.current.dispatchIntent
-
-    // Rerender with the same params
-    rerender({params: {action: 'edit' as const, documentHandle: mockDocumentHandle}})
-
-    expect(result.current.dispatchIntent).toBe(firstDispatchIntent)
-  })
-
-  it('should create new dispatchIntent function when documentHandle changes', () => {
-    const {result, rerender} = renderHook(
-      (params: {action: 'edit'; documentHandle: DocumentHandle}) => useDispatchIntent(params),
-      {
-        initialProps: {action: 'edit' as const, documentHandle: mockDocumentHandle},
-      },
-    )
-
-    const firstDispatchIntent = result.current.dispatchIntent
-
-    const newDocumentHandle: DocumentHandle = {
-      documentId: 'new-document-id',
-      documentType: 'new-document-type',
-      resource: {projectId: 'new-project-id', dataset: 'new-dataset'},
-    }
-
-    rerender({action: 'edit' as const, documentHandle: newDocumentHandle})
-
-    expect(result.current.dispatchIntent).not.toBe(firstDispatchIntent)
-  })
-
-  it('should warn if both action and intentId are provided', () => {
-    const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        action: 'edit' as const,
-        intentId: 'custom-intent' as never, // test runtime error when both are provided
-        documentHandle: mockDocumentHandle,
-      }),
-    )
-    result.current.dispatchIntent()
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      'useDispatchIntent: Both `action` and `intentId` were provided. Using `intentId` and ignoring `action`.',
-    )
-    consoleWarnSpy.mockRestore()
-  })
-
-  it('should send intent message with action and params when both are provided', () => {
-    const intentParams = {view: 'editor', tab: 'content'}
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        action: 'edit',
-        documentHandle: mockDocumentHandle,
-        parameters: intentParams,
-      }),
-    )
-
-    result.current.dispatchIntent()
-
-    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-      action: 'edit',
-      document: {
-        id: 'test-document-id',
-        type: 'test-document-type',
-      },
-      resource: {
-        id: 'test-project-id.test-dataset',
-      },
-      parameters: intentParams,
-    })
-  })
-
-  it('should send intent message with intentId and params when both are provided', () => {
-    const intentParams = {view: 'editor', tab: 'content'}
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        intentId: 'custom-intent',
-        documentHandle: mockDocumentHandle,
-        parameters: intentParams,
-      }),
-    )
-
-    result.current.dispatchIntent()
-
-    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-      intentId: 'custom-intent',
-      document: {
-        id: 'test-document-id',
-        type: 'test-document-type',
-      },
-      resource: {
-        id: 'test-project-id.test-dataset',
-      },
-      parameters: intentParams,
-    })
-  })
-
-  it('should send intent message with media library resource', () => {
-    const mockMediaLibraryHandle = {
-      documentId: 'test-asset-id',
-      documentType: 'sanity.asset',
-      resourceName: 'media-library',
-    } as const
-
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        action: 'edit',
-        documentHandle: mockMediaLibraryHandle,
-      }),
-    )
-
-    result.current.dispatchIntent()
-
-    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-      action: 'edit',
-      document: {
-        id: 'test-asset-id',
-        type: 'sanity.asset',
-      },
-      resource: {
-        id: 'media-library-id',
-        type: 'media-library',
-      },
-    })
-  })
-
-  it('should send intent message with canvas resource', () => {
-    const mockCanvasHandle = {
-      documentId: 'test-canvas-document-id',
-      documentType: 'sanity.canvas.document',
-      resourceName: 'canvas',
-    } as const
-
-    const {result} = renderHook(() =>
-      useDispatchIntent({
-        action: 'edit',
-        documentHandle: mockCanvasHandle,
-      }),
-    )
-
-    result.current.dispatchIntent()
-
-    expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-      action: 'edit',
-      document: {
-        id: 'test-canvas-document-id',
-        type: 'sanity.canvas.document',
-      },
-      resource: {
-        id: 'canvas-id',
-        type: 'canvas',
-      },
-    })
-  })
-
-  describe('default resource fallback', () => {
-    it('should use default resource from context when handle has no explicit targeting', () => {
-      const minimalHandle = {
-        documentId: 'test-document-id',
-        documentType: 'test-document-type',
-      }
-
-      const {result} = renderHook(() =>
-        useDispatchIntent({
-          action: 'edit',
-          documentHandle: minimalHandle as unknown as DocumentHandle,
-        }),
-      )
-
-      result.current.dispatchIntent()
-
-      expect(mockSendMessage).toHaveBeenCalledWith('dashboard/v1/events/intents/dispatch-intent', {
-        action: 'edit',
-        document: {
-          id: 'test-document-id',
-          type: 'test-document-type',
-        },
-        resource: {
-          id: 'test.test',
-        },
-      })
-    })
-  })
-})

package/src/hooks/dashboard/useDispatchIntent.ts

@@ -1,157 +0,0 @@
-import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
-import {type FrameMessage} from '@sanity/sdk'
-import {useCallback} from 'react'
-
-import {type DocumentHandle} from '../../config/handles'
-import {useWindowConnection} from '../comlink/useWindowConnection'
-import {useResourceIdFromDocumentHandle} from './utils/useResourceIdFromDocumentHandle'
-
-/**
- * Message type for sending intents to the dashboard
- * @beta
- */
-interface IntentMessage {
-  type: 'dashboard/v1/events/intents/dispatch-intent'
-  data: {
-    action?: 'edit'
-    intentId?: string
-    document: {
-      id: string
-      type: string
-    }
-    resource?: {
-      id: string
-      type?: 'media-library' | 'canvas'
-    }
-    parameters?: Record<string, unknown>
-  }
-}
-
-/**
- * Return type for the useDispatchIntent hook
- * @beta
- */
-interface DispatchIntent {
-  dispatchIntent: () => void
-}
-
-/**
- * Parameters for the useDispatchIntent hook
- * @beta
- */
-interface UseDispatchIntentParams {
-  action?: 'edit'
-  intentId?: string
-  documentHandle: DocumentHandle
-  parameters?: Record<string, unknown>
-}
-
-/**
- * @beta
- *
- * A hook for dispatching intent messages to the Dashboard with a document handle.
- * This allows applications to signal their intent to pass the referenced document to other applications that have registered the ability to perform specific actions on that document.
- *
- * @param params - Object containing:
- *   - `action` - Action to perform (currently only 'edit' is supported). Will prompt a picker if multiple handlers are available.
- *   - `intentId` - Specific ID of the intent to dispatch. Either `action` or `intentId` is required.
- *   - `documentHandle` - The document handle containing document ID, type, and either:
- *     - `projectId` and `dataset` for traditional dataset resources, like `{documentId: '123', documentType: 'book', projectId: 'abc123', dataset: 'production'}`
- *     - `resource` for media library, canvas, or dataset resources, like `{documentId: '123', documentType: 'sanity.asset', resource: mediaLibraryResource('ml123')}` or `{documentId: '123', documentType: 'sanity.canvas.document', resource: canvasResource('canvas123')}`
- *   - `paremeters` - Optional parameters to include in the dispatch; will be passed to the resolved intent handler
- * @returns An object containing:
- * - `dispatchIntent` - Function to dispatch the intent message
- *
- * @example
- * ```tsx
- * import {useDispatchIntent} from '@sanity/sdk-react'
- * import {Button} from '@sanity/ui'
- * import {Suspense} from 'react'
- *
- * function DispatchIntentButton({documentId, documentType, projectId, dataset}) {
- *   const {dispatchIntent} = useDispatchIntent({
- *     action: 'edit',
- *     documentHandle: {documentId, documentType, projectId, dataset},
- *   })
- *
- *   return (
- *     <Button
- *       onClick={() => dispatchIntent()}
- *       text="Dispatch Intent"
- *     />
- *   )
- * }
- *
- * // Wrap the component with Suspense since the hook may suspend
- * function MyDocumentAction({documentId, documentType, projectId, dataset}) {
- *   return (
- *     <Suspense fallback={<Button text="Loading..." disabled />}>
- *       <DispatchIntentButton
- *         documentId={documentId}
- *         documentType={documentType}
- *         projectId={projectId}
- *         dataset={dataset}
- *       />
- *     </Suspense>
- *   )
- * }
- * ```
- */
-export function useDispatchIntent(params: UseDispatchIntentParams): DispatchIntent {
-  const {action, intentId, documentHandle, parameters} = params
-  const {sendMessage} = useWindowConnection<IntentMessage, FrameMessage>({
-    name: SDK_NODE_NAME,
-    connectTo: SDK_CHANNEL_NAME,
-  })
-
-  const resource = useResourceIdFromDocumentHandle(documentHandle)
-
-  const dispatchIntent = useCallback(() => {
-    try {
-      if (!action && !intentId) {
-        throw new Error('useDispatchIntent: Either `action` or `intentId` must be provided.')
-      }
-
-      if (action && intentId) {
-        // eslint-disable-next-line no-console -- warn if both action and intentId are provided
-        console.warn(
-          'useDispatchIntent: Both `action` and `intentId` were provided. Using `intentId` and ignoring `action`.',
-        )
-      }
-
-      // Validate that we have a resource ID (which is computed from resource/resourceName or projectId+dataset)
-      if (!resource.id) {
-        throw new Error(
-          'useDispatchIntent: Unable to determine resource. Either `resource`, `resourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
-        )
-      }
-
-      const message: IntentMessage = {
-        type: 'dashboard/v1/events/intents/dispatch-intent',
-        data: {
-          ...(action && !intentId ? {action} : {}),
-          ...(intentId ? {intentId} : {}),
-          document: {
-            id: documentHandle.documentId,
-            type: documentHandle.documentType,
-          },
-          resource: {
-            id: resource.id,
-            ...(resource.type ? {type: resource.type} : {}),
-          },
-          ...(parameters && Object.keys(parameters).length > 0 ? {parameters} : {}),
-        },
-      }
-
-      sendMessage(message.type, message.data)
-    } catch (error) {
-      // eslint-disable-next-line no-console
-      console.error('Failed to dispatch intent:', error)
-      throw error
-    }
-  }, [action, intentId, documentHandle, parameters, sendMessage, resource.id, resource.type])
-
-  return {
-    dispatchIntent,
-  }
-}