@sanity/sdk-react 2.10.0 → 2.11.0

package/src/hooks/document/useApplyDocumentActions.ts

@@ -1,17 +1,14 @@
-import {
-  type ActionsResult,
-  applyDocumentActions,
-  type ApplyDocumentActionsOptions,
-  type DocumentAction,
-} from '@sanity/sdk'
+import {type ActionsResult, applyDocumentActions, type DocumentAction} from '@sanity/sdk'
+import {isDeepEqual} from '@sanity/sdk/_internal'
 import {type SanityDocument} from 'groq'
 import {useContext} from 'react'
 
+import {type ResourceHandle} from '../../config/handles'
 import {ResourcesContext} from '../../context/ResourcesContext'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {
   normalizeResourceOptions,
-  type WithResourceNameSupport,
+  useEffectiveContextResource,
 } from '../helpers/useNormalizedResourceOptions'
 // this import is used in an `{@link useEditDocument}`
 // eslint-disable-next-line unused-imports/no-unused-imports, import/consistent-type-specifier-style
@@ -29,7 +26,7 @@ interface UseApplyDocumentActions {
     action:
       | DocumentAction<TDocumentType, TDataset, TProjectId>
       | DocumentAction<TDocumentType, TDataset, TProjectId>[],
-    options?: WithResourceNameSupport<ApplyDocumentActionsOptions>,
+    options?: ResourceHandle,
   ) => Promise<ActionsResult<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
 }
 
