@sanity/sdk-react 3.8.0 → 3.9.0-next.20261007114705

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/sdk-react",
-  "version": "3.8.0",
+  "version": "3.9.0-next.20261007114705",
   "private": false,
   "description": "Sanity SDK React toolkit for Content OS",
   "keywords": [
@@ -45,7 +45,7 @@
     "@module-federation/runtime": "^2.9.2",
     "@sanity/client": "^8.9.0",
     "@sanity/message-protocol": "^0.24.0",
-    "@sanity/sdk": "3.8.0",
+    "@sanity/sdk": "3.9.0-next.20261007114705",
     "@sanity/types": "^6.17.0",
     "react-compiler-runtime": "^1.0.0",
     "react-error-boundary": "^6.1.6",
@@ -72,7 +72,7 @@
     "groq": "^6.15.0",
     "groq-js": "^2.0.0",
     "jsdom": "^30.1.2",
-    "oxfmt": "^0.71.0",
+    "oxfmt": "^0.72.0",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",
     "rolldown": "^1.2.12",

package/src/components/auth/LoginError.test.tsx

@@ -135,6 +135,70 @@ describe('LoginError', () => {
     })
   })
 
+  it('does not request access when neither the error nor the config names a project', async () => {
+    mockIsDashboardEnvironment.mockReturnValue(true)
+    const error = makeClientError(401, {
+      error: {
+        type: 'projectUserNotFoundError',
+        description: 'User is not a member of this project.',
+      },
+    })
+
+    render(
+      <ResourceProvider fallback={<div>SUSPENDED</div>}>
+        <LoginError error={error} resetErrorBoundary={vi.fn()} />
+      </ResourceProvider>,
+    )
+
+    expect(await screen.findByText('User is not a member of this project.')).toBeInTheDocument()
+    expect(screen.queryByText('SUSPENDED')).not.toBeInTheDocument()
+    expect(mockWindowConnectionFetch).not.toHaveBeenCalled()
+  })
+
+  it('prefers the project named in the error over the configured projectId', async () => {
+    mockIsDashboardEnvironment.mockReturnValue(true)
+    const error = makeClientError(401, {
+      error: {type: 'projectUserNotFoundError', description: 'No access.', projectID: 'exx11uqh'},
+    })
+
+    render(
+      <ResourceProvider projectId="abc123" dataset="production" fallback={<div>SUSPENDED</div>}>
+        <LoginError error={error} resetErrorBoundary={vi.fn()} />
+      </ResourceProvider>,
+    )
+
+    await waitFor(() => {
+      expect(mockWindowConnectionFetch).toHaveBeenCalledWith('dashboard/v1/auth/access/request', {
+        resourceType: 'project',
+        resourceId: 'exx11uqh',
+      })
+    })
+  })
+
+  it('requests access to the project named in the error without a configured projectId', async () => {
+    mockIsDashboardEnvironment.mockReturnValue(true)
+    const error = makeClientError(401, {
+      error: {
+        type: 'projectUserNotFoundError',
+        description: 'User is not a member of this project.',
+        projectID: 'exx11uqh',
+      },
+    })
+
+    render(
+      <ResourceProvider fallback={<div>SUSPENDED</div>}>
+        <LoginError error={error} resetErrorBoundary={vi.fn()} />
+      </ResourceProvider>,
+    )
+
+    await waitFor(() => {
+      expect(mockWindowConnectionFetch).toHaveBeenCalledWith('dashboard/v1/auth/access/request', {
+        resourceType: 'project',
+        resourceId: 'exx11uqh',
+      })
+    })
+  })
+
   // Mirrors the real production chain: AuthBoundary wraps the ClientError in
   // an AuthError before the error boundary hands it to LoginError. The
   // `.cause` unwrap is what makes the dashboard access request path reachable
@@ -283,6 +347,33 @@ describe('LoginError', () => {
       expect(mockLogout).not.toHaveBeenCalled()
     })
 
