@sanity/sdk-react 0.0.0-alpha.26 → 0.0.0-alpha.28

package/dist/index.d.ts

@@ -96,6 +96,18 @@ declare interface AuthBoundaryProps {
  */
 export declare type ComlinkStatus = 'idle' | 'handshaking' | 'connected' | 'disconnected'
 
+declare interface DashboardResource {
+  id: string
+  name: string
+  title: string
+  basePath: string
+  projectId: string
+  dataset: string
+  type: string
+  userApplicationId: string
+  url: string
+}
+
 /** @public */
 declare type DatasetAclMode = 'public' | 'private' | 'custom'
 
@@ -1271,6 +1283,8 @@ declare interface UseManageFavoriteProps extends DocumentHandle {
  *
  * @category Documents
  * @param documentHandle - The document handle for the document to navigate to
+ * @param preferredStudioUrl - The preferred studio url to navigate to if you have multiple
+ * studios with the same projectId and dataset
  * @returns An object containing:
  * - `navigateToStudioDocument` - Function that when called will navigate to the studio document
  * - `isConnected` - Boolean indicating if connection to Dashboard is established
@@ -1292,6 +1306,7 @@ declare interface UseManageFavoriteProps extends DocumentHandle {
  */
 export declare function useNavigateToStudioDocument(
   documentHandle: DocumentHandle,
+  preferredStudioUrl?: string,
 ): NavigateToStudioResult
 
 /**
@@ -1854,18 +1869,8 @@ export declare type WindowMessageHandler<TFrameMessage extends FrameMessage> = (
   event: TFrameMessage['data'],
 ) => TFrameMessage['response']
 
-declare interface Workspace {
-  name: string
-  title: string
-  basePath: string
-  dataset: string
-  userApplicationId: string
-  url: string
-  _ref: string
-}
-
 declare interface WorkspacesByProjectIdDataset {
-  [key: `${string}:${string}`]: Workspace[]
+  [key: `${string}:${string}`]: DashboardResource[]
 }
 
 export * from '@sanity/sdk'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk-react",
-  "version": "0.0.0-alpha.26",
+  "version": "0.0.0-alpha.28",
   "private": false,
   "description": "Sanity SDK React toolkit for Content OS",
   "keywords": [
@@ -47,9 +47,10 @@
     "@sanity/types": "^3.83.0",
     "@types/lodash-es": "^4.17.12",
     "lodash-es": "^4.17.21",
+    "react-compiler-runtime": "19.0.0-beta-ebf51a3-20250411",
     "react-error-boundary": "^5.0.0",
     "rxjs": "^7.8.2",
-    "@sanity/sdk": "0.0.0-alpha.26"
+    "@sanity/sdk": "0.0.0-alpha.28"
   },
   "devDependencies": {
     "@sanity/browserslist-config": "^1.0.5",
@@ -63,15 +64,15 @@
     "@types/react-dom": "^19.1.1",
     "@vitejs/plugin-react": "^4.3.4",
     "@vitest/coverage-v8": "3.1.1",
-    "babel-plugin-react-compiler": "19.0.0-beta-e993439-20250328",
+    "babel-plugin-react-compiler": "19.0.0-beta-ebf51a3-20250411",
     "eslint": "^9.22.0",
     "jsdom": "^25.0.1",
     "prettier": "^3.5.3",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "typescript": "^5.7.3",
-    "vite": "^6.2.5",
-    "vitest": "^3.1.1",
+    "vite": "^6.3.2",
+    "vitest": "^3.1.2",
     "@repo/config-eslint": "0.0.0",
     "@repo/config-test": "0.0.1",
     "@repo/package.bundle": "3.82.0",

package/src/context/ResourceProvider.tsx

@@ -1,5 +1,5 @@
 import {createSanityInstance, type SanityConfig, type SanityInstance} from '@sanity/sdk'
-import {Suspense, use, useEffect, useMemo, useRef} from 'react'
+import {Suspense, useContext, useEffect, useMemo, useRef} from 'react'
 
 import {SanityInstanceContext} from './SanityInstanceContext'
 
@@ -72,7 +72,7 @@ export function ResourceProvider({
   fallback,
   ...config
 }: ResourceProviderProps): React.ReactNode {
-  const parent = use(SanityInstanceContext)
+  const parent = useContext(SanityInstanceContext)
   const instance = useMemo(
     () => (parent ? parent.createChild(config) : createSanityInstance(config)),
     [config, parent],

package/src/hooks/context/useSanityInstance.ts

@@ -1,5 +1,5 @@
 import {type SanityConfig, type SanityInstance} from '@sanity/sdk'
-import {use} from 'react'
+import {useContext} from 'react'
 
 import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 
@@ -58,7 +58,7 @@ import {SanityInstanceContext} from '../../context/SanityInstanceContext'
  * @throws Error if no matching instance is found for the provided config
  */
 export const useSanityInstance = (config?: SanityConfig): SanityInstance => {
-  const instance = use(SanityInstanceContext)
+  const instance = useContext(SanityInstanceContext)
 
   if (!instance) {
     throw new Error(

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

@@ -43,13 +43,13 @@ describe('useNavigateToStudioDocument', () => {
   }
 
   const mockWorkspace = {
+    id: 'workspace123',
     name: 'workspace1',
     title: 'Workspace 1',
     basePath: '/workspace1',
     dataset: 'dataset1',
     userApplicationId: 'user1',
     url: 'https://test.sanity.studio',
-    _ref: 'workspace123',
   }
 
   beforeEach(() => {
@@ -129,7 +129,7 @@ describe('useNavigateToStudioDocument', () => {
 
   it('warns when multiple workspaces are found', () => {
     const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    const mockWorkspace2 = {...mockWorkspace, _ref: 'workspace2'}
+    const mockWorkspace2 = {...mockWorkspace, id: 'workspace2'}
 
     mockWorkspacesByProjectIdAndDataset = {
       'project1:dataset1': [mockWorkspace, mockWorkspace2],
@@ -145,16 +145,132 @@ describe('useNavigateToStudioDocument', () => {
     result.current.navigateToStudioDocument()
 
     expect(consoleSpy).toHaveBeenCalledWith(
-      'Multiple workspaces found for document',
+      'Multiple workspaces found for document and no preferred studio url',
       mockDocumentHandle,
     )
     expect(mockSendMessage).toHaveBeenCalledWith(
       'dashboard/v1/bridge/navigate-to-resource',
       expect.objectContaining({
-        resourceId: mockWorkspace._ref,
+        resourceId: mockWorkspace.id,
       }),
     )
 
     consoleSpy.mockRestore()
   })
+
+  it('warns and does not navigate when projectId or dataset is missing', () => {
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    const incompleteDocumentHandle: DocumentHandle = {
+      documentId: 'doc123',
+      documentType: 'article',
+      // missing projectId and dataset
+    }
+
+    const {result} = renderHook(() => useNavigateToStudioDocument(incompleteDocumentHandle))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Project ID and dataset are required to navigate to a studio document',
+    )
+    expect(mockSendMessage).not.toHaveBeenCalled()
+
+    consoleSpy.mockRestore()
+  })
+
+  it('uses preferred studio URL when multiple workspaces are available', () => {
+    const preferredUrl = 'https://preferred.sanity.studio'
+    const mockWorkspace2 = {...mockWorkspace, id: 'workspace2', url: preferredUrl}
+
+    mockWorkspacesByProjectIdAndDataset = {
+      'project1:dataset1': [mockWorkspace, mockWorkspace2],
+    }
+
+    const {result} = renderHook(() => useNavigateToStudioDocument(mockDocumentHandle, preferredUrl))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    // Should choose workspace2 because it matches the preferred URL
+    expect(mockSendMessage).toHaveBeenCalledWith(
+      'dashboard/v1/bridge/navigate-to-resource',
+      expect.objectContaining({
+        resourceId: 'workspace2',
+      }),
+    )
+  })
+
+  it('considers NO_PROJECT_ID:NO_DATASET workspaces when matching preferred URL', () => {
+    const preferredUrl = 'https://preferred.sanity.studio'
+    // Only have a workspace without projectId/dataset that matches the preferred URL
+    const mockWorkspaceNoProject = {
+      ...mockWorkspace,
+      id: 'workspace3',
+      url: preferredUrl,
+      projectId: undefined,
+      dataset: undefined,
+    }
+
+    mockWorkspacesByProjectIdAndDataset = {
+      'NO_PROJECT_ID:NO_DATASET': [mockWorkspaceNoProject],
+    }
+
+    const {result} = renderHook(() => useNavigateToStudioDocument(mockDocumentHandle, preferredUrl))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    // Should choose the NO_PROJECT_ID:NO_DATASET workspace because it matches the preferred URL
+    expect(mockSendMessage).toHaveBeenCalledWith(
+      'dashboard/v1/bridge/navigate-to-resource',
+      expect.objectContaining({
+        resourceId: 'workspace3',
+      }),
+    )
+  })
+
+  it('warns with preferred URL info when no matching workspace is found', () => {
+    const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const preferredUrl = 'https://nonexistent.sanity.studio'
+
+    // Set up workspaces that don't match the preferred URL
+    mockWorkspacesByProjectIdAndDataset = {
+      'project1:dataset1': [
+        {
+          ...mockWorkspace,
+          url: 'https://different.sanity.studio',
+        },
+      ],
+    }
+
+    const {result} = renderHook(() => useNavigateToStudioDocument(mockDocumentHandle, preferredUrl))
+
+    // Simulate connection
+    act(() => {
+      mockStatusCallback?.('connected')
+    })
+
+    result.current.navigateToStudioDocument()
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      `No workspace found for document with projectId: ${mockDocumentHandle.projectId} and dataset: ${mockDocumentHandle.dataset} or with preferred studio url: ${preferredUrl}`,
+    )
+    expect(mockSendMessage).not.toHaveBeenCalled()
+
+    consoleSpy.mockRestore()
+  })
 })

package/src/hooks/dashboard/useNavigateToStudioDocument.ts

@@ -4,7 +4,10 @@ import {type DocumentHandle} from '@sanity/sdk'
 import {useCallback, useState} from 'react'
 
 import {useWindowConnection} from '../comlink/useWindowConnection'
-import {useStudioWorkspacesByProjectIdDataset} from './useStudioWorkspacesByProjectIdDataset'
+import {
+  type DashboardResource,
+  useStudioWorkspacesByProjectIdDataset,
+} from './useStudioWorkspacesByProjectIdDataset'
 
 /**
  * @public
@@ -28,6 +31,8 @@ export interface NavigateToStudioResult {
  *
  * @category Documents
  * @param documentHandle - The document handle for the document to navigate to
+ * @param preferredStudioUrl - The preferred studio url to navigate to if you have multiple
+ * studios with the same projectId and dataset
  * @returns An object containing:
  * - `navigateToStudioDocument` - Function that when called will navigate to the studio document
  * - `isConnected` - Boolean indicating if connection to Dashboard is established
@@ -49,6 +54,7 @@ export interface NavigateToStudioResult {
  */
 export function useNavigateToStudioDocument(
   documentHandle: DocumentHandle,
+  preferredStudioUrl?: string,
 ): NavigateToStudioResult {
   const {workspacesByProjectIdAndDataset, isConnected: workspacesConnected} =
     useStudioWorkspacesByProjectIdDataset()
@@ -62,40 +68,69 @@ export function useNavigateToStudioDocument(
   const navigateToStudioDocument = useCallback(() => {
     const {projectId, dataset} = documentHandle
 
-    if (!workspacesConnected || status !== 'connected' || !projectId || !dataset) {
+    if (!workspacesConnected || status !== 'connected') {
+      // eslint-disable-next-line no-console
+      console.warn('Not connected to Dashboard')
       return
     }
 
-    // Find the workspace for this document
-    const workspaces = workspacesByProjectIdAndDataset[`${projectId}:${dataset}`]
-    if (!workspaces?.length) {
+    if (!projectId || !dataset) {
       // eslint-disable-next-line no-console
-      console.warn(
-        `No workspace found for document with projectId: ${projectId} and dataset: ${dataset}`,
-      )
+      console.warn('Project ID and dataset are required to navigate to a studio document')
       return
     }
 
-    if (workspaces.length > 1) {
-      // eslint-disable-next-line no-console
-      console.warn('Multiple workspaces found for document', documentHandle)
-      // eslint-disable-next-line no-console
-      console.warn('Using the first one', workspaces[0])
+    let workspace: DashboardResource | undefined
+
+    if (preferredStudioUrl) {
+      // Get workspaces matching the projectId:dataset and any workspaces without projectId/dataset,
+      // in case there hasn't been a manifest loaded yet
+      const allWorkspaces = [
+        ...(workspacesByProjectIdAndDataset[`${projectId}:${dataset}`] || []),
+        ...(workspacesByProjectIdAndDataset['NO_PROJECT_ID:NO_DATASET'] || []),
+      ]
+      workspace = allWorkspaces.find((w) => w.url === preferredStudioUrl)
+    } else {
+      const workspaces = workspacesByProjectIdAndDataset[`${projectId}:${dataset}`]
+      if (workspaces?.length > 1) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          'Multiple workspaces found for document and no preferred studio url',
+          documentHandle,
+        )
+        // eslint-disable-next-line no-console
+        console.warn('Using the first one', workspaces[0])
+      }
+
+      workspace = workspaces?.[0]
     }
 
-    const workspace = workspaces[0]
+    if (!workspace) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        `No workspace found for document with projectId: ${projectId} and dataset: ${dataset}${preferredStudioUrl ? ` or with preferred studio url: ${preferredStudioUrl}` : ''}`,
+      )
+      return
+    }
 
     const message: Bridge.Navigation.NavigateToResourceMessage = {
       type: 'dashboard/v1/bridge/navigate-to-resource',
       data: {
-        resourceId: workspace._ref,
+        resourceId: workspace.id,
         resourceType: 'studio',
         path: `/intent/edit/id=${documentHandle.documentId};type=${documentHandle.documentType}`,
       },
     }
 
     sendMessage(message.type, message.data)
-  }, [documentHandle, workspacesConnected, status, workspacesByProjectIdAndDataset, sendMessage])
+  }, [
+    documentHandle,
+    workspacesConnected,
+    status,
+    workspacesByProjectIdAndDataset,
+    sendMessage,
+    preferredStudioUrl,
+  ])
 
   return {
     navigateToStudioDocument,

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

@@ -13,52 +13,47 @@ const mockWorkspaceData = {
   context: {
     availableResources: [
       {
+        id: 'user1-workspace1',
         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',
-          },
-        ],
+        dataset: 'dataset1',
+        name: 'workspace1',
+        title: 'Workspace 1',
+        basePath: '/workspace1',
+        userApplicationId: 'user1',
+        url: 'https://test1.sanity.studio',
+        type: 'studio',
       },
       {
-        projectId: 'project2',
-        workspaces: [
-          {
-            name: 'workspace3',
-            title: 'Workspace 3',
-            basePath: '/workspace3',
-            dataset: 'dataset2',
-            userApplicationId: 'user2',
-            url: 'https://test.sanity.studio',
-            _ref: 'user2-workspace3',
-          },
-        ],
+        id: 'user1-workspace2',
+        projectId: 'project1',
+        dataset: 'dataset1',
+        name: 'workspace2',
+        title: 'Workspace 2',
+        basePath: '/workspace2',
+        userApplicationId: 'user1',
+        url: 'https://test2.sanity.studio',
+        type: 'studio',
       },
       {
-        // Project without workspaces
-        projectId: 'project3',
-        workspaces: [],
+        id: 'user2-workspace3',
+        projectId: 'project2',
+        dataset: 'dataset2',
+        name: 'workspace3',
+        title: 'Workspace 3',
+        basePath: '/workspace3',
+        userApplicationId: 'user2',
+        url: 'https://test3.sanity.studio',
+        type: 'studio',
       },
     ],
   },
 }
 
 describe('useStudioWorkspacesByResourceId', () => {
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
   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
@@ -106,33 +101,39 @@ describe('useStudioWorkspacesByResourceId', () => {
       expect(result.current.workspacesByProjectIdAndDataset).toEqual({
         'project1:dataset1': [
           {
+            id: 'user1-workspace1',
+            projectId: 'project1',
+            dataset: 'dataset1',
             name: 'workspace1',
             title: 'Workspace 1',
             basePath: '/workspace1',
-            dataset: 'dataset1',
             userApplicationId: 'user1',
-            url: 'https://test.sanity.studio',
-            _ref: 'user1-workspace1',
+            url: 'https://test1.sanity.studio',
+            type: 'studio',
           },
           {
+            id: 'user1-workspace2',
+            projectId: 'project1',
+            dataset: 'dataset1',
             name: 'workspace2',
             title: 'Workspace 2',
             basePath: '/workspace2',
-            dataset: 'dataset1',
             userApplicationId: 'user1',
-            url: 'https://test.sanity.studio',
-            _ref: 'user1-workspace2',
+            url: 'https://test2.sanity.studio',
+            type: 'studio',
           },
         ],
         'project2:dataset2': [
           {
+            id: 'user2-workspace3',
+            projectId: 'project2',
+            dataset: 'dataset2',
             name: 'workspace3',
             title: 'Workspace 3',
             basePath: '/workspace3',
-            dataset: 'dataset2',
             userApplicationId: 'user2',
-            url: 'https://test.sanity.studio',
-            _ref: 'user2-workspace3',
+            url: 'https://test3.sanity.studio',
+            type: 'studio',
           },
         ],
       })
@@ -199,60 +200,56 @@ describe('useStudioWorkspacesByResourceId', () => {
     })
   })
 
-  it('should handle projects without workspaces', async () => {
-    const mockFetch = vi.fn().mockResolvedValue({
+  it('should filter non-studio resources and handle resources without projectId/dataset', async () => {
+    const mockDataWithMixedResources = {
       context: {
         availableResources: [
           {
+            id: 'studio1',
             projectId: 'project1',
-            workspaces: [],
+            dataset: 'dataset1',
+            name: 'workspace1',
+            title: 'Workspace 1',
+            basePath: '/workspace1',
+            userApplicationId: 'user1',
+            url: 'https://test1.sanity.studio',
+            type: 'studio',
           },
-        ],
-      },
-    })
-    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(() => useStudioWorkspacesByProjectIdDataset())
-
-    // Call onStatus with 'connected' to simulate connected state
-    if (capturedOnStatus) capturedOnStatus('connected')
-
-    await waitFor(() => {
-      expect(result.current.workspacesByProjectIdAndDataset).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',
-              },
-            ],
+            id: 'non-studio',
+            projectId: 'project2',
+            dataset: 'dataset2',
+            name: 'non-studio',
+            title: 'Non Studio Resource',
+            basePath: '/non-studio',
+            userApplicationId: 'user2',
+            url: 'https://test2.sanity.studio',
+            type: 'other',
+          },
+          {
+            id: 'studio-no-project',
+            name: 'incomplete-workspace',
+            title: 'Incomplete Workspace',
+            basePath: '/incomplete',
+            userApplicationId: 'user3',
+            url: 'https://test3.sanity.studio',
+            type: 'studio',
+          },
+          {
+            id: 'studio-no-dataset',
+            projectId: 'project3',
+            name: 'no-dataset-workspace',
+            title: 'No Dataset Workspace',
+            basePath: '/no-dataset',
+            userApplicationId: 'user4',
+            url: 'https://test4.sanity.studio',
+            type: 'studio',
           },
         ],
       },
-    })
+    }
+
+    const mockFetch = vi.fn().mockResolvedValue(mockDataWithMixedResources)
     let capturedOnStatus: ((status: Status) => void) | undefined
 
     vi.mocked(useWindowConnection).mockImplementation(({onStatus}) => {
@@ -270,7 +267,23 @@ describe('useStudioWorkspacesByResourceId', () => {
     if (capturedOnStatus) capturedOnStatus('connected')
 
     await waitFor(() => {
-      expect(result.current.workspacesByProjectIdAndDataset).toEqual({})
+      // Should only include the studio resource with valid projectId and dataset
+      expect(result.current.workspacesByProjectIdAndDataset['project1:dataset1']).toHaveLength(1)
+      expect(result.current.workspacesByProjectIdAndDataset['project1:dataset1'][0].id).toBe(
+        'studio1',
+      )
+
+      // Should not include the non-studio resource
+      expect(result.current.workspacesByProjectIdAndDataset['project2:dataset2']).toBeUndefined()
+
+      // Should group resources without projectId or dataset under NO_PROJECT_ID:NO_DATASET
+      expect(
+        result.current.workspacesByProjectIdAndDataset['NO_PROJECT_ID:NO_DATASET'],
+      ).toHaveLength(2)
+      expect(
+        result.current.workspacesByProjectIdAndDataset['NO_PROJECT_ID:NO_DATASET'].map((r) => r.id),
+      ).toEqual(['studio-no-project', 'studio-no-dataset'])
+
       expect(result.current.error).toBeNull()
       expect(result.current.isConnected).toBe(true)
     })