@sanity/sdk-react 0.0.0-alpha.20 → 0.0.0-alpha.4

package/src/hooks/dashboard/useNavigateToStudioDocument.ts

@@ -1,97 +0,0 @@
-import {type Status} from '@sanity/comlink'
-import {type DocumentHandle} from '@sanity/sdk'
-import {useCallback, useState} from 'react'
-
-import {useWindowConnection} from '../comlink/useWindowConnection'
-import {useStudioWorkspacesByResourceId} from './useStudioWorkspacesByResourceId'
-
-interface NavigateToResourceMessage {
-  type: 'core/v1/bridge/navigate-to-resource'
-  data: {
-    /**
-     * Resource ID
-     */
-    resourceId: string
-    /**
-     * Resource type
-     * @example 'application' | 'studio'
-     */
-    resourceType: string
-    /**
-     * Path within the resource to navigate to.
-     */
-    path?: string
-  }
-}
-
-interface NavigateToStudioResult {
-  navigateToStudioDocument: () => void
-  isConnected: boolean
-}
-
-/**
- * @public
- * Hook that provides a function to navigate to a studio document.
- * @param documentHandle - The document handle containing document ID, type, and resource ID
- * @returns An object containing:
- * - navigateToStudioDocument - Function that when called will navigate to the studio document
- * - isConnected - Boolean indicating if connection to Core UI is established
- */
-export function useNavigateToStudioDocument(
-  documentHandle: DocumentHandle,
-): NavigateToStudioResult {
-  const {workspacesByResourceId, isConnected: workspacesConnected} =
-    useStudioWorkspacesByResourceId()
-  const [status, setStatus] = useState<Status>('idle')
-  const {sendMessage} = useWindowConnection<NavigateToResourceMessage, never>({
-    name: 'core/nodes/sdk',
-    connectTo: 'core/channels/sdk',
-    onStatus: setStatus,
-  })
-
-  const navigateToStudioDocument = useCallback(() => {
-    if (!workspacesConnected || status !== 'connected' || !documentHandle.resourceId) {
-      return
-    }
-
-    // Extract projectId and dataset from the resourceId (current format: document:projectId.dataset:documentId)
-    const [, projectAndDataset] = documentHandle.resourceId.split(':')
-    const [projectId, dataset] = projectAndDataset.split('.')
-    if (!projectId || !dataset) {
-      return
-    }
-
-    // Find the workspace for this document
-    const workspaces = workspacesByResourceId[`${projectId}:${dataset}`]
-    if (!workspaces?.length) {
-      // eslint-disable-next-line no-console
-      console.warn('No workspace found for document', documentHandle.resourceId)
-      return
-    }
-
-    if (workspaces.length > 1) {
-      // eslint-disable-next-line no-console
-      console.warn('Multiple workspaces found for document', documentHandle.resourceId)
-      // eslint-disable-next-line no-console
-      console.warn('Using the first one', workspaces[0])
-    }
-
-    const workspace = workspaces[0]
-
-    const message: NavigateToResourceMessage = {
-      type: 'core/v1/bridge/navigate-to-resource',
-      data: {
-        resourceId: workspace._ref,
-        resourceType: 'studio',
-        path: `/intent/edit/id=${documentHandle._id};type=${documentHandle._type}`,
-      },
-    }
-
-    sendMessage(message.type, message.data)
-  }, [documentHandle, workspacesConnected, status, sendMessage, workspacesByResourceId])
-
-  return {
-    navigateToStudioDocument,
-    isConnected: workspacesConnected && status === 'connected',
-  }
-}

package/src/hooks/dashboard/useStudioWorkspacesByResourceId.test.tsx

