snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/integration/metadata/suites/view-field-group/upsert-fields-widget.integration-spec.ts

@@ -0,0 +1,523 @@
+import {
+  VIEW_FIELD_GQL_FIELDS,
+  VIEW_FIELD_GROUP_GQL_FIELDS,
+  VIEW_GQL_FIELDS,
+} from 'test/integration/constants/view-gql-fields.constants';
+import { findViewFieldGroups } from 'test/integration/metadata/suites/view-field-group/utils/find-view-field-groups.util';
+import { upsertFieldsWidget } from 'test/integration/metadata/suites/view-field-group/utils/upsert-fields-widget.util';
+import { findViewFields } from 'test/integration/metadata/suites/view-field/utils/find-view-fields.util';
+import { v4 as uuidv4 } from 'uuid';
+
+type FieldsWidgetTestSetup = {
+  widgetId: string;
+  viewId: string;
+  labelIdentifierFieldMetadataId: string | null;
+  viewFields: Array<{
+    id: string;
+    fieldMetadataId: string;
+    position: number;
+    isVisible: boolean;
+    viewFieldGroupId: string | null;
+  }>;
+};
+
+const VIEW_WITH_FIELDS_AND_GROUPS_GQL_FIELDS = `
+  ${VIEW_GQL_FIELDS}
+  viewFields {
+    ${VIEW_FIELD_GQL_FIELDS}
+  }
+  viewFieldGroups {
+    ${VIEW_FIELD_GROUP_GQL_FIELDS}
+  }
+`;
+
+const fetchFieldsWidgetTestSetup = async (): Promise<FieldsWidgetTestSetup> => {
+  // TODO refactor should not use global source for that
+  const widgets = await global.testDataSource.query(
+    `SELECT id, configuration->>'viewId' AS "viewId"
+     FROM core."pageLayoutWidget"
+     WHERE type = 'FIELDS'
+       AND "deletedAt" IS NULL
+     LIMIT 1`,
+  );
+
+  expect(widgets.length).toBeGreaterThan(0);
+
+  const { id: widgetId, viewId } = widgets[0];
+
+  expect(widgetId).toBeDefined();
+  expect(viewId).toBeDefined();
+
+  // TODO refactor should not use global source for that
+  const views = await global.testDataSource.query(
+    `SELECT v."objectMetadataId", om."labelIdentifierFieldMetadataId"
+     FROM core."view" v
+     JOIN core."objectMetadata" om ON om.id = v."objectMetadataId"
+     WHERE v.id = $1`,
+    [viewId],
+  );
+
+  const labelIdentifierFieldMetadataId =
+    views[0]?.labelIdentifierFieldMetadataId ?? null;
+
+  const { data } = await findViewFields({
+    viewId,
+    gqlFields: 'id fieldMetadataId position isVisible viewFieldGroupId',
+    expectToFail: false,
+  });
+
+  const viewFields = data.getViewFields;
+
+  return { widgetId, viewId, labelIdentifierFieldMetadataId, viewFields };
+};
+
+describe('upsertFieldsWidget', () => {
+  let testSetup: FieldsWidgetTestSetup;
+
+  beforeAll(async () => {
+    testSetup = await fetchFieldsWidgetTestSetup();
+  });
+
+  describe('with groups input', () => {
+    it('should upsert fields widget with a new group and return a view', async () => {
+      const newGroupId = uuidv4();
+      const targetFields = testSetup.viewFields.slice(0, 2);
+
+      const { data, errors } = await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          groups: [
+            {
+              id: newGroupId,
+              name: 'Test Group',
+              position: 0,
+              isVisible: true,
+              fields: targetFields.map((f, index) => ({
+                viewFieldId: f.id,
+                isVisible: true,
+                position: index,
+              })),
+            },
+          ],
+        },
+        gqlFields: VIEW_WITH_FIELDS_AND_GROUPS_GQL_FIELDS,
+      });
+
+      expect(errors).toBeUndefined();
+      expect(data.upsertFieldsWidget).toBeDefined();
+      expect(data.upsertFieldsWidget.id).toBeDefined();
+      expect(data.upsertFieldsWidget.name).toBeDefined();
+
+      const { data: groupsData } = await findViewFieldGroups({
+        viewId: testSetup.viewId,
+        gqlFields: 'id name',
+        expectToFail: false,
+      });
+
+      const createdGroup = groupsData.getViewFieldGroups.find(
+        (g: { id: string }) => g.id === newGroupId,
+      );
+
+      expect(createdGroup).toBeDefined();
+      expect(createdGroup!.name).toBe('Test Group');
+    });
+
+    it('should hard-delete groups not included in the input', async () => {
+      const groupToDeleteId = uuidv4();
+      const groupToKeepId = uuidv4();
+
+      const twoFields = testSetup.viewFields.slice(0, 2);
+
+      await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          groups: [
+            {
+              id: groupToDeleteId,
+              name: 'Group To Delete',
+              position: 0,
+              isVisible: true,
+              fields: [
+                {
+                  viewFieldId: twoFields[0].id,
+                  isVisible: true,
+                  position: 0,
+                },
+              ],
+            },
+            {
+              id: groupToKeepId,
+              name: 'Group To Keep',
+              position: 1,
+              isVisible: true,
+              fields: [
+                {
+                  viewFieldId: twoFields[1].id,
+                  isVisible: true,
+                  position: 0,
+                },
+              ],
+            },
+          ],
+        },
+      });
+
+      await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          groups: [
+            {
+              id: groupToKeepId,
+              name: 'Group To Keep',
+              position: 0,
+              isVisible: true,
+              fields: [
+                {
+                  viewFieldId: twoFields[1].id,
+                  isVisible: true,
+                  position: 0,
+                },
+              ],
+            },
+          ],
+        },
+      });
+
+      // Verify the omitted group was hard-deleted (row should be completely gone)
+      const deletedGroup = await global.testDataSource.query(
+        `SELECT id FROM core."viewFieldGroup"
+         WHERE id = $1`,
+        [groupToDeleteId],
+      );
+
+      expect(deletedGroup.length).toBe(0);
+
+      const { data: keptGroupData } = await findViewFieldGroups({
+        viewId: testSetup.viewId,
+        gqlFields: 'id',
+        expectToFail: false,
+      });
+
+      const keptGroup = keptGroupData.getViewFieldGroups.find(
+        (g: { id: string }) => g.id === groupToKeepId,
+      );
+
+      expect(keptGroup).toBeDefined();
+    });
+
+    it('should update view field positions and visibility within groups', async () => {
+      const groupId = uuidv4();
+      const targetField = testSetup.viewFields.find(
+        (field) =>
+          field.fieldMetadataId !== testSetup.labelIdentifierFieldMetadataId,
+      )!;
+
+      expect(targetField).toBeDefined();
+
+      await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          groups: [
+            {
+              id: groupId,
+              name: 'Position Test Group',
+              position: 0,
+              isVisible: true,
+              fields: [
+                {
+                  viewFieldId: targetField.id,
+                  isVisible: false,
+                  position: 42,
+                },
+              ],
+            },
+          ],
+        },
+      });
+
+      const { data: fieldsData } = await findViewFields({
+        viewId: testSetup.viewId,
+        gqlFields: 'id isVisible position viewFieldGroupId',
+        expectToFail: false,
+      });
+
+      const updatedField = fieldsData.getViewFields.find(
+        (f: { id: string }) => f.id === targetField.id,
+      );
+
+      expect(updatedField).toBeDefined();
+      expect(updatedField!.isVisible).toBe(false);
+      expect(updatedField!.position).toBe(42);
+      expect(updatedField!.viewFieldGroupId).toBe(groupId);
+    });
+  });
+
+  describe('with fields input (ungrouped)', () => {
+    it('should upsert fields widget with flat fields and return a view', async () => {
+      const targetFields = testSetup.viewFields.slice(0, 3);
+
+      const { data, errors } = await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          fields: targetFields.map((f, index) => ({
+            viewFieldId: f.id,
+            isVisible: true,
+            position: index,
+          })),
+        },
+        gqlFields: VIEW_WITH_FIELDS_AND_GROUPS_GQL_FIELDS,
+      });
+
+      expect(errors).toBeUndefined();
+      expect(data.upsertFieldsWidget).toBeDefined();
+      expect(data.upsertFieldsWidget.id).toBeDefined();
+    });
+
+    it('should hard-delete all existing groups when using flat fields', async () => {
+      const groupId = uuidv4();
+      const targetField = testSetup.viewFields[0];
+
+      await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          groups: [
+            {
+              id: groupId,
+              name: 'Group To Be Deleted',
+              position: 0,
+              isVisible: true,
+              fields: [
+                {
+                  viewFieldId: targetField.id,
+                  isVisible: true,
+                  position: 0,
+                },
+              ],
+            },
+          ],
+        },
+      });
+
+      const { data: groupBeforeData } = await findViewFieldGroups({
+        viewId: testSetup.viewId,
+        gqlFields: 'id',
+        expectToFail: false,
+      });
+
+      const groupBefore = groupBeforeData.getViewFieldGroups.find(
+        (g: { id: string }) => g.id === groupId,
+      );
+
+      expect(groupBefore).toBeDefined();
+
+      await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          fields: [
+            {
+              viewFieldId: targetField.id,
+              isVisible: true,
+              position: 0,
+            },
+          ],
+        },
+      });
+
+      // Verify custom group is hard-deleted (not just deactivated)
+      const { data: allGroupsData } = await findViewFieldGroups({
+        viewId: testSetup.viewId,
+        gqlFields: 'id isActive',
+        expectToFail: false,
+      });
+
+      const specificGroup = allGroupsData.getViewFieldGroups.find(
+        (g: { id: string }) => g.id === groupId,
+      );
+
+      expect(specificGroup).toBeUndefined();
+
+      const { data: updatedFieldData } = await findViewFields({
+        viewId: testSetup.viewId,
+        gqlFields: 'id viewFieldGroupId',
+        expectToFail: false,
+      });
+
+      const updatedField = updatedFieldData.getViewFields.find(
+        (f: { id: string }) => f.id === targetField.id,
+      );
+
+      expect(updatedField).toBeDefined();
+      expect(updatedField!.viewFieldGroupId).toBeNull();
+    });
+
+    it('should update field positions and visibility without groups', async () => {
+      const targetField = testSetup.viewFields.find(
+        (field) =>
+          field.fieldMetadataId !== testSetup.labelIdentifierFieldMetadataId,
+      )!;
+
+      expect(targetField).toBeDefined();
+
+      const groupId = uuidv4();
+
+      await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          groups: [
+            {
+              id: groupId,
+              name: 'Temporary Group',
+              position: 0,
+              isVisible: true,
+              fields: [
+                {
+                  viewFieldId: targetField.id,
+                  isVisible: true,
+                  position: 0,
+                },
+              ],
+            },
+          ],
+        },
+      });
+
+      await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          fields: [
+            {
+              viewFieldId: targetField.id,
+              isVisible: false,
+              position: 99,
+            },
+          ],
+        },
+      });
+
+      const { data: updatedFieldData } = await findViewFields({
+        viewId: testSetup.viewId,
+        gqlFields: 'id isVisible position viewFieldGroupId',
+        expectToFail: false,
+      });
+
+      const updatedField = updatedFieldData.getViewFields.find(
+        (f: { id: string }) => f.id === targetField.id,
+      );
+
+      expect(updatedField).toBeDefined();
+      expect(updatedField!.isVisible).toBe(false);
+      expect(updatedField!.position).toBe(99);
+      expect(updatedField!.viewFieldGroupId).toBeNull();
+    });
+  });
+
+  describe('validation', () => {
+    it('should fail when both groups and fields are provided', async () => {
+      const targetField = testSetup.viewFields[0];
+
+      const { errors } = await upsertFieldsWidget({
+        expectToFail: true,
+        input: {
+          widgetId: testSetup.widgetId,
+          groups: [
+            {
+              id: uuidv4(),
+              name: 'Test',
+              position: 0,
+              isVisible: true,
+              fields: [
+                {
+                  viewFieldId: targetField.id,
+                  isVisible: true,
+                  position: 0,
+                },
+              ],
+            },
+          ],
+          fields: [
+            {
+              viewFieldId: targetField.id,
+              isVisible: true,
+              position: 0,
+            },
+          ],
+        },
+      });
+
+      expect(errors).toBeDefined();
+      expect(errors.length).toBeGreaterThan(0);
+    });
+
+    it('should fail when neither groups nor fields are provided', async () => {
+      const { errors } = await upsertFieldsWidget({
+        expectToFail: true,
+        input: {
+          widgetId: testSetup.widgetId,
+        },
+      });
+
+      expect(errors).toBeDefined();
+      expect(errors.length).toBeGreaterThan(0);
+    });
+
+    it('should fail when widget id does not exist', async () => {
+      const { errors } = await upsertFieldsWidget({
+        expectToFail: true,
+        input: {
+          widgetId: uuidv4(),
+          fields: [
+            {
+              viewFieldId: testSetup.viewFields[0].id,
+              isVisible: true,
+              position: 0,
+            },
+          ],
+        },
+      });
+
+      expect(errors).toBeDefined();
+      expect(errors.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('return type', () => {
+    it('should return a view with the expected fields', async () => {
+      const targetField = testSetup.viewFields[0];
+
+      const { data } = await upsertFieldsWidget({
+        expectToFail: false,
+        input: {
+          widgetId: testSetup.widgetId,
+          fields: [
+            {
+              viewFieldId: targetField.id,
+              isVisible: true,
+              position: 0,
+            },
+          ],
+        },
+        gqlFields: VIEW_WITH_FIELDS_AND_GROUPS_GQL_FIELDS,
+      });
+
+      const view = data.upsertFieldsWidget;
+
+      expect(view.id).toBeDefined();
+      expect(view.name).toBeDefined();
+      expect(view.objectMetadataId).toBeDefined();
+      expect(view.workspaceId).toBeDefined();
+      expect(view.createdAt).toBeDefined();
+      expect(view.updatedAt).toBeDefined();
+      expect(Array.isArray(view.viewFields)).toBe(true);
+      expect(Array.isArray(view.viewFieldGroups)).toBe(true);
+    });
+  });
+});

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/create-many-view-field-groups-query-factory.util.ts

@@ -0,0 +1,23 @@
+import gql from 'graphql-tag';
+import { VIEW_FIELD_GROUP_GQL_FIELDS } from 'test/integration/constants/view-gql-fields.constants';
+
+import { type CreateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/create-view-field-group.input';
+
+export const createManyViewFieldGroupsQueryFactory = ({
+  gqlFields = VIEW_FIELD_GROUP_GQL_FIELDS,
+  inputs,
+}: {
+  gqlFields?: string;
+  inputs: CreateViewFieldGroupInput[];
+}) => ({
+  query: gql`
+    mutation CreateManyViewFieldGroups($inputs: [CreateViewFieldGroupInput!]!) {
+      createManyViewFieldGroups(inputs: $inputs) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    inputs,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/create-many-view-field-groups.util.ts

@@ -0,0 +1,45 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { createManyViewFieldGroupsQueryFactory } from 'test/integration/metadata/suites/view-field-group/utils/create-many-view-field-groups-query-factory.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type CreateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/create-view-field-group.input';
+import { type ViewFieldGroupDTO } from 'src/engine/metadata-modules/view-field-group/dtos/view-field-group.dto';
+
+export const createManyViewFieldGroups = async ({
+  inputs,
+  gqlFields,
+  expectToFail,
+}: {
+  inputs: CreateViewFieldGroupInput[];
+  gqlFields?: string;
+  expectToFail?: boolean;
+}): CommonResponseBody<{
+  createManyViewFieldGroups: ViewFieldGroupDTO[];
+}> => {
+  const graphqlOperation = createManyViewFieldGroupsQueryFactory({
+    inputs,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage:
+        'View Field Groups batch creation should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage:
+        'View Field Groups batch creation has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/create-one-view-field-group.util.ts

@@ -0,0 +1,40 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { createViewFieldGroupQueryFactory } from 'test/integration/metadata/suites/view-field-group/utils/create-view-field-group-query-factory.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type CreateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/create-view-field-group.input';
+import { type ViewFieldGroupDTO } from 'src/engine/metadata-modules/view-field-group/dtos/view-field-group.dto';
+
+export const createOneViewFieldGroup = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<CreateViewFieldGroupInput>): CommonResponseBody<{
+  createViewFieldGroup: ViewFieldGroupDTO;
+}> => {
+  const graphqlOperation = createViewFieldGroupQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'View Field Group creation should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'View Field Group creation has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/create-view-field-group-query-factory.util.ts

@@ -0,0 +1,21 @@
+import gql from 'graphql-tag';
+import { VIEW_FIELD_GROUP_GQL_FIELDS } from 'test/integration/constants/view-gql-fields.constants';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type CreateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/create-view-field-group.input';
+
+export const createViewFieldGroupQueryFactory = ({
+  gqlFields = VIEW_FIELD_GROUP_GQL_FIELDS,
+  input,
+}: PerformMetadataQueryParams<CreateViewFieldGroupInput>) => ({
+  query: gql`
+    mutation CreateViewFieldGroup($input: CreateViewFieldGroupInput!) {
+      createViewFieldGroup(input: $input) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    input,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/delete-one-view-field-group.util.ts

@@ -0,0 +1,40 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { deleteViewFieldGroupQueryFactory } from 'test/integration/metadata/suites/view-field-group/utils/delete-view-field-group-query-factory.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type DeleteViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/delete-view-field-group.input';
+import { type ViewFieldGroupDTO } from 'src/engine/metadata-modules/view-field-group/dtos/view-field-group.dto';
+
+export const deleteOneViewFieldGroup = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<DeleteViewFieldGroupInput>): CommonResponseBody<{
+  deleteViewFieldGroup: ViewFieldGroupDTO;
+}> => {
+  const graphqlOperation = deleteViewFieldGroupQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'View Field Group deletion should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'View Field Group deletion has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/delete-view-field-group-query-factory.util.ts

@@ -0,0 +1,21 @@
+import gql from 'graphql-tag';
+import { VIEW_FIELD_GROUP_GQL_FIELDS } from 'test/integration/constants/view-gql-fields.constants';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type DeleteViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/delete-view-field-group.input';
+
+export const deleteViewFieldGroupQueryFactory = ({
+  gqlFields = VIEW_FIELD_GROUP_GQL_FIELDS,
+  input,
+}: PerformMetadataQueryParams<DeleteViewFieldGroupInput>) => ({
+  query: gql`
+    mutation DeleteViewFieldGroup($input: DeleteViewFieldGroupInput!) {
+      deleteViewFieldGroup(input: $input) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    input,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/destroy-one-view-field-group.util.ts

@@ -0,0 +1,41 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { destroyViewFieldGroupQueryFactory } from 'test/integration/metadata/suites/view-field-group/utils/destroy-view-field-group-query-factory.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type DestroyViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/destroy-view-field-group.input';
+import { type ViewFieldGroupDTO } from 'src/engine/metadata-modules/view-field-group/dtos/view-field-group.dto';
+
+export const destroyOneViewFieldGroup = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<DestroyViewFieldGroupInput>): CommonResponseBody<{
+  destroyViewFieldGroup: ViewFieldGroupDTO;
+}> => {
+  const graphqlOperation = destroyViewFieldGroupQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage:
+        'View Field Group destruction should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'View Field Group destruction has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/destroy-view-field-group-query-factory.util.ts

@@ -0,0 +1,21 @@
+import gql from 'graphql-tag';
+import { VIEW_FIELD_GROUP_GQL_FIELDS } from 'test/integration/constants/view-gql-fields.constants';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type DestroyViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/destroy-view-field-group.input';
+
+export const destroyViewFieldGroupQueryFactory = ({
+  gqlFields = VIEW_FIELD_GROUP_GQL_FIELDS,
+  input,
+}: PerformMetadataQueryParams<DestroyViewFieldGroupInput>) => ({
+  query: gql`
+    mutation DestroyViewFieldGroup($input: DestroyViewFieldGroupInput!) {
+      destroyViewFieldGroup(input: $input) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    input,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/find-view-field-groups-query-factory.util.ts

@@ -0,0 +1,21 @@
+import gql from 'graphql-tag';
+import { VIEW_FIELD_GROUP_GQL_FIELDS } from 'test/integration/constants/view-gql-fields.constants';
+
+export const findViewFieldGroupsQueryFactory = ({
+  gqlFields = VIEW_FIELD_GROUP_GQL_FIELDS,
+  viewId,
+}: {
+  gqlFields?: string;
+  viewId: string;
+}) => ({
+  query: gql`
+    query GetViewFieldGroups($viewId: String!) {
+      getViewFieldGroups(viewId: $viewId) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    viewId,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/find-view-field-groups.util.ts

@@ -0,0 +1,42 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { findViewFieldGroupsQueryFactory } from 'test/integration/metadata/suites/view-field-group/utils/find-view-field-groups-query-factory.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type ViewFieldGroupDTO } from 'src/engine/metadata-modules/view-field-group/dtos/view-field-group.dto';
+
+export const findViewFieldGroups = async ({
+  viewId,
+  gqlFields,
+  expectToFail,
+}: {
+  viewId: string;
+  gqlFields?: string;
+  expectToFail?: boolean;
+}): CommonResponseBody<{
+  getViewFieldGroups: ViewFieldGroupDTO[];
+}> => {
+  const graphqlOperation = findViewFieldGroupsQueryFactory({
+    viewId,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'View Field Group search should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'View Field Group search has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/update-one-view-field-group.util.ts

@@ -0,0 +1,40 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { updateViewFieldGroupQueryFactory } from 'test/integration/metadata/suites/view-field-group/utils/update-view-field-group-query-factory.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type UpdateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/update-view-field-group.input';
+import { type ViewFieldGroupDTO } from 'src/engine/metadata-modules/view-field-group/dtos/view-field-group.dto';
+
+export const updateOneViewFieldGroup = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<UpdateViewFieldGroupInput>): CommonResponseBody<{
+  updateViewFieldGroup: ViewFieldGroupDTO;
+}> => {
+  const graphqlOperation = updateViewFieldGroupQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'View Field Group update should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'View Field Group update has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/update-view-field-group-query-factory.util.ts

@@ -0,0 +1,21 @@
+import gql from 'graphql-tag';
+import { VIEW_FIELD_GROUP_GQL_FIELDS } from 'test/integration/constants/view-gql-fields.constants';
+import { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type UpdateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/update-view-field-group.input';
+
+export const updateViewFieldGroupQueryFactory = ({
+  gqlFields = VIEW_FIELD_GROUP_GQL_FIELDS,
+  input,
+}: PerformMetadataQueryParams<UpdateViewFieldGroupInput>) => ({
+  query: gql`
+    mutation UpdateViewFieldGroup($input: UpdateViewFieldGroupInput!) {
+      updateViewFieldGroup(input: $input) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    input,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/upsert-fields-widget-query-factory.util.ts

@@ -0,0 +1,23 @@
+import gql from 'graphql-tag';
+import { VIEW_GQL_FIELDS } from 'test/integration/constants/view-gql-fields.constants';
+
+import { type UpsertFieldsWidgetInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/upsert-fields-widget.input';
+
+export const upsertFieldsWidgetQueryFactory = ({
+  gqlFields = VIEW_GQL_FIELDS,
+  input,
+}: {
+  gqlFields?: string;
+  input: UpsertFieldsWidgetInput;
+}) => ({
+  query: gql`
+    mutation UpsertFieldsWidget($input: UpsertFieldsWidgetInput!) {
+      upsertFieldsWidget(input: $input) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    input,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/view-field-group/utils/upsert-fields-widget.util.ts

@@ -0,0 +1,43 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { upsertFieldsWidgetQueryFactory } from 'test/integration/metadata/suites/view-field-group/utils/upsert-fields-widget-query-factory.util';
+import { type CommonResponseBody } from 'test/integration/metadata/types/common-response-body.type';
+import { warnIfErrorButNotExpectedToFail } from 'test/integration/metadata/utils/warn-if-error-but-not-expected-to-fail.util';
+import { warnIfNoErrorButExpectedToFail } from 'test/integration/metadata/utils/warn-if-no-error-but-expected-to-fail.util';
+
+import { type UpsertFieldsWidgetInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/upsert-fields-widget.input';
+import { type ViewDTO } from 'src/engine/metadata-modules/view/dtos/view.dto';
+
+export const upsertFieldsWidget = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: {
+  input: UpsertFieldsWidgetInput;
+  gqlFields?: string;
+  expectToFail?: boolean | null;
+}): CommonResponseBody<{
+  upsertFieldsWidget: ViewDTO;
+}> => {
+  const graphqlOperation = upsertFieldsWidgetQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Upsert fields widget should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'Upsert fields widget has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};