Enable deletion of relation fields (#5338)

In this PR
1. Enable deletion of relation fields in the product and via the api
(migration part was missing in the api)
3. Change wording, only use "deactivate" and "delete" everywhere (and
not a mix of the two + "disable", "erase")

packages/twenty-front/src/modules/object-metadata/hooks/__tests__/useDeleteOneRelationMetadataItem.test.tsx

@@ -0,0 +1,49 @@
+import { ReactNode } from 'react';
+import { MockedProvider } from '@apollo/client/testing';
+import { act, renderHook } from '@testing-library/react';
+import { RecoilRoot } from 'recoil';
+
+import { useDeleteOneRelationMetadataItem } from '@/object-metadata/hooks/useDeleteOneRelationMetadataItem';
+
+import {
+  query,
+  responseData,
+  variables,
+} from '../__mocks__/useDeleteOneRelationMetadataItem';
+
+const mocks = [
+  {
+    request: {
+      query,
+      variables,
+    },
+    result: jest.fn(() => ({
+      data: {
+        deleteOneRelation: responseData,
+      },
+    })),
+  },
+];
+
+const Wrapper = ({ children }: { children: ReactNode }) => (
+  <RecoilRoot>
+    <MockedProvider mocks={mocks} addTypename={false}>
+      {children}
+    </MockedProvider>
+  </RecoilRoot>
+);
+
+describe('useDeleteOneRelationMetadataItem', () => {
+  it('should work as expected', async () => {
+    const { result } = renderHook(() => useDeleteOneRelationMetadataItem(), {
+      wrapper: Wrapper,
+    });
+
+    await act(async () => {
+      const res =
+        await result.current.deleteOneRelationMetadataItem('idToDelete');
+
+      expect(res.data).toEqual({ deleteOneRelation: responseData });
+    });
+  });
+});

packages/twenty-front/src/modules/object-metadata/hooks/__tests__/useFieldMetadataItem.test.tsx

@@ -5,17 +5,20 @@ import { RecoilRoot } from 'recoil';
 
 import { useFieldMetadataItem } from '@/object-metadata/hooks/useFieldMetadataItem';
 import { FieldMetadataItem } from '@/object-metadata/types/FieldMetadataItem';
-import { FieldMetadataType } from '~/generated/graphql';
+import { FieldMetadataType, RelationDefinitionType } from '~/generated/graphql';
 
 import {
+  FIELD_METADATA_ID,
+  FIELD_RELATION_METADATA_ID,
   objectMetadataId,
   queries,
+  RELATION_METADATA_ID,
   responseData,
   variables,
 } from '../__mocks__/useFieldMetadataItem';
 
 const fieldMetadataItem: FieldMetadataItem = {
-  id: '2c43466a-fe9e-4005-8d08-c5836067aa6c',
+  id: FIELD_METADATA_ID,
   createdAt: '',
   label: 'label',
   name: 'name',
@@ -23,11 +26,42 @@ const fieldMetadataItem: FieldMetadataItem = {
   updatedAt: '',
 };
 
+const fieldRelationMetadataItem: FieldMetadataItem = {
+  id: FIELD_RELATION_METADATA_ID,
+  createdAt: '',
+  label: 'label',
+  name: 'name',
+  type: FieldMetadataType.Relation,
+  updatedAt: '',
+  relationDefinition: {
+    relationId: RELATION_METADATA_ID,
+    direction: RelationDefinitionType.OneToMany,
+    sourceFieldMetadata: {
+      id: 'e5903d91-9b10-4f3e-b761-35c36e93b7c1',
+      name: 'sourceField',
+    },
+    targetFieldMetadata: {
+      id: 'd23d82d4-690b-489f-a8e3-fc5ed01a91f6',
+      name: 'targetField',
+    },
+    sourceObjectMetadata: {
+      id: 'bf46be8a-7c47-45a7-b2f1-30f49e14fbd9',
+      nameSingular: 'sourceObject',
+      namePlural: 'sourceObjects',
+    },
+    targetObjectMetadata: {
+      id: '987c0489-2855-4a63-bb81-93692e51b2a9',
+      nameSingular: 'targetObject',
+      namePlural: 'targetObjects',
+    },
+  },
+};
+
 const mocks = [
   {
     request: {
-      query: queries.eraseMetadataField,
-      variables: variables.eraseMetadataField,
+      query: queries.deleteMetadataField,
+      variables: variables.deleteMetadataField,
     },
     result: jest.fn(() => ({
       data: {
@@ -35,6 +69,17 @@ const mocks = [
       },
     })),
   },
+  {
+    request: {
+      query: queries.deleteMetadataFieldRelation,
+      variables: variables.deleteMetadataFieldRelation,
+    },
+    result: jest.fn(() => ({
+      data: {
+        deleteOneRelation: responseData.fieldRelation,
+      },
+    })),
+  },
   {
     request: {
       query: queries.activateMetadataField,
@@ -60,7 +105,7 @@ const mocks = [
   {
     request: {
       query: queries.activateMetadataField,
-      variables: variables.disableMetadataField,
+      variables: variables.deactivateMetadataField,
     },
     result: jest.fn(() => ({
       data: {
@@ -111,13 +156,14 @@ describe('useFieldMetadataItem', () => {
     });
   });
 
-  it('should disableMetadataField', async () => {
+  it('should deactivateMetadataField', async () => {
     const { result } = renderHook(() => useFieldMetadataItem(), {
       wrapper: Wrapper,
     });
 
     await act(async () => {
-      const res = await result.current.disableMetadataField(fieldMetadataItem);
+      const res =
+        await result.current.deactivateMetadataField(fieldMetadataItem);
 
       expect(res.data).toEqual({
         updateOneField: responseData.default,
@@ -125,17 +171,33 @@ describe('useFieldMetadataItem', () => {
     });
   });
 
-  it('should eraseMetadataField', async () => {
+  it('should deleteOneFieldMetadataItem when calling deleteMetadataField for a non-relation field', async () => {
     const { result } = renderHook(() => useFieldMetadataItem(), {
       wrapper: Wrapper,
     });
 
     await act(async () => {
-      const res = await result.current.eraseMetadataField(fieldMetadataItem);
+      const res = await result.current.deleteMetadataField(fieldMetadataItem);
 
       expect(res.data).toEqual({
         deleteOneField: responseData.default,
       });
     });
   });
+
+  it('should deleteOneFieldMetadataItem when calling deleteMetadataField for a relation field', async () => {
+    const { result } = renderHook(() => useFieldMetadataItem(), {
+      wrapper: Wrapper,
+    });
+
+    await act(async () => {
+      const res = await result.current.deleteMetadataField(
+        fieldRelationMetadataItem,
+      );
+
+      expect(res.data).toEqual({
+        deleteOneRelation: responseData.fieldRelation,
+      });
+    });
+  });
 });