+    it('requests access over the bus to the project named in the error', async () => {
+      const requests: PayloadOf<'access.request'>[] = []
+      host.subscribe('access.request', (message) => {
+        requests.push(message.payload)
+        message.reply({ok: true})
+      })
+      const error = new AuthError(
+        makeClientError(401, {
+          error: {
+            type: 'projectUserNotFoundError',
+            description: 'No access.',
+            projectID: 'exx11uqh',
+          },
+        }),
+      )
+
+      render(
+        <ResourceProvider fallback={<div>SUSPENDED</div>}>
+          <LoginError error={error} resetErrorBoundary={vi.fn()} />
+        </ResourceProvider>,
+      )
+
+      await waitFor(() => {
+        expect(requests).toEqual([{resourceType: 'project', resourceId: 'exx11uqh'}])
+      })
+    })
+
     const projectUserNotFound = () =>
       new AuthError(
         makeClientError(401, {

package/src/components/auth/LoginError.tsx

@@ -3,6 +3,7 @@ import {AuthStateType} from '@sanity/sdk'
 import {
   getClientErrorApiBody,
   getClientErrorApiDescription,
+  getClientErrorApiProjectId,
   isDashboardEnvironment,
   isProjectUserNotFoundClientError,
 } from '@sanity/sdk/_internal'
@@ -60,13 +61,15 @@ export function LoginError({error, resetErrorBoundary}: LoginErrorProps): React.
   const isProjectUserNotFound =
     !!clientError && clientError.statusCode === 401 && isProjectUserNotFoundClientError(clientError)
 
+  const accessProjectId = clientError && getClientErrorApiProjectId(clientError)
+
   // The dashboard access request flow relies on a comlink connection to the
   // parent window. In standalone apps that connection never materializes, so
   // we must skip it entirely to avoid suspending forever on the parent's
-  // Suspense boundary. Resolving to the projectId (or null) here lets the JSX
+  // Suspense boundary. Resolving to a project ID (or null) here lets the JSX
   // render the child with a single non-null guard.
   const dashboardAccessProjectId =
-    isProjectUserNotFound && projectId && isInDashboard ? projectId : null
+    isProjectUserNotFound && isInDashboard ? accessProjectId || projectId || null : null
 
   const handleRetry = useCallback(async () => {
     await logout()

package/src/hooks/document/useDocument.test-d.ts

@@ -0,0 +1,65 @@
+import {createDocumentHandle} from '@sanity/sdk'
+import {expectTypeOf, test} from 'vitest'
+
+import {useDocument} from './useDocument'
+
+// End-to-end check that the resource-keyed lookup reaches the hook. The resolver reads
+// `SanitySchemasByResource`; this asserts `useDocument` passes the handle's project and
+// dataset through to it.
+//
+// Only covers the form where the literals are written at the call site. A handle built from
+// a selected resource, or arriving as a `DocumentHandle<'post'>` prop, still carries `string`
+// and resolves to nothing. That is the propagation work, tracked separately.
+
+type HookPost = {
+  _id: string
+  _type: 'post'
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  title: string
+}
+interface ProductionPost extends Omit<HookPost, 'title'> {
+  title: number
+}
+
+// Registered the way generated files do: as globals, which the interfaces `@sanity/client`
+// exports extend. Every file in this package's type-check program sees these registrations, not
+// only this test, so their keys must stay unique across the package's tests.
+declare global {
+  interface SanitySchemasByResource {
+    'hook1.test': HookPost
+    'hook2.production': ProductionPost
+  }
+}
+
+const testHandle = createDocumentHandle({
+  projectId: 'hook1',
+  dataset: 'test',
+  documentId: 'a',
+  documentType: 'post',
+})
+const productionHandle = createDocumentHandle({
+  projectId: 'hook2',
+  dataset: 'production',
+  documentId: 'a',
+  documentType: 'post',
+})
+
+test('useDocument resolves the document type for each handle resource', () => {
+  expectTypeOf(useDocument(testHandle).data).toEqualTypeOf<HookPost | null>()
+  expectTypeOf(useDocument(productionHandle).data).toEqualTypeOf<ProductionPost | null>()
+})
+
+test('useDocument preserves the resource when selecting a field', () => {
+  expectTypeOf(useDocument({...testHandle, path: 'title'}).data).toEqualTypeOf<string | undefined>()
+  expectTypeOf(useDocument({...productionHandle, path: 'title'}).data).toEqualTypeOf<
+    number | undefined
+  >()
+})
+
+test('explicit resource generics require a matching handle', () => {
+  useDocument<'title', 'post', 'test', 'hook1'>({...testHandle, path: 'title'})
+  // @ts-expect-error The handle belongs to a different project and dataset.
+  useDocument<'title', 'post', 'test', 'hook1'>({...productionHandle, path: 'title'})
+})

package/src/hooks/document/useDocument.ts

@@ -61,7 +61,7 @@ interface UseDocument {
     TDataset extends string = string,
     TProjectId extends string = string,
   >(
-    options: UseDocumentOptions<TPath, TDocumentType>,
+    options: UseDocumentOptions<TPath, TDocumentType, TDataset, TProjectId>,
   ): {
     data: JsonMatch<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath> | undefined
   }
@@ -139,7 +139,7 @@ interface UseDocument {
     TDataset extends string = string,
     TProjectId extends string = string,
   >(
-    options: UseDocumentOptions<TPath, TDocumentType>,
+    options: UseDocumentOptions<TPath, TDocumentType, TDataset, TProjectId>,
   ): TPath extends string
     ? {
         data: