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>
2025-10-10 19:11:00 +02:00
parent 00eef8ba33
commit 448091e81f
9 changed files with 814 additions and 198 deletions
@@ -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);
+  });
+});
@@ -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,
+    });
+  });
@@ -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);
+    })
+  );
+};
@@ -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,
+    ),
+  };
+};
@@ -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;
@@ -2,6 +2,8 @@ import { isNull, isUndefined } from '@sniptt/guards';

 import { type CurrentWorkspaceMember } from '@/auth/states/currentWorkspaceMemberState';
 import { type ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
+import { getFieldMetadataFromGqlField } from '@/object-record/cache/utils/getFieldMetadataFromGqlField';
+import { getFieldMetadataMorphRelationFromGqlField } from '@/object-record/cache/utils/getFieldMetadataMorphRelationFromGqlField';
 import {
  getRecordFromCache,
  type GetRecordFromCacheArgs,
@@ -51,16 +53,9 @@ export const computeOptimisticRecordFromInput = ({
        objectMetadataItem.fields.find((field) => {
          if (!isFieldMorphRelation(field)) return false;

-          return field.morphRelations?.some((morphRelation) => {
-            const computedFieldName = computeMorphRelationFieldName({
-              fieldName: field.name,
-              relationType: morphRelation.type,
-              targetObjectMetadataNameSingular:
-                morphRelation.targetObjectMetadata.nameSingular,
-              targetObjectMetadataNamePlural:
-                morphRelation.targetObjectMetadata.namePlural,
-            });
-            return computedFieldName === recordKey.replace('Id', '');
+          return getFieldMetadataFromGqlField({
+            objectMetadataItem,
+            gqlField: recordKey,
          });
        });

@@ -120,7 +115,8 @@ export const computeOptimisticRecordFromInput = ({
    }

    const isRelationField = isFieldRelation(fieldMetadataItem);
-    if (!isRelationField) {
+    const isMorphRelationField = isFieldMorphRelation(fieldMetadataItem);
+    if (!isRelationField && !isMorphRelationField) {
      if (!isDefined(recordInputFieldValue)) {
        continue;
      }
@@ -133,78 +129,183 @@ export const computeOptimisticRecordFromInput = ({
      continue;
    }

-    if (fieldMetadataItem.relation?.type === RelationType.ONE_TO_MANY) {
-      continue;
-    }
+    if (isRelationField) {
+      if (fieldMetadataItem.relation?.type === RelationType.ONE_TO_MANY) {
+        continue;
+      }

-    const isManyToOneRelation =
-      fieldMetadataItem.relation?.type === RelationType.MANY_TO_ONE;
-    if (!isManyToOneRelation) {
-      continue;
-    }
+      const isManyToOneRelation =
+        fieldMetadataItem.relation?.type === RelationType.MANY_TO_ONE;
+      if (!isManyToOneRelation) {
+        continue;
+      }

-    if (!isUndefined(recordInputFieldValue)) {
-      throw new Error(
-        `Should never provide relation mutation through anything else than the fieldId e.g companyId and not company, encountered: ${fieldMetadataItem.name}`,
+      if (!isUndefined(recordInputFieldValue)) {
+        throw new Error(
+          `Should never provide relation mutation through anything else than the fieldId e.g companyId and not company, encountered: ${fieldMetadataItem.name}`,
+        );
+      }
+
+      const relationFieldIdName = getForeignKeyNameFromRelationFieldName(
+        fieldMetadataItem.name,
      );
-    }

-    const relationFieldIdName = getForeignKeyNameFromRelationFieldName(
-      fieldMetadataItem.name,
-    );
+      const recordInputFieldIdValue: string | null | undefined =
+        recordInput[relationFieldIdName];

-    const recordInputFieldIdValue: string | null | undefined =
-      recordInput[relationFieldIdName];
+      if (isUndefined(recordInputFieldIdValue)) {
+        continue;
+      }

-    if (isUndefined(recordInputFieldIdValue)) {
-      continue;
-    }
-
-    const relationIdFieldMetadataItem = objectMetadataItem.fields.find(
-      (field) => field.name === relationFieldIdName,
-    );
-
-    if (
-      !isDefined(relationIdFieldMetadataItem) &&
-      !isDefined(fieldMetadataItem.settings?.joinColumnName)
-    ) {
-      throw new Error(
-        'Should never occur, encountered unknown relationId within relations definitions',
+      const relationIdFieldMetadataItem = objectMetadataItem.fields.find(
+        (field) => field.name === relationFieldIdName,
      );
-    }

-    if (isNull(recordInputFieldIdValue)) {
-      optimisticRecord[relationFieldIdName] = null;
-      optimisticRecord[fieldMetadataItem.name] = null;
-      continue;
-    }
+      if (
+        !isDefined(relationIdFieldMetadataItem) &&
+        !isDefined(fieldMetadataItem.settings?.joinColumnName)
+      ) {
+        throw new Error(
+          'Should never occur, encountered unknown relationId within relations definitions',
+        );
+      }

-    const targetNameSingular =
-      fieldMetadataItem.relation?.targetObjectMetadata.nameSingular;
-    const targetObjectMetataDataItem = objectMetadataItems.find(
-      ({ nameSingular }) => nameSingular === targetNameSingular,
-    );
-    if (!isDefined(targetObjectMetataDataItem)) {
-      throw new Error(
-        'Should never occur, encountered invalid relation definition',
+      if (isNull(recordInputFieldIdValue)) {
+        optimisticRecord[relationFieldIdName] = null;
+        optimisticRecord[fieldMetadataItem.name] = null;
+        continue;
+      }
+
+      const targetNameSingular =
+        fieldMetadataItem.relation?.targetObjectMetadata.nameSingular;
+      const targetObjectMetataDataItem = objectMetadataItems.find(
+        ({ nameSingular }) => nameSingular === targetNameSingular,
      );
+      if (!isDefined(targetObjectMetataDataItem)) {
+        throw new Error(
+          'Should never occur, encountered invalid relation definition',
+        );
+      }
+
+      const cachedRecord = getRecordFromCache({
+        cache,
+        objectMetadataItem: targetObjectMetataDataItem,
+        objectMetadataItems,
+        recordId: recordInputFieldIdValue as string,
+        objectPermissionsByObjectMetadataId,
+      });
+
+      optimisticRecord[relationFieldIdName] = recordInputFieldIdValue;
+
+      if (!isDefined(cachedRecord) || Object.keys(cachedRecord).length <= 0) {
+        continue;
+      }
+
+      optimisticRecord[fieldMetadataItem.name] = cachedRecord;
    }

-    const cachedRecord = getRecordFromCache({
-      cache,
-      objectMetadataItem: targetObjectMetataDataItem,
-      objectMetadataItems,
-      recordId: recordInputFieldIdValue as string,
-      objectPermissionsByObjectMetadataId,
-    });
+    if (isMorphRelationField) {
+      const relationType = fieldMetadataItem.settings?.relationType;
+      if (relationType === RelationType.ONE_TO_MANY) {
+        continue;
+      }

-    optimisticRecord[relationFieldIdName] = recordInputFieldIdValue;
+      const isManyToOneRelation = relationType === RelationType.MANY_TO_ONE;
+      if (!isManyToOneRelation) {
+        continue;
+      }

-    if (!isDefined(cachedRecord) || Object.keys(cachedRecord).length <= 0) {
-      continue;
+      if (!isUndefined(recordInputFieldValue)) {
+        throw new Error(
+          `Should never provide relation mutation through anything else than the fieldId e.g companyId and not company, encountered: ${fieldMetadataItem.name}`,
+        );
+      }
+
+      const relationFieldIdNames = fieldMetadataItem.morphRelations?.map(
+        (morphRelation) => {
+          return computeMorphRelationFieldName({
+            fieldName: fieldMetadataItem.name,
+            relationType,
+            targetObjectMetadataNameSingular:
+              morphRelation.targetObjectMetadata.nameSingular,
+            targetObjectMetadataNamePlural:
+              morphRelation.targetObjectMetadata.namePlural,
+          });
+        },
+      );
+
+      const relationFieldName = relationFieldIdNames?.find(
+        (relationFieldIdName) => recordInput[`${relationFieldIdName}Id`],
+      );
+
+      const relationFieldIdName = `${relationFieldName}Id`;
+
+      if (isUndefined(relationFieldName)) {
+        continue;
+      }
+
+      const recordInputFieldIdValue: string | null | undefined =
+        recordInput[relationFieldIdName];
+
+      if (isUndefined(recordInputFieldIdValue)) {
+        continue;
+      }
+
+      const relationIdFieldMetadataItem = getFieldMetadataFromGqlField({
+        objectMetadataItem,
+        gqlField: relationFieldName,
+      });
+
+      if (
+        !isDefined(relationIdFieldMetadataItem) &&
+        !isDefined(fieldMetadataItem.settings?.joinColumnName)
+      ) {
+        throw new Error(
+          'Should never occur, encountered unknown relationId within relations definitions',
+        );
+      }
+
+      if (isNull(recordInputFieldIdValue)) {
+        optimisticRecord[relationFieldName] = null;
+        optimisticRecord[fieldMetadataItem.name] = null;
+        continue;
+      }
+
+      if (!isDefined(fieldMetadataItem.morphRelations)) {
+        throw new Error(
+          'Should never occur, encountered invalid relation definition',
+        );
+      }
+
+      const fieldMetadataMorphRelation =
+        getFieldMetadataMorphRelationFromGqlField({
+          objectMetadataItems,
+          fieldMetadata: { morphRelations: fieldMetadataItem.morphRelations },
+          gqlField: relationFieldName,
+        });
+
+      if (!isDefined(fieldMetadataMorphRelation?.targetObjectMetadata)) {
+        throw new Error(
+          'Should never occur, encountered invalid relation definition',
+        );
+      }
+
+      const cachedRecord = getRecordFromCache({
+        cache,
+        objectMetadataItem: fieldMetadataMorphRelation.targetObjectMetadata,
+        objectMetadataItems,
+        recordId: recordInputFieldIdValue as string,
+        objectPermissionsByObjectMetadataId,
+      });
+
+      optimisticRecord[relationFieldIdName] = recordInputFieldIdValue;
+
+      if (!isDefined(cachedRecord) || Object.keys(cachedRecord).length <= 0) {
+        continue;
+      }
+
+      optimisticRecord[relationFieldName] = cachedRecord;
    }
-
-    optimisticRecord[fieldMetadataItem.name] = cachedRecord;
  }

  return optimisticRecord;