@sanity/sdk-react 0.0.0 → 0.0.2

package/src/hooks/dashboard/useStudioWorkspacesByProjectIdDataset.ts

@@ -1,4 +1,3 @@
-import {type Status} from '@sanity/comlink'
 import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
 import {useEffect, useState} from 'react'
 
@@ -23,35 +22,62 @@ interface WorkspacesByProjectIdDataset {
 interface StudioWorkspacesResult {
   workspacesByProjectIdAndDataset: WorkspacesByProjectIdDataset
   error: string | null
-  isConnected: boolean
 }
 
 /**
  * Hook that fetches studio workspaces and organizes them by projectId:dataset
  * @internal
+ *
+ * @example
+ * ```tsx
+ * import {useStudioWorkspacesByProjectIdDataset} from '@sanity/sdk-react'
+ * import {Card, Code, Button} from '@sanity/ui'
+ * import {Suspense} from 'react'
+ *
+ * function WorkspacesCard() {
+ *   const {workspacesByProjectIdAndDataset, error} = useStudioWorkspacesByProjectIdDataset()
+ *   if (error) {
+ *     return <div>Error: {error}</div>
+ *   }
+ *   return (
+ *     <Card padding={4} radius={2} shadow={1}>
+ *       <Code language="json">
+ *         {JSON.stringify(workspacesByProjectIdAndDataset, null, 2)}
+ *       </Code>
+ *     </Card>
+ *   )
+ * }
+ *
+ * // Wrap the component with Suspense since the hook may suspend
+ * function DashboardWorkspaces() {
+ *   return (
+ *     <Suspense fallback={<Button text="Loading..." disabled />}>
+ *       <WorkspacesCard />
+ *     </Suspense>
+ *   )
+ * }
+ * ```
  */
 export function useStudioWorkspacesByProjectIdDataset(): StudioWorkspacesResult {
   const [workspacesByProjectIdAndDataset, setWorkspacesByProjectIdAndDataset] =
     useState<WorkspacesByProjectIdDataset>({})
-  const [status, setStatus] = useState<Status>('idle')
   const [error, setError] = useState<string | null>(null)
 
   const {fetch} = useWindowConnection({
     name: SDK_NODE_NAME,
     connectTo: SDK_CHANNEL_NAME,
-    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
+    if (!fetch) return
 
     async function fetchWorkspaces(signal: AbortSignal) {
       try {
         const data = await fetch<{
           context: {availableResources: Array<DashboardResource>}
-        }>('dashboard/v1/bridge/context', undefined, {signal})
+        }>('dashboard/v1/context', undefined, {signal})
 
         const workspaceMap: WorkspacesByProjectIdDataset = {}
         const noProjectIdAndDataset: DashboardResource[] = []
@@ -91,11 +117,10 @@ export function useStudioWorkspacesByProjectIdDataset(): StudioWorkspacesResult
     return () => {
       controller.abort()
     }
-  }, [fetch, status])
+  }, [fetch])
 
   return {
     workspacesByProjectIdAndDataset,
     error,
-    isConnected: status === 'connected',
   }
 }

package/src/hooks/comlink/useRecordDocumentHistoryEvent.test.ts

@@ -1,85 +0,0 @@
-import {type Message, type Node, type Status} from '@sanity/comlink'
-import {getOrCreateNode} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {act, renderHook} from '../../../test/test-utils'
-import {useRecordDocumentHistoryEvent} from './useRecordDocumentHistoryEvent'
-
-vi.mock(import('@sanity/sdk'), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    getOrCreateNode: vi.fn(),
-    releaseNode: vi.fn(),
-  }
-})
-
-describe('useRecordDocumentHistoryEvent', () => {
-  let node: Node<Message, Message>
-  let statusCallback: ((status: Status) => void) | null = null
-
-  const mockDocumentHandle = {
-    documentId: 'mock-id',
-    documentType: 'mock-type',
-    resourceType: 'studio' as const,
-    resourceId: 'mock-resource-id',
-  }
-
-  function createMockNode() {
-    return {
-      on: vi.fn(() => () => {}),
-      post: vi.fn(),
-      stop: vi.fn(),
-      onStatus: vi.fn((callback) => {
-        statusCallback = callback
-        return () => {}
-      }),
-    } as unknown as Node<Message, Message>
-  }
-
-  beforeEach(() => {
-    statusCallback = null
-    node = createMockNode()
-    vi.mocked(getOrCreateNode).mockReturnValue(node)
-  })
-
-  it('should initialize with correct connection status', () => {
-    const {result} = renderHook(() => useRecordDocumentHistoryEvent(mockDocumentHandle))
-
-    expect(result.current.isConnected).toBe(false)
-
-    act(() => {
-      statusCallback?.('connected')
-    })
-
-    expect(result.current.isConnected).toBe(true)
-  })
-
-  it('should send correct message when recording events', () => {
-    const {result} = renderHook(() => useRecordDocumentHistoryEvent(mockDocumentHandle))
-
-    result.current.recordEvent('viewed')
-
-    expect(node.post).toHaveBeenCalledWith('dashboard/v1/events/history', {
-      eventType: 'viewed',
-      document: {
-        id: 'mock-id',
-        type: 'mock-type',
-        resource: {
-          id: 'mock-resource-id',
-          type: 'studio',
-        },
-      },
-    })
-  })
-
-  it('should handle errors when sending messages', () => {
-    vi.mocked(node.post).mockImplementation(() => {
-      throw new Error('Failed to send message')
-    })
-
-    const {result} = renderHook(() => useRecordDocumentHistoryEvent(mockDocumentHandle))
-
-    expect(() => result.current.recordEvent('viewed')).toThrow('Failed to send message')
-  })
-})