@@ -1,274 +0,0 @@
-import {type Message, type Status} from '@sanity/comlink'
-import {renderHook, waitFor} from '@testing-library/react'
-import {describe, expect, it, vi} from 'vitest'
-
-import {useWindowConnection, type WindowConnection} from '../comlink/useWindowConnection'
-import {useStudioWorkspacesByResourceId} from './useStudioWorkspacesByResourceId'
-
-vi.mock('../comlink/useWindowConnection', () => ({
-  useWindowConnection: vi.fn(),
-}))
-
-const mockWorkspaceData = {
-  context: {
-    availableResources: [
-      {
-        projectId: 'project1',
-        workspaces: [
-          {
-            name: 'workspace1',
-            title: 'Workspace 1',
-            basePath: '/workspace1',
-            dataset: 'dataset1',
-            userApplicationId: 'user1',
-            url: 'https://test.sanity.studio',
-            _ref: 'user1-workspace1',
-          },
-          {
-            name: 'workspace2',
-            title: 'Workspace 2',
-            basePath: '/workspace2',
-            dataset: 'dataset1',
-            userApplicationId: 'user1',
-            url: 'https://test.sanity.studio',
-            _ref: 'user1-workspace2',
-          },
-        ],
-      },
-      {
-        projectId: 'project2',
-        workspaces: [
-          {
-            name: 'workspace3',
-            title: 'Workspace 3',
-            basePath: '/workspace3',
-            dataset: 'dataset2',
-            userApplicationId: 'user2',
-            url: 'https://test.sanity.studio',
-            _ref: 'user2-workspace3',
-          },
-        ],
-      },
-      {
-        // Project without workspaces
-        projectId: 'project3',
-        workspaces: [],
-      },
-    ],
-  },
-}
-
-describe('useStudioWorkspacesByResourceId', () => {
-  it('should return empty workspaces and connected=false when not connected', async () => {
-    // Create a mock that captures the onStatus callback
-    let capturedOnStatus: ((status: Status) => void) | undefined
-
-    vi.mocked(useWindowConnection).mockImplementation(({onStatus}) => {
-      capturedOnStatus = onStatus
-
-      return {
-        fetch: undefined,
-        sendMessage: vi.fn(),
-      } as unknown as WindowConnection<Message>
-    })
-
-    const {result} = renderHook(() => useStudioWorkspacesByResourceId())
-
-    // Call onStatus with 'idle' to simulate not connected
-    if (capturedOnStatus) capturedOnStatus('idle')
-
-    expect(result.current).toEqual({
-      workspacesByResourceId: {},
-      error: null,
-      isConnected: false,
-    })
-  })
-
-  it('should process workspaces into lookup by projectId:dataset', async () => {
-    const mockFetch = vi.fn().mockResolvedValue(mockWorkspaceData)
-    let capturedOnStatus: ((status: Status) => void) | undefined
-
-    vi.mocked(useWindowConnection).mockImplementation(({onStatus}) => {
-      capturedOnStatus = onStatus
-
-      return {
-        fetch: mockFetch,
-        sendMessage: vi.fn(),
-      } as unknown as WindowConnection<Message>
-    })
-
-    const {result} = renderHook(() => useStudioWorkspacesByResourceId())
-
-    // Call onStatus with 'connected' to simulate connected state
-    if (capturedOnStatus) capturedOnStatus('connected')
-
-    await waitFor(() => {
-      expect(result.current.workspacesByResourceId).toEqual({
-        'project1:dataset1': [
-          {
-            name: 'workspace1',
-            title: 'Workspace 1',
-            basePath: '/workspace1',
-            dataset: 'dataset1',
-            userApplicationId: 'user1',
-            url: 'https://test.sanity.studio',
-            _ref: 'user1-workspace1',
-          },
-          {
-            name: 'workspace2',
-            title: 'Workspace 2',
-            basePath: '/workspace2',
-            dataset: 'dataset1',
-            userApplicationId: 'user1',
-            url: 'https://test.sanity.studio',
-            _ref: 'user1-workspace2',
-          },
-        ],
-        'project2:dataset2': [
-          {
-            name: 'workspace3',
-            title: 'Workspace 3',
-            basePath: '/workspace3',
-            dataset: 'dataset2',
-            userApplicationId: 'user2',
-            url: 'https://test.sanity.studio',
-            _ref: 'user2-workspace3',
-          },
-        ],
-      })
-      expect(result.current.error).toBeNull()
-      expect(result.current.isConnected).toBe(true)
-    })
-
-    expect(mockFetch).toHaveBeenCalledWith('core/v1/bridge/context', undefined, expect.any(Object))
-  })
-
-  it('should handle fetch errors', async () => {
-    const mockFetch = vi.fn().mockRejectedValue(new Error('Failed to fetch'))
-    let capturedOnStatus: ((status: Status) => void) | undefined
-
-    vi.mocked(useWindowConnection).mockImplementation(({onStatus}) => {
-      capturedOnStatus = onStatus
-
-      return {
-        fetch: mockFetch,
-        sendMessage: vi.fn(),
-      } as unknown as WindowConnection<Message>
-    })
-
-    const {result} = renderHook(() => useStudioWorkspacesByResourceId())
-
-    // Call onStatus with 'connected' to simulate connected state
-    if (capturedOnStatus) capturedOnStatus('connected')
-
-    await waitFor(() => {
-      expect(result.current.workspacesByResourceId).toEqual({})
-      expect(result.current.error).toBe('Failed to fetch workspaces')
-      expect(result.current.isConnected).toBe(true)
-    })
-  })
-
-  it('should handle AbortError silently', async () => {
-    const abortError = new Error('Aborted')
-    abortError.name = 'AbortError'
-    const mockFetch = vi.fn().mockRejectedValue(abortError)
-    let capturedOnStatus: ((status: Status) => void) | undefined
-
-    vi.mocked(useWindowConnection).mockImplementation(({onStatus}) => {
-      capturedOnStatus = onStatus
-
-      return {
-        fetch: mockFetch,
-        sendMessage: vi.fn(),
-      } as unknown as WindowConnection<Message>
-    })
-
-    const {result} = renderHook(() => useStudioWorkspacesByResourceId())
-
-    // Call onStatus with 'connected' to simulate connected state
-    if (capturedOnStatus) capturedOnStatus('connected')
-
-    await waitFor(() => {
-      expect(result.current.workspacesByResourceId).toEqual({})
-      expect(result.current.error).toBeNull()
-      expect(result.current.isConnected).toBe(true)
-    })
-  })
-
-  it('should handle projects without workspaces', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      context: {
-        availableResources: [
-          {
-            projectId: 'project1',
-            workspaces: [],
-          },
-        ],
-      },
-    })
-    let capturedOnStatus: ((status: Status) => void) | undefined
-
-    vi.mocked(useWindowConnection).mockImplementation(({onStatus}) => {
-      capturedOnStatus = onStatus
-
-      return {
-        fetch: mockFetch,
-        sendMessage: vi.fn(),
-      } as unknown as WindowConnection<Message>
-    })
-
-    const {result} = renderHook(() => useStudioWorkspacesByResourceId())
-
-    // Call onStatus with 'connected' to simulate connected state
-    if (capturedOnStatus) capturedOnStatus('connected')
-
-    await waitFor(() => {
-      expect(result.current.workspacesByResourceId).toEqual({})
-      expect(result.current.error).toBeNull()
-      expect(result.current.isConnected).toBe(true)
-    })
-  })
-
-  it('should handle projects without projectId', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
-      context: {
-        availableResources: [
-          {
-            workspaces: [
-              {
-                name: 'workspace1',
-                title: 'Workspace 1',
-                basePath: '/workspace1',
-                dataset: 'dataset1',
-                userApplicationId: 'user1',
-                url: 'https://test.sanity.studio',
-                _ref: 'user1-workspace1',
-              },
-            ],
-          },
-        ],
-      },
-    })
-    let capturedOnStatus: ((status: Status) => void) | undefined
-
-    vi.mocked(useWindowConnection).mockImplementation(({onStatus}) => {
-      capturedOnStatus = onStatus
-
-      return {
-        fetch: mockFetch,
-        sendMessage: vi.fn(),
-      } as unknown as WindowConnection<Message>
-    })
-
-    const {result} = renderHook(() => useStudioWorkspacesByResourceId())
-
-    // Call onStatus with 'connected' to simulate connected state
-    if (capturedOnStatus) capturedOnStatus('connected')
-
-    await waitFor(() => {
-      expect(result.current.workspacesByResourceId).toEqual({})
-      expect(result.current.error).toBeNull()
-      expect(result.current.isConnected).toBe(true)
-    })
-  })
-})

