@sanity/sdk-react 2.18.0 → 3.0.0-rc.1

package/src/hooks/organizations/useOrganization.test-d.ts

@@ -4,37 +4,44 @@ import {expectTypeOf, test} from 'vitest'
 import {useOrganization} from './useOrganization'
 
 test('useOrganization — no flags: members and features both omitted', () => {
-  expectTypeOf(useOrganization({organizationId: 'org_1'})).toEqualTypeOf<
+  expectTypeOf(useOrganization({organizationId: 'org_1'}).data).toEqualTypeOf<
     Organization<false, false>
   >()
 })
 
+test('useOrganization — returns the FetcherHookResult envelope', () => {
+  const result = useOrganization({organizationId: 'org_1'})
+  expectTypeOf(result.isFetching).toEqualTypeOf<boolean>()
+  expectTypeOf(result.error).toEqualTypeOf<unknown>()
+  expectTypeOf(result.refetch).toEqualTypeOf<() => Promise<Organization<false, false>>>()
+})
+
 test('useOrganization — includeMembers: true adds members to the type', () => {
-  expectTypeOf(useOrganization({organizationId: 'org_1', includeMembers: true})).toEqualTypeOf<
+  expectTypeOf(useOrganization({organizationId: 'org_1', includeMembers: true}).data).toEqualTypeOf<
     Organization<true, false>
   >()
   type Result = ReturnType<typeof useOrganization<true, false>>
-  expectTypeOf<Result['members']>().toEqualTypeOf<OrganizationMember[]>()
+  expectTypeOf<Result['data']['members']>().toEqualTypeOf<OrganizationMember[]>()
 })
 
 test('useOrganization — includeFeatures: true adds features to the type', () => {
-  expectTypeOf(useOrganization({organizationId: 'org_1', includeFeatures: true})).toEqualTypeOf<
-    Organization<false, true>
-  >()
+  expectTypeOf(
+    useOrganization({organizationId: 'org_1', includeFeatures: true}).data,
+  ).toEqualTypeOf<Organization<false, true>>()
 })
 
 test('useOrganization — both flags true → both arrays present', () => {
   expectTypeOf(
-    useOrganization({organizationId: 'org_1', includeMembers: true, includeFeatures: true}),
+    useOrganization({organizationId: 'org_1', includeMembers: true, includeFeatures: true}).data,
   ).toEqualTypeOf<Organization<true, true>>()
 })
 
 test('useOrganization — both flags false → bare base shape', () => {
   expectTypeOf(
-    useOrganization({organizationId: 'org_1', includeMembers: false, includeFeatures: false}),
+    useOrganization({organizationId: 'org_1', includeMembers: false, includeFeatures: false}).data,
   ).toEqualTypeOf<Organization<false, false>>()
   type Result = ReturnType<typeof useOrganization<false, false>>
-  expectTypeOf<Result['id']>().toEqualTypeOf<string>()
+  expectTypeOf<Result['data']['id']>().toEqualTypeOf<string>()
 })
 
 test('useOrganization — rejects non-boolean flag values', () => {
@@ -44,10 +51,10 @@ test('useOrganization — rejects non-boolean flag values', () => {
 
 test('useOrganization — non-literal boolean flag makes members optional', () => {
   const includeMembers = false as boolean
-  expectTypeOf(useOrganization({organizationId: 'org_1', includeMembers})).toEqualTypeOf<
+  expectTypeOf(useOrganization({organizationId: 'org_1', includeMembers}).data).toEqualTypeOf<
     Organization<boolean, false>
   >()
   type Result = ReturnType<typeof useOrganization<boolean, false>>
-  expectTypeOf<Result['members']>().toEqualTypeOf<OrganizationMember[] | undefined>()
-  expectTypeOf<Pick<Result, 'members'>>().toEqualTypeOf<{members?: OrganizationMember[]}>()
+  expectTypeOf<Result['data']['members']>().toEqualTypeOf<OrganizationMember[] | undefined>()
+  expectTypeOf<Pick<Result['data'], 'members'>>().toEqualTypeOf<{members?: OrganizationMember[]}>()
 })

package/src/hooks/organizations/useOrganization.test.ts

@@ -1,65 +1,63 @@
-import {getOrganizationState, type OrganizationOptions, type SanityInstance} from '@sanity/sdk'
+import {type Organization, organization, type StateSource} from '@sanity/sdk'
+import {type FetcherSnapshot} from '@sanity/sdk/_internal'
+import {type Observable} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {renderHook} from '../../../test/test-utils'
+import {useOrganization} from './useOrganization'
 
-vi.mock('@sanity/sdk', () => ({
-  getOrganizationState: vi.fn(() => ({
-    getCurrent: vi.fn(() => undefined),
-  })),
-  resolveOrganization: vi.fn(),
-}))
-vi.mock('../helpers/createStateSourceHook', () => ({
-  createStateSourceHook: vi.fn(),
-}))
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...original, organization: {getState: vi.fn(), resolveState: vi.fn(), refetch: vi.fn()}}
+})
+
+const stateSource = (
+  current: Organization | undefined,
+): StateSource<FetcherSnapshot<Organization>> => {
+  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<FetcherSnapshot<Organization>>
+}
+
+const sanityInstance = expect.objectContaining({config: expect.any(Object)})
 
 describe('useOrganization', () => {
   beforeEach(() => {
-    vi.resetModules()
-    vi.mock('@sanity/sdk', () => ({
-      getOrganizationState: vi.fn(() => ({
-        getCurrent: vi.fn(() => undefined),
-      })),
-      resolveOrganization: vi.fn(),
-    }))
-    vi.mock('../helpers/createStateSourceHook', () => ({
-      createStateSourceHook: vi.fn(),
-    }))
-  })
-
-  it('should call createStateSourceHook with correct arguments on import', async () => {
-    await import('./useOrganization')
-
-    expect(createStateSourceHook).toHaveBeenCalled()
-    expect(createStateSourceHook).toHaveBeenCalledWith(
-      expect.objectContaining({
-        getState: expect.any(Function),
-        shouldSuspend: expect.any(Function),
-        suspender: expect.any(Function),
-      }),
+    vi.clearAllMocks()
+    vi.mocked(organization.getState).mockReturnValue(
+      stateSource({id: 'org_1'} as unknown as Organization),
     )
   })
 
-  it('shouldSuspend should call getOrganizationState and getCurrent', async () => {
-    await import('./useOrganization')
-
-    const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
-    expect(mockCreateStateSourceHook.mock.calls.length).toBeGreaterThan(0)
-    const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
-    const shouldSuspend = createStateSourceHookArgs.shouldSuspend
-
-    const mockInstance = {} as SanityInstance
-    const mockOptions: OrganizationOptions = {organizationId: 'org_1'}
-
-    const result = shouldSuspend(mockInstance, mockOptions)
-
-    const mockGetOrganizationState = getOrganizationState as ReturnType<typeof vi.fn>
-    expect(mockGetOrganizationState).toHaveBeenCalledWith(mockInstance, mockOptions)
+  it('reads the organization fetcher with the passed options', () => {
+    renderHook(() => useOrganization({organizationId: 'org_1'}))
+    expect(organization.getState).toHaveBeenCalledWith(sanityInstance, {organizationId: 'org_1'})
+  })
 
-    expect(mockGetOrganizationState.mock.results.length).toBeGreaterThan(0)
-    const getOrganizationStateMockResult = mockGetOrganizationState.mock.results[0].value
-    expect(getOrganizationStateMockResult.getCurrent).toHaveBeenCalled()
+  it('returns the fetcher data in the result envelope', () => {
+    const {result} = renderHook(() => useOrganization({organizationId: 'org_1'}))
+    expect(result.current.data).toEqual({id: 'org_1'})
+    expect(result.current.isFetching).toBe(false)
+    expect(typeof result.current.refetch).toBe('function')
+  })
 
-    expect(result).toBe(true)
+  it('suspends via the organization fetcher until data is available', () => {
+    vi.mocked(organization.getState).mockReturnValue(stateSource(undefined))
+    vi.mocked(organization.resolveState).mockReturnValue(new Promise(() => {}))
+    renderHook(() => useOrganization({organizationId: 'org_1'}))
+    expect(organization.resolveState).toHaveBeenCalled()
   })
 })

package/src/hooks/organizations/useOrganization.ts

@@ -1,40 +1,34 @@
-import {
-  getOrganizationState,
-  type Organization,
-  type OrganizationOptions,
-  resolveOrganization,
-} from '@sanity/sdk'
+import {type Organization, organization, type OrganizationOptions} from '@sanity/sdk'
 
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
 
 /**
  * Returns metadata for a given organisation.
  *
  * @category Organizations
  * @param options - Configuration options
- * @returns The metadata for the organisation. `members` is included only when
- *   `includeMembers: true`; `features` is included only when `includeFeatures: true`.
+ * @returns A {@link FetcherHookResult} whose `data` is the metadata for the
+ *   organisation. `members` is included only when `includeMembers: true`;
+ *   `features` is included only when `includeFeatures: true`.
  * @example
  * ```tsx
  * function OrganizationName({organizationId}: {organizationId: string}) {
- *   const organization = useOrganization({organizationId})
+ *   const {data: organization} = useOrganization({organizationId})
  *
  *   return <h1>{organization.name}</h1>
  * }
  * ```
  * @example
  * ```tsx
- * const organizationWithMembers = useOrganization({organizationId, includeMembers: true})
- * const organizationWithFeatures = useOrganization({organizationId, includeFeatures: true})
+ * const {data: organizationWithMembers} = useOrganization({organizationId, includeMembers: true})
+ * const {data: organizationWithFeatures} = useOrganization({organizationId, includeFeatures: true})
  * ```
  * @public
  * @function
  */
-export const useOrganization = createStateSourceHook({
-  getState: getOrganizationState,
-  shouldSuspend: (instance, ...params) =>
-    getOrganizationState(instance, ...params).getCurrent() === undefined,
-  suspender: resolveOrganization,
-}) as <IncludeMembers extends boolean = false, IncludeFeatures extends boolean = false>(
+export const useOrganization = createFetcherHook(organization) as <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+>(
   options: OrganizationOptions<IncludeMembers, IncludeFeatures>,
-) => Organization<IncludeMembers, IncludeFeatures>
+) => FetcherHookResult<Organization<IncludeMembers, IncludeFeatures>>

package/src/hooks/organizations/useOrganizations.test-d.ts

@@ -4,33 +4,42 @@ import {expectTypeOf, test} from 'vitest'
 import {useOrganizations} from './useOrganizations'
 
 test('useOrganizations — no args: members and features both omitted', () => {
-  expectTypeOf(useOrganizations()).toEqualTypeOf<Organizations<false, false>>()
+  expectTypeOf(useOrganizations().data).toEqualTypeOf<Organizations<false, false>>()
+})
+
+test('useOrganizations — returns the FetcherHookResult envelope', () => {
+  const result = useOrganizations()
+  expectTypeOf(result.isFetching).toEqualTypeOf<boolean>()
+  expectTypeOf(result.error).toEqualTypeOf<unknown>()
+  expectTypeOf(result.refetch).toEqualTypeOf<() => Promise<Organizations<false, false>>>()
 })
 
 test('useOrganizations — includeMembers: true adds members to the type', () => {
-  expectTypeOf(useOrganizations({includeMembers: true})).toEqualTypeOf<Organizations<true, false>>()
+  expectTypeOf(useOrganizations({includeMembers: true}).data).toEqualTypeOf<
+    Organizations<true, false>
+  >()
   type Result = ReturnType<typeof useOrganizations<true, false>>
-  expectTypeOf<Result[number]['members']>().toEqualTypeOf<OrganizationMember[]>()
+  expectTypeOf<Result['data'][number]['members']>().toEqualTypeOf<OrganizationMember[]>()
 })
 
 test('useOrganizations — includeFeatures: true adds features to the type', () => {
-  expectTypeOf(useOrganizations({includeFeatures: true})).toEqualTypeOf<
+  expectTypeOf(useOrganizations({includeFeatures: true}).data).toEqualTypeOf<
     Organizations<false, true>
   >()
 })
 
 test('useOrganizations — both flags true → both arrays present', () => {
-  expectTypeOf(useOrganizations({includeMembers: true, includeFeatures: true})).toEqualTypeOf<
+  expectTypeOf(useOrganizations({includeMembers: true, includeFeatures: true}).data).toEqualTypeOf<
     Organizations<true, true>
   >()
 })
 
 test('useOrganizations — both flags false → bare base shape', () => {
-  expectTypeOf(useOrganizations({includeMembers: false, includeFeatures: false})).toEqualTypeOf<
-    Organizations<false, false>
-  >()
+  expectTypeOf(
+    useOrganizations({includeMembers: false, includeFeatures: false}).data,
+  ).toEqualTypeOf<Organizations<false, false>>()
   type Result = ReturnType<typeof useOrganizations<false, false>>
-  expectTypeOf<Result[number]['id']>().toEqualTypeOf<string>()
+  expectTypeOf<Result['data'][number]['id']>().toEqualTypeOf<string>()
 })
 
 test('useOrganizations — rejects non-boolean flag values', () => {
@@ -39,17 +48,21 @@ test('useOrganizations — rejects non-boolean flag values', () => {
 })
 
 test('useOrganizations — includeImplicitMemberships does not change the data shape', () => {
-  expectTypeOf(useOrganizations({includeImplicitMemberships: true})).toEqualTypeOf<
+  expectTypeOf(useOrganizations({includeImplicitMemberships: true}).data).toEqualTypeOf<
     Organizations<false, false>
   >()
 })
 
 test('useOrganizations — non-literal boolean flag makes members optional', () => {
   const includeMembers = false as boolean
-  expectTypeOf(useOrganizations({includeMembers})).toEqualTypeOf<Organizations<boolean, false>>()
+  expectTypeOf(useOrganizations({includeMembers}).data).toEqualTypeOf<
+    Organizations<boolean, false>
+  >()
   type Result = ReturnType<typeof useOrganizations<boolean, false>>
-  expectTypeOf<Result[number]['members']>().toEqualTypeOf<OrganizationMember[] | undefined>()
-  expectTypeOf<Pick<Result[number], 'members'>>().toEqualTypeOf<{
+  expectTypeOf<Result['data'][number]['members']>().toEqualTypeOf<
+    OrganizationMember[] | undefined
+  >()
+  expectTypeOf<Pick<Result['data'][number], 'members'>>().toEqualTypeOf<{
     members?: OrganizationMember[]
   }>()
 })

package/src/hooks/organizations/useOrganizations.test.ts

@@ -1,85 +1,63 @@
-import {getOrganizationsState, type SanityInstance} from '@sanity/sdk'
+import {type Organizations, organizations, type StateSource} from '@sanity/sdk'
+import {type FetcherSnapshot} from '@sanity/sdk/_internal'
+import {type Observable} from 'rxjs'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {renderHook} from '../../../test/test-utils'
+import {useOrganizations} from './useOrganizations'
 
-vi.mock('@sanity/sdk', () => ({
-  getOrganizationsState: vi.fn(() => ({
-    getCurrent: vi.fn(() => undefined),
-  })),
-  resolveOrganizations: vi.fn(),
-}))
-vi.mock('../helpers/createStateSourceHook', () => ({
-  createStateSourceHook: vi.fn(),
-}))
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {...original, organizations: {getState: vi.fn(), resolveState: vi.fn(), refetch: vi.fn()}}
+})
+
+const stateSource = (
+  current: Organizations | undefined,
+): StateSource<FetcherSnapshot<Organizations>> => {
+  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<FetcherSnapshot<Organizations>>
+}
+
+const sanityInstance = expect.objectContaining({config: expect.any(Object)})
 
 describe('useOrganizations', () => {
   beforeEach(() => {
-    vi.resetModules()
-    vi.mock('@sanity/sdk', () => ({
-      getOrganizationsState: vi.fn(() => ({
-        getCurrent: vi.fn(() => undefined),
-      })),
-      resolveOrganizations: vi.fn(),
-    }))
-    vi.mock('../helpers/createStateSourceHook', () => ({
-      createStateSourceHook: vi.fn(),
-    }))
-  })
-
-  it('should call createStateSourceHook with correct arguments on import', async () => {
-    await import('./useOrganizations')
-
-    expect(createStateSourceHook).toHaveBeenCalled()
-    expect(createStateSourceHook).toHaveBeenCalledWith(
-      expect.objectContaining({
-        getState: expect.any(Function),
-        shouldSuspend: expect.any(Function),
-        suspender: expect.any(Function),
-      }),
+    vi.clearAllMocks()
+    vi.mocked(organizations.getState).mockReturnValue(
+      stateSource([{id: 'org_1'}] as unknown as Organizations),
     )
   })
 
-  it('shouldSuspend should call getOrganizationsState and getCurrent', async () => {
-    await import('./useOrganizations')
-
-    const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
-    expect(mockCreateStateSourceHook.mock.calls.length).toBeGreaterThan(0)
-    const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
-    const shouldSuspend = createStateSourceHookArgs.shouldSuspend
-
-    const mockInstance = {} as SanityInstance
-
-    const result = shouldSuspend(mockInstance, undefined)
-
-    const mockGetOrganizationsState = getOrganizationsState as ReturnType<typeof vi.fn>
-    expect(mockGetOrganizationsState).toHaveBeenCalledWith(mockInstance, undefined)
-
-    expect(mockGetOrganizationsState.mock.results.length).toBeGreaterThan(0)
-    const getOrganizationsStateMockResult = mockGetOrganizationsState.mock.results[0].value
-    expect(getOrganizationsStateMockResult.getCurrent).toHaveBeenCalled()
-
-    expect(result).toBe(true)
+  it('reads the organizations fetcher with the passed options', () => {
+    renderHook(() => useOrganizations({includeMembers: true}))
+    expect(organizations.getState).toHaveBeenCalledWith(sanityInstance, {includeMembers: true})
   })
 
-  it('should handle different parameter combinations in shouldSuspend', async () => {
-    await import('./useOrganizations')
-
-    const mockCreateStateSourceHook = createStateSourceHook as ReturnType<typeof vi.fn>
-    const createStateSourceHookArgs = mockCreateStateSourceHook.mock.calls[0][0]
-    const shouldSuspend = createStateSourceHookArgs.shouldSuspend
-
-    const mockInstance = {} as SanityInstance
+  it('returns the fetcher data in the result envelope', () => {
+    const {result} = renderHook(() => useOrganizations())
+    expect(result.current.data).toEqual([{id: 'org_1'}])
+    expect(result.current.isFetching).toBe(false)
+    expect(typeof result.current.refetch).toBe('function')
+  })
 
-    expect(() => shouldSuspend(mockInstance, undefined)).not.toThrow()
-    expect(() => shouldSuspend(mockInstance, {includeMembers: true})).not.toThrow()
-    expect(() => shouldSuspend(mockInstance, {includeFeatures: true})).not.toThrow()
-    expect(() =>
-      shouldSuspend(mockInstance, {
-        includeMembers: true,
-        includeFeatures: true,
-        includeImplicitMemberships: true,
-      }),
-    ).not.toThrow()
+  it('suspends via the organizations fetcher until data is available', () => {
+    vi.mocked(organizations.getState).mockReturnValue(stateSource(undefined))
+    vi.mocked(organizations.resolveState).mockReturnValue(new Promise(() => {}))
+    renderHook(() => useOrganizations())
+    expect(organizations.resolveState).toHaveBeenCalled()
   })
 })

package/src/hooks/organizations/useOrganizations.ts

@@ -1,22 +1,18 @@
-import {
-  getOrganizationsState,
-  type Organizations,
-  type OrganizationsOptions,
-  resolveOrganizations,
-} from '@sanity/sdk'
+import {type Organizations, organizations, type OrganizationsOptions} from '@sanity/sdk'
 
-import {createStateSourceHook} from '../helpers/createStateSourceHook'
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
 
 /**
  * Returns metadata for each organisation the current user has access to.
  *
  * @category Organizations
  * @param options - Configuration options
- * @returns An array of organisation metadata. `members` is included only when
- *   `includeMembers: true`; `features` is included only when `includeFeatures: true`.
+ * @returns A {@link FetcherHookResult} whose `data` is an array of organisation
+ *   metadata. `members` is included only when `includeMembers: true`; `features`
+ *   is included only when `includeFeatures: true`.
  * @example
  * ```tsx
- * const organizations = useOrganizations()
+ * const {data: organizations} = useOrganizations()
  *
  * return (
  *   <select>
@@ -28,18 +24,16 @@ import {createStateSourceHook} from '../helpers/createStateSourceHook'
  * ```
  * @example
  * ```tsx
- * const organizationsWithMembers = useOrganizations({includeMembers: true})
- * const organizationsWithFeatures = useOrganizations({includeFeatures: true})
- * const organizationsIncludingImplicit = useOrganizations({includeImplicitMemberships: true})
+ * const {data: organizationsWithMembers} = useOrganizations({includeMembers: true})
+ * const {data: organizationsWithFeatures} = useOrganizations({includeFeatures: true})
+ * const {data: organizationsIncludingImplicit} = useOrganizations({includeImplicitMemberships: true})
  * ```
  * @public
  * @function
  */
-export const useOrganizations = createStateSourceHook({
-  getState: getOrganizationsState,
-  shouldSuspend: (instance, ...params) =>
-    getOrganizationsState(instance, ...params).getCurrent() === undefined,
-  suspender: resolveOrganizations,
-}) as <IncludeMembers extends boolean = false, IncludeFeatures extends boolean = false>(
+export const useOrganizations = createFetcherHook(organizations) as <
+  IncludeMembers extends boolean = false,
+  IncludeFeatures extends boolean = false,
+>(
   options?: OrganizationsOptions<IncludeMembers, IncludeFeatures>,
-) => Organizations<IncludeMembers, IncludeFeatures>
+) => FetcherHookResult<Organizations<IncludeMembers, IncludeFeatures>>

package/src/hooks/projects/useProject.test-d.ts

@@ -4,31 +4,38 @@ import {expectTypeOf, test} from 'vitest'
 import {useProject} from './useProject'
 
 test('useProject — no args: members and features both included by default', () => {
-  expectTypeOf(useProject()).toEqualTypeOf<Project<true, true>>()
+  expectTypeOf(useProject().data).toEqualTypeOf<Project<true, true>>()
   type Result = ReturnType<typeof useProject<true, true>>
-  expectTypeOf<Result['members']>().toEqualTypeOf<ProjectMember[]>()
+  expectTypeOf<Result['data']['members']>().toEqualTypeOf<ProjectMember[]>()
+})
+
+test('useProject — returns the FetcherHookResult envelope', () => {
+  const result = useProject()
+  expectTypeOf(result.isFetching).toEqualTypeOf<boolean>()
+  expectTypeOf(result.error).toEqualTypeOf<unknown>()
+  expectTypeOf(result.refetch).toEqualTypeOf<() => Promise<Project<true, true>>>()
 })
 
 test('useProject — includeMembers: false drops members from the type', () => {
-  expectTypeOf(useProject({includeMembers: false})).toEqualTypeOf<Project<false, true>>()
+  expectTypeOf(useProject({includeMembers: false}).data).toEqualTypeOf<Project<false, true>>()
 })
 
 test('useProject — includeFeatures: false drops features from the type', () => {
-  expectTypeOf(useProject({includeFeatures: false})).toEqualTypeOf<Project<true, false>>()
+  expectTypeOf(useProject({includeFeatures: false}).data).toEqualTypeOf<Project<true, false>>()
 })
 
 test('useProject — both flags true → both arrays present', () => {
-  expectTypeOf(useProject({includeMembers: true, includeFeatures: true})).toEqualTypeOf<
+  expectTypeOf(useProject({includeMembers: true, includeFeatures: true}).data).toEqualTypeOf<
     Project<true, true>
   >()
 })
 
 test('useProject — both flags false → bare base shape', () => {
-  expectTypeOf(useProject({includeMembers: false, includeFeatures: false})).toEqualTypeOf<
+  expectTypeOf(useProject({includeMembers: false, includeFeatures: false}).data).toEqualTypeOf<
     Project<false, false>
   >()
   type Result = ReturnType<typeof useProject<false, false>>
-  expectTypeOf<Result['id']>().toEqualTypeOf<string>()
+  expectTypeOf<Result['data']['id']>().toEqualTypeOf<string>()
 })
 
 test('useProject — rejects non-boolean flag values', () => {
@@ -37,13 +44,13 @@ test('useProject — rejects non-boolean flag values', () => {
 })
 
 test('useProject — projectId alone does not change the data shape', () => {
-  expectTypeOf(useProject({projectId: 'p'})).toEqualTypeOf<Project<true, true>>()
+  expectTypeOf(useProject({projectId: 'p'}).data).toEqualTypeOf<Project<true, true>>()
 })
 
 test('useProject — non-literal boolean flag makes members optional', () => {
   const includeMembers = false as boolean
-  expectTypeOf(useProject({includeMembers})).toEqualTypeOf<Project<boolean, true>>()
+  expectTypeOf(useProject({includeMembers}).data).toEqualTypeOf<Project<boolean, true>>()
   type Result = ReturnType<typeof useProject<boolean, true>>
-  expectTypeOf<Result['members']>().toEqualTypeOf<ProjectMember[] | undefined>()
-  expectTypeOf<Pick<Result, 'members'>>().toEqualTypeOf<{members?: ProjectMember[]}>()
+  expectTypeOf<Result['data']['members']>().toEqualTypeOf<ProjectMember[] | undefined>()
+  expectTypeOf<Pick<Result['data'], 'members'>>().toEqualTypeOf<{members?: ProjectMember[]}>()
 })