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

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>
         ),

package/src/hooks/auth/useVerifyOrgProjects.tsx

@@ -27,13 +27,20 @@ export function useVerifyOrgProjects(disabled = false, projectIds?: string[]): s
   const instance = useSanityInstance()
   const [error, setError] = useState<string | null>(null)
 
+  const isInactive = disabled || !projectIds || projectIds.length === 0
+
+  // Reset stale errors when verification turns off so the next activation
+  // doesn't briefly leak the previous result.
+  const [prevInactive, setPrevInactive] = useState(isInactive)
+  if (prevInactive !== isInactive) {
+    setPrevInactive(isInactive)
+    if (isInactive) setError(null)
+  }
+
   useEffect(() => {
-    if (disabled || !projectIds || projectIds.length === 0) {
-      if (error !== null) setError(null)
-      return
-    }
+    if (isInactive) return
 
-    const verificationObservable$ = observeOrganizationVerificationState(instance, projectIds)
+    const verificationObservable$ = observeOrganizationVerificationState(instance, projectIds!)
 
     const subscription = verificationObservable$.subscribe((result: OrgVerificationResult) => {
       setError(result.error)
@@ -42,7 +49,7 @@ export function useVerifyOrgProjects(disabled = false, projectIds?: string[]): s
     return () => {
       subscription.unsubscribe()
     }
-  }, [instance, disabled, error, projectIds])
+  }, [instance, isInactive, projectIds])
 
   return error
 }

package/src/hooks/client/useClient.test.tsx

@@ -6,10 +6,7 @@ import {useClient} from './useClient'
 
 describe('useClient', () => {
   const wrapper = ({children}: {children: React.ReactNode}) => (
-    <ResourceProvider
-      resource={{projectId: 'test-project', dataset: 'test-dataset'}}
-      fallback={null}
-    >
+    <ResourceProvider projectId="test-project" dataset="test-dataset" fallback={null}>
       {children}
     </ResourceProvider>
   )

package/src/hooks/client/useClient.ts

@@ -39,4 +39,5 @@ export const useClient = createStateSourceHook({
     }
     return getClientState(instance, options)
   },
+  getConfig: (options: ClientOptions) => options,
 })

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

@@ -0,0 +1,32 @@
+import {renderHook as reactRenderHook} from '@testing-library/react'
+import {type ReactNode} from 'react'
+import {describe, expect, it} from 'vitest'
+
+import {renderHook} from '../../../test/test-utils'
+import {ResourceProvider} from '../../context/ResourceProvider'
+import {useResource} from './useResource'
+
+describe('useResource', () => {
+  it('returns the resource from the instance config when no explicit resource is set', () => {
+    // test-utils wraps with ResourceProvider projectId="test" dataset="test"
+    const {result} = renderHook(() => useResource())
+    expect(result.current).toEqual({projectId: 'test', dataset: 'test'})
+  })
+
+  it('returns the explicit resource when ResourceProvider has a resource prop', () => {
+    const resource = {projectId: 'explicit-project', dataset: 'explicit-dataset'}
+    const {result} = reactRenderHook(() => useResource(), {
+      wrapper: ({children}: {children: ReactNode}) => (
+        <ResourceProvider resource={resource} fallback={null}>
+          {children}
+        </ResourceProvider>
+      ),
+    })
+    expect(result.current).toEqual(resource)
+  })
+
+  it('returns undefined when no resource or instance config is available', () => {
+    const {result} = reactRenderHook(() => useResource())
+    expect(result.current).toBeUndefined()
+  })
+})

package/src/hooks/context/useResource.ts

@@ -0,0 +1,24 @@
+import {type DocumentResource} from '@sanity/sdk'
+
+import {useEffectiveContextResource} from '../helpers/useNormalizedResourceOptions'
+
+/**
+ * Returns the currently active `DocumentResource` for the nearest resource context.
+ *
+ * Resolves in priority order:
+ * 1. A `resource` prop on the nearest `<ResourceProvider>`
+ * 2. The `projectId`/`dataset` from the current `SanityInstance` config
+ * 3. `undefined` when neither is available
+ *
+ * @public
+ * @category Platform
+ *
+ * @example
+ * ```tsx
+ * const resource = useResource()
+ * console.log(resource?.projectId, resource?.dataset)
+ * ```
+ */
+export function useResource(): DocumentResource | undefined {
+  return useEffectiveContextResource()
+}

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

@@ -1,7 +1,7 @@
-import {createSanityInstance, type SanityInstance} from '@sanity/sdk'
+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'
@@ -16,20 +16,89 @@ describe('useSanityInstance', () => {
   }
 
   it('should return the Sanity instance from context', () => {
-    const instance = createSanityInstance()
+    // Create a Sanity instance
+    const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
 
+    // Render the hook with the wrapper that provides the context
     const {result} = renderHook(() => useSanityInstance(), {
       wrapper: createWrapper(instance),
     })
 
+    // Check that the correct instance is returned
     expect(result.current).toBe(instance)
   })
 
   it('should throw an error if no instance is found in context', () => {
+    // Expect the hook to throw when no instance is in context
     expect(() => {
       renderHook(() => useSanityInstance(), {
         wrapper: createWrapper(null),
       })
     }).toThrow('SanityInstance context not found')
   })
+
+  it('should return the current instance when no config is provided', () => {
+    // Create a Sanity instance
+    const instance = createSanityInstance({projectId: 'gp', dataset: 'gp-ds'})
+
+    // Render the hook with the wrapper that provides the context
+    const {result} = renderHook(() => useSanityInstance(), {
+      wrapper: createWrapper(instance),
+    })
+
+    // Should return the instance
+    expect(result.current).toBe(instance)
+  })
+
+  describe('deprecated config parameter', () => {
+    let warnSpy: ReturnType<typeof vi.spyOn>
+
+    beforeEach(() => {
+      warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    })
+
+    afterEach(() => {
+      warnSpy.mockRestore()
+    })
+
+    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'}
+
+      const {result} = renderHook(() => useSanityInstance(requestedConfig), {
+        wrapper: createWrapper(instance),
+      })
+
+      expect(result.current).toBe(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')
+    })
+
+    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),
+      })
+
+      expect(warnSpy).toHaveBeenCalledTimes(1)
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('[useSanityInstance]'))
+
+      rerender()
+      rerender()
+      expect(warnSpy).toHaveBeenCalledTimes(1)
+    })
+
+    it('does not warn when no config is passed', () => {
+      const instance = createSanityInstance({projectId: 'test-project', dataset: 'test-dataset'})
+      renderHook(() => useSanityInstance(), {wrapper: createWrapper(instance)})
+
+      expect(warnSpy).not.toHaveBeenCalled()
+    })
+  })
 })

package/src/hooks/context/useSanityInstance.ts

@@ -1,34 +1,56 @@
-import {type SanityInstance} from '@sanity/sdk'
+import {type SanityConfig, type SanityInstance} from '@sanity/sdk'
 import {useContext} from 'react'
 
 import {SanityInstanceContext} from '../../context/SanityInstanceContext'
 
+const warnedCallers = new Set<string>()
+
 /**
- * Retrieves the current Sanity instance from React context.
+ * Retrieves the current Sanity instance from context
  *
  * @public
  *
  * @category Platform
- * @returns The current 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 React context,
- * provided by a `ResourceProvider` or `SanityApp`.
+ * 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`.
  *
  * @example Get the current instance
  * ```tsx
  * const instance = useSanityInstance()
- * console.log(instance.config)
+ * console.log(instance.config.projectId)
  * ```
  *
  * @throws Error if no SanityInstance is found in context
  */
-export const useSanityInstance = (): SanityInstance => {
+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.',
+      )
+    }
+  }
+
   const instance = useContext(SanityInstanceContext)
 
   if (!instance) {
     throw new Error(
-      'SanityInstance context not found. Please ensure that your component is wrapped in a ResourceProvider or a SanityApp component.',
+      `SanityInstance context not found. Please ensure that your component is wrapped in a ResourceProvider or a SanityApp component.`,
     )
   }