@sanity/sdk-react 0.0.0-rc.6 → 0.0.0

package/src/hooks/releases/usePerspective.test.tsx

@@ -0,0 +1,120 @@
+import {type ClientPerspective} from '@sanity/client'
+import {
+  getActiveReleasesState,
+  getPerspectiveState,
+  type PerspectiveHandle,
+  type ReleaseDocument,
+  type SanityInstance,
+} from '@sanity/sdk'
+import {renderHook} from '@testing-library/react'
+import {BehaviorSubject} from 'rxjs'
+import {describe, expect, it, vi} from 'vitest'
+
+import {useSanityInstance} from '../context/useSanityInstance'
+import {usePerspective} from './usePerspective'
+
+// Mock the useSanityInstance hook
+vi.mock('../context/useSanityInstance', () => ({
+  useSanityInstance: vi.fn(),
+}))
+
+// Mock the SDK functions
+vi.mock('@sanity/sdk', async () => {
+  const actual = await vi.importActual('@sanity/sdk')
+  return {
+    ...actual,
+    getPerspectiveState: vi.fn(),
+    // getPerspectiveState uses getActiveReleasesState
+    // to determine if it should suspend
+    getActiveReleasesState: vi.fn(),
+  }
+})
+
+describe('usePerspective', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should suspend when initial state is undefined', () => {
+    const mockInstance = {} as SanityInstance
+    vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
+
+    const perspectiveHandle: PerspectiveHandle = {
+      perspective: 'published',
+    }
+
+    const mockSubject = new BehaviorSubject<ClientPerspective | undefined>(undefined)
+    const mockStateSource = {
+      subscribe: vi.fn((callback) => {
+        const subscription = mockSubject.subscribe(callback)
+        return () => subscription.unsubscribe()
+      }),
+      getCurrent: vi.fn(() => undefined),
+      observable: mockSubject,
+    }
+
+    // Mock the active releases observable for the suspender
+    const mockReleaseDoc: ReleaseDocument = {
+      _id: 'release1',
+      _type: 'release',
+      _createdAt: '2021-01-01T00:00:00Z',
+      _updatedAt: '2021-01-01T00:00:00Z',
+      _rev: 'rev1',
+      name: 'Test Release',
+      metadata: {
+        title: 'Test Release',
+        releaseType: 'asap',
+      },
+    }
+    const mockReleasesSubject = new BehaviorSubject([mockReleaseDoc])
+    const mockReleasesStateSource = {
+      subscribe: vi.fn(),
+      getCurrent: vi.fn(),
+      observable: mockReleasesSubject,
+    }
+
+    vi.mocked(getPerspectiveState).mockReturnValue(mockStateSource)
+    vi.mocked(getActiveReleasesState).mockReturnValue(mockReleasesStateSource)
+
+    const {result} = renderHook(() => {
+      try {
+        return usePerspective(perspectiveHandle)
+      } catch (e) {
+        return e
+      }
+    })
+
+    // Verify that the hook threw a promise (suspended)
+    expect(result.current).toBeInstanceOf(Promise)
+    expect(mockStateSource.getCurrent).toHaveBeenCalled()
+  })
+
+  it('should resolve with perspective when data is available', () => {
+    const mockInstance = {} as SanityInstance
+    vi.mocked(useSanityInstance).mockReturnValue(mockInstance)
+
+    const perspectiveHandle: PerspectiveHandle = {
+      perspective: 'published',
+    }
+
+    const mockPerspective: ClientPerspective = 'published'
+    const mockSubject = new BehaviorSubject<ClientPerspective>(mockPerspective)
+    const mockStateSource = {
+      subscribe: vi.fn((callback) => {
+        const subscription = mockSubject.subscribe(callback)
+        return () => subscription.unsubscribe()
+      }),
+      getCurrent: vi.fn(() => mockPerspective),
+      observable: mockSubject,
+    }
+
+    vi.mocked(getPerspectiveState).mockReturnValue(mockStateSource)
+
+    const {result} = renderHook(() => usePerspective(perspectiveHandle))
+
+    // Verify that the hook returned the perspective without suspending
+    expect(result.current).toEqual(mockPerspective)
+    expect(mockStateSource.getCurrent).toHaveBeenCalled()
+    expect(getPerspectiveState).toHaveBeenCalledWith(mockInstance, perspectiveHandle)
+  })
+})

package/src/hooks/releases/usePerspective.ts

@@ -0,0 +1,50 @@
+import {
+  getActiveReleasesState,
+  getPerspectiveState,
+  type PerspectiveHandle,
+  type SanityInstance,
+  type StateSource,
+} from '@sanity/sdk'
+import {filter, firstValueFrom} from 'rxjs'
+
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
+
+/**
+ * @public
+ */
+type UsePerspective = {
+  (perspectiveHandle: PerspectiveHandle): string | string[]
+}
+
+/**
+ * @public
+ * @function
+ *
+ * Returns a single or stack of perspectives for the given perspective handle,
+ * which can then be used to correctly query the documents
+ * via the `perspective` parameter in the client.
+ *
+ * @param perspectiveHandle - The perspective handle to get the perspective for.
+ * @category Documents
+ * @example
+ * ```tsx
+ * import {usePerspective, useQuery} from '@sanity/sdk-react'
+
+ * const perspective = usePerspective({perspective: 'rxg1346', projectId: 'abc123', dataset: 'production'})
+ * const {data} = useQuery<Movie[]>('*[_type == "movie"]', {
+ *   perspective: perspective,
+ * })
+ * ```
+ *
+ * @returns The perspective for the given perspective handle.
+ */
+export const usePerspective: UsePerspective = createStateSourceHook({
+  getState: getPerspectiveState as (
+    instance: SanityInstance,
+    perspectiveHandle?: PerspectiveHandle,
+  ) => StateSource<string | string[]>,
+  shouldSuspend: (instance: SanityInstance, options?: PerspectiveHandle): boolean =>
+    getPerspectiveState(instance, options).getCurrent() === undefined,
+  suspender: (instance: SanityInstance, _options?: PerspectiveHandle) =>
+    firstValueFrom(getActiveReleasesState(instance).observable.pipe(filter(Boolean))),
+})