package/src/hooks/comlink/useWindowConnection.test.ts

@@ -1,135 +0,0 @@
-import {type Message, type Node, type Status} from '@sanity/comlink'
-import {getOrCreateNode, releaseNode} from '@sanity/sdk'
-import {beforeEach, describe, expect, it, vi} from 'vitest'
-
-import {act, renderHook} from '../../../test/test-utils'
-import {useWindowConnection} from './useWindowConnection'
-
-vi.mock(import('@sanity/sdk'), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    getOrCreateNode: vi.fn(),
-    createNode: vi.fn(),
-    releaseNode: vi.fn(),
-  }
-})
-interface TestMessage {
-  type: 'TEST_MESSAGE'
-  data: {someData: string}
-}
-
-interface AnotherMessage {
-  type: 'ANOTHER_MESSAGE'
-  data: {otherData: number}
-}
-
-type TestMessages = TestMessage | AnotherMessage
-
-describe('useWindowConnection', () => {
-  let node: Node<Message, Message>
-  let statusCallback: ((status: Status) => void) | null = null
-
-  function createMockNode() {
-    return {
-      // return unsubscribe function
-      on: vi.fn(() => () => {}),
-      post: vi.fn(),
-      stop: vi.fn(),
-      onStatus: vi.fn((callback) => {
-        statusCallback = callback
-        return () => {}
-      }),
-    } as unknown as Node<Message, Message>
-  }
-
-  beforeEach(() => {
-    statusCallback = null
-    node = createMockNode()
-    vi.mocked(getOrCreateNode).mockReturnValue(node as unknown as Node<Message, Message>)
-  })
-
-  it('should call onStatus callback when status changes', () => {
-    const onStatusMock = vi.fn()
-    renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-        onStatus: onStatusMock,
-      }),
-    )
-
-    act(() => {
-      statusCallback?.('connected')
-    })
-    expect(onStatusMock).toHaveBeenCalledWith('connected')
-
-    act(() => {
-      statusCallback?.('disconnected')
-    })
-    expect(onStatusMock).toHaveBeenCalledWith('disconnected')
-  })
-
-  it('should not throw if onStatus is not provided', () => {
-    renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-      }),
-    )
-
-    expect(() => {
-      act(() => {
-        statusCallback?.('connected')
-      })
-    }).not.toThrow()
-  })
-
-  it('should register message handlers', () => {
-    const mockHandler = vi.fn()
-    const mockData = {someData: 'test'}
-
-    renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-        onMessage: {
-          TEST_MESSAGE: mockHandler,
-          ANOTHER_MESSAGE: vi.fn(),
-        },
-      }),
-    )
-
-    const onCallback = vi.mocked(node.on).mock.calls[0][1]
-    onCallback(mockData)
-
-    expect(mockHandler).toHaveBeenCalledWith(mockData)
-  })
-
-  it('should send messages through the node', () => {
-    const {result} = renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-      }),
-    )
-
-    result.current.sendMessage('TEST_MESSAGE', {someData: 'test'})
-    expect(node.post).toHaveBeenCalledWith('TEST_MESSAGE', {someData: 'test'})
-
-    result.current.sendMessage('ANOTHER_MESSAGE', {otherData: 123})
-    expect(node.post).toHaveBeenCalledWith('ANOTHER_MESSAGE', {otherData: 123})
-  })
-
-  it('should cleanup on unmount', () => {
-    const {unmount} = renderHook(() =>
-      useWindowConnection<TestMessages, TestMessages>({
-        name: 'test',
-        connectTo: 'window',
-      }),
-    )
-
-    unmount()
-    expect(releaseNode).toHaveBeenCalled()
-  })
-})