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

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 { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type 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 },
+  },
+});

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

@@ -0,0 +1,43 @@
+import {
+  type 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 { 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 FieldMetadataType } from 'twenty-shared/types';
+
+import { type FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
+
+export const createOneFieldMetadata = async <T extends FieldMetadataType>({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<CreateOneFieldFactoryInput>): CommonResponseBody<{
+  createOneField: FieldMetadataDTO<T>;
+}> => {
+  const graphqlOperation = createOneFieldMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Field Metadata creation should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      errorMessage: 'Field metadata creation should not have failed',
+      response,
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/create-one-select-field-metadata-for-integration-tests.util.ts

@@ -0,0 +1,41 @@
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import {
+  type FieldMetadataComplexOption,
+  FieldMetadataType,
+} from 'twenty-shared/types';
+
+import { type CreateOneFieldMetadataInput } from 'src/engine/metadata-modules/field-metadata/dtos/create-field.input';
+
+export const createOneSelectFieldMetadataForIntegrationTests = async ({
+  input,
+  expectToFail = false,
+}: {
+  input: Partial<CreateOneFieldMetadataInput> & {
+    objectMetadataId: string;
+    options?: FieldMetadataComplexOption[];
+    name?: string;
+  };
+  expectToFail?: boolean;
+}) => {
+  const {
+    data: {
+      createOneField: { id: selectFieldMetadataId },
+    },
+  } = await createOneFieldMetadata({
+    expectToFail,
+    input: {
+      name: 'normalField',
+      type: FieldMetadataType.SELECT,
+      label: 'Select Field',
+      options: [
+        { label: 'Option 1', value: 'OPTION_1', color: 'blue', position: 0 },
+        { label: 'Option 2', value: 'OPTION_2', color: 'red', position: 1 },
+        { label: 'Option 3', value: 'OPTION_3', color: 'green', position: 2 },
+      ],
+      ...input,
+    },
+    gqlFields: 'id',
+  });
+
+  return { selectFieldMetadataId };
+};

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 { type 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,
+  },
+});

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

@@ -0,0 +1,37 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import {
+  type DeleteOneFieldFactoryInput,
+  deleteOneFieldMetadataQueryFactory,
+} from 'test/integration/metadata/suites/field-metadata/utils/delete-one-field-metadata-query-factory.util';
+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';
+
+export const deleteOneFieldMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<DeleteOneFieldFactoryInput>) => {
+  const graphqlOperation = deleteOneFieldMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Field Metadata deletion should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      errorMessage: 'Field metadata deletion should not have failed',
+      response,
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

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 { type 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(paging: $paging, filter: $filter) {
+          edges {
+            node {
+              ${gqlFields}
+            }
+          }
+        }
+      }
+    `,
+  variables: {
+    filter: input.filter,
+    paging: input.paging,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata.util.ts

@@ -0,0 +1,40 @@
+import {
+  type 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 { 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';
+
+export const findManyFieldsMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<FindManyFieldsMetadataFactoryInput>) => {
+  const graphqlOperation = findManyFieldsMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Field Metadata retrieval should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      errorMessage: 'Field metadata retrieval should not have failed',
+      response,
+    });
+  }
+
+  return {
+    errors: response.body.errors,
+    fields: response.body.data.fields?.edges,
+  };
+};

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 { type PerformMetadataQueryParams } from 'test/integration/metadata/types/perform-metadata-query.type';
+
+import { type 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,
+  },
+});

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

@@ -0,0 +1,42 @@
+import {
+  type UpdateOneFieldFactoryInput,
+  updateOneFieldMetadataQueryFactory,
+} from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata-query-factory.util';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.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 FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+
+export const updateOneFieldMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<UpdateOneFieldFactoryInput>): CommonResponseBody<{
+  updateOneField: FieldMetadataEntity;
+}> => {
+  const graphqlOperation = updateOneFieldMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Field Metadata update should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      errorMessage: 'Field metadata update should not have failed',
+      response,
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};