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

package/src/context/workbenchToken.ts

@@ -0,0 +1,63 @@
+import {from, type Observable, of} from 'rxjs'
+import {catchError, switchMap} from 'rxjs/operators'
+
+// The workbench host installs its shared message bus on this well-known global
+// symbol before it loads federated remotes. It must match the key used by
+// `@sanity/workbench` (`Symbol.for('sanity.os.bus')`).
+const OS_BUS_KEY = Symbol.for('sanity.os.bus')
+
+/**
+ * Whether this app is running as a federated remote inside the workbench.
+ *
+ * Federation shares the host's realm, so the installed bus is visible on
+ * `globalThis`. This is `false` in a standalone app, where we must never import
+ * `@sanity/workbench` (it would install a bus and add bundle weight for no
+ * reason). Note: this is a different embedding model to the Core UI iframe,
+ * which is detected separately via the dashboard context — that signal is not
+ * set on the federation path.
+ *
+ * @internal
+ */
+export function isWorkbenchEnvironment(): boolean {
+  return typeof globalThis === 'object' && OS_BUS_KEY in globalThis
+}
+
+/**
+ * Observes the session token issued by the workbench "OS", tracking the OS auth
+ * state over time.
+ *
+ * Returns `undefined` when the app is not embedded in the workbench, so the
+ * caller uses its normal auth flow. Inside the workbench, subscribes to the
+ * `auth.token` state topic, emitting the current token — or `null` when the OS
+ * is signed out — and re-emitting as the OS auth state changes, so sign-in/out
+ * propagates instead of being captured once. Any bus error is treated as "no
+ * token" (`null`). The token is used in-memory only and never persisted.
+ *
+ * @internal
+ */
+export function observeWorkbenchToken(): Observable<string | null> | undefined {
+  if (!isWorkbenchEnvironment()) return undefined
+
+  return from(import('@sanity/workbench')).pipe(
+    switchMap(({os}) => os.subscribe('auth.token')),
+    // Any failure (importing the host bundle, or the subscription) means "no OS token".
+    catchError(() => of(null)),
+  )
+}
+
+/**
+ * Asks the workbench "OS" to reissue the session token, e.g. after its current
+ * one was rejected with a 401. Fire-and-forget: the reissued token arrives via
+ * the `auth.token` subscription in {@link observeWorkbenchToken}. No-op outside
+ * the workbench.
+ *
+ * @internal
+ */
+export function refreshWorkbenchToken(): void {
+  if (!isWorkbenchEnvironment()) return
+
+  void import('@sanity/workbench').then(
+    ({os}) => os.emit('auth.token.refresh', undefined),
+    () => {},
+  )
+}

package/src/hooks/access/useCheckPermissions.test-d.ts

@@ -0,0 +1,15 @@
+import {expectTypeOf, test} from 'vitest'
+
+import {type FetcherHookResult} from '../helpers/createFetcherHook'
+import {useCheckPermissions} from './useCheckPermissions'
+
+test('useCheckPermissions — the result is keyed by exactly the permissions passed', () => {
+  const result = useCheckPermissions('project', 'proj_1', ['read', 'write'])
+  expectTypeOf(result).toEqualTypeOf<FetcherHookResult<Record<'read' | 'write', boolean>>>()
+  expectTypeOf(result.data).toEqualTypeOf<Record<'read' | 'write', boolean>>()
+})
+
+test('useCheckPermissions — rejects an unknown resource type', () => {
+  // @ts-expect-error — resourceType must be an AccessResourceType
+  void useCheckPermissions('not-a-resource', 'id', ['read'])
+})

package/src/hooks/access/useCheckPermissions.test.tsx

