Optimistic rendering of morph relations (#14997)

The optimistic rendering of a morph relation Is broken. We intend to fix
it here.

- mapping of gql fields


Fixes https://github.com/twentyhq/core-team-issues/issues/1322

---------

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

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

@@ -0,0 +1,177 @@
+import { type FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
+import { RelationType } from 'twenty-shared/types';
+import { FieldMetadataType } from '~/generated-metadata/graphql';
+import { getFieldMetadataFromGqlField } from '../getFieldMetadataFromGqlField';
+
+const objectMetadataItemGenerator = (relationType: RelationType) => {
+  return {
+    nameSingular: 'opportunity',
+    namePlural: 'opportunities',
+    fields: [
+      {
+        name: 'owner',
+        type: FieldMetadataType.MORPH_RELATION,
+        morphRelations: [
+          {
+            type: relationType,
+            targetObjectMetadata: {
+              nameSingular: 'company',
+              namePlural: 'companies',
+            },
+            targetFieldMetadata: {
+              name: 'ownedBy',
+              type: FieldMetadataType.RELATION,
+            },
+            sourceFieldMetadata: {
+              name: 'owner',
+              type: FieldMetadataType.MORPH_RELATION,
+            },
+            sourceObjectMetadata: {
+              nameSingular: 'opportunity',
+              namePlural: 'opportunities',
+            },
+          },
+          {
+            type: relationType,
+            targetObjectMetadata: {
+              nameSingular: 'person',
+              namePlural: 'people',
+            },
+            targetFieldMetadata: {
+              name: 'ownedBy',
+              type: FieldMetadataType.RELATION,
+            },
+            sourceFieldMetadata: {
+              name: 'owner',
+              type: FieldMetadataType.MORPH_RELATION,
+            },
+            sourceObjectMetadata: {
+              nameSingular: 'opportunity',
+              namePlural: 'opportunities',
+            },
+          },
+        ],
+      } as unknown as FieldMetadataItem,
+    ],
+  };
+};
+
+describe('getFieldMetadataFromGqlField', () => {
+  it('should find "name"', () => {
+    const objectMetadataItem = {
+      fields: [
+        {
+          name: 'name',
+          type: FieldMetadataType.FULL_NAME,
+        } as unknown as FieldMetadataItem,
+      ],
+    };
+
+    const result = getFieldMetadataFromGqlField({
+      objectMetadataItem,
+      gqlField: 'name',
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.name).toBe('name');
+    expect(result?.type).toBe(FieldMetadataType.FULL_NAME);
+  });
+
+  it('should find company by join column name of a relation field', () => {
+    const objectMetadataItem = {
+      fields: [
+        {
+          name: 'company',
+          type: FieldMetadataType.RELATION,
+          settings: {
+            joinColumnName: 'companyId',
+          },
+        } as FieldMetadataItem,
+      ],
+    };
+
+    const result = getFieldMetadataFromGqlField({
+      objectMetadataItem,
+      gqlField: 'companyId',
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.name).toBe('company');
+    expect(result?.type).toBe(FieldMetadataType.RELATION);
+    expect(result?.settings?.joinColumnName).toBe('companyId');
+  });
+
+  it('should return undefined for non-existent field', () => {
+    const objectMetadataItem = {
+      fields: [
+        {
+          name: 'name',
+          type: FieldMetadataType.TEXT,
+        } as unknown as FieldMetadataItem,
+      ],
+    };
+
+    const result = getFieldMetadataFromGqlField({
+      objectMetadataItem,
+      gqlField: 'nonExistentField',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it('should find owner by direct morph relation ONE_TO_MANY field name', () => {
+    const objectMetadataItem = objectMetadataItemGenerator(
+      RelationType.ONE_TO_MANY,
+    );
+    const result = getFieldMetadataFromGqlField({
+      objectMetadataItem,
+      gqlField: 'owner',
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.name).toBe('owner');
+    expect(result?.type).toBe(FieldMetadataType.MORPH_RELATION);
+  });
+
+  it('should find ownerCompanies by computed morph relation ONE_TO_MANY field name', () => {
+    const objectMetadataItem = objectMetadataItemGenerator(
+      RelationType.ONE_TO_MANY,
+    );
+    const result = getFieldMetadataFromGqlField({
+      objectMetadataItem,
+      gqlField: 'ownerCompanies',
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.name).toBe('owner');
+    expect(result?.type).toBe(FieldMetadataType.MORPH_RELATION);
+  });
+
+  it('should find ownerPerson by computed morph relation MANY_TO_ONE field name', () => {
+    const objectMetadataItem = objectMetadataItemGenerator(
+      RelationType.MANY_TO_ONE,
+    );
+    const result = getFieldMetadataFromGqlField({
+      objectMetadataItem,
+      gqlField: 'ownerPerson',
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.name).toBe('owner');
+    expect(result?.type).toBe(FieldMetadataType.MORPH_RELATION);
+  });
+
+  it('should find ownerPersonId by computed morph relation join column name MANY_TO_ONE field name', () => {
+    const objectMetadataItem = objectMetadataItemGenerator(
+      RelationType.MANY_TO_ONE,
+    );
+    const result = getFieldMetadataFromGqlField({
+      objectMetadataItem,
+      gqlField: 'ownerPersonId',
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.name).toBe('owner');
+    expect(result?.type).toBe(FieldMetadataType.MORPH_RELATION);
+  });
+});

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

@@ -0,0 +1,20 @@
+import { type FieldMorphRelationMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
+import { computeMorphRelationFieldName } from 'twenty-shared/utils';
+export const computePossibleMorphGqlFieldForFieldName = ({
+  fieldMetadata,
+}: {
+  fieldMetadata: Pick<
+    FieldMorphRelationMetadata,
+    'morphRelations' | 'fieldName'
+  >;
+}) =>
+  fieldMetadata.morphRelations.map((morphRelation) => {
+    return computeMorphRelationFieldName({
+      fieldName: fieldMetadata.fieldName,
+      relationType: morphRelation.type,
+      targetObjectMetadataNameSingular:
+        morphRelation.targetObjectMetadata.nameSingular,
+      targetObjectMetadataNamePlural:
+        morphRelation.targetObjectMetadata.namePlural,
+    });
+  });

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

@@ -0,0 +1,35 @@
+import { type ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
+import { computePossibleMorphGqlFieldForFieldName } from '@/object-record/cache/utils/computePossibleMorphGqlFieldForFieldName';
+import { isFieldMorphRelation } from '@/object-record/record-field/ui/types/guards/isFieldMorphRelation';
+
+export const getFieldMetadataFromGqlField = ({
+  objectMetadataItem,
+  gqlField,
+}: {
+  objectMetadataItem: Pick<ObjectMetadataItem, 'fields'>;
+  gqlField: string;
+}) => {
+  return (
+    objectMetadataItem.fields.find((field) => field.name === gqlField) ??
+    objectMetadataItem.fields.find(
+      (field) => field.settings?.joinColumnName === gqlField,
+    ) ??
+    objectMetadataItem.fields.filter(isFieldMorphRelation).find((field) => {
+      const morphRelations = field.morphRelations;
+      if (!morphRelations) return false;
+      const possibleMorphRelationsNames =
+        computePossibleMorphGqlFieldForFieldName({
+          fieldMetadata: {
+            morphRelations: field.morphRelations ?? [],
+            fieldName: field.name,
+          },
+        });
+      return possibleMorphRelationsNames
+        .flatMap((possibleMorphRelationName) => [
+          possibleMorphRelationName,
+          `${possibleMorphRelationName}Id`,
+        ])
+        .includes(gqlField);
+    })
+  );
+};

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

@@ -0,0 +1,74 @@
+import { type ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
+import { getFieldMetadataItemById } from '@/object-metadata/utils/getFieldMetadataItemById';
+
+import { type FieldMorphRelationMetadata } from '@/object-record/record-field/ui/types/FieldMetadata';
+import { computeMorphRelationFieldName } from 'twenty-shared/utils';
+
+export const getFieldMetadataMorphRelationFromGqlField = ({
+  objectMetadataItems,
+  fieldMetadata,
+  gqlField,
+}: {
+  objectMetadataItems: ObjectMetadataItem[];
+  fieldMetadata: Pick<FieldMorphRelationMetadata, 'morphRelations'>;
+  gqlField: string;
+}) => {
+  const possibleMorphRelationGqlFields = fieldMetadata.morphRelations.map(
+    (morphRelation) => {
+      const targetObjectMetadata = objectMetadataItems.find(
+        (objectMetadataItem) =>
+          objectMetadataItem.id === morphRelation.targetObjectMetadata.id,
+      );
+      if (!targetObjectMetadata) {
+        return {
+          gqlField: undefined,
+          morphRelation: undefined,
+        };
+      }
+      const computedName = computeMorphRelationFieldName({
+        fieldName: morphRelation.sourceFieldMetadata.name,
+        relationType: morphRelation.type,
+        targetObjectMetadataNameSingular: targetObjectMetadata.nameSingular,
+        targetObjectMetadataNamePlural: targetObjectMetadata.namePlural,
+      });
+
+      return {
+        gqlField: computedName,
+        morphRelation,
+      };
+    },
+  );
+
+  const gqlFieldMorphRelation = possibleMorphRelationGqlFields.find(
+    (possibeMorphRelationGqlField) =>
+      possibeMorphRelationGqlField.gqlField === gqlField,
+  );
+
+  if (!gqlFieldMorphRelation || !gqlFieldMorphRelation.morphRelation) {
+    return undefined;
+  }
+
+  return {
+    morphRelation: gqlFieldMorphRelation.morphRelation,
+    sourceFieldMetadata: getFieldMetadataItemById({
+      fieldMetadataId:
+        gqlFieldMorphRelation.morphRelation.sourceFieldMetadata.id,
+      objectMetadataItems,
+    }),
+    targetFieldMetadata: getFieldMetadataItemById({
+      fieldMetadataId:
+        gqlFieldMorphRelation.morphRelation?.targetFieldMetadata.id,
+      objectMetadataItems,
+    }),
+    targetObjectMetadata: objectMetadataItems.find(
+      (objectMetadataItem) =>
+        objectMetadataItem.id ===
+        gqlFieldMorphRelation.morphRelation?.targetObjectMetadata.id,
+    ),
+    sourceObjectMetadata: objectMetadataItems.find(
+      (objectMetadataItem) =>
+        objectMetadataItem.id ===
+        gqlFieldMorphRelation.morphRelation?.sourceObjectMetadata.id,
+    ),
+  };
+};

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

@@ -1,6 +1,7 @@
 import { isNull, isUndefined } from '@sniptt/guards';
 
 import { type ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
+import { getFieldMetadataFromGqlField } from '@/object-record/cache/utils/getFieldMetadataFromGqlField';
 import { getNodeTypename } from '@/object-record/cache/utils/getNodeTypename';
 import { getObjectTypename } from '@/object-record/cache/utils/getObjectTypename';
 import { getRecordConnectionFromRecords } from '@/object-record/cache/utils/getRecordConnectionFromRecords';
@@ -48,11 +49,10 @@ export const getRecordNodeFromRecord = <T extends ObjectRecord>({
           return undefined;
         }
 
-        const field =
-          objectMetadataItem.fields.find((field) => field.name === fieldName) ??
-          objectMetadataItem.fields.find(
-            (field) => field.settings?.joinColumnName === fieldName,
-          );
+        const field = getFieldMetadataFromGqlField({
+          objectMetadataItem,
+          gqlField: fieldName,
+        });
 
         if (isUndefined(field)) {
           return undefined;