Fix missing relation column on tasks / notes table

packages/twenty-front/src/modules/object-metadata/hooks/useActiveFieldMetadataItems.ts

@@ -1,4 +1,5 @@
 import { type ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
+import { isActiveFieldMetadataItem } from '@/object-metadata/utils/isActiveFieldMetadataItem';
 import { useMemo } from 'react';
 
 export const useActiveFieldMetadataItems = ({
@@ -10,7 +11,11 @@ export const useActiveFieldMetadataItems = ({
     () =>
       objectMetadataItem
         ? objectMetadataItem.readableFields.filter(
-            ({ isActive, isSystem }) => isActive && !isSystem,
+            ({ isActive, isSystem, name }) =>
+              isActiveFieldMetadataItem({
+                objectNameSingular: objectMetadataItem.nameSingular,
+                fieldMetadata: { isActive, isSystem, name },
+              }),
           )
         : [],
     [objectMetadataItem],

packages/twenty-front/src/modules/object-metadata/utils/__tests__/isActiveFieldMetadataItem.test.ts

@@ -0,0 +1,43 @@
+import { isActiveFieldMetadataItem } from '@/object-metadata/utils/isActiveFieldMetadataItem';
+
+describe('isActiveFieldMetadataItem', () => {
+  it('should return false for inactive fields', () => {
+    const res = isActiveFieldMetadataItem({
+      fieldMetadata: { isActive: false, isSystem: false, name: 'fieldName' },
+      objectNameSingular: 'objectNameSingular',
+    });
+    expect(res).toBe(false);
+  });
+
+  it('should return true for active fields', () => {
+    const res = isActiveFieldMetadataItem({
+      fieldMetadata: { isActive: true, isSystem: false, name: 'fieldName' },
+      objectNameSingular: 'objectNameSingular',
+    });
+    expect(res).toBe(true);
+  });
+
+  it('should return false for system fields', () => {
+    const res = isActiveFieldMetadataItem({
+      fieldMetadata: { isActive: true, isSystem: true, name: 'fieldName' },
+      objectNameSingular: 'objectNameSingular',
+    });
+    expect(res).toBe(false);
+  });
+
+  it('should return true for note targets', () => {
+    const res = isActiveFieldMetadataItem({
+      fieldMetadata: { isActive: true, isSystem: false, name: 'noteTargets' },
+      objectNameSingular: 'note',
+    });
+    expect(res).toBe(true);
+  });
+
+  it('should return true for task targets', () => {
+    const res = isActiveFieldMetadataItem({
+      fieldMetadata: { isActive: true, isSystem: false, name: 'taskTargets' },
+      objectNameSingular: 'task',
+    });
+    expect(res).toBe(true);
+  });
+});

packages/twenty-front/src/modules/object-metadata/utils/isActiveFieldMetadataItem.ts

@@ -0,0 +1,31 @@
+import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
+import { type FieldMetadataItem } from '../types/FieldMetadataItem';
+
+type IsFieldMetadataAvailableForViewFieldArgs = {
+  objectNameSingular: string;
+  fieldMetadata: Pick<FieldMetadataItem, 'name' | 'isSystem' | 'isActive'>;
+};
+
+export const isActiveFieldMetadataItem = ({
+  objectNameSingular,
+  fieldMetadata,
+}: IsFieldMetadataAvailableForViewFieldArgs) => {
+  if (fieldMetadata.isActive === false) {
+    return false;
+  }
+
+  if (
+    (objectNameSingular === CoreObjectNameSingular.Note &&
+      fieldMetadata.name === 'noteTargets') ||
+    (objectNameSingular === CoreObjectNameSingular.Task &&
+      fieldMetadata.name === 'taskTargets')
+  ) {
+    return true;
+  }
+
+  if (fieldMetadata.isSystem === true) {
+    return false;
+  }
+
+  return true;
+};

packages/twenty-front/src/modules/object-record/record-field/states/visibleRecordFieldsComponentSelector.ts

@@ -1,4 +1,5 @@
-import { flattenedReadableFieldMetadataItemsSelector } from '@/object-metadata/states/flattenedReadableFieldMetadataItemIdsSelector';
+import { objectMetadataItemsState } from '@/object-metadata/states/objectMetadataItemsState';
+import { isActiveFieldMetadataItem } from '@/object-metadata/utils/isActiveFieldMetadataItem';
 import { RecordFieldsComponentInstanceContext } from '@/object-record/record-field/states/context/RecordFieldsComponentInstanceContext';
 import { currentRecordFieldsComponentState } from '@/object-record/record-field/states/currentRecordFieldsComponentState';
 import { createComponentSelector } from '@/ui/utilities/state/component-state/utils/createComponentSelector';
@@ -16,20 +17,41 @@ export const visibleRecordFieldsComponentSelector = createComponentSelector({
         }),
       );
 
-      const readableFieldMetadataItems = get(
-        flattenedReadableFieldMetadataItemsSelector,
-      );
+      const objectMetadataItems = get(objectMetadataItemsState);
 
       const filteredVisibleAndReadableRecordFields = currentRecordFields.filter(
-        (recordFieldToFilter) =>
-          recordFieldToFilter.isVisible === true &&
-          readableFieldMetadataItems.some(
-            (fieldMetadataItemToFilter) =>
-              fieldMetadataItemToFilter.id ===
-                recordFieldToFilter.fieldMetadataItemId &&
-              fieldMetadataItemToFilter.isActive === true &&
-              fieldMetadataItemToFilter.isSystem !== true,
-          ),
+        (recordFieldToFilter) => {
+          if (!recordFieldToFilter.isVisible) {
+            return false;
+          }
+
+          const objectMetadataItem = objectMetadataItems.find(
+            (objectMetadataItem) =>
+              objectMetadataItem.fields.some(
+                (fieldMetadataItem) =>
+                  fieldMetadataItem.id ===
+                  recordFieldToFilter.fieldMetadataItemId,
+              ),
+          );
+
+          if (!objectMetadataItem) {
+            return false;
+          }
+
+          const fieldMetadataItem = objectMetadataItem.fields.find(
+            (fieldMetadataItem) =>
+              fieldMetadataItem.id === recordFieldToFilter.fieldMetadataItemId,
+          );
+
+          if (!fieldMetadataItem) {
+            return false;
+          }
+
+          return isActiveFieldMetadataItem({
+            objectNameSingular: objectMetadataItem.nameSingular,
+            fieldMetadata: fieldMetadataItem,
+          });
+        },
       );
 
       return [...filteredVisibleAndReadableRecordFields].sort(