@@ -0,0 +1,53 @@
+import {checkPermissions, 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 {renderHook} from '../../../test/test-utils'
+import {useCheckPermissions} from './useCheckPermissions'
+
+vi.mock('@sanity/sdk', async (importOriginal) => {
+  const original = await importOriginal<typeof import('@sanity/sdk')>()
+  return {
+    ...original,
+    checkPermissions: {getState: vi.fn(), resolveState: vi.fn(), refetch: vi.fn()},
+  }
+})
+
+const stateSource = (
+  current: Record<string, boolean>,
+): StateSource<FetcherSnapshot<Record<string, boolean>>> => {
+  const snapshot = {
+    status: 'success',
+    data: current,
+    error: undefined,
+    isFetching: false,
+    dataUpdatedAt: 1,
+  }
+  return {
+    getCurrent: vi.fn(() => snapshot),
+    subscribe: vi.fn(() => () => {}),
+    get observable(): Observable<unknown> {
+      throw new Error('Not implemented')
+    },
+  } as unknown as StateSource<FetcherSnapshot<Record<string, boolean>>>
+}
+
+const sanityInstance = expect.objectContaining({config: expect.any(Object)})
+
+describe('useCheckPermissions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(checkPermissions.getState).mockReturnValue(stateSource({'sanity.project.read': true}))
+  })
+
+  it('forwards every param to the fetcher and returns the permission map', () => {
+    const {result} = renderHook(() =>
+      useCheckPermissions('project', 'proj_1', ['sanity.project.read']),
+    )
+    expect(checkPermissions.getState).toHaveBeenCalledWith(sanityInstance, 'project', 'proj_1', [
+      'sanity.project.read',
+    ])
+    expect(result.current.data).toEqual({'sanity.project.read': true})
+  })
+})

package/src/hooks/access/useCheckPermissions.ts

@@ -0,0 +1,24 @@
+import {type AccessResourceType, checkPermissions} from '@sanity/sdk'
+
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
+
+/**
+ * Checks whether the current user holds the given permissions on a resource.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * `data` maps each requested permission to whether the user has it — keyed by
+ * exactly the permission strings you passed.
+ *
+ * @public
+ * @param resourceType - The type of resource (e.g. `'project'`, `'organization'`).
+ * @param resourceId - The resource id.
+ * @param permissions - The permission names to check.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export const useCheckPermissions = createFetcherHook(checkPermissions) as <
+  Permission extends string,
+>(
+  resourceType: AccessResourceType,
+  resourceId: string,
+  permissions: Permission[],
+) => FetcherHookResult<Record<Permission, boolean>>

package/src/hooks/agent/agentActions.test.tsx

@@ -12,7 +12,7 @@ import {
   useAgentTranslate,
 } from './agentActions'
 
-vi.mock('@sanity/sdk', async (orig) => {
+vi.mock('@sanity/sdk/agent', async (orig) => {
   const actual = await orig()
   return {
     ...(actual as Record<string, any>),
@@ -26,7 +26,7 @@ vi.mock('@sanity/sdk', async (orig) => {
 
 describe('agent action hooks', () => {
   const wrapper = ({children}: {children: React.ReactNode}) => (
-    <ResourceProvider resource={{projectId: 'p', dataset: 'd'}} fallback={null}>
+    <ResourceProvider projectId="p" dataset="d" fallback={null}>
       {children}
     </ResourceProvider>
   )

package/src/hooks/agent/agentActions.ts

@@ -7,23 +7,17 @@ import {
   agentPrompt,
   type AgentPromptOptions,
   type AgentPromptResult,
-  type AgentResourceOptions,
   agentTransform,
   type AgentTransformOptions,
   agentTranslate,
   type AgentTranslateOptions,
-  type SanityInstance,
-} from '@sanity/sdk'
-import {useCallback, useContext} from 'react'
+} from '@sanity/sdk/agent'
+import {useCallback} from 'react'
 import {firstValueFrom} from 'rxjs'
 
-import {ResourceContext} from '../../context/DefaultResourceContext'
-import {ResourcesContext} from '../../context/ResourcesContext'
+import {type ResourceHandle} from '../../config/handles'
 import {useSanityInstance} from '../context/useSanityInstance'
-import {
-  normalizeResourceOptions,
-  type WithResourceNameSupport,
-} from '../helpers/useNormalizedResourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 
 interface Subscription {
   unsubscribe(): void
@@ -44,26 +38,6 @@ interface Subscribable<T> {
   ): Subscription
 }
 
-function useAgentCallback<TOptions extends object, TReturn>(
-  action: (instance: SanityInstance, options: TOptions & AgentResourceOptions) => TReturn,
-): (options: TOptions & WithResourceNameSupport<AgentResourceOptions>) => TReturn {
-  const instance = useSanityInstance()
-  const resources = useContext(ResourcesContext)
-  const contextResource = useContext(ResourceContext)
-  return useCallback(
-    (options: TOptions & WithResourceNameSupport<AgentResourceOptions>) => {
-      const {resource} = normalizeResourceOptions(
-        {resource: options.resource, resourceName: options.resourceName},
-        resources,
-        contextResource,
-      )
-      const {resourceName: _, ...rest} = options
-      return action(instance, {...rest, resource} as TOptions & AgentResourceOptions)
-    },
-    [instance, resources, contextResource, action],
-  )
-}
-
 /**
  * @alpha
  * Generates content for a document (or specific fields) via Sanity Agent Actions.
@@ -131,10 +105,16 @@ function useAgentCallback<TOptions extends object, TReturn>(
  *
  * @category Agent Actions
  */
