[permissions] QA fixes (#13698)

In this PR

- Introduction of readableFields and updatableFields in
objectMetadataItem selector to ease filtering from a developer
experience perspective ( + to help developers think to do it). In
discussion @lucasbordeau @charlesBochet
- Remove non-updatable field from CSV import process (@etiennejouan)
- QA fix / Non-readable fields should not show on show page
- QA fix / It should not be offered to create a kanban view on a
non-readable field
- QA fix / It should not be offered to create view groups on a
non-readable field
- QA fix / Rating field should have a readonly mode

---------

Co-authored-by: Charles Bochet <charles@twenty.com>

packages/twenty-front/src/modules/object-record/cache/utils/getRecordFromCache.ts

@@ -7,9 +7,9 @@ import { RecordGqlFields } from '@/object-record/graphql/types/RecordGqlFields';
 import { generateDepthOneRecordGqlFields } from '@/object-record/graphql/utils/generateDepthOneRecordGqlFields';
 import { ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { capitalize } from 'twenty-shared/utils';
-import { ObjectPermission } from '~/generated/graphql';
 import { isEmptyObject } from '~/utils/isEmptyObject';
 import { isUndefinedOrNull } from '~/utils/isUndefinedOrNull';
+import { ObjectPermissions } from 'twenty-shared/types';
 
 export type GetRecordFromCacheArgs = {
   cache: ApolloCache<object>;
@@ -17,7 +17,10 @@ export type GetRecordFromCacheArgs = {
   objectMetadataItems: ObjectMetadataItem[];
   objectMetadataItem: ObjectMetadataItem;
   recordGqlFields?: RecordGqlFields;
-  objectPermissionsByObjectMetadataId: Record<string, ObjectPermission>;
+  objectPermissionsByObjectMetadataId: Record<
+    string,
+    ObjectPermissions & { objectMetadataId: string }
+  >;
   isFieldsPermissionsEnabled?: boolean;
 };
 export const getRecordFromCache = <T extends ObjectRecord = ObjectRecord>({

packages/twenty-front/src/modules/object-record/cache/utils/updateRecordFromCache.ts

@@ -6,8 +6,8 @@ import { mapObjectMetadataToGraphQLQuery } from '@/object-metadata/utils/mapObje
 import { getRecordNodeFromRecord } from '@/object-record/cache/utils/getRecordNodeFromRecord';
 import { RecordGqlNode } from '@/object-record/graphql/types/RecordGqlNode';
 import { ObjectRecord } from '@/object-record/types/ObjectRecord';
+import { ObjectPermissions } from 'twenty-shared/types';
 import { capitalize } from 'twenty-shared/utils';
-import { ObjectPermission } from '~/generated/graphql';
 import { isUndefinedOrNull } from '~/utils/isUndefinedOrNull';
 
 export const updateRecordFromCache = <T extends ObjectRecord>({
@@ -24,7 +24,10 @@ export const updateRecordFromCache = <T extends ObjectRecord>({
   cache: ApolloCache<object>;
   recordGqlFields: Record<string, boolean>;
   record: T;
-  objectPermissionsByObjectMetadataId: Record<string, ObjectPermission>;
+  objectPermissionsByObjectMetadataId: Record<
+    string,
+    ObjectPermissions & { objectMetadataId: string }
+  >;
   isFieldsPermissionsEnabled?: boolean;
 }) => {
   if (isUndefinedOrNull(objectMetadataItem)) {

packages/twenty-front/src/modules/object-record/graphql/utils/generateDepthOneRecordGqlFields.ts

@@ -8,14 +8,17 @@ export type GenerateDepthOneRecordGqlFields = {
 export const generateDepthOneRecordGqlFields = ({
   objectMetadataItem,
 }: GenerateDepthOneRecordGqlFields) =>
-  objectMetadataItem.fields.reduce<Record<string, true>>((acc, field) => {
-    return {
-      ...acc,
-      ...(isDefined(field.settings?.joinColumnName)
-        ? {
-            [field.settings.joinColumnName]: true,
-          }
-        : {}),
-      [field.name]: true,
-    };
-  }, {});
+  objectMetadataItem.readableFields.reduce<Record<string, true>>(
+    (acc, field) => {
+      return {
+        ...acc,
+        ...(isDefined(field.settings?.joinColumnName)
+          ? {
+              [field.settings.joinColumnName]: true,
+            }
+          : {}),
+        [field.name]: true,
+      };
+    },
+    {},
+  );

packages/twenty-front/src/modules/object-record/hooks/__tests__/useAggregateRecordsQuery.test.tsx

@@ -11,6 +11,29 @@ import { getJestMetadataAndApolloMocksWrapper } from '~/testing/jest/getJestMeta
 jest.mock('@/object-metadata/hooks/useObjectMetadataItem');
 jest.mock('@/object-record/utils/generateAggregateQuery');
 
+const fields = [
+  {
+    id: '20202020-fed9-4ce5-9502-02a8efaf46e1',
+    name: 'amount',
+    label: 'Amount',
+    type: FieldMetadataType.NUMBER,
+    isCustom: false,
+    isActive: true,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as FieldMetadataItem,
+  {
+    id: '20202020-dd4a-4ea4-bb7b-1c7300491b65',
+    name: 'name',
+    label: 'Name',
+    type: FieldMetadataType.TEXT,
+    isCustom: false,
+    isActive: true,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as FieldMetadataItem,
+];
+
 const mockObjectMetadataItem: ObjectMetadataItem = {
   nameSingular: 'company',
   namePlural: 'companies',
@@ -23,28 +46,9 @@ const mockObjectMetadataItem: ObjectMetadataItem = {
   isActive: true,
   createdAt: new Date().toISOString(),
   updatedAt: new Date().toISOString(),
-  fields: [
-    {
-      id: '20202020-fed9-4ce5-9502-02a8efaf46e1',
-      name: 'amount',
-      label: 'Amount',
-      type: FieldMetadataType.NUMBER,
-      isCustom: false,
-      isActive: true,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    } as FieldMetadataItem,
-    {
-      id: '20202020-dd4a-4ea4-bb7b-1c7300491b65',
-      name: 'name',
-      label: 'Name',
-      type: FieldMetadataType.TEXT,
-      isCustom: false,
-      isActive: true,
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    } as FieldMetadataItem,
-  ],
+  fields,
+  readableFields: fields,
+  updatableFields: fields,
   indexMetadatas: [],
   isLabelSyncedWithName: true,
   isRemote: false,
@@ -118,19 +122,19 @@ describe('useAggregateRecordsQuery', () => {
     );
   });
 
-  it('should throw error for invalid aggregation operation', () => {
-    expect(() =>
-      renderHook(
-        () =>
-          useAggregateRecordsQuery({
-            objectNameSingular: 'company',
-            recordGqlFieldsAggregate: {
-              name: [AggregateOperations.SUM],
-            },
-          }),
-        { wrapper: Wrapper },
-      ),
-    ).toThrow();
+  it('should early return for invalid aggregation operation', () => {
+    const { result } = renderHook(
+      () =>
+        useAggregateRecordsQuery({
+          objectNameSingular: 'company',
+          recordGqlFieldsAggregate: {
+            name: [AggregateOperations.SUM],
+          },
+        }),
+      { wrapper: Wrapper },
+    );
+
+    expect(result.current.gqlFieldToFieldMap).toEqual({});
   });
 
   it('should handle multiple aggregations', () => {

packages/twenty-front/src/modules/object-record/hooks/useAggregateRecordsQuery.ts

@@ -28,8 +28,11 @@ export const useAggregateRecordsQuery = ({
 
   const apolloCoreClient = useApolloCoreClient();
   const availableAggregations = useMemo(
-    () => getAvailableAggregationsFromObjectFields(objectMetadataItem.fields),
-    [objectMetadataItem.fields],
+    () =>
+      getAvailableAggregationsFromObjectFields(
+        objectMetadataItem.readableFields,
+      ),
+    [objectMetadataItem.readableFields],
   );
 
   const recordGqlFields: RecordGqlFields = {};
@@ -42,9 +45,7 @@ export const useAggregateRecordsQuery = ({
           availableAggregations[fieldName]?.[aggregateOperation];
 
         if (!isDefined(fieldToQuery)) {
-          throw new Error(
-            `Cannot query operation ${aggregateOperation} on field ${fieldName}`,
-          );
+          return;
         }
         gqlFieldToFieldMap[fieldToQuery] = [fieldName, aggregateOperation];
 

packages/twenty-front/src/modules/object-record/hooks/useAttachRelatedRecordFromRecord.ts

@@ -25,7 +25,7 @@ export const useAttachRelatedRecordFromRecord = ({
     objectNameSingular: recordObjectNameSingular,
   });
 
-  const fieldOnObject = objectMetadataItem.fields.find((field) => {
+  const fieldOnObject = objectMetadataItem.readableFields.find((field) => {
     return field.name === fieldNameOnRecordObject;
   });
 

packages/twenty-front/src/modules/object-record/hooks/useDetachRelatedRecordFromRecord.ts

@@ -21,7 +21,7 @@ export const useDetachRelatedRecordFromRecord = ({
     objectNameSingular: recordObjectNameSingular,
   });
 
-  const fieldOnObject = objectMetadataItem.fields.find((field) => {
+  const fieldOnObject = objectMetadataItem.readableFields.find((field) => {
     return field.name === fieldNameOnRecordObject;
   });
 

packages/twenty-front/src/modules/object-record/hooks/useObjectPermissions.ts

@@ -1,11 +1,14 @@
 import { useRecoilValue } from 'recoil';
 
 import { currentUserWorkspaceState } from '@/auth/states/currentUserWorkspaceState';
+import { ObjectPermissions } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
-import { ObjectPermission } from '~/generated/graphql';
 
 type useObjectPermissionsReturnType = {
-  objectPermissionsByObjectMetadataId: Record<string, ObjectPermission>;
+  objectPermissionsByObjectMetadataId: Record<
+    string,
+    ObjectPermissions & { objectMetadataId: string }
+  >;
 };
 
 export const useObjectPermissions = (): useObjectPermissionsReturnType => {
@@ -19,7 +22,10 @@ export const useObjectPermissions = (): useObjectPermissionsReturnType => {
   }
 
   const objectPermissionsByObjectMetadataId = objectPermissions?.reduce(
-    (acc: Record<string, ObjectPermission>, objectPermission) => {
+    (
+      acc: Record<string, ObjectPermissions & { objectMetadataId: string }>,
+      objectPermission,
+    ) => {
       acc[objectPermission.objectMetadataId] = objectPermission;
       return acc;
     },

packages/twenty-front/src/modules/object-record/hooks/useObjectPermissionsForObject.ts

@@ -1,9 +1,12 @@
 import { getObjectPermissionsForObject } from '~/modules/object-metadata/utils/getObjectPermissionsForObject';
 
 import { useMemo } from 'react';
+import { ObjectPermissions } from 'twenty-shared/types';
 import { useObjectPermissions } from './useObjectPermissions';
 
-export const useObjectPermissionsForObject = (objectMetadataId: string) => {
+export const useObjectPermissionsForObject = (
+  objectMetadataId: string,
+): ObjectPermissions & { objectMetadataId: string } => {
   const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
 
   return useMemo(() => {

packages/twenty-front/src/modules/object-record/object-filter-dropdown/hooks/useOptionsForSelect.ts

@@ -16,7 +16,7 @@ export const useOptionsForSelect = (fieldMetadataId: string) => {
     objectNameSingular,
   });
 
-  const fieldMetadataItem = objectMetadataItem.fields.find(
+  const fieldMetadataItem = objectMetadataItem.readableFields.find(
     (field) => field.id === fieldMetadataId,
   );
 

packages/twenty-front/src/modules/object-record/object-options-dropdown/hooks/__tests__/useObjectOptionsForTable.test.tsx

@@ -1,19 +1,35 @@
+import { objectMetadataItemsState } from '@/object-metadata/states/objectMetadataItemsState';
+import { FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
 import { useObjectOptionsForTable } from '@/object-record/object-options-dropdown/hooks/useObjectOptionsForTable';
+import { FieldMetadata } from '@/object-record/record-field/types/FieldMetadata';
 import { RecordTableComponentInstanceContext } from '@/object-record/record-table/states/context/RecordTableComponentInstanceContext';
 import { tableColumnsComponentState } from '@/object-record/record-table/states/tableColumnsComponentState';
+import { ColumnDefinition } from '@/object-record/record-table/types/ColumnDefinition';
 import { DropResult, ResponderProvided } from '@hello-pangea/dnd';
 import { renderHook } from '@testing-library/react';
 import { act } from 'react';
 import { RecoilRoot } from 'recoil';
 
 describe('useObjectOptionsForTable', () => {
-  const initialRecoilState = [
-    { fieldMetadataId: 'field1', isVisible: true, position: 0 },
-    { fieldMetadataId: 'field2', isVisible: true, position: 1 },
-    { fieldMetadataId: 'field3', isVisible: true, position: 2 },
-    { fieldMetadataId: 'field4', isVisible: true, position: 3 },
-    { fieldMetadataId: 'field5', isVisible: true, position: 4 },
-  ];
+  const fieldMetadataItems = [
+    { id: 'id-1', name: 'field1' },
+    { id: 'id-2', name: 'field2' },
+    { id: 'id-3', name: 'field3' },
+    { id: 'id-4', name: 'field4' },
+    { id: 'id-5', name: 'field5' },
+  ] as FieldMetadataItem[];
+
+  const columnDefinitionsWithMetadata = fieldMetadataItems.map(
+    (field, index) => ({
+      fieldMetadataId: field.id,
+      isVisible: true,
+      position: index + 1,
+      metadata: {
+        fieldName: field.name,
+      },
+    }),
+  );
 
   const renderWithRecoil = () =>
     renderHook(() => useObjectOptionsForTable('instance-id', 'object-id'), {
@@ -27,8 +43,18 @@ describe('useObjectOptionsForTable', () => {
                 tableColumnsComponentState.atomFamily({
                   instanceId: 'instance-id',
                 }),
-                initialRecoilState as any,
+                columnDefinitionsWithMetadata as ColumnDefinition<FieldMetadata>[],
               );
+              set(objectMetadataItemsState, [
+                {
+                  id: 'object-id',
+                  nameSingular: 'Object',
+                  namePlural: 'Objects',
+                  fields: fieldMetadataItems,
+                  readableFields: fieldMetadataItems,
+                  updatableFields: fieldMetadataItems,
+                } as ObjectMetadataItem,
+              ]);
             }}
           >
             {children}
@@ -43,7 +69,7 @@ describe('useObjectOptionsForTable', () => {
     const dropResult = {
       source: { droppableId: 'droppable', index: 2 },
       destination: { droppableId: 'droppable', index: 3 },
-      draggableId: 'field3',
+      draggableId: 'field2',
       type: 'TYPE',
       mode: 'FLUID',
       reason: 'DROP',
@@ -60,28 +86,43 @@ describe('useObjectOptionsForTable', () => {
 
     expect(result.current.visibleTableColumns).toEqual([
       {
-        fieldMetadataId: 'field1',
+        fieldMetadataId: 'id-1',
         isVisible: true,
+        metadata: {
+          fieldName: 'field1',
+        },
         position: 0,
       },
       {
-        fieldMetadataId: 'field3',
+        fieldMetadataId: 'id-3',
         isVisible: true,
+        metadata: {
+          fieldName: 'field3',
+        },
         position: 1,
       },
       {
-        fieldMetadataId: 'field2',
+        fieldMetadataId: 'id-2',
         isVisible: true,
+        metadata: {
+          fieldName: 'field2',
+        },
         position: 2,
       },
       {
-        fieldMetadataId: 'field4',
+        fieldMetadataId: 'id-4',
         isVisible: true,
+        metadata: {
+          fieldName: 'field4',
+        },
         position: 3,
       },
       {
-        fieldMetadataId: 'field5',
+        fieldMetadataId: 'id-5',
         isVisible: true,
+        metadata: {
+          fieldName: 'field5',
+        },
         position: 4,
       },
     ]);

packages/twenty-front/src/modules/object-record/object-options-dropdown/hooks/__tests__/useSearchRecordGroupField.test.tsx

@@ -23,13 +23,16 @@ describe('useSearchRecordGroupField', () => {
     });
 
   it('filters fields correctly based on input', () => {
+    const fields = [
+      { type: FieldMetadataType.SELECT, label: 'First' },
+      { type: FieldMetadataType.SELECT, label: 'Second' },
+      { type: FieldMetadataType.TEXT, label: 'Third' },
+    ];
     const mockContextValue = {
       objectMetadataItem: {
-        fields: [
-          { type: FieldMetadataType.SELECT, label: 'First' },
-          { type: FieldMetadataType.SELECT, label: 'Second' },
-          { type: FieldMetadataType.TEXT, label: 'Third' },
-        ],
+        fields,
+        readableFields: fields,
+        updatableFields: fields,
       },
     };
 
@@ -45,13 +48,16 @@ describe('useSearchRecordGroupField', () => {
   });
 
   it('returns all select fields when search input is empty', () => {
+    const fields = [
+      { type: FieldMetadataType.SELECT, label: 'First' },
+      { type: FieldMetadataType.SELECT, label: 'Second' },
+      { type: FieldMetadataType.TEXT, label: 'Third' },
+    ];
     const mockContextValue = {
       objectMetadataItem: {
-        fields: [
-          { type: FieldMetadataType.SELECT, label: 'First' },
-          { type: FieldMetadataType.SELECT, label: 'Second' },
-          { type: FieldMetadataType.TEXT, label: 'Third' },
-        ],
+        fields,
+        readableFields: fields,
+        updatableFields: fields,
       },
     };
 

packages/twenty-front/src/modules/object-record/object-options-dropdown/hooks/useSearchRecordGroupField.ts

@@ -14,12 +14,12 @@ export const useSearchRecordGroupField = () => {
     const searchInputLowerCase =
       recordGroupFieldSearchInput.toLocaleLowerCase();
 
-    return objectMetadataItem.fields.filter(
+    return objectMetadataItem.readableFields.filter(
       (field) =>
         field.type === FieldMetadataType.SELECT &&
         field.label.toLocaleLowerCase().includes(searchInputLowerCase),
     );
-  }, [objectMetadataItem.fields, recordGroupFieldSearchInput]);
+  }, [objectMetadataItem.readableFields, recordGroupFieldSearchInput]);
 
   return {
     recordGroupFieldSearchInput,

packages/twenty-front/src/modules/object-record/object-sort-dropdown/utils/__tests__/turnSortsIntoOrderBy.test.ts

@@ -3,21 +3,25 @@ import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
 import { RecordGqlOperationOrderBy } from '@/object-record/graphql/types/RecordGqlOperationOrderBy';
 import { turnSortsIntoOrderBy } from '@/object-record/object-sort-dropdown/utils/turnSortsIntoOrderBy';
 import { RecordSort } from '@/object-record/record-sort/types/RecordSort';
-import { FieldMetadataType } from '~/generated-metadata/graphql';
 import { EachTestingContext } from 'twenty-shared/testing';
+import { FieldMetadataType } from '~/generated-metadata/graphql';
+
+const fields = [
+  {
+    name: 'name',
+    updatedAt: '2021-01-01',
+    createdAt: '2021-01-01',
+    id: '20202020-18b3-4099-86e3-c46b2d5d42f2',
+    type: FieldMetadataType.POSITION,
+    label: 'label',
+  },
+];
 
 const objectMetadataItemWithPositionField: ObjectMetadataItem = {
   id: 'object1',
-  fields: [
-    {
-      name: 'name',
-      updatedAt: '2021-01-01',
-      createdAt: '2021-01-01',
-      id: '20202020-18b3-4099-86e3-c46b2d5d42f2',
-      type: FieldMetadataType.POSITION,
-      label: 'label',
-    },
-  ],
+  fields,
+  readableFields: fields,
+  updatableFields: fields,
   indexMetadatas: [],
   createdAt: '2021-01-01',
   updatedAt: '2021-01-01',

packages/twenty-front/src/modules/object-record/record-board/record-board-column/components/RecordBoardColumnHeaderAggregateDropdownContent.tsx

@@ -1,5 +1,5 @@
 import { useDropdownContextStateManagement } from '@/dropdown-context-state-management/hooks/useDropdownContextStateManagement';
-import { getReadRestrictedFieldMetadataIdsFromObjectPermissions } from '@/object-metadata/utils/getReadRestrictedFieldMetadataIdsFromObjectPermissions';
+import { getNonReadableFieldMetadataIdsFromObjectPermissions } from '@/object-metadata/utils/getNonReadableFieldMetadataIdsFromObjectPermissions';
 import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions';
 import { RecordBoardColumnHeaderAggregateDropdownContext } from '@/object-record/record-board/record-board-column/components/RecordBoardColumnHeaderAggregateDropdownContext';
 import { RecordBoardColumnHeaderAggregateDropdownFieldsContent } from '@/object-record/record-board/record-board-column/components/RecordBoardColumnHeaderAggregateDropdownFieldsContent';
@@ -11,6 +11,7 @@ import { NON_STANDARD_AGGREGATE_OPERATION_OPTIONS } from '@/object-record/record
 import { PERCENT_AGGREGATE_OPERATION_OPTIONS } from '@/object-record/record-table/record-table-footer/constants/percentAggregateOperationOptions';
 import { AvailableFieldsForAggregateOperation } from '@/object-record/types/AvailableFieldsForAggregateOperation';
 import { getAvailableFieldsIdsForAggregationFromObjectFields } from '@/object-record/utils/getAvailableFieldsIdsForAggregationFromObjectFields';
+import { getObjectPermissionsFromMapByObjectMetadataId } from '@/settings/roles/role-permissions/objects-permissions/utils/getObjectPermissionsFromMapByObjectMetadataId';
 import { t } from '@lingui/core/macro';
 
 export const AggregateDropdownContent = () => {
@@ -22,11 +23,11 @@ export const AggregateDropdownContent = () => {
   const { objectPermissionsByObjectMetadataId } = useObjectPermissions();
 
   const restrictedFieldMetadataIds =
-    getReadRestrictedFieldMetadataIdsFromObjectPermissions({
-      objectPermissions: [
-        objectPermissionsByObjectMetadataId[objectMetadataItem.id],
-      ],
-      objectMetadataId: objectMetadataItem.id,
+    getNonReadableFieldMetadataIdsFromObjectPermissions({
+      objectPermissions: getObjectPermissionsFromMapByObjectMetadataId({
+        objectPermissionsByObjectMetadataId,
+        objectMetadataId: objectMetadataItem.id,
+      }),
     });
 
   const readableFields = objectMetadataItem.fields.filter(

packages/twenty-front/src/modules/object-record/record-board/record-board-column/utils/__tests__/buildRecordGqlFieldsAggregateForView.test.ts

@@ -8,6 +8,24 @@ import { FieldMetadataType } from '~/generated-metadata/graphql';
 const MOCK_FIELD_ID = '7d2d7b5e-7b3e-4b4a-8b0a-7b3e4b4a8b0a';
 
 describe('buildRecordGqlFieldsAggregateForView', () => {
+  const fields = [
+    {
+      id: MOCK_FIELD_ID,
+      name: 'amount',
+      type: FieldMetadataType.NUMBER,
+    } as FieldMetadataItem,
+    {
+      id: '06b33746-5293-4d07-9f7f-ebf5ad396064',
+      name: 'name',
+      type: FieldMetadataType.TEXT,
+    } as FieldMetadataItem,
+    {
+      id: 'e46b9ba4-144b-4d10-a092-03a7521c8aa0',
+      name: 'createdAt',
+      type: FieldMetadataType.DATE_TIME,
+    } as FieldMetadataItem,
+  ];
+
   const mockObjectMetadata: ObjectMetadataItem = {
     id: '123',
     nameSingular: 'opportunity',
@@ -22,23 +40,9 @@ describe('buildRecordGqlFieldsAggregateForView', () => {
     labelIdentifierFieldMetadataId: '06b33746-5293-4d07-9f7f-ebf5ad396064',
     imageIdentifierFieldMetadataId: null,
     isLabelSyncedWithName: true,
-    fields: [
-      {
-        id: MOCK_FIELD_ID,
-        name: 'amount',
-        type: FieldMetadataType.NUMBER,
-      } as FieldMetadataItem,
-      {
-        id: '06b33746-5293-4d07-9f7f-ebf5ad396064',
-        name: 'name',
-        type: FieldMetadataType.TEXT,
-      } as FieldMetadataItem,
-      {
-        id: 'e46b9ba4-144b-4d10-a092-03a7521c8aa0',
-        name: 'createdAt',
-        type: FieldMetadataType.DATE_TIME,
-      } as FieldMetadataItem,
-    ],
+    fields,
+    readableFields: fields,
+    updatableFields: fields,
     indexMetadatas: [],
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),

packages/twenty-front/src/modules/object-record/record-field/components/FieldDisplay.tsx

@@ -51,8 +51,12 @@ import { isFieldText } from '../types/guards/isFieldText';
 import { isFieldUuid } from '../types/guards/isFieldUuid';
 
 export const FieldDisplay = () => {
-  const { fieldDefinition, isLabelIdentifier, isForbidden } =
-    useContext(FieldContext);
+  const {
+    fieldDefinition,
+    isLabelIdentifier,
+    isForbidden,
+    isRecordFieldReadOnly,
+  } = useContext(FieldContext);
 
   const isChipDisplay = isFieldIdentifierDisplay(
     fieldDefinition,
@@ -96,7 +100,7 @@ export const FieldDisplay = () => {
   ) : isFieldBoolean(fieldDefinition) ? (
     <BooleanFieldDisplay />
   ) : isFieldRating(fieldDefinition) ? (
-    <RatingFieldDisplay />
+    <RatingFieldDisplay readonly={isRecordFieldReadOnly} />
   ) : isFieldRichText(fieldDefinition) ? (
     <RichTextFieldDisplay />
   ) : isFieldRichTextV2(fieldDefinition) ? (

packages/twenty-front/src/modules/object-record/record-field/components/FieldInput.tsx

@@ -139,7 +139,7 @@ export const FieldInput = ({
       ) : isFieldBoolean(fieldDefinition) ? (
         <BooleanFieldInput onSubmit={onSubmit} readonly={isReadOnly} />
       ) : isFieldRating(fieldDefinition) ? (
-        <RatingFieldInput onSubmit={onSubmit} />
+        <RatingFieldInput onSubmit={onSubmit} readonly={isReadOnly} />
       ) : isFieldSelect(fieldDefinition) ? (
         <SelectFieldInput onSubmit={onSubmit} onCancel={onCancel} />
       ) : isFieldMultiSelect(fieldDefinition) ? (

packages/twenty-front/src/modules/object-record/record-field/meta-types/display/components/RatingFieldDisplay.tsx

@@ -1,8 +1,8 @@
 import { useRatingFieldDisplay } from '@/object-record/record-field/meta-types/hooks/useRatingFieldDisplay';
 import { RatingInput } from '@/ui/field/input/components/RatingInput';
 
-export const RatingFieldDisplay = () => {
+export const RatingFieldDisplay = ({ readonly }: { readonly?: boolean }) => {
   const { rating } = useRatingFieldDisplay();
 
-  return <RatingInput value={rating} readonly />;
+  return <RatingInput value={rating} readonly={readonly} />;
 };

packages/twenty-front/src/modules/object-record/record-filter/utils/__tests__/turnAnyFieldFilterIntoRecordGqlFilter.test.ts

@@ -138,6 +138,8 @@ const mockObjectMetadataItem: ObjectMetadataItem = {
   nameSingular: 'test',
   namePlural: 'tests',
   fields: [],
+  readableFields: [],
+  updatableFields: [],
 };
 
 const mockObjectMetadataItemWithAllFields: ObjectMetadataItem = {

packages/twenty-front/src/modules/object-record/record-index/contexts/RecordIndexContext.ts

@@ -1,5 +1,5 @@
 import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
-import { ObjectPermission } from '~/generated/graphql';
+import { ObjectPermissions } from 'twenty-shared/types';
 import { createRequiredContext } from '~/utils/createRequiredContext';
 
 export type RecordIndexContextValue = {
@@ -8,7 +8,10 @@ export type RecordIndexContextValue = {
   objectNamePlural: string;
   objectNameSingular: string;
   objectMetadataItem: ObjectMetadataItem;
-  objectPermissionsByObjectMetadataId: Record<string, ObjectPermission>;
+  objectPermissionsByObjectMetadataId: Record<
+    string,
+    ObjectPermissions & { objectMetadataId: string }
+  >;
   recordIndexId: string;
 };
 

packages/twenty-front/src/modules/object-record/record-picker/multiple-record-picker/hooks/useMultipleRecordPickerPerformSearch.ts

@@ -10,6 +10,7 @@ import { multipleRecordPickerSearchFilterComponentState } from '@/object-record/
 import { multipleRecordPickerSearchableObjectMetadataItemsComponentState } from '@/object-record/record-picker/multiple-record-picker/states/multipleRecordPickerSearchableObjectMetadataItemsComponentState';
 import { searchRecordStoreComponentFamilyState } from '@/object-record/record-picker/multiple-record-picker/states/searchRecordStoreComponentFamilyState';
 import { RecordPickerPickableMorphItem } from '@/object-record/record-picker/types/RecordPickerPickableMorphItem';
+import { getObjectPermissionsFromMapByObjectMetadataId } from '@/settings/roles/role-permissions/objects-permissions/utils/getObjectPermissionsFromMapByObjectMetadataId';
 import { ApolloClient } from '@apollo/client';
 import { isNonEmptyArray } from '@sniptt/guards';
 import { useRecoilCallback } from 'recoil';
@@ -104,8 +105,10 @@ export const useMultipleRecordPickerPerformSearch = () => {
         const filteredSearchableObjectMetadataItems =
           searchableObjectMetadataItems.filter(
             (objectMetadataItem) =>
-              objectPermissionsByObjectMetadataId[objectMetadataItem.id]
-                .canReadObjectRecords === true,
+              getObjectPermissionsFromMapByObjectMetadataId({
+                objectPermissionsByObjectMetadataId,
+                objectMetadataId: objectMetadataItem.id,
+              }).canReadObjectRecords === true,
           );
 
         const [

packages/twenty-front/src/modules/object-record/record-show/components/FieldsCard.tsx

@@ -21,8 +21,9 @@ import { RecordDetailRelationSection } from '@/object-record/record-show/record-
 import { getRecordFieldInputInstanceId } from '@/object-record/utils/getRecordFieldInputId';
 import { isFieldCellSupported } from '@/object-record/utils/isFieldCellSupported';
 import { useIsInRightDrawerOrThrow } from '@/ui/layout/right-drawer/contexts/RightDrawerContext';
-import { FieldMetadataType } from '~/generated-metadata/graphql';
 import { isDefined } from 'twenty-shared/utils';
+import { FieldMetadataType } from '~/generated-metadata/graphql';
+import { getObjectPermissionsFromMapByObjectMetadataId } from '@/settings/roles/role-permissions/objects-permissions/utils/getObjectPermissionsFromMapByObjectMetadataId';
 
 type FieldsCardProps = {
   objectNameSingular: string;
@@ -56,7 +57,7 @@ export const FieldsCard = ({
 
   const { isInRightDrawer } = useIsInRightDrawerOrThrow();
 
-  const availableFieldMetadataItems = objectMetadataItem.fields
+  const availableFieldMetadataItems = objectMetadataItem.readableFields
     .filter(
       (fieldMetadataItem) =>
         isFieldCellSupported(fieldMetadataItem, objectMetadataItems) &&
@@ -138,9 +139,10 @@ export const FieldsCard = ({
                     isRecordFieldReadOnly: isRecordFieldReadOnly({
                       isRecordReadOnly,
                       objectPermissions:
-                        objectPermissionsByObjectMetadataId[
-                          objectMetadataItem.id
-                        ],
+                        getObjectPermissionsFromMapByObjectMetadataId({
+                          objectPermissionsByObjectMetadataId,
+                          objectMetadataId: objectMetadataItem.id,
+                        }),
                       fieldMetadataId: fieldMetadataItem.id,
                       objectNameSingular,
                       fieldName: fieldMetadataItem.name,
@@ -188,9 +190,10 @@ export const FieldsCard = ({
                   isRecordFieldReadOnly: isRecordFieldReadOnly({
                     isRecordReadOnly,
                     objectPermissions:
-                      objectPermissionsByObjectMetadataId[
-                        objectMetadataItem.id
-                      ],
+                      getObjectPermissionsFromMapByObjectMetadataId({
+                        objectPermissionsByObjectMetadataId,
+                        objectMetadataId: objectMetadataItem.id,
+                      }),
                     fieldMetadataId: fieldMetadataItem.id,
                     objectNameSingular,
                     fieldName: fieldMetadataItem.name,
@@ -239,8 +242,10 @@ export const FieldsCard = ({
             isDisplayModeFixHeight: true,
             isRecordFieldReadOnly: isRecordFieldReadOnly({
               isRecordReadOnly,
-              objectPermissions:
-                objectPermissionsByObjectMetadataId[objectMetadataItem.id],
+              objectPermissions: getObjectPermissionsFromMapByObjectMetadataId({
+                objectPermissionsByObjectMetadataId,
+                objectMetadataId: objectMetadataItem.id,
+              }),
               fieldMetadataId: fieldMetadataItem.id,
               objectNameSingular,
               fieldName: fieldMetadataItem.name,

packages/twenty-front/src/modules/object-record/record-show/hooks/useRecordShowContainerTabs.ts

@@ -6,6 +6,7 @@ import { useObjectPermissions } from '@/object-record/hooks/useObjectPermissions
 import { BASE_RECORD_LAYOUT } from '@/object-record/record-show/constants/BaseRecordLayout';
 import { CardType } from '@/object-record/record-show/types/CardType';
 import { RecordLayout } from '@/object-record/record-show/types/RecordLayout';
+import { getObjectPermissionsFromMapByObjectMetadataId } from '@/settings/roles/role-permissions/objects-permissions/utils/getObjectPermissionsFromMapByObjectMetadataId';
 import { RecordLayoutTab } from '@/ui/layout/tab-list/types/RecordLayoutTab';
 import { SingleTabProps } from '@/ui/layout/tab-list/types/SingleTabProps';
 import { useIsMobile } from '@/ui/utilities/responsive/hooks/useIsMobile';
@@ -300,8 +301,10 @@ export const useRecordShowContainerTabs = (
         const permissionHide =
           hide.ifNoReadPermission &&
           isDefined(targetObjectNameSingular) &&
-          !objectPermissionsByObjectMetadataId[targetObjectMetadataId ?? '']
-            ?.canReadObjectRecords;
+          !getObjectPermissionsFromMapByObjectMetadataId({
+            objectPermissionsByObjectMetadataId,
+            objectMetadataId: targetObjectMetadataId ?? '',
+          })?.canReadObjectRecords;
 
         const requiredObjectsInactive =
           hide.ifRequiredObjectsInactive.length > 0 &&

packages/twenty-front/src/modules/object-record/record-table/hooks/useSetTableColumns.ts

@@ -1,19 +1,13 @@
-import { currentUserWorkspaceState } from '@/auth/states/currentUserWorkspaceState';
+import { objectMetadataItemsState } from '@/object-metadata/states/objectMetadataItemsState';
 import { FieldMetadata } from '@/object-record/record-field/types/FieldMetadata';
 import { tableColumnsComponentState } from '@/object-record/record-table/states/tableColumnsComponentState';
 import { ColumnDefinition } from '@/object-record/record-table/types/ColumnDefinition';
 import { getSnapshotValue } from '@/ui/utilities/state/utils/getSnapshotValue';
-import { useFeatureFlagsMap } from '@/workspace/hooks/useFeatureFlagsMap';
 import { useRecoilCallback } from 'recoil';
-import { RestrictedField } from 'twenty-shared/types';
-import { FeatureFlagKey } from '~/generated/graphql';
+import { isDefined } from 'twenty-shared/utils';
 import { isDeeplyEqual } from '~/utils/isDeeplyEqual';
 
 export const useSetTableColumns = () => {
-  const featureFlags = useFeatureFlagsMap();
-  const isFieldsPermissionsEnabled =
-    featureFlags[FeatureFlagKey.IS_FIELDS_PERMISSIONS_ENABLED];
-
   const setTableColumns = useRecoilCallback(
     ({ snapshot, set }) =>
       (
@@ -21,6 +15,19 @@ export const useSetTableColumns = () => {
         recordTableId: string,
         objectMetadataId: string,
       ) => {
+        const objectMetadataItems = getSnapshotValue(
+          snapshot,
+          objectMetadataItemsState,
+        );
+
+        const objectMetadataItem = objectMetadataItems.find(
+          (item) => item.id === objectMetadataId,
+        );
+
+        if (!isDefined(objectMetadataItem)) {
+          return;
+        }
+
         const tableColumns = getSnapshotValue(
           snapshot,
           tableColumnsComponentState.atomFamily({
@@ -28,30 +35,11 @@ export const useSetTableColumns = () => {
           }),
         );
 
-        let columnsToSet = columns;
-
-        if (isFieldsPermissionsEnabled) {
-          const restrictedFields = getSnapshotValue(
-            snapshot,
-            currentUserWorkspaceState,
-          )?.objectPermissions?.find(
-            (permission) => permission.objectMetadataId === objectMetadataId,
-          )?.restrictedFields;
-
-          const restrictedFieldMetadataIds = Object.entries(
-            restrictedFields ?? {},
-          )
-            .filter(
-              ([_fieldMetadataId, restrictedField]) =>
-                (restrictedField as RestrictedField).canRead === false,
-            )
-            .map(([fieldMetadataId]) => fieldMetadataId);
-          const nonRestrictedColumns = columns.filter(
-            (column) =>
-              !restrictedFieldMetadataIds?.includes(column.fieldMetadataId),
-          );
-          columnsToSet = nonRestrictedColumns;
-        }
+        const columnsToSet = columns.filter((column) =>
+          objectMetadataItem.readableFields
+            .map((field) => field.name)
+            .includes(column.metadata.fieldName),
+        );
 
         if (isDeeplyEqual(tableColumns, columnsToSet)) {
           return;
@@ -63,7 +51,7 @@ export const useSetTableColumns = () => {
           columnsToSet,
         );
       },
-    [isFieldsPermissionsEnabled],
+    [],
   );
 
   return { setTableColumns };

packages/twenty-front/src/modules/object-record/spreadsheet-import/hooks/useOpenObjectRecordsSpreadsheetImportDialog.ts

@@ -44,7 +44,7 @@ export const useOpenObjectRecordsSpreadsheetImportDialog = (
   ) => {
     const availableFieldMetadataItemsToImport =
       spreadsheetImportFilterAvailableFieldMetadataItems(
-        objectMetadataItem.fields,
+        objectMetadataItem.updatableFields,
       );
 
     const spreadsheetImportFields = buildSpreadsheetImportFields(

packages/twenty-front/src/modules/object-record/utils/__tests__/generateAggregateQuery.test.ts

@@ -16,6 +16,8 @@ describe('generateAggregateQuery', () => {
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
       fields: [],
+      readableFields: [],
+      updatableFields: [],
       indexMetadatas: [],
       isLabelSyncedWithName: true,
       isRemote: false,
@@ -55,6 +57,8 @@ describe('generateAggregateQuery', () => {
       createdAt: new Date().toISOString(),
       updatedAt: new Date().toISOString(),
       fields: [],
+      readableFields: [],
+      updatableFields: [],
       indexMetadatas: [],
       isLabelSyncedWithName: true,
       isRemote: false,

packages/twenty-front/src/modules/object-record/utils/generateFindManyRecordsQuery.ts

@@ -3,8 +3,8 @@ import gql from 'graphql-tag';
 import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
 import { mapObjectMetadataToGraphQLQuery } from '@/object-metadata/utils/mapObjectMetadataToGraphQLQuery';
 import { RecordGqlOperationGqlRecordFields } from '@/object-record/graphql/types/RecordGqlOperationGqlRecordFields';
+import { ObjectPermissions } from 'twenty-shared/types';
 import { capitalize } from 'twenty-shared/utils';
-import { ObjectPermission } from '~/generated/graphql';
 
 export type QueryCursorDirection = 'before' | 'after';
 
@@ -22,7 +22,10 @@ export const generateFindManyRecordsQuery = ({
   recordGqlFields?: RecordGqlOperationGqlRecordFields;
   computeReferences?: boolean;
   cursorDirection?: QueryCursorDirection;
-  objectPermissionsByObjectMetadataId: Record<string, ObjectPermission>;
+  objectPermissionsByObjectMetadataId: Record<
+    string,
+    ObjectPermissions & { objectMetadataId: string }
+  >;
   isFieldsPermissionsEnabled?: boolean;
 }) => gql`
 query FindMany${capitalize(