@sanity/sdk-react 2.10.0 → 2.11.0

package/src/hooks/context/useSanityInstance.test.tsx

@@ -1,7 +1,7 @@
 import {createSanityInstance, type SanityConfig, type SanityInstance} from '@sanity/sdk'
 import {renderHook} from '@testing-library/react'
 import {type ReactNode} from 'react'
-import {describe, expect, it} from 'vitest'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 import {useSanityInstance} from './useSanityInstance'
@@ -37,137 +37,68 @@ describe('useSanityInstance', () => {
     }).toThrow('SanityInstance context not found')
   })
 
-  it('should include the requested config in error message when no instance found', () => {
-    const requestedConfig = {projectId: 'test', dataset: 'test'}
-
-    // Expect the hook to throw and include the requested config in the error
-    expect(() => {
-      renderHook(() => useSanityInstance(requestedConfig), {
-        wrapper: createWrapper(null),
-      })
-    }).toThrow(JSON.stringify(requestedConfig, null, 2))
-  })
-
-  it('should find a matching instance with provided config', () => {
-    // Create a parent instance
-    const parentInstance = createSanityInstance({
-      projectId: 'parent-project',
-      dataset: 'parent-dataset',
-    })
-
-    // Create a child instance
-    const childInstance = parentInstance.createChild({dataset: 'child-dataset'})
-
-    // Render the hook with the child instance and request the parent config
-    const {result} = renderHook(
-      () => useSanityInstance({projectId: 'parent-project', dataset: 'parent-dataset'}),
-      {wrapper: createWrapper(childInstance)},
-    )
-
-    // Should match and return the parent instance
-    expect(result.current).toBe(parentInstance)
-  })
-
-  it('should throw an error if no matching instance is found for config', () => {
-    // Create an instance
-    const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
-
-    // Request a config that doesn't match
-    const requestedConfig: SanityConfig = {
-      projectId: 'non-existent',
-      dataset: 'not-found',
-    }
-
-    // Expect the hook to throw for a non-matching config
-    expect(() => {
-      renderHook(() => useSanityInstance(requestedConfig), {
-        wrapper: createWrapper(instance),
-      })
-    }).toThrow('Could not find a matching Sanity instance')
-  })
-
-  it('should include the requested config in error message when no matching instance', () => {
-    const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
-    const requestedConfig = {projectId: 'different', dataset: 'different'}
-
-    // Expect the error to include the requested config details
-    expect(() => {
-      renderHook(() => useSanityInstance(requestedConfig), {
-        wrapper: createWrapper(instance),
-      })
-    }).toThrow(JSON.stringify(requestedConfig, null, 2))
-  })
-
   it('should return the current instance when no config is provided', () => {
-    // Create a hierarchy of instances
-    const grandparent = createSanityInstance({projectId: 'gp', dataset: 'gp-ds'})
-    const parent = grandparent.createChild({projectId: 'p'})
-    const child = parent.createChild({dataset: 'child-ds'})
+    // Create a Sanity instance
+    const instance = createSanityInstance({projectId: 'gp', dataset: 'gp-ds'})
 
-    // Render the hook with the child instance and no config
+    // Render the hook with the wrapper that provides the context
     const {result} = renderHook(() => useSanityInstance(), {
-      wrapper: createWrapper(child),
+      wrapper: createWrapper(instance),
     })
 
-    // Should return the child instance
-    expect(result.current).toBe(child)
+    // Should return the instance
+    expect(result.current).toBe(instance)
   })
 
