refactor: useGetAccess now uses the canAll endpoint to massively reduce traffic through acquisitions and our module -- ERM-3967 (#765)

* refactor: useGetAccess now uses the canAll endpoint to massively reduce traffic through acquisitions and our module

* test(useGetAccess): Fixed broken test

Author: EthanFreestone

lib/AccessControl/constants/restrictions.js

@@ -5,6 +5,9 @@ export const UPDATE = 'update';
 export const CLAIM = 'claim';
 export const APPLY_POLICIES = 'apply_policies';
 
+export const ALL = 'ALL'; // Technically not a real restriction, but we surface a "canAll" endpoint now.
+
+// Don't include ALL here
 export const RESTRICTIONS = [
   READ,
   CREATE,
@@ -35,6 +38,8 @@ export const CAN_CREATE = 'canCreate';
 export const CAN_DELETE = 'canDelete';
 export const CAN_UPDATE = 'canUpdate';
 export const CAN_APPLY_POLICIES = 'canApplyPolicies';
+export const CAN_ALL = 'canAll';
+
 
 // Helper methods to go from restriction -> canAccess or restrictionPolicies. Potentially slightly overkill
 export const getCanAccessFromRestriction = (restriction) => {
@@ -49,6 +54,8 @@ export const getCanAccessFromRestriction = (restriction) => {
       return CAN_UPDATE;
     case APPLY_POLICIES:
       return CAN_APPLY_POLICIES;
+    case ALL: // Technically not a real restriction, but we surface a "canAll" endpoint now.
+      return CAN_ALL;
     default:
       return null;
   }

lib/AccessControl/hooks/useGetAccess/useGetAccess.js

@@ -1,99 +1,41 @@
-// Currently this is handled via 5 different calls to our API (CLAIM is a different thing)
-// This isn't the most ideal, so bring together in "nice" single hook
 import useCanAccess from '../useCanAccess';
 import {
-  APPLY_POLICIES,
-  CREATE,
-  DELETE,
+  ALL,
   getCanAccessFromRestriction,
-  READ,
-  UPDATE
 } from '../../constants';
 
 const useGetAccess = ({
   resourceEndpoint,
   resourceId,
-  restrictions, // Array of restrictions to fetch,
   queryNamespaceGenerator,
   queryOptions // Shared between the queries
 }) => {
-  // ---------- EDIT ----------
-  const canEditQuery = useCanAccess({
+  const canAccessQuery = useCanAccess({
     resourceEndpoint,
     resourceId,
-    restriction: UPDATE,
-    queryNamespaceGenerator: () => queryNamespaceGenerator(UPDATE, getCanAccessFromRestriction(UPDATE)),
-    queryOptions: {
-      enabled: restrictions.includes(UPDATE),
-      ...queryOptions
-    }
+    restriction: ALL,
+    queryNamespaceGenerator: () => queryNamespaceGenerator(ALL, getCanAccessFromRestriction(ALL)),
+    queryOptions
   });
-  const { canAccess: canEdit, isLoading: canEditLoading } = canEditQuery;
-
-  // ---------- CREATE ----------
-  const canCreateQuery = useCanAccess({
-    resourceEndpoint,
-    resourceId,
-    restriction: CREATE,
-    queryNamespaceGenerator: () => queryNamespaceGenerator(CREATE, getCanAccessFromRestriction(CREATE)),
-    queryOptions: {
-      enabled: restrictions.includes(CREATE),
-    }
-  });
-  const { canAccess: canCreate, isLoading: canCreateLoading } = canCreateQuery;
-
-  // ---------- APPLY_POLICIES ----------
-  const canApplyPoliciesQuery = useCanAccess({
-    resourceEndpoint,
-    resourceId,
-    restriction: APPLY_POLICIES,
-    queryNamespaceGenerator: () => queryNamespaceGenerator(APPLY_POLICIES, getCanAccessFromRestriction(APPLY_POLICIES)),
-    queryOptions: {
-      enabled: restrictions.includes(APPLY_POLICIES),
-    }
-  });
-  const { canAccess: canApplyPolicies, isLoading: canApplyPoliciesLoading } = canApplyPoliciesQuery;
-
-  // ---------- READ ----------
-  const canReadQuery = useCanAccess({
-    resourceEndpoint,
-    resourceId,
-    restriction: READ,
-    queryNamespaceGenerator: () => queryNamespaceGenerator(READ, getCanAccessFromRestriction(READ)),
-    queryOptions: {
-      enabled: restrictions.includes(READ),
-    }
-  });
-  const { canAccess: canRead, isLoading: canReadLoading } = canReadQuery;
-
-  // ---------- DELETE ----------
-  const canDeleteQuery = useCanAccess({
-    resourceEndpoint,
-    resourceId,
-    restriction: DELETE,
-    queryNamespaceGenerator: () => queryNamespaceGenerator(DELETE, getCanAccessFromRestriction(DELETE)),
-    queryOptions: {
-      enabled: restrictions.includes(DELETE),
-    }
-  });
-  const { canAccess: canDelete, isLoading: canDeleteLoading } = canDeleteQuery;
+  const {
+    canAccessObj: {
+      canApplyPolicies,
+      canCreate,
+      canDelete,
+      canRead,
+      canUpdate: canEdit
+    } = {},
+    isLoading
+  } = canAccessQuery;
 
   return ({
+    isLoading,
+    canAccessQuery,
     canCreate,
-    canCreateLoading,
-    canCreateQuery,
     canRead,
-    canReadLoading,
-    canReadQuery,
     canEdit,
-    canEditLoading,
-    canEditQuery,
     canDelete,
-    canDeleteLoading,
-    canDeleteQuery,
     canApplyPolicies,
-    canApplyPoliciesLoading,
-    canApplyPoliciesQuery
   });
 };
 

lib/AccessControl/hooks/useGetAccess/useGetAccess.test.js

@@ -26,62 +26,38 @@ describe('useGetAccess', () => {
       queryNamespaceGenerator,
       resourceEndpoint: '/wibble',
       resourceId: '123',
-      restrictions: [READ, UPDATE]
     }))?.result;
   });
 
   test('useCanAccess called the correct number of times', () => {
-    expect(useCanAccess).toHaveBeenCalledTimes(5);
+    expect(useCanAccess).toHaveBeenCalledTimes(1);
   });
 
   let mockCall;
   describe.each([
     {
       restriction: UPDATE,
-      expectedQueryOptions: { enabled: true },
-      expectedQueryNamespace: ['update', 'canUpdate'],
-      callIndex: 0
     },
     {
       restriction: CREATE,
-      expectedQueryOptions: { enabled: false },
-      expectedQueryNamespace: ['create', 'canCreate'],
-      callIndex: 1
     },
     {
       restriction: APPLY_POLICIES,
-      expectedQueryOptions: { enabled: false },
-      expectedQueryNamespace: ['apply_policies', 'canApplyPolicies'],
-      callIndex: 2
     },
     {
       restriction: READ,
-      expectedQueryOptions: { enabled: true },
-      expectedQueryNamespace: ['read', 'canRead'],
-      callIndex: 3
     },
     {
       restriction: DELETE,
-      expectedQueryOptions: { enabled: false },
-      expectedQueryNamespace: ['delete', 'canDelete'],
-      callIndex: 4
     }
-  ])('useGetAccess $restriction', ({
-    callIndex,
-    expectedQueryNamespace,
-    expectedQueryOptions,
-  }) => {
+  ])('useGetAccess $restriction', () => {
     beforeEach(() => {
-      mockCall = useCanAccess.mock.calls[callIndex][0];
-    });
-
-    test('queryOptions are as expected', () => {
-      expect(mockCall).toHaveProperty('queryOptions', expectedQueryOptions);
+      mockCall = useCanAccess.mock.calls[0][0];
     });
 
     test('queryNamespaceGenerator returns expected namespace', () => {
       const queryNamespace = mockCall.queryNamespaceGenerator();
-      expect(queryNamespace).toEqual(expectedQueryNamespace);
+      expect(queryNamespace).toEqual(['ALL', 'canAll']);
     });
   });
 });