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

package/src/hooks/datasets/useDatasets.test.tsx

@@ -1,10 +1,6 @@
 import {type DatasetsResponse} from '@sanity/client'
-import {
-  createSanityInstance,
-  getDatasetsState,
-  resolveDatasets,
-  type StateSource,
-} from '@sanity/sdk'
+import {createSanityInstance, datasets, type StateSource} from '@sanity/sdk'
+import {type FetcherSnapshot} from '@sanity/sdk/_internal'
 import {type ReactNode} from 'react'
 import {type Observable} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
@@ -16,32 +12,43 @@ import {useDatasets} from './useDatasets'
 
 vi.mock('@sanity/sdk', async (importOriginal) => {
   const original = await importOriginal<typeof import('@sanity/sdk')>()
-  return {...original, getDatasetsState: vi.fn(), resolveDatasets: vi.fn()}
+  return {...original, datasets: {getState: vi.fn(), resolveState: vi.fn()}}
 })
 
 const stateSource = (
   current: DatasetsResponse | undefined,
-): StateSource<DatasetsResponse | undefined> =>
-  ({
-    getCurrent: vi.fn(() => current),
-    subscribe: vi.fn(),
+): StateSource<FetcherSnapshot<DatasetsResponse>> => {
+  // Cache the snapshot: useSyncExternalStore requires a referentially stable current value.
+  const snapshot = current
+    ? {status: 'success', data: current, error: undefined, isFetching: false, dataUpdatedAt: 1}
+    : {
+        status: 'pending',
+        data: undefined,
+        error: undefined,
+        isFetching: true,
+        dataUpdatedAt: undefined,
+      }
+  return {
+    getCurrent: vi.fn(() => snapshot),
+    subscribe: vi.fn(() => () => {}),
     get observable(): Observable<unknown> {
       throw new Error('Not implemented')
     },
-  }) as unknown as StateSource<DatasetsResponse | undefined>
+  } as unknown as StateSource<FetcherSnapshot<DatasetsResponse>>
+}
 
 const sanityInstance = expect.objectContaining({config: expect.any(Object)})
 
 describe('useDatasets', () => {
   beforeEach(() => {
     vi.clearAllMocks()
-    vi.mocked(getDatasetsState).mockReturnValue(stateSource([] as unknown as DatasetsResponse))
+    vi.mocked(datasets.getState).mockReturnValue(stateSource([] as unknown as DatasetsResponse))
   })
 
   it('resolves the projectId from the instance config resource', () => {
     // test-utils wraps with ResourceProvider projectId="test" dataset="test".
     renderHook(() => useDatasets())
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       sanityInstance,
       expect.objectContaining({projectId: 'test'}),
     )
@@ -49,7 +56,7 @@ describe('useDatasets', () => {
 
   it('lets an explicit projectId override the ambient resource', () => {
     renderHook(() => useDatasets({projectId: 'explicit-project'}))
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       sanityInstance,
       expect.objectContaining({projectId: 'explicit-project'}),
     )
@@ -66,7 +73,7 @@ describe('useDatasets', () => {
         </ResourceProvider>
       ),
     })
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       sanityInstance,
       expect.objectContaining({projectId: 'resource-project'}),
     )
@@ -82,7 +89,7 @@ describe('useDatasets', () => {
     })
     // A dataset-less config can't form a DatasetResource; the projectId is carried
     // via ProjectContext and injected so project-scoped reads still resolve it.
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       sanityInstance,
       expect.objectContaining({projectId: 'config-project'}),
     )
@@ -101,16 +108,16 @@ describe('useDatasets', () => {
         </SanityInstanceContext.Provider>
       ),
     })
-    expect(getDatasetsState).toHaveBeenCalledWith(
+    expect(datasets.getState).toHaveBeenCalledWith(
       emptyInstance,
       expect.objectContaining({projectId: 'bare-project'}),
     )
   })
 
-  it('suspends via resolveDatasets until dataset data is available', () => {
-    vi.mocked(getDatasetsState).mockReturnValue(stateSource(undefined))
-    vi.mocked(resolveDatasets).mockReturnValue(new Promise(() => {}))
+  it('suspends via the datasets fetcher until dataset data is available', () => {
+    vi.mocked(datasets.getState).mockReturnValue(stateSource(undefined))
+    vi.mocked(datasets.resolveState).mockReturnValue(new Promise(() => {}))
     renderHook(() => useDatasets())
-    expect(resolveDatasets).toHaveBeenCalled()
+    expect(datasets.resolveState).toHaveBeenCalled()
   })
 })

package/src/hooks/datasets/useDatasets.ts

@@ -1,64 +1,42 @@
 import {type DatasetsResponse} from '@sanity/client'
-import {
-  getDatasetsState,
-  type ProjectHandle,
-  resolveDatasets,
-  type SanityInstance,
-  type StateSource,
-} from '@sanity/sdk'
+import {datasets, type ProjectHandle} from '@sanity/sdk'
 
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
 import {useResolvedProjectId} from '../helpers/useResolvedProjectId'
 
-type UseDatasets = {
-  /**
-   *
-   * Returns metadata for each dataset the current user has access to.
-   *
-   * @category Datasets
-   * @param options - Optional project/resource to read datasets for. Defaults to
-   *   the resource named in `ResourceProvider`/`SDKProvider`.
-   * @returns The metadata for your the datasets
-   *
-   * @example
-   * ```tsx
-   * const datasets = useDatasets()
-   *
-   * return (
-   *   <select>
-   *     {datasets.map((dataset) => (
-   *       <option key={dataset.name}>{dataset.name}</option>
-   *     ))}
-   *   </select>
-   * )
-   * ```
-   *
-   * @remarks
-   * The `projectId` is resolved in order from:
-   * 1. an explicit `projectId` option
-   * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
-   * 3. The active resource (`ResourceProvider`/`SDKProvider`)
-   * 4. `instance.config`.
-   */
-  (options?: ProjectHandle): DatasetsResponse
-}
-
-const useDatasetsBase = createStateSourceHook({
-  getState: getDatasetsState as (
-    instance: SanityInstance,
-    projectHandle?: ProjectHandle,
-  ) => StateSource<DatasetsResponse>,
-  shouldSuspend: (instance, projectHandle?: ProjectHandle) =>
-    // remove `undefined` since we're suspending when that is the case
-    getDatasetsState(instance, projectHandle).getCurrent() === undefined,
-  suspender: resolveDatasets,
-})
+const useDatasetsBase = createFetcherHook(datasets)
 
 /**
+ * Returns metadata for each dataset the current user has access to.
+ *
+ * @category Datasets
+ * @param options - Optional project/resource to read datasets for. Defaults to
+ *   the resource named in `ResourceProvider`/`SDKProvider`.
+ * @returns A {@link FetcherHookResult} whose `data` is the metadata for the
+ *   datasets.
+ *
+ * @example
+ * ```tsx
+ * const {data: datasets} = useDatasets()
+ *
+ * return (
+ *   <select>
+ *     {datasets.map((dataset) => (
+ *       <option key={dataset.name}>{dataset.name}</option>
+ *     ))}
+ *   </select>
+ * )
+ * ```
+ *
+ * @remarks
+ * The `projectId` is resolved in order from:
+ * 1. an explicit `projectId` option
+ * 2. A legacy ProjectContext (e.g. a `<ResourceProvider projectId="…">` with no dataset), then
+ * 3. The active resource (`ResourceProvider`/`SDKProvider`)
+ * 4. `instance.config`.
  * @public
- * @function
  */
-export const useDatasets: UseDatasets = (options) => {
+export function useDatasets(options?: ProjectHandle): FetcherHookResult<DatasetsResponse> {
   const projectId = useResolvedProjectId(options)
   return useDatasetsBase(projectId ? {...options, projectId} : options)
 }

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

@@ -1,379 +0,0 @@
-import {type Message} from '@sanity/comlink'
-import {type FavoriteStatusResponse, getFavoritesState, resolveFavoritesState} from '@sanity/sdk'
-import {act, renderHook} from '@testing-library/react'
-import {BehaviorSubject} from 'rxjs'
-import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
-
-import {ResourceProvider} from '../../context/ResourceProvider'
-import {useWindowConnection, type WindowConnection} from '../comlink/useWindowConnection'
-import {useManageFavorite} from './useManageFavorite'
-
-type MockFetch = (type: string, data?: unknown, options?: unknown) => Promise<{success: boolean}>
-type MockSendMessage = (type: string, data?: unknown) => void
-
-vi.mock(import('@sanity/sdk'), async (importOriginal) => {
-  const actual = await importOriginal()
-  return {
-    ...actual,
-    getFavoritesState: vi.fn(),
-    resolveFavoritesState: vi.fn(),
-  }
-})
-
-vi.mock('../comlink/useWindowConnection', () => ({
-  useWindowConnection: vi.fn(),
-}))
-
-describe('useManageFavorite', () => {
-  let favoriteStatusSubject: BehaviorSubject<FavoriteStatusResponse>
-  let mockFetch: Mock<MockFetch>
-  let mockSendMessage: Mock<MockSendMessage>
-
-  const mockDocumentHandle = {
-    documentId: 'mock-id',
-    documentType: 'mock-type',
-    resourceType: 'studio' as const,
-  }
-
-  beforeEach(() => {
-    favoriteStatusSubject = new BehaviorSubject<FavoriteStatusResponse>({isFavorited: false})
-
-    // Mock getFavoritesState
-    vi.mocked(getFavoritesState).mockImplementation(() => ({
-      subscribe: (callback?: () => void) => {
-        if (!callback) return () => {}
-
-        const subscription = favoriteStatusSubject.subscribe(() => callback())
-        callback() // Initial call
-        return () => subscription.unsubscribe()
-      },
-      getCurrent: () => favoriteStatusSubject.getValue(),
-      observable: favoriteStatusSubject.asObservable(),
-    }))
-
-    // Mock resolveFavoritesState
-    vi.mocked(resolveFavoritesState).mockImplementation(async () => {
-      const newValue = {isFavorited: !favoriteStatusSubject.getValue().isFavorited}
-      favoriteStatusSubject.next(newValue)
-      return newValue
-    })
-
-    // Mock useWindowConnection
-    mockFetch = vi.fn<MockFetch>().mockResolvedValue({success: true})
-    mockSendMessage = vi.fn<MockSendMessage>()
-    vi.mocked(useWindowConnection).mockImplementation(
-      () =>
-        ({
-          fetch: (type: string, data?: unknown, options: unknown = {}) =>
-            mockFetch(type, data, options),
-          sendMessage: mockSendMessage,
-        }) as unknown as WindowConnection<Message>,
-    )
-  })
-
-  afterEach(() => {
-    favoriteStatusSubject.complete()
-    vi.clearAllMocks()
-  })
-
-  it('should initialize with default states', () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-
-    expect(result.current.isFavorited).toBe(false)
-  })
-
-  it('should handle favorite action and update state', async () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test" dataset="test" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-
-    expect(result.current.isFavorited).toBe(false)
-
-    await act(async () => {
-      await result.current.favorite()
-    })
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      'dashboard/v1/events/favorite/mutate',
-      {
-        document: {
-          id: 'mock-id',
-          type: 'mock-type',
-          resource: {
-            id: 'test.test',
-            type: 'studio',
-          },
-        },
-        eventType: 'added',
-      },
-      // empty options object (from useWindowConnection)
-      {},
-    )
-    expect(resolveFavoritesState).toHaveBeenCalled()
-    expect(result.current.isFavorited).toBe(true)
-  })
-
-  it('should handle unfavorite action and update state', async () => {
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test" dataset="test" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-
-    // Set initial state to favorited
-    await act(async () => {
-      favoriteStatusSubject.next({isFavorited: true})
-    })
-
-    expect(result.current.isFavorited).toBe(true)
-
-    await act(async () => {
-      await result.current.unfavorite()
-    })
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      'dashboard/v1/events/favorite/mutate',
-      {
-        document: {
-          id: 'mock-id',
-          type: 'mock-type',
-          resource: {
-            id: 'test.test',
-            type: 'studio',
-          },
-        },
-        eventType: 'removed',
-      },
-      {},
-    )
-    expect(resolveFavoritesState).toHaveBeenCalled()
-    expect(result.current.isFavorited).toBe(false)
-  })
-
-  it('should not update state if favorite action fails', async () => {
-    mockFetch.mockResolvedValueOnce({success: false})
-
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-
-    expect(result.current.isFavorited).toBe(false)
-
-    await act(async () => {
-      await result.current.favorite()
-    })
-
-    expect(resolveFavoritesState).not.toHaveBeenCalled()
-    expect(result.current.isFavorited).toBe(false)
-  })
-
-  it('should throw error during favorite/unfavorite actions', async () => {
-    const errorMessage = 'Failed to update favorite status'
-    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-
-    mockFetch.mockImplementation(() => {
-      throw new Error(errorMessage)
-    })
-
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-
-    await act(async () => {
-      await expect(result.current.favorite()).rejects.toThrow(errorMessage)
-    })
-
-    expect(resolveFavoritesState).not.toHaveBeenCalled()
-    expect(result.current.isFavorited).toBe(false)
-
-    await act(async () => {
-      await expect(result.current.unfavorite()).rejects.toThrow(errorMessage)
-    })
-
-    expect(resolveFavoritesState).not.toHaveBeenCalled()
-    consoleErrorSpy.mockRestore()
-  })
-
-  it('should throw error when studio resource is missing projectId or dataset', () => {
-    const mockDocumentHandleWithoutProjectId = {
-      documentId: 'mock-id',
-      documentType: 'mock-type',
-      resourceType: 'studio' as const,
-    }
-
-    expect(() =>
-      renderHook(() => useManageFavorite(mockDocumentHandleWithoutProjectId), {
-        wrapper: ({children}) => (
-          <ResourceProvider projectId={undefined} dataset={undefined} fallback={null}>
-            {children}
-          </ResourceProvider>
-        ),
-      }),
-    ).toThrow('projectId and dataset are required for studio resources')
-  })
-
-  it('should throw error when resourceId is missing for non-studio resources', () => {
-    const mockMediaDocumentHandle = {
-      documentId: 'mock-id',
-      documentType: 'mock-type',
-      resourceType: 'media-library' as const,
-      resourceId: undefined,
-    }
-
-    expect(() =>
-      renderHook(() => useManageFavorite(mockMediaDocumentHandle), {
-        wrapper: ({children}) => (
-          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-            {children}
-          </ResourceProvider>
-        ),
-      }),
-    ).toThrow('resourceId is required for media-library and canvas resources')
-  })
-
-  it('should include schemaName in payload when provided', async () => {
-    const mockDocumentHandleWithSchema = {
-      ...mockDocumentHandle,
-      schemaName: 'testSchema',
-    }
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandleWithSchema), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-
-    await act(async () => {
-      await result.current.favorite()
-    })
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      'dashboard/v1/events/favorite/mutate',
-      {
-        document: {
-          id: 'mock-id',
-          type: 'mock-type',
-          resource: {
-            id: 'test-project.test-dataset',
-            type: 'studio',
-            schemaName: 'testSchema',
-          },
-        },
-        eventType: 'added',
-      },
-      {},
-    )
-  })
-
-  it('should default isFavorited to false if state is undefined', () => {
-    // Mock getFavoritesState to return undefined for getCurrent
-    vi.mocked(getFavoritesState).mockImplementation(() => ({
-      subscribe: (callback?: () => void) => {
-        if (!callback) return () => {}
-        callback()
-        return () => {}
-      },
-      getCurrent: () => undefined,
-      observable: favoriteStatusSubject.asObservable(),
-    }))
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-    expect(result.current.isFavorited).toBe(false)
-  })
-
-  it('should do nothing if fetch is missing', async () => {
-    vi.mocked(useWindowConnection).mockReturnValue({
-      fetch: undefined,
-      sendMessage: mockSendMessage,
-    } as unknown as WindowConnection<Message>)
-    const {result} = renderHook(() => useManageFavorite(mockDocumentHandle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-    await act(async () => {
-      await result.current.favorite()
-      await result.current.unfavorite()
-    })
-    expect(mockFetch).not.toHaveBeenCalled()
-  })
-
-  it('should do nothing if documentId is missing', async () => {
-    const handle = {...mockDocumentHandle, documentId: undefined}
-    // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-    await act(async () => {
-      await result.current.favorite()
-      await result.current.unfavorite()
-    })
-    expect(mockFetch).not.toHaveBeenCalled()
-  })
-
-  it('should do nothing if documentType is missing', async () => {
-    const handle = {...mockDocumentHandle, documentType: undefined}
-    // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-    await act(async () => {
-      await result.current.favorite()
-      await result.current.unfavorite()
-    })
-    expect(mockFetch).not.toHaveBeenCalled()
-  })
-
-  it('should do nothing if resourceType is missing', async () => {
-    const handle = {...mockDocumentHandle, resourceType: undefined, resourceId: 'studio'}
-    // @ts-expect-error -- no access to ManageFavorite props type
-    const {result} = renderHook(() => useManageFavorite(handle), {
-      wrapper: ({children}) => (
-        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
-          {children}
-        </ResourceProvider>
-      ),
-    })
-    await act(async () => {
-      await result.current.favorite()
-      await result.current.unfavorite()
-    })
-    expect(mockFetch).not.toHaveBeenCalled()
-  })
-})