package/src/hooks/dashboard/useStudioWorkspacesByResourceId.ts

@@ -1,91 +0,0 @@
-import {type Status} from '@sanity/comlink'
-import {useEffect, useState} from 'react'
-
-import {useWindowConnection} from '../comlink/useWindowConnection'
-
-interface Workspace {
-  name: string
-  title: string
-  basePath: string
-  dataset: string
-  userApplicationId: string
-  url: string
-  _ref: string
-}
-
-interface WorkspacesByResourceId {
-  [key: string]: Workspace[] // key format: `${projectId}:${dataset}`
-}
-
-interface StudioWorkspacesResult {
-  workspacesByResourceId: WorkspacesByResourceId
-  error: string | null
-  isConnected: boolean
-}
-
-/**
- * Hook that fetches studio workspaces and organizes them by projectId:dataset
- * @internal
- */
-export function useStudioWorkspacesByResourceId(): StudioWorkspacesResult {
-  const [workspacesByResourceId, setWorkspacesByResourceId] = useState<WorkspacesByResourceId>({})
-  const [status, setStatus] = useState<Status>('idle')
-  const [error, setError] = useState<string | null>(null)
-
-  const {fetch} = useWindowConnection({
-    name: 'core/nodes/sdk',
-    connectTo: 'core/channels/sdk',
-    onStatus: setStatus,
-  })
-
-  // Once computed, this should probably be in a store and poll for changes
-  // However, our stores are currently being refactored
-  useEffect(() => {
-    if (!fetch || status !== 'connected') return
-
-    async function fetchWorkspaces(signal: AbortSignal) {
-      try {
-        const data = await fetch<{
-          context: {availableResources: Array<{projectId: string; workspaces: Workspace[]}>}
-        }>('core/v1/bridge/context', undefined, {signal})
-
-        const workspaceMap: WorkspacesByResourceId = {}
-
-        data.context.availableResources.forEach((resource) => {
-          if (!resource.projectId || !resource.workspaces?.length) return
-
-          resource.workspaces.forEach((workspace) => {
-            const key = `${resource.projectId}:${workspace.dataset}`
-            if (!workspaceMap[key]) {
-              workspaceMap[key] = []
-            }
-            workspaceMap[key].push(workspace)
-          })
-        })
-
-        setWorkspacesByResourceId(workspaceMap)
-        setError(null)
-      } catch (err: unknown) {
-        if (err instanceof Error) {
-          if (err.name === 'AbortError') {
-            return
-          }
-          setError('Failed to fetch workspaces')
-        }
-      }
-    }
-
-    const controller = new AbortController()
-    fetchWorkspaces(controller.signal)
-
-    return () => {
-      controller.abort()
-    }
-  }, [fetch, status])
-
-  return {
-    workspacesByResourceId,
-    error,
-    isConnected: status === 'connected',
-  }
-}