-  it('should match child instance when it satisfies the config', () => {
-    // Create a parent instance
-    const parent = createSanityInstance({projectId: 'parent', dataset: 'parent-ds'})
+  describe('deprecated config parameter', () => {
+    let warnSpy: ReturnType<typeof vi.spyOn>
 
-    // Create a child instance that inherits projectId
-    const child = parent.createChild({dataset: 'child-ds'})
+    beforeEach(() => {
+      warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    })
 
-    // Render the hook with the child instance and request by the child's dataset
-    const {result} = renderHook(() => useSanityInstance({dataset: 'child-ds'}), {
-      wrapper: createWrapper(child),
+    afterEach(() => {
+      warnSpy.mockRestore()
     })
 
-    // Should match and return the child instance
-    expect(result.current).toBe(child)
-  })
+    it('should return the current context instance regardless of config', () => {
+      const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+      const requestedConfig: SanityConfig = {projectId: 'test-project', dataset: 'test-dataset'}
 
-  it('should match partial config correctly', () => {
-    // Create an instance with multiple config values
-    const instance = createSanityInstance({
-      projectId: 'test-proj',
-      dataset: 'test-ds',
+      const {result} = renderHook(() => useSanityInstance(requestedConfig), {
+        wrapper: createWrapper(instance),
+      })
+
+      expect(result.current).toBe(instance)
     })
 
-    // Should match when requesting just one property
-    const {result} = renderHook(() => useSanityInstance({dataset: 'test-ds'}), {
-      wrapper: createWrapper(instance),
+    it('should throw if no instance in context even when config is provided', () => {
+      expect(() => {
+        renderHook(() => useSanityInstance({projectId: 'test'}), {
+          wrapper: createWrapper(null),
+        })
+      }).toThrow('SanityInstance context not found')
     })
 
-    expect(result.current).toBe(instance)
-  })
+    it('warns once when a config argument is passed', () => {
+      const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+      const {rerender} = renderHook(() => useSanityInstance({projectId: 'test-project'}), {
+        wrapper: createWrapper(instance),
+      })
 
-  it("should match deeper in hierarchy when current instance doesn't match", () => {
-    // Create a three-level hierarchy
-    const root = createSanityInstance({projectId: 'root', dataset: 'root-ds'})
-    const middle = root.createChild({projectId: 'middle'})
-    const leaf = middle.createChild({dataset: 'leaf-ds'})
+      expect(warnSpy).toHaveBeenCalledTimes(1)
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('[useSanityInstance]'))
 
-    // Request config matching the root from the leaf
-    const {result} = renderHook(() => useSanityInstance({projectId: 'root', dataset: 'root-ds'}), {
-      wrapper: createWrapper(leaf),
+      rerender()
+      rerender()
+      expect(warnSpy).toHaveBeenCalledTimes(1)
     })
 
-    // Should find and return the root instance
-    expect(result.current).toBe(root)
-  })
+    it('does not warn when no config is passed', () => {
+      const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+      renderHook(() => useSanityInstance(), {wrapper: createWrapper(instance)})
 
-  it('should match undefined values in config', () => {
-    // Create instance with only projectId
-    const rootInstance = createSanityInstance({projectId: 'test'})
-
-    // Match specifically looking for undefined dataset
-    const {result} = renderHook(() => useSanityInstance({dataset: undefined}), {
-      wrapper: createWrapper(rootInstance),
+      expect(warnSpy).not.toHaveBeenCalled()
     })
-
-    expect(result.current).toBe(rootInstance)
   })
 })

package/src/hooks/context/useSanityInstance.ts

@@ -3,78 +3,56 @@ import {useContext} from 'react'
 
 import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 
+const warnedCallers = new Set<string>()
+
 /**
- * Retrieves the current Sanity instance or finds a matching instance from the hierarchy
+ * Retrieves the current Sanity instance from context
  *
  * @public
  *
  * @category Platform
- * @param config - Optional configuration to match against when finding an instance
- * @returns The current or matching Sanity instance
+ * @param config - Deprecated. Formerly used to match against the instance hierarchy.
+ * @returns The current Sanity instance
  *
  * @remarks
- * This hook accesses the nearest Sanity instance from the React context. When provided with
- * a configuration object, it traverses up the instance hierarchy to find the closest instance
- * that matches the specified configuration using shallow comparison of properties.
- *
+ * This hook accesses the nearest Sanity instance from the React context.
  * The hook must be used within a component wrapped by a `ResourceProvider` or `SanityApp`.
  *
- * Use this hook when you need to:
- * - Access the current SanityInstance from context
- * - Find a specific instance with matching project/dataset configuration
- * - Access a parent instance with specific configuration values
- *
  * @example Get the current instance
  * ```tsx
- * // Get the current instance from context
  * const instance = useSanityInstance()
  * console.log(instance.config.projectId)
  * ```
  *
- * @example Find an instance with specific configuration
- * ```tsx
- * // Find an instance matching the given project and dataset
- * const instance = useSanityInstance({
- *   projectId: 'abc123',
- *   dataset: 'production'
- * })
- *
- * // Use instance for API calls
- * const fetchDocument = (docId) => {
- *   // Instance is guaranteed to have the matching config
- *   return client.fetch(`*[_id == $id][0]`, { id: docId })
- * }
- * ```
- *
- * @example Match partial configuration
- * ```tsx
- * // Find an instance with specific auth configuration
- * const instance = useSanityInstance({
- *   auth: { requireLogin: true }
- * })
- * ```
- *
  * @throws Error if no SanityInstance is found in context
- * @throws Error if no matching instance is found for the provided config
  */
-export const useSanityInstance = (config?: SanityConfig): SanityInstance => {
-  const instance = useContext(SanityInstanceContext)
-
-  if (!instance) {
-    throw new Error(
-      `SanityInstance context not found. ${config ? `Requested config: ${JSON.stringify(config, null, 2)}. ` : ''}Please ensure that your component is wrapped in a ResourceProvider or a SanityApp component.`,
-    )
+export const useSanityInstance = (
+  /**
+   * @deprecated Passing a config to match against the instance hierarchy is deprecated.
+   * Use `useSanityInstance()` without arguments instead.
+   */
+  config?: SanityConfig,
+): SanityInstance => {
+  if (config !== undefined) {
+    const caller = new Error().stack?.split('\n')[2]?.trim() ?? 'unknown'
+    if (!warnedCallers.has(caller)) {
+      warnedCallers.add(caller)
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[useSanityInstance] Passing a config argument is deprecated and has no effect. ' +
+          'SDK apps use a single instance for all resources, so the config argument is no longer needed. ' +
+          'Call useSanityInstance() without arguments instead, or useResource() to get your currently active resource.',
+      )
+    }
   }
 
-  if (!config) return instance
+  const instance = useContext(SanityInstanceContext)
 
-  const match = instance.match(config)
-  if (!match) {
+  if (!instance) {
     throw new Error(
-      `Could not find a matching Sanity instance for the requested configuration: ${JSON.stringify(config, null, 2)}.
-Please ensure there is a ResourceProvider component with a matching configuration in the component hierarchy.`,
+      `SanityInstance context not found. Please ensure that your component is wrapped in a ResourceProvider or a SanityApp component.`,
     )
   }
 
-  return match
+  return instance
 }

package/src/hooks/dashboard/useDispatchIntent.test.ts

@@ -1,4 +1,5 @@
 import {type DocumentHandle} from '@sanity/sdk'
+import {renderHook as reactRenderHook} from '@testing-library/react'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
 import {renderHook} from '../../../test/test-utils'
@@ -227,12 +228,14 @@ describe('useDispatchIntent', () => {
 
   describe('error handling', () => {
     it('should throw error when neither resource nor projectId/dataset is provided', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
       const invalidHandle = {
         documentId: 'test-document-id',
         documentType: 'test-document-type',
       }
 
-      const {result} = renderHook(() =>
+      // Use a minimal wrapper with no resource context so the normalization has nothing to fall back to
+      const {result} = reactRenderHook(() =>
         useDispatchIntent({
           action: 'edit',
           documentHandle: invalidHandle as unknown as DocumentHandle,
@@ -242,6 +245,7 @@ describe('useDispatchIntent', () => {
       expect(() => result.current.dispatchIntent()).toThrow(
         'useDispatchIntent: Unable to determine resource. Either `resource`, `resourceName`, or both `projectId` and `dataset` must be provided in documentHandle.',
       )
+      consoleErrorSpy.mockRestore()
     })
   })
 })

package/src/hooks/dashboard/useDispatchIntent.ts

@@ -1,9 +1,9 @@
 import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'
-import {type DocumentHandle, type FrameMessage} from '@sanity/sdk'
+import {type FrameMessage} from '@sanity/sdk'
 import {useCallback} from 'react'
 
+import {type DocumentHandle} from '../../config/handles'
 import {useWindowConnection} from '../comlink/useWindowConnection'
-import {type WithResourceNameSupport} from '../helpers/useNormalizedResourceOptions'
 import {useResourceIdFromDocumentHandle} from './utils/useResourceIdFromDocumentHandle'
 
 /**
@@ -42,7 +42,7 @@ interface DispatchIntent {
 interface UseDispatchIntentParams {
   action?: 'edit'
   intentId?: string
-  documentHandle: WithResourceNameSupport<DocumentHandle>
+  documentHandle: DocumentHandle
   parameters?: Record<string, unknown>
 }
 

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

@@ -2,12 +2,15 @@ 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, vi} from 'vitest'
+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 {
@@ -23,8 +26,8 @@ vi.mock('../comlink/useWindowConnection', () => ({
 
 describe('useManageFavorite', () => {
   let favoriteStatusSubject: BehaviorSubject<FavoriteStatusResponse>
-  let mockFetch: ReturnType<typeof vi.fn>
-  let mockSendMessage: ReturnType<typeof vi.fn>
+  let mockFetch: Mock<MockFetch>
+  let mockSendMessage: Mock<MockSendMessage>
 
   const mockDocumentHandle = {
     documentId: 'mock-id',
@@ -56,15 +59,16 @@ describe('useManageFavorite', () => {
     })
 
     // Mock useWindowConnection
-    mockFetch = vi.fn().mockResolvedValue({success: true})
-    mockSendMessage = vi.fn()
-    vi.mocked(useWindowConnection).mockImplementation(() => {
-      return {
-        fetch: (type: string, data?: unknown, options: unknown = {}) =>
-          mockFetch(type, data, options),
-        sendMessage: mockSendMessage,
-      }
-    })
+    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(() => {

package/src/hooks/dashboard/utils/useResourceIdFromDocumentHandle.ts

@@ -19,13 +19,9 @@ export function useResourceIdFromDocumentHandle(
   documentHandle: DocumentHandle,
 ): DashboardMessageResource {
   const options = useNormalizedResourceOptions(documentHandle)
-  const {projectId, dataset, resource} = options
+  const {resource} = options
   let resourceId: string = ''
   let resourceType: 'media-library' | 'canvas' | undefined
-  if (projectId && dataset) {
-    resourceId = `${projectId}.${dataset}`
-  }
-
   if (resource) {
     if (isDatasetResource(resource)) {
       resourceId = `${resource.projectId}.${resource.dataset}`

package/src/hooks/document/{useApplyDocumentActions.test.ts → useApplyDocumentActions.test.tsx}

@@ -1,7 +1,9 @@
-import {applyDocumentActions, type SanityInstance} from '@sanity/sdk'
+import {applyDocumentActions, createSanityInstance} from '@sanity/sdk'
+import {renderHook as reactRenderHook} from '@testing-library/react'
 import {describe, it} from 'vitest'
 
 import {renderHook} from '../../../test/test-utils'
+import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {useApplyDocumentActions} from './useApplyDocumentActions'
 
@@ -12,18 +14,7 @@ vi.mock('@sanity/sdk', async (importOriginal) => {
 
 vi.mock('../context/useSanityInstance')
 
-// These are quite fragile mocks, but they are useful enough for now.
-const instances: Record<string, SanityInstance | undefined> = {
-  'p123.d': {__id: 'p123.d'} as unknown as SanityInstance,
-  'p.d123': {__id: 'p.d123'} as unknown as SanityInstance,
-  'p123.d123': {__id: 'p123.d123'} as unknown as SanityInstance,
-}
-
-const instance = {
-  match({projectId = 'p', dataset = 'd'}): SanityInstance | undefined {
-    return instances[`${projectId}.${dataset}`]
-  },
-} as unknown as SanityInstance
+const instance = createSanityInstance({projectId: 'p', dataset: 'd'})
 
 describe('useApplyDocumentActions', () => {
   beforeEach(() => {
@@ -31,7 +22,7 @@ describe('useApplyDocumentActions', () => {
     vi.mocked(useSanityInstance).mockReturnValueOnce(instance)
   })
 
-  it('uses the SanityInstance', async () => {
+  it('uses the effective context resource', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     result.current({
       type: 'document.edit',
@@ -45,43 +36,28 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
+          // resource named in test-utils
+          resource: {projectId: 'test', dataset: 'test'},
         },
       ],
+      resource: {projectId: 'test', dataset: 'test'},
     })
   })
 
-  it('uses SanityInstance.match when projectId is overrideen', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
-    result.current({
-      type: 'document.edit',
-      documentType: 'post',
-      documentId: 'abc',
-
-      projectId: 'p123',
-    })
-
-    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instances['p123.d'], {
-      actions: [
-        {
-          type: 'document.edit',
-          documentType: 'post',
-          documentId: 'abc',
-
-          projectId: 'p123',
-        },
-      ],
-    })
-  })
-
-  it('uses SanityInstance when dataset is overrideen', async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
-    result.current({
-      type: 'document.edit',
-      documentType: 'post',
-      documentId: 'abc',
-
-      dataset: 'd123',
+  it('uses the SanityInstance when resource is not provided', async () => {
+    const {result} = reactRenderHook(() => useApplyDocumentActions(), {
+      wrapper: ({children}) => (
+        <SanityInstanceContext.Provider value={instance}>{children}</SanityInstanceContext.Provider>
+      ),
     })
+    result.current(
+      {
+        type: 'document.edit',
+        documentType: 'post',
+        documentId: 'abc',
+      },
+      {},
+    )
 
     expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
       actions: [
@@ -89,51 +65,36 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-
-          dataset: 'd123',
+          resource: {projectId: 'p', dataset: 'd'},
         },
       ],
+      resource: {projectId: 'p', dataset: 'd'},
     })
   })
 
-  it('uses SanityInstance.amcth when projectId and dataset is overrideen', async () => {
+  it('resolves resource from projectId and dataset in action', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     result.current({
       type: 'document.edit',
       documentType: 'post',
       documentId: 'abc',
-
-      projectId: 'p123',
+      projectId: 'p',
       dataset: 'd123',
     })
 
-    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instances['p123.d123'], {
+    expect(applyDocumentActions).toHaveBeenCalledExactlyOnceWith(instance, {
       actions: [
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-
-          projectId: 'p123',
-          dataset: 'd123',
+          resource: {projectId: 'p', dataset: 'd123'},
         },
       ],
+      resource: {projectId: 'p', dataset: 'd123'},
     })
   })
 
-  it("throws if SanityInstance.match doesn't find anything", async () => {
-    const {result} = renderHook(() => useApplyDocumentActions())
-    expect(() => {
-      result.current({
-        type: 'document.edit',
-        documentType: 'post',
-        documentId: 'abc',
-
-        projectId: 'other',
-      })
-    }).toThrow()
-  })
-
   it('throws when actions have mismatched project IDs', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
@@ -143,15 +104,17 @@ describe('useApplyDocumentActions', () => {
           documentType: 'post',
           documentId: 'abc',
           projectId: 'p123',
+          dataset: 'd',
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
           projectId: 'p456',
+          dataset: 'd',
         },
       ])
-    }).toThrow(/Mismatched project IDs found in actions/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
   it('throws when actions have mismatched datasets', async () => {
@@ -173,7 +136,7 @@ describe('useApplyDocumentActions', () => {
           dataset: 'd2',
         },
       ])
-    }).toThrow(/Mismatched datasets found in actions/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
   it('throws when actions have mismatched resources', async () => {
@@ -196,7 +159,7 @@ describe('useApplyDocumentActions', () => {
     }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when mixing projectId and resource (projectId first)', async () => {
+  it('throws when mixing projectId/dataset and resource with a mismatch (projectId first)', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
       result.current([
@@ -204,19 +167,20 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          projectId: 'p',
+          projectId: 'p1',
+          dataset: 'd',
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          resource: {projectId: 'p', dataset: 'd'},
+          resource: {projectId: 'p2', dataset: 'd'},
         },
       ])
-    }).toThrow(/Mismatches between projectId\/dataset options and resource/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('throws when mixing resource and projectId (resource first)', async () => {
+  it('throws when mixing resource and projectId/dataset with a mismatch (resource first)', async () => {
     const {result} = renderHook(() => useApplyDocumentActions())
     expect(() => {
       result.current([
@@ -224,15 +188,16 @@ describe('useApplyDocumentActions', () => {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'abc',
-          resource: {projectId: 'p', dataset: 'd'},
+          resource: {projectId: 'p1', dataset: 'd'},
         },
         {
           type: 'document.edit',
           documentType: 'post',
           documentId: 'def',
-          projectId: 'p',
+          projectId: 'p2',
+          dataset: 'd',
         },
       ])
-    }).toThrow(/Mismatches between projectId\/dataset options and resource/)
+    }).toThrow(/Mismatched resources found in actions/)
   })
 })