feat: new relation sync-metadata, twenty-orm, create/update (#10217)

Fix https://github.com/twentyhq/core-team-issues/issues/330#issue-2827026606 and https://github.com/twentyhq/core-team-issues/issues/327#issue-2827001814 What this PR does when `isNewRelationEnabled` is set to `true`: - [x] Drop the creation of the foreign key as a `FieldMetadata` - [x] Stop creating `RelationMetadata` - [x] Properly fill `FieldMetadata` of type `RELATION` during the sync command - [x] Use new relation settings in TwentyORM - [x] Properly create `FieldMetadata` relations when we create a new object - [x] Handle `database:reset` with new relations --------- Co-authored-by: Charles Bochet <charles@twenty.com> Co-authored-by: Charles Bochet <charlesBochet@users.noreply.github.com>
2025-04-22 19:01:39 +02:00
parent de1489aabb
commit cc29c25176
160 changed files with 3247 additions and 711 deletions
--- a/packages/twenty-front/src/modules/object-metadata/utils/tests/mapFieldMetadataToGraphQLQuery.test.ts
+++ b/packages/twenty-front/src/modules/object-metadata/utils/tests/mapFieldMetadataToGraphQLQuery.test.ts
@ -14,7 +14,8 @@ describe('mapFieldMetadataToGraphQLQuery', () => {
  it('should return fieldName if simpleValue', async () => {
    const res = mapFieldMetadataToGraphQLQuery({
      objectMetadataItems: generatedMockObjectMetadataItems,
-      field: personObjectMetadataItem.fields.find(
+      gqlField: 'id',
+      fieldMetadata: personObjectMetadataItem.fields.find(
        (field) => field.name === 'id',
      )!,
    });
@ -23,7 +24,8 @@ describe('mapFieldMetadataToGraphQLQuery', () => {
  it('should return fieldName if composite', async () => {
    const res = mapFieldMetadataToGraphQLQuery({
      objectMetadataItems: generatedMockObjectMetadataItems,
-      field: personObjectMetadataItem.fields.find(
+      gqlField: 'name',
+      fieldMetadata: personObjectMetadataItem.fields.find(
        (field) => field.name === 'name',
      )!,
    });
@ -39,7 +41,8 @@ describe('mapFieldMetadataToGraphQLQuery', () => {
  it('should return non relation subFields if relation', async () => {
    const res = mapFieldMetadataToGraphQLQuery({
      objectMetadataItems: generatedMockObjectMetadataItems,
-      field: personObjectMetadataItem.fields.find(
+      gqlField: 'company',
+      fieldMetadata: personObjectMetadataItem.fields.find(
        (field) => field.name === 'company',
      )!,
    });
@ -115,7 +118,8 @@ idealCustomerProfile
        id: true,
        idealCustomerProfile: true,
      },
-      field: personObjectMetadataItem.fields.find(
+      gqlField: 'company',
+      fieldMetadata: personObjectMetadataItem.fields.find(
        (field) => field.name === 'company',
      )!,
    });
--- a/packages/twenty-front/src/modules/object-metadata/utils/tests/shouldFieldBeQueried.test.ts
+++ b/packages/twenty-front/src/modules/object-metadata/utils/tests/shouldFieldBeQueried.test.ts
@ -5,14 +5,16 @@ describe('shouldFieldBeQueried', () => {
  describe('if recordGqlFields is absent, we query all except relations', () => {
    it('should be queried if the field is not a relation', () => {
      const res = shouldFieldBeQueried({
-        field: { name: 'fieldName', type: FieldMetadataType.BOOLEAN },
+        gqlField: 'fieldName',
+        fieldMetadata: { name: 'fieldName', type: FieldMetadataType.BOOLEAN },
      });
      expect(res).toBe(true);
    });

    it('should not be queried if the field is a relation', () => {
      const res = shouldFieldBeQueried({
-        field: { name: 'fieldName', type: FieldMetadataType.RELATION },
+        gqlField: 'fieldName',
+        fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
      });
      expect(res).toBe(false);
    });
@ -21,8 +23,9 @@ describe('shouldFieldBeQueried', () => {
  describe('if recordGqlFields is present, we respect it', () => {
    it('should be queried if true', () => {
      const res = shouldFieldBeQueried({
+        gqlField: 'fieldName',
+        fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
        recordGqlFields: { fieldName: true },
-        field: { name: 'fieldName', type: FieldMetadataType.RELATION },
      });
      expect(res).toBe(true);
    });
@ -30,23 +33,26 @@ describe('shouldFieldBeQueried', () => {
    it('should be queried if object', () => {
      const res = shouldFieldBeQueried({
        recordGqlFields: { fieldName: { subFieldName: false } },
-        field: { name: 'fieldName', type: FieldMetadataType.RELATION },
+        fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
+        gqlField: 'fieldName',
      });
      expect(res).toBe(true);
    });

    it('should not be queried if false', () => {
      const res = shouldFieldBeQueried({
+        gqlField: 'fieldName',
+        fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
        recordGqlFields: { fieldName: false },
-        field: { name: 'fieldName', type: FieldMetadataType.RELATION },
      });
      expect(res).toBe(false);
    });

    it('should not be queried if absent', () => {
      const res = shouldFieldBeQueried({
+        gqlField: 'fieldName',
+        fieldMetadata: { name: 'fieldName', type: FieldMetadataType.RELATION },
        recordGqlFields: { otherFieldName: false },
-        field: { name: 'fieldName', type: FieldMetadataType.RELATION },
      });
      expect(res).toBe(false);
    });
--- a/packages/twenty-front/src/modules/object-metadata/utils/mapFieldMetadataToGraphQLQuery.ts
+++ b/packages/twenty-front/src/modules/object-metadata/utils/mapFieldMetadataToGraphQLQuery.ts
@ -12,40 +12,50 @@ import { FieldMetadataItem } from '../types/FieldMetadataItem';

 type MapFieldMetadataToGraphQLQueryArgs = {
  objectMetadataItems: ObjectMetadataItem[];
-  field: Pick<FieldMetadataItem, 'name' | 'type' | 'relationDefinition'>;
+  gqlField: string;
+  fieldMetadata: Pick<
+    FieldMetadataItem,
+    'name' | 'type' | 'relationDefinition' | 'settings'
+  >;
  relationRecordGqlFields?: RecordGqlFields;
  computeReferences?: boolean;
 };
 // TODO: change ObjectMetadataItems mock before refactoring with relationDefinition computed field
 export const mapFieldMetadataToGraphQLQuery = ({
  objectMetadataItems,
-  field,
+  gqlField,
+  fieldMetadata,
  relationRecordGqlFields,
  computeReferences = false,
 }: MapFieldMetadataToGraphQLQueryArgs): string => {
-  const fieldType = field.type;
+  const fieldType = fieldMetadata.type;

  const fieldIsNonCompositeField = isNonCompositeField(fieldType);

  if (fieldIsNonCompositeField) {
-    return field.name;
+    return gqlField;
  }

  if (
    fieldType === FieldMetadataType.RELATION &&
-    field.relationDefinition?.direction === RelationDefinitionType.MANY_TO_ONE
+    fieldMetadata.relationDefinition?.direction ===
+      RelationDefinitionType.MANY_TO_ONE
  ) {
    const relationMetadataItem = objectMetadataItems.find(
      (objectMetadataItem) =>
        objectMetadataItem.id ===
-        field.relationDefinition?.targetObjectMetadata.id,
+        fieldMetadata.relationDefinition?.targetObjectMetadata.id,
    );

    if (isUndefined(relationMetadataItem)) {
      return '';
    }

-    return `${field.name}
+    if (gqlField === fieldMetadata.settings?.joinColumnName) {
+      return `${gqlField}`;
+    }
+
+    return `${gqlField}
 ${mapObjectMetadataToGraphQLQuery({
  objectMetadataItems,
  objectMetadataItem: relationMetadataItem,
@ -57,19 +67,20 @@ ${mapObjectMetadataToGraphQLQuery({

  if (
    fieldType === FieldMetadataType.RELATION &&
-    field.relationDefinition?.direction === RelationDefinitionType.ONE_TO_MANY
+    fieldMetadata.relationDefinition?.direction ===
+      RelationDefinitionType.ONE_TO_MANY
  ) {
    const relationMetadataItem = objectMetadataItems.find(
      (objectMetadataItem) =>
        objectMetadataItem.id ===
-        field.relationDefinition?.targetObjectMetadata.id,
+        fieldMetadata.relationDefinition?.targetObjectMetadata.id,
    );

    if (isUndefined(relationMetadataItem)) {
      return '';
    }

-    return `${field.name}
+    return `${gqlField}
 {
  edges {
    node ${mapObjectMetadataToGraphQLQuery({
@ -84,7 +95,7 @@ ${mapObjectMetadataToGraphQLQuery({
  }

  if (fieldType === FieldMetadataType.LINKS) {
-    return `${field.name}
+    return `${gqlField}
 {
  primaryLinkUrl
  primaryLinkLabel
@ -93,7 +104,7 @@ ${mapObjectMetadataToGraphQLQuery({
  }

  if (fieldType === FieldMetadataType.CURRENCY) {
-    return `${field.name}
+    return `${gqlField}
 {
  amountMicros
  currencyCode
@ -102,7 +113,7 @@ ${mapObjectMetadataToGraphQLQuery({
  }

  if (fieldType === FieldMetadataType.FULL_NAME) {
-    return `${field.name}
+    return `${gqlField}
 {
  firstName
  lastName
@ -110,7 +121,7 @@ ${mapObjectMetadataToGraphQLQuery({
  }

  if (fieldType === FieldMetadataType.ADDRESS) {
-    return `${field.name}
+    return `${gqlField}
 {
  addressStreet1
  addressStreet2
@ -124,7 +135,7 @@ ${mapObjectMetadataToGraphQLQuery({
  }

  if (fieldType === FieldMetadataType.ACTOR) {
-    return `${field.name}
+    return `${gqlField}
 {
    source
    workspaceMemberId
@ -134,7 +145,7 @@ ${mapObjectMetadataToGraphQLQuery({
  }

  if (fieldType === FieldMetadataType.EMAILS) {
-    return `${field.name}
+    return `${gqlField}
 {
  primaryEmail
  additionalEmails
@ -142,7 +153,7 @@ ${mapObjectMetadataToGraphQLQuery({
  }

  if (fieldType === FieldMetadataType.PHONES) {
-    return `${field.name}
+    return `${gqlField}
    {
      primaryPhoneNumber
      primaryPhoneCountryCode
@ -152,7 +163,7 @@ ${mapObjectMetadataToGraphQLQuery({
  }

  if (fieldType === FieldMetadataType.RICH_TEXT_V2) {
-    return `${field.name}
+    return `${gqlField}
 {
  blocknote
  markdown
--- a/packages/twenty-front/src/modules/object-metadata/utils/mapObjectMetadataToGraphQLQuery.ts
+++ b/packages/twenty-front/src/modules/object-metadata/utils/mapObjectMetadataToGraphQLQuery.ts
@ -3,6 +3,8 @@ import { mapFieldMetadataToGraphQLQuery } from '@/object-metadata/utils/mapField
 import { shouldFieldBeQueried } from '@/object-metadata/utils/shouldFieldBeQueried';
 import { RecordGqlFields } from '@/object-record/graphql/types/RecordGqlFields';
 import { isRecordGqlFieldsNode } from '@/object-record/graphql/utils/isRecordGraphlFieldsNode';
+import { FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';

 type MapObjectMetadataToGraphQLQueryArgs = {
  objectMetadataItems: ObjectMetadataItem[];
@ -18,16 +20,40 @@ export const mapObjectMetadataToGraphQLQuery = ({
  computeReferences = false,
  isRootLevel = true,
 }: MapObjectMetadataToGraphQLQueryArgs): string => {
-  const fieldsThatShouldBeQueried =
-    objectMetadataItem?.fields
-      .filter((field) => field.isActive)
-      .sort((fieldA, fieldB) => fieldA.name.localeCompare(fieldB.name))
-      .filter((field) =>
+  const manyToOneRelationFields = objectMetadataItem?.fields
+    .filter((field) => field.isActive)
+    .filter((field) => field.type === FieldMetadataType.RELATION)
+    .filter((field) => isDefined(field.settings?.joinColumnName));
+
+  const manyToOneRelationGqlFieldWithFieldMetadata =
+    manyToOneRelationFields.map((field) => ({
+      gqlField: field.settings?.joinColumnName,
+      fieldMetadata: field,
+    }));
+
+  const gqlFieldWithFieldMetadataThatCouldBeQueried = [
+    ...objectMetadataItem.fields
+      .filter((fieldMetadata) => fieldMetadata.isActive)
+      .map((fieldMetadata) => ({
+        gqlField: fieldMetadata.name,
+        fieldMetadata,
+      })),
+    ...manyToOneRelationGqlFieldWithFieldMetadata,
+  ].sort((gqlFieldWithFieldMetadataA, gqlFieldWithFieldMetadataB) =>
+    gqlFieldWithFieldMetadataA.gqlField.localeCompare(
+      gqlFieldWithFieldMetadataB.gqlField,
+    ),
+  );
+
+  const gqlFieldWithFieldMetadataThatSouldBeQueried =
+    gqlFieldWithFieldMetadataThatCouldBeQueried.filter(
+      (gqlFieldWithFieldMetadata) =>
        shouldFieldBeQueried({
-          field,
+          gqlField: gqlFieldWithFieldMetadata.gqlField,
+          fieldMetadata: gqlFieldWithFieldMetadata.fieldMetadata,
          recordGqlFields,
        }),
-      ) ?? [];
+    );

  if (!isRootLevel && computeReferences) {
    return `{
@ -37,9 +63,10 @@ export const mapObjectMetadataToGraphQLQuery = ({

  return `{
 __typename
-${fieldsThatShouldBeQueried
-  .map((field) => {
-    const currentRecordGqlFields = recordGqlFields?.[field.name];
+${gqlFieldWithFieldMetadataThatSouldBeQueried
+  .map((gqlFieldWithFieldMetadata) => {
+    const currentRecordGqlFields =
+      recordGqlFields?.[gqlFieldWithFieldMetadata.gqlField];
    const relationRecordGqlFields = isRecordGqlFieldsNode(
      currentRecordGqlFields,
    )
@ -47,7 +74,8 @@ ${fieldsThatShouldBeQueried
      : undefined;
    return mapFieldMetadataToGraphQLQuery({
      objectMetadataItems,
-      field,
+      gqlField: gqlFieldWithFieldMetadata.gqlField,
+      fieldMetadata: gqlFieldWithFieldMetadata.fieldMetadata,
      relationRecordGqlFields,
      computeReferences,
    });
--- a/packages/twenty-front/src/modules/object-metadata/utils/shouldFieldBeQueried.ts
+++ b/packages/twenty-front/src/modules/object-metadata/utils/shouldFieldBeQueried.ts
@ -3,27 +3,30 @@ import { ObjectRecord } from '@/object-record/types/ObjectRecord';
 import { FieldMetadataType } from '~/generated-metadata/graphql';
 import { isUndefinedOrNull } from '~/utils/isUndefinedOrNull';

-import { FieldMetadataItem } from '../types/FieldMetadataItem';
 import { isDefined } from 'twenty-shared/utils';
+import { FieldMetadataItem } from '../types/FieldMetadataItem';

 export const shouldFieldBeQueried = ({
-  field,
+  gqlField,
+  fieldMetadata,
  recordGqlFields,
 }: {
-  field: Pick<FieldMetadataItem, 'name' | 'type'>;
+  gqlField: string;
+  fieldMetadata: Pick<FieldMetadataItem, 'name' | 'type'>;
  objectRecord?: ObjectRecord;
  recordGqlFields?: RecordGqlOperationGqlRecordFields;
 }): any => {
  if (
    isUndefinedOrNull(recordGqlFields) &&
-    field.type !== FieldMetadataType.RELATION
+    fieldMetadata.type !== FieldMetadataType.RELATION
  ) {
    return true;
  }
+
  if (
    isDefined(recordGqlFields) &&
-    isDefined(recordGqlFields[field.name]) &&
-    recordGqlFields[field.name] !== false
+    isDefined(recordGqlFields[gqlField]) &&
+    recordGqlFields[gqlField] !== false
  ) {
    return true;
  }