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

package/src/context/renderSanityApp.test.tsx

@@ -1,4 +1,4 @@
-import {type SanityConfig} from '@sanity/sdk'
+import {type DocumentResource} from '@sanity/sdk'
 import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {SanityApp} from '../components/SanityApp'
@@ -26,6 +26,7 @@ vi.mock('react-dom/client', () => ({
 
 describe('renderSanityApp', () => {
   let rootElement: HTMLElement | null
+  let namedResources: Record<string, DocumentResource>
 
   beforeEach(() => {
     vi.clearAllMocks()
@@ -34,6 +35,9 @@ describe('renderSanityApp', () => {
     mockCreateRoot.mockClear()
     rootElement = document.createElement('div')
     document.body.appendChild(rootElement)
+    namedResources = {
+      default: {projectId: 'test-project', dataset: 'production'},
+    }
   })
 
   afterEach(() => {
@@ -44,53 +48,44 @@ describe('renderSanityApp', () => {
   })
 
   it('throws error when rootElement is null', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
-
-    expect(() => renderSanityApp(null, namedSources, {}, <div>Test</div>)).toThrowError(
+    expect(() => renderSanityApp(null, namedResources, {}, <div>Test</div>)).toThrowError(
       'Missing root element to mount application into',
     )
   })
 
   it('creates root with the provided element', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
-
-    renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
+    renderSanityApp(rootElement, namedResources, {}, <div>Test</div>)
 
     expect(mockCreateRoot).toHaveBeenCalledWith(rootElement)
     expect(mockCreateRoot).toHaveBeenCalledTimes(1)
   })
 
-  it('converts namedSources object to array of configs', () => {
-    const namedSources = {
-      main: {projectId: 'project-1', dataset: 'production'},
+  it('merges namedResources into a single config and resources map', () => {
+    namedResources = {
+      default: {projectId: 'project-1', dataset: 'production'},
       secondary: {projectId: 'project-2', dataset: 'staging'},
     }
 
-    renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
+    renderSanityApp(rootElement, namedResources, {}, <div>Test</div>)
 
     expect(mockRender).toHaveBeenCalledTimes(1)
     const renderCall = mockRender.mock.calls[0][0]
     expect(renderCall).toBeDefined()
 
-    // The renderCall is the SanityApp component directly when not using StrictMode
     expect(renderCall.type).toBe(SanityApp)
-    expect(renderCall.props.config).toEqual([
-      {projectId: 'project-1', dataset: 'production'},
-      {projectId: 'project-2', dataset: 'staging'},
-    ])
+    // config has no resource fields
+    expect(renderCall.props.config).toEqual(undefined)
+    // resources map is populated from named entries
+    expect(renderCall.props.resources).toEqual({
+      default: {projectId: 'project-1', dataset: 'production'},
+      secondary: {projectId: 'project-2', dataset: 'staging'},
+    })
   })
 
   it('renders without StrictMode when reactStrictMode is false', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
     const children = <div>Test Children</div>
 
-    renderSanityApp(rootElement, namedSources, {reactStrictMode: false}, children)
+    renderSanityApp(rootElement, namedResources, {reactStrictMode: false}, children)
 
     expect(mockRender).toHaveBeenCalledTimes(1)
     const renderCall = mockRender.mock.calls[0][0]
@@ -101,12 +96,9 @@ describe('renderSanityApp', () => {
   })
 
   it('renders without StrictMode by default', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
     const children = <div>Test Children</div>
 
-    renderSanityApp(rootElement, namedSources, {}, children)
+    renderSanityApp(rootElement, namedResources, {}, children)
 
     expect(mockRender).toHaveBeenCalledTimes(1)
     const renderCall = mockRender.mock.calls[0][0]
@@ -117,17 +109,14 @@ describe('renderSanityApp', () => {
   })
 
   it('renders with StrictMode when reactStrictMode is true', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
     const children = <div>Test Children</div>
 
-    renderSanityApp(rootElement, namedSources, {reactStrictMode: true}, children)
+    renderSanityApp(rootElement, namedResources, {reactStrictMode: true}, children)
 
     expect(mockRender).toHaveBeenCalledTimes(1)
     const renderCall = mockRender.mock.calls[0][0]
 
-    // Should have StrictMode wrapper (StrictMode is a Symbol in React 18)
+    // Should have StrictMode wrapper (StrictMode is a Symbol)
     expect(renderCall.type).toBeDefined()
     expect(renderCall.type.toString()).toContain('Symbol')
     const strictModeChild = renderCall.props.children
@@ -136,11 +125,7 @@ describe('renderSanityApp', () => {
   })
 
   it('passes loading fallback to SanityApp', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
-
-    renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
+    renderSanityApp(rootElement, namedResources, {}, <div>Test</div>)
 
     expect(mockRender).toHaveBeenCalledTimes(1)
     const renderCall = mockRender.mock.calls[0][0]
@@ -151,103 +136,51 @@ describe('renderSanityApp', () => {
   })
 
   it('returns an unmount function', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
-
-    const unmount = renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
+    const unmount = renderSanityApp(rootElement, namedResources, {}, <div>Test</div>)
 
     expect(typeof unmount).toBe('function')
   })
 
   it('calls root.unmount when unmount function is invoked', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
-
-    const unmount = renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
+    const unmount = renderSanityApp(rootElement, namedResources, {}, <div>Test</div>)
 
     expect(mockUnmount).not.toHaveBeenCalled()
     unmount()
     expect(mockUnmount).toHaveBeenCalledTimes(1)
   })
 
-  it('handles empty namedSources object', () => {
-    const namedSources = {}
+  it('handles empty namedResources object', () => {
+    namedResources = {}
 
-    renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
+    renderSanityApp(rootElement, namedResources, {}, <div>Test</div>)
 
     expect(mockRender).toHaveBeenCalledTimes(1)
     const renderCall = mockRender.mock.calls[0][0]
     const sanityAppElement = renderCall
 
     expect(sanityAppElement.type).toBe(SanityApp)
-    expect(sanityAppElement.props.config).toEqual([])
+    expect(sanityAppElement.props.config).toEqual(undefined)
+    expect(sanityAppElement.props.resources).toEqual({})
   })
 
   it('handles single namedSource', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
+    const namedResource = {
+      default: {projectId: 'test-project', dataset: 'production'},
     }
-
-    renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
+    renderSanityApp(rootElement, namedResource, {}, <div>Test</div>)
 
     expect(mockRender).toHaveBeenCalledTimes(1)
     const renderCall = mockRender.mock.calls[0][0]
     const sanityAppElement = renderCall
 
     expect(sanityAppElement.type).toBe(SanityApp)
-    expect(sanityAppElement.props.config).toEqual([
-      {projectId: 'test-project', dataset: 'production'},
-    ])
-  })
-
-  it('handles multiple namedSources', () => {
-    const namedSources = {
-      main: {projectId: 'project-1', dataset: 'production'},
-      blog: {projectId: 'project-2', dataset: 'staging'},
-      ecommerce: {projectId: 'project-3', dataset: 'development'},
-    }
-
-    renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
-
-    expect(mockRender).toHaveBeenCalledTimes(1)
-    const renderCall = mockRender.mock.calls[0][0]
-    const sanityAppElement = renderCall
-
-    expect(sanityAppElement.type).toBe(SanityApp)
-    expect(sanityAppElement.props.config).toHaveLength(3)
-    expect(sanityAppElement.props.config).toEqual([
-      {projectId: 'project-1', dataset: 'production'},
-      {projectId: 'project-2', dataset: 'staging'},
-      {projectId: 'project-3', dataset: 'development'},
-    ])
-  })
-
-  it('preserves order of namedSources in config array', () => {
-    const namedSources = {
-      z: {projectId: 'project-z', dataset: 'z-dataset'},
-      a: {projectId: 'project-a', dataset: 'a-dataset'},
-      m: {projectId: 'project-m', dataset: 'm-dataset'},
-    }
-
-    renderSanityApp(rootElement, namedSources, {}, <div>Test</div>)
-
-    const renderCall = mockRender.mock.calls[0][0]
-    const sanityAppElement = renderCall
-
-    // Object.values preserves insertion order in modern JS
-    expect(sanityAppElement.props.config).toEqual([
-      {projectId: 'project-z', dataset: 'z-dataset'},
-      {projectId: 'project-a', dataset: 'a-dataset'},
-      {projectId: 'project-m', dataset: 'm-dataset'},
-    ])
+    expect(sanityAppElement.props.config).toEqual(undefined)
+    expect(sanityAppElement.props.resources).toEqual({
+      default: {projectId: 'test-project', dataset: 'production'},
+    })
   })
 
   it('passes children to SanityApp', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
     const children = (
       <div>
         <h1>Test App</h1>
@@ -255,7 +188,7 @@ describe('renderSanityApp', () => {
       </div>
     )
 
-    renderSanityApp(rootElement, namedSources, {}, children)
+    renderSanityApp(rootElement, namedResources, {}, children)
 
     const renderCall = mockRender.mock.calls[0][0]
     const sanityAppElement = renderCall
@@ -264,12 +197,8 @@ describe('renderSanityApp', () => {
   })
 
   it('works with different types of children', () => {
-    const namedSources = {
-      main: {projectId: 'test-project', dataset: 'production'},
-    }
-
     // Test with string children
-    renderSanityApp(rootElement, namedSources, {}, 'String child')
+    renderSanityApp(rootElement, namedResources, {}, 'String child')
 
     let renderCall = mockRender.mock.calls[0][0]
     let sanityAppElement = renderCall
@@ -278,7 +207,7 @@ describe('renderSanityApp', () => {
 
     // Test with null children
     mockRender.mockClear()
-    renderSanityApp(rootElement, namedSources, {}, null)
+    renderSanityApp(rootElement, namedResources, {}, null)
 
     renderCall = mockRender.mock.calls[0][0]
     sanityAppElement = renderCall
@@ -288,7 +217,7 @@ describe('renderSanityApp', () => {
     // Test with array of children
     mockRender.mockClear()
     const arrayChildren = [<div key="1">Child 1</div>, <div key="2">Child 2</div>]
-    renderSanityApp(rootElement, namedSources, {}, arrayChildren)
+    renderSanityApp(rootElement, namedResources, {}, arrayChildren)
 
     renderCall = mockRender.mock.calls[0][0]
     sanityAppElement = renderCall
@@ -296,50 +225,19 @@ describe('renderSanityApp', () => {
     expect(sanityAppElement.props.children).toEqual(arrayChildren)
   })
 
-  it('integrates with StrictMode and passes all props correctly', () => {
-    const namedSources = {
-      main: {
-        projectId: 'test-project',
-        dataset: 'production',
-        apiVersion: '2023-01-01',
-      } as SanityConfig,
-      secondary: {
-        projectId: 'test-project-2',
-        dataset: 'staging',
-      } as SanityConfig,
-    }
-    const children = <div>App Content</div>
-
-    renderSanityApp(rootElement, namedSources, {reactStrictMode: true}, children)
-
-    const renderCall = mockRender.mock.calls[0][0]
-
-    // Verify StrictMode wrapper (StrictMode is a Symbol in React 18)
-    expect(renderCall.type).toBeDefined()
-    expect(renderCall.type.toString()).toContain('Symbol')
-
-    // Verify SanityApp is inside StrictMode
-    const strictModeChild = renderCall.props.children
-    expect(strictModeChild.type).toBe(SanityApp)
-
-    // Verify all props are passed correctly
-    expect(strictModeChild.props.config).toEqual([
-      {projectId: 'test-project', dataset: 'production', apiVersion: '2023-01-01'},
-      {projectId: 'test-project-2', dataset: 'staging'},
-    ])
-    expect(strictModeChild.props.fallback).toEqual(<div>Loading...</div>)
-    expect(strictModeChild.props.children).toEqual(children)
-  })
-
   it('can be called multiple times with different roots', () => {
     const rootElement2 = document.createElement('div')
     document.body.appendChild(rootElement2)
 
-    const namedSources1 = {main: {projectId: 'project-1', dataset: 'production'}}
-    const namedSources2 = {main: {projectId: 'project-2', dataset: 'staging'}}
+    const namedResources1 = {
+      default: {projectId: 'project-1', dataset: 'production'},
+    }
+    const namedResources2 = {
+      default: {projectId: 'project-2', dataset: 'staging'},
+    }
 
-    const unmount1 = renderSanityApp(rootElement, namedSources1, {}, <div>App 1</div>)
-    const unmount2 = renderSanityApp(rootElement2, namedSources2, {}, <div>App 2</div>)
+    const unmount1 = renderSanityApp(rootElement, namedResources1, {}, <div>App 1</div>)
+    const unmount2 = renderSanityApp(rootElement2, namedResources2, {}, <div>App 2</div>)
 
     expect(mockCreateRoot).toHaveBeenCalledTimes(2)
     expect(mockCreateRoot).toHaveBeenNthCalledWith(1, rootElement)

package/src/context/renderSanityApp.tsx

@@ -1,4 +1,4 @@
-import {type SanityConfig} from '@sanity/sdk'
+import {type DocumentResource} from '@sanity/sdk'
 import {StrictMode} from 'react'
 import {createRoot} from 'react-dom/client'
 
@@ -8,16 +8,14 @@ interface RenderSanitySDKAppOptions {
   reactStrictMode?: boolean
 }
 
-/** In-flight CLI PR is using named sources since it's aspirational.
- *  We can transform the shape in this function until it's finalized.
- */
-interface NamedSources {
-  [key: string]: SanityConfig
+interface NamedResources {
+  [key: string]: DocumentResource
 }
+
 /** @internal */
 export function renderSanityApp(
   rootElement: HTMLElement | null,
-  namedSources: NamedSources,
+  namedResources: NamedResources,
   options: RenderSanitySDKAppOptions,
   children: React.ReactNode,
 ): () => void {
@@ -27,18 +25,16 @@ export function renderSanityApp(
   const {reactStrictMode = false} = options
 
   const root = createRoot(rootElement)
-  const config = Object.values(namedSources)
-
   root.render(
     reactStrictMode ? (
       <StrictMode>
-        {/* TODO: think about a loading component we want to be "universal" */}
-        <SanityApp config={config} fallback={<div>Loading...</div>}>
+        {/* TODO: we should find some way to pass top-level config, like auth, from a flatfile */}
+        <SanityApp resources={namedResources} fallback={<div>Loading...</div>}>
           {children}
         </SanityApp>
       </StrictMode>
     ) : (
-      <SanityApp config={config} fallback={<div>Loading...</div>}>
+      <SanityApp resources={namedResources} fallback={<div>Loading...</div>}>
         {children}
       </SanityApp>
     ),

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

@@ -26,7 +26,7 @@ vi.mock('@sanity/sdk', async (orig) => {
 
 describe('agent action hooks', () => {
   const wrapper = ({children}: {children: React.ReactNode}) => (
-    <ResourceProvider projectId="p" dataset="d" fallback={null}>
+    <ResourceProvider resource={{projectId: 'p', dataset: 'd'}} fallback={null}>
       {children}
     </ResourceProvider>
   )

package/src/hooks/agent/agentActions.ts

@@ -7,15 +7,23 @@ import {
   agentPrompt,
   type AgentPromptOptions,
   type AgentPromptResult,
+  type AgentResourceOptions,
   agentTransform,
   type AgentTransformOptions,
   agentTranslate,
   type AgentTranslateOptions,
   type SanityInstance,
 } from '@sanity/sdk'
+import {useCallback, useContext} from 'react'
 import {firstValueFrom} from 'rxjs'
 
-import {createCallbackHook} from '../helpers/createCallbackHook'
+import {ResourceContext} from '../../context/DefaultResourceContext'
+import {ResourcesContext} from '../../context/ResourcesContext'
+import {useSanityInstance} from '../context/useSanityInstance'
+import {
+  normalizeResourceOptions,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
 
 interface Subscription {
   unsubscribe(): void
@@ -36,6 +44,26 @@ 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.
@@ -103,10 +131,11 @@ interface Subscribable<T> {
  *
  * @category Agent Actions
  */
-export const useAgentGenerate: () => (options: AgentGenerateOptions) => Subscribable<unknown> =
-  createCallbackHook(agentGenerate) as unknown as () => (
-    options: AgentGenerateOptions,
-  ) => Subscribable<unknown>
+export function useAgentGenerate(): (
+  options: AgentGenerateOptions & WithResourceNameSupport<AgentResourceOptions>,
+) => Subscribable<unknown> {
+  return useAgentCallback<AgentGenerateOptions, Subscribable<unknown>>(agentGenerate)
+}
 
 /**
  * @alpha
@@ -179,10 +208,11 @@ export const useAgentGenerate: () => (options: AgentGenerateOptions) => Subscrib
  *
  * @category Agent Actions
  */
-export const useAgentTransform: () => (options: AgentTransformOptions) => Subscribable<unknown> =
-  createCallbackHook(agentTransform) as unknown as () => (
-    options: AgentTransformOptions,
-  ) => Subscribable<unknown>
+export function useAgentTransform(): (
+  options: AgentTransformOptions & WithResourceNameSupport<AgentResourceOptions>,
+) => Subscribable<unknown> {
+  return useAgentCallback<AgentTransformOptions, Subscribable<unknown>>(agentTransform)
+}
 
 /**
  * @alpha
@@ -274,10 +304,11 @@ export const useAgentTransform: () => (options: AgentTransformOptions) => Subscr
  *
  * @category Agent Actions
  */
-export const useAgentTranslate: () => (options: AgentTranslateOptions) => Subscribable<unknown> =
-  createCallbackHook(agentTranslate) as unknown as () => (
-    options: AgentTranslateOptions,
-  ) => Subscribable<unknown>
+export function useAgentTranslate(): (
+  options: AgentTranslateOptions & WithResourceNameSupport<AgentResourceOptions>,
+) => Subscribable<unknown> {
+  return useAgentCallback<AgentTranslateOptions, Subscribable<unknown>>(agentTranslate)
+}
 
 /**
  * @internal
@@ -285,7 +316,7 @@ export const useAgentTranslate: () => (options: AgentTranslateOptions) => Subscr
  */
 function promptAdapter(
   instance: SanityInstance,
-  options: AgentPromptOptions,
+  options: AgentPromptOptions & AgentResourceOptions,
 ): Promise<AgentPromptResult> {
   return firstValueFrom(agentPrompt(instance, options))
 }
@@ -384,8 +415,11 @@ function promptAdapter(
  *
  * @category Agent Actions
  */
-export const useAgentPrompt: () => (options: AgentPromptOptions) => Promise<AgentPromptResult> =
-  createCallbackHook(promptAdapter)
+export function useAgentPrompt(): (
+  options: AgentPromptOptions & WithResourceNameSupport<AgentResourceOptions>,
+) => Promise<AgentPromptResult> {
+  return useAgentCallback<AgentPromptOptions, Promise<AgentPromptResult>>(promptAdapter)
+}
 
 /**
  * @internal
@@ -393,7 +427,7 @@ export const useAgentPrompt: () => (options: AgentPromptOptions) => Promise<Agen
  */
 function patchAdapter(
   instance: SanityInstance,
-  options: AgentPatchOptions,
+  options: AgentPatchOptions & AgentResourceOptions,
 ): Promise<AgentPatchResult> {
   return firstValueFrom(agentPatch(instance, options))
 }
@@ -547,5 +581,8 @@ function patchAdapter(
  *
  * @category Agent Actions
  */
-export const useAgentPatch: () => (options: AgentPatchOptions) => Promise<AgentPatchResult> =
-  createCallbackHook(patchAdapter)
+export function useAgentPatch(): (
+  options: AgentPatchOptions & WithResourceNameSupport<AgentResourceOptions>,
+) => Promise<AgentPatchResult> {
+  return useAgentCallback<AgentPatchOptions, Promise<AgentPatchResult>>(patchAdapter)
+}

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

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

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

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