Fix deactivate objects impacts (#11185)

In this PR: - Remove deactivated objects from ActivityTargetInlineCell record picker - Prevent users to deactivate createdAt, updatedAt, deletedAt fields on any objects Still left: - write unit tests on the assert utils - write integration tests on field metadata service - prevent users to deactivate createdAt, updatedAt, deletedAt on FE
2025-03-26 20:45:46 +01:00
parent 90e884d33f
commit 5bd10d40cb
49 changed files with 861 additions and 531 deletions
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/create-one-field-metadata.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/create-one-field-metadata.integration-spec.ts
@ -1,21 +1,33 @@
-import { createOneFieldMetadataFactory } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-factory.util';
-import { createListingCustomObject } from 'test/integration/metadata/suites/object-metadata/utils/create-test-object-metadata.util';
-import { deleteOneObjectMetadataItem } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
-import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
 import { FieldMetadataType } from 'twenty-shared/types';

 describe('createOne', () => {
  describe('FieldMetadataService name/label sync', () => {
-    let listingObjectId = '';
+    let createdObjectMetadataId = '';

    beforeEach(async () => {
-      const { objectMetadataId: createdObjectId } =
-        await createListingCustomObject();
+      const {
+        data: {
+          createOneObject: { id: objectMetadataId },
+        },
+      } = await createOneObjectMetadata({
+        input: {
+          nameSingular: 'myTestObject',
+          namePlural: 'myTestObjects',
+          labelSingular: 'My Test Object',
+          labelPlural: 'My Test Objects',
+          icon: 'Icon123',
+        },
+      });

-      listingObjectId = createdObjectId;
+      createdObjectMetadataId = objectMetadataId;
    });
    afterEach(async () => {
-      await deleteOneObjectMetadataItem(listingObjectId);
+      await deleteOneObjectMetadata({
+        input: { idToDelete: createdObjectMetadataId },
+      });
    });
    it('should create a field when name and label are synced correctly', async () => {
      // Arrange
@ -24,13 +36,13 @@ describe('createOne', () => {
        name: FIELD_NAME,
        label: 'Test Field',
        type: FieldMetadataType.TEXT,
-        objectMetadataId: listingObjectId,
+        objectMetadataId: createdObjectMetadataId,
        isLabelSyncedWithName: true,
      };

      // Act
-      const graphqlOperation = createOneFieldMetadataFactory({
-        input: { field: createFieldInput },
+      const { data } = await createOneFieldMetadata({
+        input: createFieldInput,
        gqlFields: `
          id
          name
@ -39,10 +51,8 @@ describe('createOne', () => {
        `,
      });

-      const response = await makeMetadataAPIRequest(graphqlOperation);
-
      // Assert
-      expect(response.body.data.createOneField.name).toBe(FIELD_NAME);
+      expect(data.createOneField.name).toBe(FIELD_NAME);
    });

    it('should set isLabelSyncWithName to false if not in input', async () => {
@ -51,26 +61,22 @@ describe('createOne', () => {
        name: 'testField',
        label: 'Test Field',
        type: FieldMetadataType.TEXT,
-        objectMetadataId: listingObjectId,
+        objectMetadataId: createdObjectMetadataId,
      };

      // Act
-      const graphqlOperation = createOneFieldMetadataFactory({
-        input: { field: createFieldInput },
+      const { data } = await createOneFieldMetadata({
+        input: createFieldInput,
        gqlFields: `
-          id
-          name
-          label
-          isLabelSyncedWithName
-        `,
+            id
+            name
+            label
+            isLabelSyncedWithName
+          `,
      });

-      const response = await makeMetadataAPIRequest(graphqlOperation);
-
      // Assert
-      expect(response.body.data.createOneField.isLabelSyncedWithName).toBe(
-        false,
-      );
+      expect(data.createOneField.isLabelSyncedWithName).toBe(false);
    });

    it('should return an error when name and label are not synced but isLabelSyncedWithName is true', async () => {
@ -79,25 +85,24 @@ describe('createOne', () => {
        name: 'testField',
        label: 'Different Label',
        type: FieldMetadataType.TEXT,
-        objectMetadataId: listingObjectId,
+        objectMetadataId: createdObjectMetadataId,
        isLabelSyncedWithName: true,
      };

-      const graphqlOperation = createOneFieldMetadataFactory({
-        input: { field: createFieldInput },
+      // Act
+      const { errors } = await createOneFieldMetadata({
+        input: createFieldInput,
        gqlFields: `
            id
            name
            label
            isLabelSyncedWithName
-        `,
+          `,
+        expectToFail: true,
      });

-      // Act
-      const response = await makeMetadataAPIRequest(graphqlOperation);
-
      // Assert
-      expect(response.body.errors[0].message).toBe(
+      expect(errors[0].message).toBe(
        'Name is not synced with label. Expected name: "differentLabel", got testField',
      );
    });
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/delete-one-field-metadata.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/delete-one-field-metadata.integration-spec.ts
@ -1,12 +1,16 @@
 import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';
 import { findOneOperationFactory } from 'test/integration/graphql/utils/find-one-operation-factory.util';
 import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
-import { createCustomTextFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-custom-text-field-metadata.util';
-import { deleteOneFieldMetadataItemFactory } from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata-factory.util';
-import { updateOneFieldMetadataFactory } from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata-factory.util';
-import { createListingCustomObject } from 'test/integration/metadata/suites/object-metadata/utils/create-test-object-metadata.util';
-import { deleteOneObjectMetadataItem } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
-import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { deleteOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata.util';
+import { updateOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata.util';
+import {
+  LISTING_NAME_PLURAL,
+  LISTING_NAME_SINGULAR,
+} from 'test/integration/metadata/suites/object-metadata/constants/test-object-names.constant';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { FieldMetadataType } from 'twenty-shared/types';

 describe('deleteOne', () => {
  describe('Kanban aggregate operation', () => {
@ -15,14 +19,27 @@ describe('deleteOne', () => {
    let viewId = '';

    beforeEach(async () => {
-      const { objectMetadataId: createdObjectId } =
-        await createListingCustomObject();
+      const { data } = await createOneObjectMetadata({
+        input: {
+          nameSingular: LISTING_NAME_SINGULAR,
+          namePlural: LISTING_NAME_PLURAL,
+          labelSingular: 'Listing',
+          labelPlural: 'Listings',
+          icon: 'IconBuildingSkyscraper',
+        },
+      });

-      listingObjectId = createdObjectId;
-      const { fieldMetadataId: createdFieldMetadaId } =
-        await createCustomTextFieldMetadata(createdObjectId);
+      listingObjectId = data.createOneObject.id;
+      const { data: createdFieldData } = await createOneFieldMetadata({
+        input: {
+          name: 'house',
+          type: FieldMetadataType.TEXT,
+          label: 'House',
+          objectMetadataId: listingObjectId,
+        },
+      });

-      testFieldId = createdFieldMetadaId;
+      testFieldId = createdFieldData.createOneField.id;

      // create view
      const graphqlOperation = createOneOperationFactory({
@ -49,7 +66,9 @@ describe('deleteOne', () => {
      viewId = createdView.id;
    });
    afterEach(async () => {
-      await deleteOneObjectMetadataItem(listingObjectId);
+      await deleteOneObjectMetadata({
+        input: { idToDelete: listingObjectId },
+      });
    });
    it('should reset kanban aggregate operation when deleting a field used as kanbanAggregateOperationFieldMetadataId', async () => {
      // Arrange
@ -76,25 +95,25 @@ describe('deleteOne', () => {
      expect(viewResponse.body.data.view.kanbanAggregateOperation).toBe('MAX');

      // Deactivate field to be able to delete it after
-      const deactivateFieldOperation = updateOneFieldMetadataFactory({
-        input: { id: testFieldId, update: { isActive: false } },
+      await updateOneFieldMetadata({
+        input: {
+          idToUpdate: testFieldId,
+          updatePayload: { isActive: false },
+        },
        gqlFields: `
              id
              isActive
          `,
      });

-      await makeMetadataAPIRequest(deactivateFieldOperation);
-
      // Act
-      const graphqlOperation = deleteOneFieldMetadataItemFactory({
-        idToDelete: testFieldId,
+      const { data } = await deleteOneFieldMetadata({
+        input: { idToDelete: testFieldId },
      });
-      const response = await makeMetadataAPIRequest(graphqlOperation);

      // Assert
      // 1. Field is deleted
-      expect(response.body.data.deleteOneField.id).toBe(testFieldId);
+      expect(data.deleteOneField.id).toBe(testFieldId);

      // 2. Kanban aggregate operation has been reset on view using this field as kanbanAggregateOperationFieldMetadataId
      const updatedViewResponse =
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/update-one-field-metadata.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/update-one-field-metadata.integration-spec.ts
@ -1,8 +1,12 @@
-import { createCustomTextFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-custom-text-field-metadata.util';
-import { updateOneFieldMetadataFactory } from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata-factory.util';
-import { createListingCustomObject } from 'test/integration/metadata/suites/object-metadata/utils/create-test-object-metadata.util';
-import { deleteOneObjectMetadataItem } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
-import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { updateOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata.util';
+import {
+  LISTING_NAME_PLURAL,
+  LISTING_NAME_SINGULAR,
+} from 'test/integration/metadata/suites/object-metadata/constants/test-object-names.constant';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { FieldMetadataType } from 'twenty-shared/types';

 describe('updateOne', () => {
  describe('FieldMetadataService name/label sync', () => {
@ -10,18 +14,35 @@ describe('updateOne', () => {
    let testFieldId = '';

    beforeEach(async () => {
-      const { objectMetadataId: createdObjectId } =
-        await createListingCustomObject();
+      const { data } = await createOneObjectMetadata({
+        input: {
+          labelSingular: LISTING_NAME_SINGULAR,
+          labelPlural: LISTING_NAME_PLURAL,
+          nameSingular: LISTING_NAME_SINGULAR,
+          namePlural: LISTING_NAME_PLURAL,
+          icon: 'IconBuildingSkyscraper',
+          isLabelSyncedWithName: true,
+        },
+      });

-      listingObjectId = createdObjectId;
+      listingObjectId = data.createOneObject.id;

-      const { fieldMetadataId: createdFieldMetadaId } =
-        await createCustomTextFieldMetadata(createdObjectId);
+      const { data: createdFieldMetadata } = await createOneFieldMetadata({
+        input: {
+          objectMetadataId: listingObjectId,
+          type: FieldMetadataType.TEXT,
+          name: 'testName',
+          label: 'Test name',
+          isLabelSyncedWithName: true,
+        },
+      });

-      testFieldId = createdFieldMetadaId;
+      testFieldId = createdFieldMetadata.createOneField.id;
    });
    afterEach(async () => {
-      await deleteOneObjectMetadataItem(listingObjectId);
+      await deleteOneObjectMetadata({
+        input: { idToDelete: listingObjectId },
+      });
    });

    it('should update a field name and label when they are synced correctly', async () => {
@ -29,11 +50,12 @@ describe('updateOne', () => {
      const updateFieldInput = {
        name: 'newName',
        label: 'New name',
+        isLabelSyncedWithName: true,
      };

      // Act
-      const graphqlOperation = updateOneFieldMetadataFactory({
-        input: { id: testFieldId, update: updateFieldInput },
+      const { data } = await updateOneFieldMetadata({
+        input: { idToUpdate: testFieldId, updatePayload: updateFieldInput },
        gqlFields: `
            id
            name
@ -42,10 +64,8 @@ describe('updateOne', () => {
        `,
      });

-      const response = await makeMetadataAPIRequest(graphqlOperation);
-
      // Assert
-      expect(response.body.data.updateOneField.name).toBe('newName');
+      expect(data.updateOneField.name).toBe('newName');
    });

    it('should update a field name and label when they are not synced correctly and labelSync is false', async () => {
@ -57,8 +77,8 @@ describe('updateOne', () => {
      };

      // Act
-      const graphqlOperation = updateOneFieldMetadataFactory({
-        input: { id: testFieldId, update: updateFieldInput },
+      const { data } = await updateOneFieldMetadata({
+        input: { idToUpdate: testFieldId, updatePayload: updateFieldInput },
        gqlFields: `
              id
              name
@ -67,33 +87,31 @@ describe('updateOne', () => {
          `,
      });

-      const response = await makeMetadataAPIRequest(graphqlOperation);
-
      // Assert
-      expect(response.body.data.updateOneField.name).toBe('differentName');
+      expect(data.updateOneField.name).toBe('differentName');
    });

    it('should not update a field name if it is not synced correctly with label and labelSync is true', async () => {
      // Arrange
      const updateFieldInput = {
        name: 'newName',
+        isLabelSyncedWithName: true,
      };

      // Act
-      const graphqlOperation = updateOneFieldMetadataFactory({
-        input: { id: testFieldId, update: updateFieldInput },
+      const { errors } = await updateOneFieldMetadata({
+        input: { idToUpdate: testFieldId, updatePayload: updateFieldInput },
        gqlFields: `
              id
              name
              label
              isLabelSyncedWithName
          `,
+        expectToFail: true,
      });

-      const response = await makeMetadataAPIRequest(graphqlOperation);
-
      // Assert
-      expect(response.body.errors[0].message).toBe(
+      expect(errors[0].message).toBe(
        'Name is not synced with label. Expected name: "testName", got newName',
      );
    });
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-custom-text-field-metadata.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-custom-text-field-metadata.util.ts
@ -1,30 +0,0 @@
-import { createOneFieldMetadataFactory } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-factory.util';
-import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
-import { FieldMetadataType } from 'twenty-shared/types';
-
-const FIELD_NAME = 'testName';
-
-export const createCustomTextFieldMetadata = async (
-  objectMetadataItemId: string,
-) => {
-  const createFieldInput = {
-    name: FIELD_NAME,
-    label: 'Test name',
-    type: FieldMetadataType.TEXT,
-    objectMetadataId: objectMetadataItemId,
-    isLabelSyncedWithName: true,
-  };
-  const graphqlOperation = createOneFieldMetadataFactory({
-    input: { field: createFieldInput },
-    gqlFields: `
-          id
-          name
-          label
-          isLabelSyncedWithName
-      `,
-  });
-
-  const response = await makeMetadataAPIRequest(graphqlOperation);
-
-  return { fieldMetadataId: response.body.data.createOneField.id };
-};
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-factory.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-factory.util.ts
@ -1,24 +0,0 @@
-import gql from 'graphql-tag';
-
-import { CreateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/create-field.input';
-
-type CreateOneFieldFactoryParams = {
-  gqlFields: string;
-  input?: { field: Omit<CreateFieldInput, 'workspaceId' | 'dataSourceId'> };
-};
-
-export const createOneFieldMetadataFactory = ({
-  gqlFields,
-  input,
-}: CreateOneFieldFactoryParams) => ({
-  query: gql`
-        mutation CreateOneFieldMetadataItem($input: CreateOneFieldMetadataInput!) {
-          createOneField(input: $input) {
-            ${gqlFields}
-        }
-      }
-      `,
-  variables: {
-    input,
-  },
-});
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-query-factory.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-query-factory.util.ts
@ -0,0 +1,25 @@
+import gql from 'graphql-tag';
+import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { CreateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/create-field.input';
+
+export type CreateOneFieldFactoryInput = Omit<
+  CreateFieldInput,
+  'workspaceId' | 'dataSourceId'
+>;
+
+export const createOneFieldMetadataQueryFactory = ({
+  input,
+  gqlFields = 'id',
+}: PerformMetadataQueryParams<CreateOneFieldFactoryInput>) => ({
+  query: gql`
+        mutation CreateOneFieldMetadataItem($input: CreateOneFieldMetadataInput!) {
+          createOneField(input: $input) {
+            ${gqlFields}
+        }
+      }
+      `,
+  variables: {
+    input: { field: input },
+  },
+});
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util.ts
@ -0,0 +1,29 @@
+import {
+  CreateOneFieldFactoryInput,
+  createOneFieldMetadataQueryFactory,
+} from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+export const createOneFieldMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+}: PerformMetadataQueryParams<CreateOneFieldFactoryInput>) => {
+  const graphqlOperation = createOneFieldMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Field Metadata creation should have failed but did not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata-factory.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata-factory.util.ts
@ -1,20 +0,0 @@
-import gql from 'graphql-tag';
-
-type DeleteOneFieldFactoryParams = {
-  idToDelete: string;
-};
-
-export const deleteOneFieldMetadataItemFactory = ({
-  idToDelete,
-}: DeleteOneFieldFactoryParams) => ({
-  query: gql`
-    mutation DeleteOneFieldMetadataItem($idToDelete: UUID!) {
-      deleteOneField(input: { id: $idToDelete }) {
-        id
-      }
-    }
-  `,
-  variables: {
-    idToDelete,
-  },
-});
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata-query-factory.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata-query-factory.util.ts
@ -0,0 +1,22 @@
+import gql from 'graphql-tag';
+import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+export type DeleteOneFieldFactoryInput = {
+  idToDelete: string;
+};
+
+export const deleteOneFieldMetadataQueryFactory = ({
+  input,
+  gqlFields = 'id',
+}: PerformMetadataQueryParams<DeleteOneFieldFactoryInput>) => ({
+  query: gql`
+        mutation DeleteOneFieldMetadataItem($idToDelete: UUID!) {
+          deleteOneField(input: { id: $idToDelete }) {
+            ${gqlFields}
+        }
+      }
+      `,
+  variables: {
+    idToDelete: input.idToDelete,
+  },
+});
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata.util.ts
@ -1,10 +1,29 @@
 import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
-import { deleteOneFieldMetadataItemFactory } from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata-factory.util';
+import {
+  DeleteOneFieldFactoryInput,
+  deleteOneFieldMetadataQueryFactory,
+} from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata-query-factory.util';
+import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';

-export const deleteFieldMetadata = async (fieldMetadataId: string) => {
-  const graphqlOperation = deleteOneFieldMetadataItemFactory({
-    idToDelete: fieldMetadataId,
+export const deleteOneFieldMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+}: PerformMetadataQueryParams<DeleteOneFieldFactoryInput>) => {
+  const graphqlOperation = deleteOneFieldMetadataQueryFactory({
+    input,
+    gqlFields,
  });

-  await makeGraphqlAPIRequest(graphqlOperation);
+  const response = await makeGraphqlAPIRequest(graphqlOperation);
+
+  if (expectToFail) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Field Metadata deletion should have failed but did not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
 };
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata-query-factory.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata-query-factory.util.ts
@ -0,0 +1,28 @@
+import gql from 'graphql-tag';
+import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+export type FindManyFieldsMetadataFactoryInput = {
+  filter: object;
+  paging: object;
+};
+
+export const findManyFieldsMetadataQueryFactory = ({
+  gqlFields = 'id',
+  input,
+}: PerformMetadataQueryParams<FindManyFieldsMetadataFactoryInput>) => ({
+  query: gql`
+      query FieldsMetadata($filter: FieldFilter!, $paging: CursorPaging!) {
+        fields(filter: $filter, paging: $paging) {
+          edges {
+            node {
+              ${gqlFields}
+            }
+          }
+        }
+      }
+    `,
+  variables: {
+    filter: input.filter,
+    paging: input.paging,
+  },
+});
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata.util.ts
@ -0,0 +1,29 @@
+import {
+  FindManyFieldsMetadataFactoryInput,
+  findManyFieldsMetadataQueryFactory,
+} from 'test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+export const findManyFieldsMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+}: PerformMetadataQueryParams<FindManyFieldsMetadataFactoryInput>) => {
+  const graphqlOperation = findManyFieldsMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Field Metadata retrieval should have failed but did not',
+    });
+  }
+
+  return response.body.data.fields.edges.map((edge) => edge.node);
+};
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata-factory.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata-factory.util.ts
@ -1,25 +0,0 @@
-import gql from 'graphql-tag';
-
-import { UpdateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/update-field.input';
-
-type UpdateOneFieldFactoryParams = {
-  gqlFields: string;
-  input: { id: string; update: Omit<UpdateFieldInput, 'workspaceId' | 'id'> };
-};
-
-export const updateOneFieldMetadataFactory = ({
-  gqlFields,
-  input,
-}: UpdateOneFieldFactoryParams) => ({
-  query: gql`
-        mutation UpdateOneFieldMetadataItem($idToUpdate: UUID!, $updatePayload: UpdateFieldInput!) {
-            updateOneField(input: {id: $idToUpdate, update: $updatePayload}) {
-            ${gqlFields}
-        }
-      }
-      `,
-  variables: {
-    idToUpdate: input.id,
-    updatePayload: input.update,
-  },
-});
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata-query-factory.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata-query-factory.util.ts
@ -0,0 +1,26 @@
+import gql from 'graphql-tag';
+import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { UpdateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/update-field.input';
+
+export type UpdateOneFieldFactoryInput = {
+  idToUpdate: string;
+  updatePayload: Omit<UpdateFieldInput, 'workspaceId' | 'id'>;
+};
+
+export const updateOneFieldMetadataQueryFactory = ({
+  gqlFields = 'id',
+  input,
+}: PerformMetadataQueryParams<UpdateOneFieldFactoryInput>) => ({
+  query: gql`
+        mutation UpdateOneFieldMetadataItem($idToUpdate: UUID!, $updatePayload: UpdateFieldInput!) {
+            updateOneField(input: {id: $idToUpdate, update: $updatePayload}) {
+            ${gqlFields}
+        }
+      }
+      `,
+  variables: {
+    idToUpdate: input.idToUpdate,
+    updatePayload: input.updatePayload,
+  },
+});
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata.util.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata.util.ts
@ -0,0 +1,29 @@
+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import {
+  UpdateOneFieldFactoryInput,
+  updateOneFieldMetadataQueryFactory,
+} from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata-query-factory.util';
+import { PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+export const updateOneFieldMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+}: PerformMetadataQueryParams<UpdateOneFieldFactoryInput>) => {
+  const graphqlOperation = updateOneFieldMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeGraphqlAPIRequest(graphqlOperation);
+
+  if (expectToFail) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Field Metadata update should have failed but did not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};