@@ -219,73 +216,42 @@ interface UseApplyDocumentActions {
 export const useApplyDocumentActions: UseApplyDocumentActions = () => {
   const instance = useSanityInstance()
   const resources = useContext(ResourcesContext)
+  const effectiveContextResource = useEffectiveContextResource()
 
   return (actionOrActions, options) => {
     const actions = Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]
-    const normalizedOptions = options ? normalizeResourceOptions(options, resources) : undefined
+    const optionsResource = options
+      ? normalizeResourceOptions(options, resources, effectiveContextResource).resource
+      : undefined
 
-    let projectId
-    let dataset
+    const normalizedActions = actions.map((action) =>
+      normalizeResourceOptions(action, resources, effectiveContextResource),
+    )
     let resource
-    for (const action of actions) {
-      if (action.projectId) {
-        if (resource) {
-          throw new Error(
-            `Mismatches between projectId/dataset options and resource in actions. Found projectId "${action.projectId}" and dataset "${action.dataset}" but expected resource "${resource}".`,
-          )
-        }
-        if (!projectId) projectId = action.projectId
-        if (action.projectId !== projectId) {
-          throw new Error(
-            `Mismatched project IDs found in actions. All actions must belong to the same project. Found "${action.projectId}" but expected "${projectId}".`,
-          )
-        }
-
-        if (action.dataset) {
-          if (!dataset) dataset = action.dataset
-          if (action.dataset !== dataset) {
-            throw new Error(
-              `Mismatched datasets found in actions. All actions must belong to the same dataset. Found "${action.dataset}" but expected "${dataset}".`,
-            )
-          }
-        }
-      }
 
-      if (action.resource) {
-        if (!resource) resource = action.resource
-        if (action.resource !== resource) {
-          throw new Error(
-            `Mismatched resources found in actions. All actions must belong to the same resource. Found "${action.resource}" but expected "${resource}".`,
-          )
-        }
-        if (projectId || dataset) {
-          throw new Error(
-            `Mismatches between projectId/dataset options and resource in actions. Found "${action.resource}" but expected project "${projectId}" and dataset "${dataset}".`,
-          )
-        }
-      }
-    }
-
-    if (projectId || dataset) {
-      const actualInstance = instance.match({projectId, dataset})
-      if (!actualInstance) {
+    for (const action of normalizedActions) {
+      if (!resource && action.resource) resource = action.resource
+      if (!isDeepEqual(action.resource, resource)) {
         throw new Error(
-          `Could not find a matching Sanity instance for the requested action: ${JSON.stringify({projectId, dataset}, null, 2)}.
-  Please ensure there is a ResourceProvider component with a matching configuration in the component hierarchy.`,
+          `Mismatched resources found in actions. All actions must belong to the same resource. Found "${JSON.stringify(action.resource)}" but expected "${JSON.stringify(resource)}".`,
         )
       }
+    }
+
+    if (optionsResource && resource && !isDeepEqual(optionsResource, resource)) {
+      throw new Error(
+        `Mismatched resources found in actions. Found top-level resource "${JSON.stringify(optionsResource)}" but expected resource from action handles "${JSON.stringify(resource)}".`,
+      )
+    }
 
-      return applyDocumentActions(actualInstance, {
-        actions,
-        resource,
-        ...normalizedOptions,
-      })
+    const effectiveResource = resource ?? optionsResource ?? effectiveContextResource
+    if (!effectiveResource) {
+      throw new Error('No resource found. Provide a resource via the action handle or context.')
     }
 
     return applyDocumentActions(instance, {
-      actions,
-      resource,
-      ...normalizedOptions,
+      actions: normalizedActions as DocumentAction[],
+      resource: effectiveResource,
     })
   }
 }

package/src/hooks/document/useDocument.ts

@@ -2,11 +2,9 @@ import {type DocumentOptions, getDocumentState, type JsonMatch, resolveDocument}
 import {type SanityDocument} from 'groq'
 import {identity} from 'rxjs'
 
+import {type DocumentHandle} from '../../config/handles'
 import {createStateSourceHook} from '../helpers/createStateSourceHook'
-import {
-  useNormalizedResourceOptions,
-  type WithResourceNameSupport,
-} from '../helpers/useNormalizedResourceOptions'
+import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 // used in an `{@link useDocumentProjection}` and `{@link useQuery}`
 // eslint-disable-next-line import/consistent-type-specifier-style, unused-imports/no-unused-imports
@@ -43,7 +41,7 @@ type UseDocumentOptions<
   TDocumentType extends string = string,
   TDataset extends string = string,
   TProjectId extends string = string,
-> = WithResourceNameSupport<DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>>
+> = DocumentHandle<TDocumentType, TDataset, TProjectId> & {path?: TPath}
 
 interface UseDocument {
   /** @internal */

package/src/hooks/document/useDocumentEvent.ts

@@ -1,6 +1,7 @@
-import {type DatasetHandle, type DocumentEvent, subscribeDocumentEvents} from '@sanity/sdk'
+import {type DocumentEvent, subscribeDocumentEvents} from '@sanity/sdk'
 import {useCallback, useEffect, useInsertionEffect, useRef} from 'react'
 
+import {type ResourceHandle} from '../../config/handles'
 import {useSanityInstance} from '../context/useSanityInstance'
 import {useNormalizedResourceOptions} from '../helpers/useNormalizedResourceOptions'
 import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
@@ -11,7 +12,7 @@ import {useTrackHookUsage} from '../helpers/useTrackHookUsage'
 export interface UseDocumentEventOptions<
   TDataset extends string = string,
   TProjectId extends string = string,
-> extends DatasetHandle<TDataset, TProjectId> {
+> extends ResourceHandle<TDataset, TProjectId> {
   onEvent: (documentEvent: DocumentEvent) => void
 }
 
@@ -91,7 +92,7 @@ export function useDocumentEvent<
     return ref.current(documentEvent)
   }, [])
 
-  const instance = useSanityInstance(datasetHandle)
+  const instance = useSanityInstance()
   useEffect(() => {
     return subscribeDocumentEvents(instance, {
       eventHandler: stableHandler,

package/src/hooks/document/useDocumentPermissions.test.tsx

@@ -1,8 +1,9 @@
 import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
-import {act, renderHook, waitFor} from '@testing-library/react'
+import {renderHook as reactRenderHook} from '@testing-library/react'
 import {BehaviorSubject, firstValueFrom, Observable} from 'rxjs'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+import {afterEach, beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
 
+import {act, renderHook, waitFor} from '../../../test/test-utils'
 import {ResourceProvider} from '../../context/ResourceProvider'
 import {useDocumentPermissions} from './useDocumentPermissions'
 
@@ -24,12 +25,12 @@ vi.mock('rxjs', async (importOriginal) => {
 })
 
 describe('usePermissions', () => {
+  const mockResource = {projectId: 'project1', dataset: 'dataset1'}
   const mockAction: DocumentAction = {
     type: 'document.publish',
     documentId: 'doc1',
     documentType: 'article',
-    projectId: 'project1',
-    dataset: 'dataset1',
+    resource: mockResource,
   }
 
   const mockPermissionAllowed: DocumentPermissionsResult = {allowed: true}
@@ -46,8 +47,8 @@ describe('usePermissions', () => {
   }
 
   let permissionsSubject: BehaviorSubject<DocumentPermissionsResult | undefined>
-  let mockSubscribe: ReturnType<typeof vi.fn>
-  let mockGetCurrent: ReturnType<typeof vi.fn>
+  let mockSubscribe: Mock<(onStoreChanged?: () => void) => () => void>
+  let mockGetCurrent: Mock<() => DocumentPermissionsResult | undefined>
 
   beforeEach(() => {
     vi.clearAllMocks()
@@ -71,7 +72,7 @@ describe('usePermissions', () => {
       observable:
         permissionsSubject.asObservable() as unknown as Observable<DocumentPermissionsResult>,
       subscribe: mockSubscribe,
-      getCurrent: mockGetCurrent,
+      getCurrent: mockGetCurrent as unknown as () => DocumentPermissionsResult,
     })
   })
 
@@ -85,20 +86,13 @@ describe('usePermissions', () => {
       permissionsSubject.next(mockPermissionAllowed)
     })
 
-    const {result} = renderHook(() => useDocumentPermissions(mockAction), {
-      wrapper: ({children}) => (
-        <ResourceProvider
-          projectId={mockAction.projectId}
-          dataset={mockAction.dataset}
-          fallback={null}
-        >
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useDocumentPermissions(mockAction))
 
     // ResourceProvider handles the instance configuration
-    expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), {actions: [mockAction]})
+    expect(getPermissionsState).toHaveBeenCalledWith(
+      expect.any(Object),
+      expect.objectContaining({actions: [mockAction], resource: mockResource}),
+    )
     expect(result.current).toEqual(mockPermissionAllowed)
   })
 
@@ -108,17 +102,7 @@ describe('usePermissions', () => {
       permissionsSubject.next(mockPermissionDenied)
     })
 
-    const {result} = renderHook(() => useDocumentPermissions(mockAction), {
-      wrapper: ({children}) => (
-        <ResourceProvider
-          projectId={mockAction.projectId}
-          dataset={mockAction.dataset}
-          fallback={null}
-        >
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result} = renderHook(() => useDocumentPermissions(mockAction))
 
     expect(result.current).toEqual(mockPermissionDenied)
     expect(result.current.allowed).toBe(false)
@@ -129,141 +113,58 @@ describe('usePermissions', () => {
   it('should accept an array of actions', () => {
     const actions = [mockAction, {...mockAction, documentId: 'doc2'}]
 
-    renderHook(() => useDocumentPermissions(actions), {
-      wrapper: ({children}) => (
-        <ResourceProvider
-          projectId={mockAction.projectId}
-          dataset={mockAction.dataset}
-          fallback={null}
-        >
-          {children}
-        </ResourceProvider>
-      ),
-    })
-
-    expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), {actions})
-  })
-
-  it('should throw an error if actions have mismatched project IDs', () => {
-    const actions = [
-      mockAction,
-      {...mockAction, projectId: 'different-project', documentId: 'doc2'},
-    ]
-
-    expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatched project IDs found in actions/)
-  })
-
-  it('should throw an error if actions have mismatched datasets', () => {
-    const actions = [mockAction, {...mockAction, dataset: 'different-dataset', documentId: 'doc2'}]
+    renderHook(() => useDocumentPermissions(actions))
 
-    expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatched datasets found in actions/)
+    expect(getPermissionsState).toHaveBeenCalledWith(
+      expect.any(Object),
+      expect.objectContaining({actions, resource: mockResource}),
+    )
   })
 
   it('should throw an error if actions have mismatched resources', () => {
     const actions = [
+      mockAction,
       {
-        type: 'document.publish' as const,
-        documentId: 'doc1',
-        documentType: 'article',
-        resource: {projectId: 'p1', dataset: 'd1'},
-      },
-      {
-        type: 'document.publish' as const,
+        ...mockAction,
+        resource: {projectId: 'different-project', dataset: 'dataset1'},
         documentId: 'doc2',
-        documentType: 'article',
-        resource: {projectId: 'p2', dataset: 'd2'},
       },
     ]
 
     expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
+      renderHook(() => useDocumentPermissions(actions))
     }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('should throw an error when mixing projectId and resource (projectId first)', () => {
+  it('should throw an error if actions have mismatched datasets', () => {
     const actions = [
       mockAction,
       {
-        type: 'document.publish' as const,
+        ...mockAction,
+        resource: {projectId: 'project1', dataset: 'different-dataset'},
         documentId: 'doc2',
-        documentType: 'article',
-        resource: {projectId: 'p', dataset: 'd'},
       },
     ]
 
     expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatches between projectId\/dataset options and resource/)
+      renderHook(() => useDocumentPermissions(actions))
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
-  it('should throw an error when mixing resource and projectId (resource first)', () => {
+  it('should throw an error when mixing different resources', () => {
     const actions = [
+      mockAction,
       {
         type: 'document.publish' as const,
-        documentId: 'doc1',
+        documentId: 'doc2',
         documentType: 'article',
         resource: {projectId: 'p', dataset: 'd'},
       },
-      mockAction,
     ]
 
     expect(() => {
-      renderHook(() => useDocumentPermissions(actions), {
-        wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
-            {children}
-          </ResourceProvider>
-        ),
-      })
-    }).toThrow(/Mismatches between projectId\/dataset options and resource/)
+      renderHook(() => useDocumentPermissions(actions))
+    }).toThrow(/Mismatched resources found in actions/)
   })
 
   it('should wait for permissions to be ready before rendering', async () => {
@@ -277,7 +178,7 @@ describe('usePermissions', () => {
     vi.mocked(firstValueFrom).mockReturnValueOnce(mockPromise)
 
     // This should throw the promise and suspend
-    const {result} = renderHook(
+    const {result} = reactRenderHook(
       () => {
         try {
           return useDocumentPermissions(mockAction)
@@ -290,11 +191,7 @@ describe('usePermissions', () => {
       },
       {
         wrapper: ({children}) => (
-          <ResourceProvider
-            projectId={mockAction.projectId}
-            dataset={mockAction.dataset}
-            fallback={null}
-          >
+          <ResourceProvider resource={mockResource} fallback={null}>
             {children}
           </ResourceProvider>
         ),
@@ -310,27 +207,38 @@ describe('usePermissions', () => {
 
     // Now it should render properly
     await waitFor(() => {
-      expect(getPermissionsState).toHaveBeenCalledWith(expect.any(Object), {actions: [mockAction]})
+      expect(getPermissionsState).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.objectContaining({actions: [mockAction], resource: mockResource}),
+      )
     })
   })
 
+  it('throws when no resource is found from action or context', () => {
+    // Provide SanityInstance via ResourceProvider but no resource, so contextResource is undefined
+    expect(() => {
+      reactRenderHook(
+        () =>
+          useDocumentPermissions({
+            type: 'document.publish',
+            documentId: 'doc1',
+            documentType: 'article',
+            // no resource
+          } as never),
+        {
+          wrapper: ({children}) => <ResourceProvider fallback={null}>{children}</ResourceProvider>,
+        },
+      )
+    }).toThrow(/No resource found/)
+  })
+
   it('should react to permission state changes', async () => {
     // Start with permission allowed
     act(() => {
       permissionsSubject.next(mockPermissionAllowed)
     })
 
-    const {result, rerender} = renderHook(() => useDocumentPermissions(mockAction), {
-      wrapper: ({children}) => (
-        <ResourceProvider
-          projectId={mockAction.projectId}
-          dataset={mockAction.dataset}
-          fallback={null}
-        >
-          {children}
-        </ResourceProvider>
-      ),
-    })
+    const {result, rerender} = renderHook(() => useDocumentPermissions(mockAction))
 
     expect(result.current).toEqual(mockPermissionAllowed)
 

package/src/hooks/document/useDocumentPermissions.ts

@@ -1,10 +1,20 @@
 import {type DocumentAction, type DocumentPermissionsResult, getPermissionsState} from '@sanity/sdk'
-import {useCallback, useMemo, useSyncExternalStore} from 'react'
+import {isDeepEqual} from '@sanity/sdk/_internal'
+import {useCallback, useContext, useMemo, useSyncExternalStore} from 'react'
 import {filter, firstValueFrom} from 'rxjs'
 
+import {ResourcesContext} from '../../context/ResourcesContext'
 import {useSanityInstance} from '../context/useSanityInstance'
+import {
+  normalizeResourceOptions,
+  useEffectiveContextResource,
+  type WithResourceNameSupport,
+} from '../helpers/useNormalizedResourceOptions'
 import {trackHookUsage} from '../helpers/useTrackHookUsage'
 
+const noopSubscribe = () => () => {}
+const returnUndefined = () => undefined
+
 /**
  *
  * @public
@@ -83,74 +93,87 @@ import {trackHookUsage} from '../helpers/useTrackHookUsage'
  * ```
  */
 export function useDocumentPermissions(
-  actionOrActions: DocumentAction | DocumentAction[],
+  actionOrActions:
+    | WithResourceNameSupport<DocumentAction>
+    | WithResourceNameSupport<DocumentAction>[],
 ): DocumentPermissionsResult {
-  const actions = useMemo(
-    () => (Array.isArray(actionOrActions) ? actionOrActions : [actionOrActions]),
-    [actionOrActions],
-  )
-  // if actions is an array, we need to check that all actions belong to the same project and dataset
-  let projectId
-  let dataset
-  let resource
+  const instance = useSanityInstance()
+  trackHookUsage(instance, 'useDocumentPermissions')
+  const effectiveContextResource = useEffectiveContextResource()
+  const resources = useContext(ResourcesContext)
 
-  for (const action of actions) {
-    if (action.projectId) {
-      if (resource) {
-        throw new Error(
-          `Mismatches between projectId/dataset options and resource in actions. Found projectId "${action.projectId}" and dataset "${action.dataset}" but expected resource "${resource}".`,
+  const {
+    actions: normalizedActions,
+    resource: actionResource,
+    error: validationError,
+  } = useMemo(() => {
+    const normalized = Array.isArray(actionOrActions)
+      ? actionOrActions.map((action) =>
+          normalizeResourceOptions(action, resources, effectiveContextResource),
         )
-      }
-      if (!projectId) projectId = action.projectId
-      if (action.projectId !== projectId) {
-        throw new Error(
-          `Mismatched project IDs found in actions. All actions must belong to the same project. Found "${action.projectId}" but expected "${projectId}".`,
-        )
-      }
+      : [normalizeResourceOptions(actionOrActions, resources, effectiveContextResource)]
 
-      if (action.dataset) {
-        if (!dataset) dataset = action.dataset
-        if (action.dataset !== dataset) {
-          throw new Error(
-            `Mismatched datasets found in actions. All actions must belong to the same dataset. Found "${action.dataset}" but expected "${dataset}".`,
-          )
+    let resource
+    for (const action of normalized) {
+      if (action.resource) {
+        if (!resource) resource = action.resource
+        if (!isDeepEqual(action.resource, resource)) {
+          return {
+            actions: normalized,
+            resource,
+            error: new Error(
+              `Mismatched resources found in actions. All actions must belong to the same resource. Found "${JSON.stringify(action.resource)}" but expected "${JSON.stringify(resource)}".`,
+            ),
+          }
         }
       }
     }
+    return {actions: normalized, resource, error: undefined}
+  }, [actionOrActions, resources, effectiveContextResource])
 
-    if (action.resource) {
-      if (!resource) resource = action.resource
-      if (action.resource !== resource) {
-        throw new Error(
-          `Mismatched resources found in actions. All actions must belong to the same resource. Found "${action.resource}" but expected "${resource}".`,
-        )
-      }
-      if (projectId || dataset) {
-        throw new Error(
-          `Mismatches between projectId/dataset options and resource in actions. Found "${action.resource}" but expected project "${projectId}" and dataset "${dataset}".`,
-        )
-      }
-    }
-  }
+  const effectiveResource = actionResource ?? effectiveContextResource
+
+  // Keep hooks unconditional — validation errors and missing-resource errors are
+  // thrown after all hooks so that the hook call count stays stable across renders.
+  const permissionsOptions = useMemo(
+    () =>
+      effectiveResource
+        ? {
+            resource: effectiveResource,
+            // `Omit<>` on `DocumentAction` loses the discriminant; runtime values are still actions.
+            actions: normalizedActions as DocumentAction[],
+          }
+        : undefined,
+    [effectiveResource, normalizedActions],
+  )
+
+  const stateSource = useMemo(
+    () => (permissionsOptions ? getPermissionsState(instance, permissionsOptions) : undefined),
+    [permissionsOptions, instance],
+  )
 
-  const instance = useSanityInstance({projectId, dataset})
-  trackHookUsage(instance, 'useDocumentPermissions')
   const isDocumentReady = useCallback(
-    () => getPermissionsState(instance, {actions}).getCurrent() !== undefined,
-    [actions, instance],
+    () => stateSource !== undefined && stateSource.getCurrent() !== undefined,
+    [stateSource],
+  )
+
+  const result = useSyncExternalStore(
+    stateSource?.subscribe ?? noopSubscribe,
+    stateSource?.getCurrent ?? returnUndefined,
   )
+
+  // All hooks have been called — safe to throw now.
+  if (validationError) throw validationError
+  if (!effectiveResource) {
+    throw new Error(
+      'No resource found. Provide a resource via the action handle or wrap with a resource context.',
+    )
+  }
   if (!isDocumentReady()) {
     throw firstValueFrom(
-      getPermissionsState(instance, {actions}).observable.pipe(
-        filter((result) => result !== undefined),
-      ),
+      stateSource!.observable.pipe(filter((permissions) => permissions !== undefined)),
     )
   }
 
-  const {subscribe, getCurrent} = useMemo(
-    () => getPermissionsState(instance, {actions}),
-    [actions, instance],
-  )
-
-  return useSyncExternalStore(subscribe, getCurrent) as DocumentPermissionsResult
+  return result as DocumentPermissionsResult
 }