package/src/hooks/datasets/useDatasets.ts

@@ -1,37 +0,0 @@
-import {type DatasetsResponse} from '@sanity/client'
-import {getDatasetsState, resolveDatasets, type SanityInstance, type StateSource} from '@sanity/sdk'
-
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
-
-type UseDatasets = {
-  /**
-   *
-   * Returns metadata for each dataset in your organization.
-   *
-   * @category Datasets
-   * @returns The metadata for your organization's datasets
-   *
-   * @example
-   * ```tsx
-   * const datasets = useDatasets()
-   *
-   * return (
-   *   <select>
-   *     {datasets.map((dataset) => (
-   *       <option key={dataset.name}>{dataset.name}</option>
-   *     ))}
-   *   </select>
-   * )
-   * ```
-   *
-   */
-  (): DatasetsResponse
-}
-
-/** @public */
-export const useDatasets: UseDatasets = createStateSourceHook({
-  // remove `undefined` since we're suspending when that is the case
-  getState: getDatasetsState as (instance: SanityInstance) => StateSource<DatasetsResponse>,
-  shouldSuspend: (instance) => getDatasetsState(instance).getCurrent() === undefined,
-  suspender: resolveDatasets,
-})

package/src/hooks/document/useApplyActions.test.ts

@@ -1,25 +0,0 @@
-import {applyActions, createDocument, type ResourceId} from '@sanity/sdk'
-import {describe, it} from 'vitest'
-
-import {createCallbackHook} from '../helpers/createCallbackHook'
-
-vi.mock('../helpers/createCallbackHook', () => ({
-  createCallbackHook: vi.fn((cb) => () => cb),
-}))
-vi.mock('@sanity/sdk', async (importOriginal) => {
-  const original = await importOriginal<typeof import('@sanity/sdk')>()
-  return {...original, applyActions: vi.fn()}
-})
-
-describe('useApplyActions', () => {
-  it('calls `createCallbackHook` with `applyActions`', async () => {
-    const {useApplyActions} = await import('./useApplyActions')
-    const resourceId: ResourceId = 'project1.dataset1'
-    expect(createCallbackHook).not.toHaveBeenCalled()
-
-    expect(applyActions).not.toHaveBeenCalled()
-    const apply = useApplyActions(resourceId)
-    apply(createDocument({_type: 'author'}))
-    expect(applyActions).toHaveBeenCalledWith(createDocument({_type: 'author'}))
-  })
-})