-export function useAgentGenerate(): (
-  options: AgentGenerateOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Subscribable<unknown> {
-  return useAgentCallback<AgentGenerateOptions, Subscribable<unknown>>(agentGenerate)
+export function useAgentGenerate(
+  resourceHandle?: ResourceHandle,
+): (options: AgentGenerateOptions) => Subscribable<unknown> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentGenerateOptions) =>
+      agentGenerate(instance, options, resource) as unknown as Subscribable<unknown>,
+    [instance, resource],
+  )
 }
 
 /**
@@ -208,10 +188,16 @@ export function useAgentGenerate(): (
  *
  * @category Agent Actions
  */
-export function useAgentTransform(): (
-  options: AgentTransformOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Subscribable<unknown> {
-  return useAgentCallback<AgentTransformOptions, Subscribable<unknown>>(agentTransform)
+export function useAgentTransform(
+  resourceHandle?: ResourceHandle,
+): (options: AgentTransformOptions) => Subscribable<unknown> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentTransformOptions) =>
+      agentTransform(instance, options, resource) as unknown as Subscribable<unknown>,
+    [instance, resource],
+  )
 }
 
 /**
@@ -304,21 +290,16 @@ export function useAgentTransform(): (
  *
  * @category Agent Actions
  */
-export function useAgentTranslate(): (
-  options: AgentTranslateOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Subscribable<unknown> {
-  return useAgentCallback<AgentTranslateOptions, Subscribable<unknown>>(agentTranslate)
-}
-
-/**
- * @internal
- * Adapter to convert the agentPrompt observable to a Promise.
- */
-function promptAdapter(
-  instance: SanityInstance,
-  options: AgentPromptOptions & AgentResourceOptions,
-): Promise<AgentPromptResult> {
-  return firstValueFrom(agentPrompt(instance, options))
+export function useAgentTranslate(
+  resourceHandle?: ResourceHandle,
+): (options: AgentTranslateOptions) => Subscribable<unknown> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentTranslateOptions) =>
+      agentTranslate(instance, options, resource) as unknown as Subscribable<unknown>,
+    [instance, resource],
+  )
 }
 
 /**
@@ -415,21 +396,15 @@ function promptAdapter(
  *
  * @category Agent Actions
  */
-export function useAgentPrompt(): (
-  options: AgentPromptOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Promise<AgentPromptResult> {
-  return useAgentCallback<AgentPromptOptions, Promise<AgentPromptResult>>(promptAdapter)
-}
-
-/**
- * @internal
- * Adapter to convert the agentPatch observable to a Promise.
- */
-function patchAdapter(
-  instance: SanityInstance,
-  options: AgentPatchOptions & AgentResourceOptions,
-): Promise<AgentPatchResult> {
-  return firstValueFrom(agentPatch(instance, options))
+export function useAgentPrompt(
+  resourceHandle?: ResourceHandle,
+): (options: AgentPromptOptions) => Promise<AgentPromptResult> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentPromptOptions) => firstValueFrom(agentPrompt(instance, options, resource)),
+    [instance, resource],
+  )
 }
 
 /**
@@ -581,8 +556,13 @@ function patchAdapter(
  *
  * @category Agent Actions
  */
-export function useAgentPatch(): (
-  options: AgentPatchOptions & WithResourceNameSupport<AgentResourceOptions>,
-) => Promise<AgentPatchResult> {
-  return useAgentCallback<AgentPatchOptions, Promise<AgentPatchResult>>(patchAdapter)
+export function useAgentPatch(
+  resourceHandle?: ResourceHandle,
+): (options: AgentPatchOptions) => Promise<AgentPatchResult> {
+  const instance = useSanityInstance()
+  const {resource} = useNormalizedResourceOptions(resourceHandle ?? {})
+  return useCallback(
+    (options: AgentPatchOptions) => firstValueFrom(agentPatch(instance, options, resource)),
+    [instance, resource],
+  )
 }

package/src/hooks/agent/useAgentResourceContext.ts

@@ -1,5 +1,5 @@
 import {type Events, SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
-import {type FrameMessage} from '@sanity/sdk'
+import {type FrameMessage} from '@sanity/sdk/comlink'
 import {useCallback, useEffect, useRef} from 'react'
 
 import {useWindowConnection} from '../comlink/useWindowConnection'

package/src/hooks/applications/useApplication.test-d.ts

@@ -0,0 +1,30 @@
+import {
+  type Application,
+  type ApplicationDeployment,
+  type ApplicationStudioConfig,
+} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type FetcherHookResult} from '../helpers/createFetcherHook'
+import {useApplication} from './useApplication'
+
+test('useApplication — no include: the base application', () => {
+  const result = useApplication('app_1')
+  expectTypeOf(result).toEqualTypeOf<FetcherHookResult<Application<never>>>()
+  expectTypeOf<
+    Extract<keyof typeof result.data, 'activeDeployment' | 'config'>
+  >().toEqualTypeOf<never>()
+})
+
+test('useApplication — config.studio include adds config.studio', () => {
+  const result = useApplication('app_1', {include: ['config.studio']})
+  expectTypeOf(result.data).toEqualTypeOf<Application<'config.studio'>>()
+  expectTypeOf(result.data.config.studio).toEqualTypeOf<ApplicationStudioConfig>()
+})
+
+test('useApplication — a deployment-child include forces the deployment in', () => {
+  const result = useApplication('app_1', {include: ['activeDeployment']})
+  expectTypeOf(
+    result.data.activeDeployment,
+  ).toEqualTypeOf<ApplicationDeployment<'activeDeployment'> | null>()
+})

package/src/hooks/applications/useApplication.ts

@@ -0,0 +1,22 @@
+import {type Application, application, type ApplicationInclude} from '@sanity/sdk'
+
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
+
+/**
+ * Returns a single application by id.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * The `include` tokens you pass shape `data`: each requested token adds its
+ * field, and omitted ones are absent from the type.
+ *
+ * @public
+ * @param applicationId - The application id.
+ * @param options - Optional `include` list to expand related resources.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export const useApplication = createFetcherHook(application) as <
+  Include extends ApplicationInclude = never,
+>(
+  applicationId: string,
+  options?: {include?: Include[]},
+) => FetcherHookResult<Application<Include>>

package/src/hooks/applications/useApplications.test-d.ts

@@ -0,0 +1,31 @@
+import {type Application, type ApplicationInterface, type ApplicationsResponse} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type FetcherHookResult} from '../helpers/createFetcherHook'
+import {useApplications} from './useApplications'
+
+test('useApplications — no include: base items, no deployment or config', () => {
+  const result = useApplications({organizationId: 'org_1'})
+  expectTypeOf(result).toEqualTypeOf<FetcherHookResult<ApplicationsResponse<never>>>()
+  type Item = (typeof result.data.data)[number]
+  expectTypeOf<Extract<keyof Item, 'activeDeployment' | 'config'>>().toEqualTypeOf<never>()
+})
+
+test('useApplications — include shapes each item', () => {
+  const result = useApplications({organizationId: 'org_1', include: ['interfaces']})
+  expectTypeOf(result.data).toEqualTypeOf<ApplicationsResponse<'interfaces'>>()
+  type Item = (typeof result.data.data)[number]
+  expectTypeOf<NonNullable<Item['activeDeployment']>['interfaces']>().toEqualTypeOf<
+    ApplicationInterface[]
+  >()
+})
+
+test('useApplications — result data is the current include-narrowed application', () => {
+  const result = useApplications({organizationId: 'org_1', include: ['config.studio']})
+  expectTypeOf(result.data.data).toEqualTypeOf<Application<'config.studio'>[]>()
+})
+
+test('useApplications — requires an organizationId', () => {
+  // @ts-expect-error — organizationId is required
+  void useApplications({})
+})

package/src/hooks/applications/useApplications.ts

@@ -0,0 +1,25 @@
+import {
+  type ApplicationInclude,
+  applications,
+  type ApplicationsOptions,
+  type ApplicationsResponse,
+} from '@sanity/sdk'
+
+import {createFetcherHook, type FetcherHookResult} from '../helpers/createFetcherHook'
+
+/**
+ * Returns the applications matching the given options.
+ *
+ * The hook suspends until the first fetch succeeds, so `data` is always present.
+ * The `include` tokens you pass shape `data.data`: each requested token adds its
+ * field, and omitted ones are absent from the type.
+ *
+ * @public
+ * @param options - Filter and include options for the applications list.
+ * @returns The result envelope `{data, isFetching, error, refetch}`.
+ */
+export const useApplications = createFetcherHook(applications) as <
+  Include extends ApplicationInclude = never,
+>(
+  options: ApplicationsOptions<Include>,
+) => FetcherHookResult<ApplicationsResponse<Include>>

package/src/hooks/applications/useDeleteApplication.test-d.ts

@@ -0,0 +1,12 @@
+import {type DeleteApplicationInput, type DeletedResult} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type MutationHookResult} from '../helpers/createMutationHook'
+import {useDeleteApplication} from './useDeleteApplication'
+
+test('useDeleteApplication — returns the mutation envelope', () => {
+  const result = useDeleteApplication()
+  expectTypeOf(result).toEqualTypeOf<MutationHookResult<DeleteApplicationInput, DeletedResult>>()
+  expectTypeOf(result.mutate).parameter(0).toEqualTypeOf<DeleteApplicationInput>()
+  expectTypeOf(result.data).toEqualTypeOf<DeletedResult | undefined>()
+})

