Morph Relations : deleteOneField (#13349)

This PR adapts teh deleteOneField to make sure morph relations can be
deleted, either
- from a relation type, 
- or from a morph relation type (which is the most obvious case).

This PR covers 
- the deletion of fieldMetadata 
- and the migrationof workspace schemas, by using the already existing
definition of relation migrations

This PR implements a new test suite: "Delete Object metadata with morph
relation" and completes the other test suites for FieldMetadata and
ObjectMetadata creation/deletion.

Last, we added a nitpick from @paul I forgot on a previous PR on
process-nested-realtion-v2

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

packages/twenty-server/test/integration/metadata/suites/object-metadata/morph-relation/delete-one-object-metadata-with-morph-relation.integration-spec.ts

@@ -1,5 +1,110 @@
+import { findManyFieldsMetadataQueryFactory } from 'test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata-query-factory.util';
+import { createMorphRelationBetweenObjects } from 'test/integration/metadata/suites/object-metadata/utils/create-morph-relation-between-objects.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { forceCreateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/force-create-one-object-metadata.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
 describe('Delete Object metadata with morph relation should succeed', () => {
-  it('should succeed', () => {
-    // 'TODO guillim : once delete is implemented'
+  let opportunityId = '';
+  let personId = '';
+  let companyId = '';
+  let morphRelationField: { id: string };
+
+  beforeEach(async () => {
+    const {
+      data: {
+        createOneObject: { id: aId },
+      },
+    } = await forceCreateOneObjectMetadata({
+      input: {
+        nameSingular: 'opportunityForDelete',
+        namePlural: 'opportunitiesForDelete',
+        labelSingular: 'Opportunity For Delete',
+        labelPlural: 'Opportunities For Delete',
+        icon: 'IconOpportunity',
+      },
+    });
+
+    opportunityId = aId;
+    const {
+      data: {
+        createOneObject: { id: bId },
+      },
+    } = await forceCreateOneObjectMetadata({
+      input: {
+        nameSingular: 'personForDelete',
+        namePlural: 'peopleForDelete',
+        labelSingular: 'Person For Delete',
+        labelPlural: 'People For Delete',
+        icon: 'IconPerson',
+      },
+    });
+
+    personId = bId;
+    const {
+      data: {
+        createOneObject: { id: cId },
+      },
+    } = await forceCreateOneObjectMetadata({
+      input: {
+        nameSingular: 'companyForDelete',
+        namePlural: 'companiesForDelete',
+        labelSingular: 'Company For Delete',
+        labelPlural: 'Companies For Delete',
+        icon: 'IconCompany',
+      },
+    });
+
+    companyId = cId;
+  });
+
+  afterEach(async () => {
+    await deleteOneObjectMetadata({ input: { idToDelete: opportunityId } });
+    await deleteOneObjectMetadata({ input: { idToDelete: personId } });
+    await deleteOneObjectMetadata({ input: { idToDelete: companyId } });
+  });
+
+  it('When deleting source object, the relation on the target should be deleted', async () => {
+    morphRelationField = await createMorphRelationBetweenObjects({
+      objectMetadataId: opportunityId,
+      firstTargetObjectMetadataId: personId,
+      secondTargetObjectMetadataId: companyId,
+      type: FieldMetadataType.MORPH_RELATION,
+      relationType: RelationType.MANY_TO_ONE,
+    });
+
+    await deleteOneObjectMetadata({ input: { idToDelete: opportunityId } });
+    const fieldAfterDeletion = await findFieldMetadata({
+      fieldMetadataId: morphRelationField.id,
+    });
+
+    expect(fieldAfterDeletion).toBeUndefined();
   });
 });
+
+const findFieldMetadata = async ({
+  fieldMetadataId,
+}: {
+  fieldMetadataId: string;
+}) => {
+  const operation = findManyFieldsMetadataQueryFactory({
+    gqlFields: `
+      id
+      name
+      object { id nameSingular }
+      relation { type targetFieldMetadata { id } targetObjectMetadata { id } }
+      settings
+    `,
+    input: {
+      filter: { id: { eq: fieldMetadataId } },
+      paging: { first: 1 },
+    },
+  });
+  const fields = await makeMetadataAPIRequest(operation);
+  const field = fields.body.data.fields.edges?.[0]?.node;
+
+  return field;
+};

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/create-morph-relation-between-objects.util.ts

@@ -4,6 +4,7 @@ import { FieldMetadataType } from 'twenty-shared/types';
 
 import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
 
+import { RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
 import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
 
 export const createMorphRelationBetweenObjects = async ({
@@ -51,13 +52,6 @@ export const createMorphRelationBetweenObjects = async ({
     ],
   };
 
-  // TODO: add morphRelations to the query once available
-  // morphRelations {
-  //   type
-  //   targetFieldMetadata {
-  //     id
-  //   }
-  // }
   const {
     data: { createOneField: createdFieldPerson },
   } = await createOneFieldMetadata({
@@ -72,9 +66,20 @@ export const createMorphRelationBetweenObjects = async ({
               id
               nameSingular
             }
+            morphRelations {
+              type
+              targetFieldMetadata {
+                id
+              }
+              targetObjectMetadata {
+                id
+              }
+            }
           `,
     expectToFail: false,
   });
 
-  return createdFieldPerson as FieldMetadataEntity<FieldMetadataType.MORPH_RELATION>;
+  return createdFieldPerson as FieldMetadataEntity<FieldMetadataType.MORPH_RELATION> & {
+    morphRelations: RelationDTO[];
+  };
 };