package/src/hooks/document/useApplyActions.ts

@@ -1,74 +0,0 @@
-import {
-  type ActionsResult,
-  applyActions,
-  type ApplyActionsOptions,
-  type DocumentAction,
-  type ResourceId,
-} from '@sanity/sdk'
-import {type SanityDocument} from '@sanity/types'
-
-import {createCallbackHook} from '../helpers/createCallbackHook'
-
-/**
- *
- * @beta
- *
- * Provides a callback for applying one or more actions to a document.
- *
- * @category Documents
- * @param resourceId - The resource ID of the document to apply actions to. If not provided, the document will use the default resource.
- * @returns A function that takes one more more {@link DocumentAction}s and returns a promise that resolves to an {@link ActionsResult}.
- * @example Publish or unpublish a document
- * ```
- * import { publishDocument, unpublishDocument } from '@sanity/sdk'
- * import { useApplyActions } from '@sanity/sdk-react'
- *
- * const apply = useApplyActions()
- * const myDocument = { _id: 'my-document-id', _type: 'my-document-type' }
- *
- * return (
- *   <button onClick={() => apply(publishDocument(myDocument))}>Publish</button>
- *   <button onClick={() => apply(unpublishDocument(myDocument))}>Unpublish</button>
- * )
- * ```
- *
- * @example Create and publish a new document
- * ```
- * import { createDocument, publishDocument } from '@sanity/sdk'
- * import { useApplyActions } from '@sanity/sdk-react'
- *
- * const apply = useApplyActions()
- *
- * const handleCreateAndPublish = () => {
- *   const handle = { _id: window.crypto.randomUUID(), _type: 'my-document-type' }
- *   apply([
- *     createDocument(handle),
- *     publishDocument(handle),
- *   ])
- * }
- *
- * return (
- *   <button onClick={handleCreateAndPublish}>
- *     I’m feeling lucky
- *   </button>
- * )
- * ```
- */
-export function useApplyActions(
-  resourceId?: ResourceId,
-): <TDocument extends SanityDocument>(
-  action: DocumentAction<TDocument> | DocumentAction<TDocument>[],
-  options?: ApplyActionsOptions,
-) => Promise<ActionsResult<TDocument>>
-
-/** @beta */
-export function useApplyActions(
-  resourceId?: ResourceId,
-): (
-  action: DocumentAction | DocumentAction[],
-  options?: ApplyActionsOptions,
-) => Promise<ActionsResult> {
-  return _useApplyActions(resourceId)()
-}
-
-const _useApplyActions = (resourceId?: ResourceId) => createCallbackHook(applyActions, resourceId)