package/src/hooks/applications/useDeleteApplication.ts

@@ -0,0 +1,11 @@
+import {deleteApplication} from '@sanity/sdk'
+
+import {createMutationHook} from '../helpers/createMutationHook'
+
+/**
+ * Soft-deletes an application.
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
+ */
+export const useDeleteApplication = createMutationHook(deleteApplication)

package/src/hooks/applications/useUpdateApplication.test-d.ts

@@ -0,0 +1,12 @@
+import {type Application, type UpdateApplicationInput} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {type MutationHookResult} from '../helpers/createMutationHook'
+import {useUpdateApplication} from './useUpdateApplication'
+
+test('useUpdateApplication — returns the mutation envelope', () => {
+  const result = useUpdateApplication()
+  expectTypeOf(result).toEqualTypeOf<MutationHookResult<UpdateApplicationInput, Application>>()
+  expectTypeOf(result.mutate).parameter(0).toEqualTypeOf<UpdateApplicationInput>()
+  expectTypeOf(result.data).toEqualTypeOf<Application | undefined>()
+})

package/src/hooks/applications/useUpdateApplication.ts

@@ -0,0 +1,11 @@
+import {updateApplication} from '@sanity/sdk'
+
+import {createMutationHook} from '../helpers/createMutationHook'
+
+/**
+ * Updates an application's mutable properties (title, icon, visibility).
+ *
+ * @internal
+ * @returns The mutation envelope `{mutate, isPending, error, data, reset}`.
+ */
+export const useUpdateApplication = createMutationHook(updateApplication)

package/src/hooks/auth/useDashboardOrganizationId.test.tsx

@@ -22,10 +22,7 @@ describe('useDashboardOrganizationId', () => {
 
     const {result} = renderHook(() => useDashboardOrganizationId(), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -44,10 +41,7 @@ describe('useDashboardOrganizationId', () => {
 
     const {result} = renderHook(() => useDashboardOrganizationId(), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),

package/src/hooks/auth/useVerifyOrgProjects.test.tsx

@@ -26,10 +26,7 @@ describe('useVerifyOrgProjects', () => {
   it('should return null and not observe state if disabled', () => {
     const {result} = renderHook(() => useVerifyOrgProjects(true, testProjectIds), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -42,10 +39,7 @@ describe('useVerifyOrgProjects', () => {
   it('should return null and not observe state if projectIds is missing or empty', () => {
     const {result: resultUndefined} = renderHook(() => useVerifyOrgProjects(false, undefined), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -55,10 +49,7 @@ describe('useVerifyOrgProjects', () => {
 
     const {result: resultEmpty} = renderHook(() => useVerifyOrgProjects(false, []), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -73,10 +64,7 @@ describe('useVerifyOrgProjects', () => {
 
     const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -92,10 +80,7 @@ describe('useVerifyOrgProjects', () => {
 
     const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -117,10 +102,7 @@ describe('useVerifyOrgProjects', () => {
 
     const {result} = renderHook(() => useVerifyOrgProjects(false, testProjectIds), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -142,10 +124,7 @@ describe('useVerifyOrgProjects', () => {
 
     const {unmount} = renderHook(() => useVerifyOrgProjects(false, testProjectIds), {
       wrapper: ({children}) => (
-        <ResourceProvider
-          resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-          fallback={null}
-        >
+        <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
           {children}
         </ResourceProvider>
       ),
@@ -173,10 +152,7 @@ describe('useVerifyOrgProjects', () => {
       {
         initialProps: {disabled: false, pIds: testProjectIds},
         wrapper: ({children}) => (
-          <ResourceProvider
-            resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-            fallback={null}
-          >
+          <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
             {children}
           </ResourceProvider>
         ),