package/src/hooks/document/useDocument.test.ts

@@ -1,81 +0,0 @@
-// tests/useDocument.test.ts
-import {
-  createSanityInstance,
-  getDocumentState,
-  resolveDocument,
-  type StateSource,
-} from '@sanity/sdk'
-import {type SanityDocument} from '@sanity/types'
-import {renderHook} from '@testing-library/react'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {useSanityInstance} from '../context/useSanityInstance'
-import {useDocument} from './useDocument'
-
-vi.mock('@sanity/sdk', async (importOriginal) => {
-  const original = await importOriginal<typeof import('@sanity/sdk')>()
-  return {...original, getDocumentState: vi.fn(), resolveDocument: vi.fn()}
-})
-
-vi.mock('../context/useSanityInstance', () => ({
-  useSanityInstance: vi.fn(),
-}))
-
-// Create a fake instance to be returned by useSanityInstance.
-const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
-const doc: SanityDocument = {
-  _id: 'doc1',
-  foo: 'bar',
-  _type: 'book',
-  _rev: 'tx0',
-  _createdAt: '2025-02-06T00:11:00.000Z',
-  _updatedAt: '2025-02-06T00:11:00.000Z',
-}
-
-describe('useDocument hook', () => {
-  beforeEach(() => {
-    vi.resetAllMocks()
-    vi.mocked(useSanityInstance).mockReturnValue(instance)
-  })
-
-  it('returns the current document when ready (without a path)', () => {
-    const getCurrent = vi.fn().mockReturnValue(doc)
-    const subscribe = vi.fn().mockReturnValue(vi.fn())
-    vi.mocked(getDocumentState).mockReturnValue({
-      getCurrent,
-      subscribe,
-    } as unknown as StateSource<unknown>)
-
-    const {result} = renderHook(() => useDocument({_id: 'doc1', _type: 'book'}))
-
-    expect(result.current).toEqual(doc)
-    expect(getCurrent).toHaveBeenCalled()
-    expect(subscribe).toHaveBeenCalled()
-  })
-
-  it('throws a promise (suspends) when the document is not ready', () => {
-    const getCurrent = vi.fn().mockReturnValue(undefined)
-    const subscribe = vi.fn().mockReturnValue(vi.fn())
-    vi.mocked(getDocumentState).mockReturnValue({
-      getCurrent,
-      subscribe,
-    } as unknown as StateSource<unknown>)
-
-    const resolveDocPromise = Promise.resolve(doc)
-
-    // Also, simulate resolveDocument to return a known promise.
-    vi.mocked(resolveDocument).mockReturnValue(resolveDocPromise)
-
-    // Render the hook and capture the thrown promise.
-    const {result} = renderHook(() => {
-      try {
-        return useDocument({_id: 'doc1', _type: 'book'})
-      } catch (e) {
-        return e
-      }
-    })
-
-    // When the document is not ready, the hook throws the promise from resolveDocument.
-    expect(result.current).toBe(resolveDocPromise)
-  })
-})