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

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

@@ -0,0 +1,92 @@
+import { type CreateOneFieldFactoryInput } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-query-factory.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { type FieldMetadataType } from 'twenty-shared/types';
+
+import { type RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+import { type RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
+import { type FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';
+
+export const createMorphRelationBetweenObjects = async ({
+  objectMetadataId,
+  firstTargetObjectMetadataId,
+  secondTargetObjectMetadataId,
+  type,
+  relationType,
+  name,
+  label,
+  isLabelSyncedWithName,
+  targetFieldLabel,
+  targetFieldIcon,
+}: {
+  objectMetadataId: string;
+  firstTargetObjectMetadataId: string;
+  secondTargetObjectMetadataId: string;
+  type: FieldMetadataType;
+  relationType: RelationType;
+  name?: string;
+  label?: string;
+  isLabelSyncedWithName?: boolean;
+  targetFieldLabel?: string;
+  targetFieldIcon?: string;
+}) => {
+  const createFieldInput: CreateOneFieldFactoryInput = {
+    name: name || 'owner',
+    label: label || 'owner field',
+    type,
+    objectMetadataId,
+    isLabelSyncedWithName: isLabelSyncedWithName || false,
+    morphRelationsCreationPayload: [
+      {
+        targetObjectMetadataId: firstTargetObjectMetadataId,
+        targetFieldLabel: targetFieldLabel || 'opportunity',
+        targetFieldIcon: targetFieldIcon || 'IconListOpportunity',
+        type: relationType,
+      },
+      {
+        targetObjectMetadataId: secondTargetObjectMetadataId,
+        targetFieldLabel: targetFieldLabel || 'opportunity',
+        targetFieldIcon: targetFieldIcon || 'IconListOpportunity',
+        type: relationType,
+      },
+    ],
+  };
+
+  const {
+    data: { createOneField: createdFieldPerson },
+  } = await createOneFieldMetadata({
+    input: createFieldInput,
+    gqlFields: `
+            id
+            type
+            name
+            label
+            isLabelSyncedWithName
+            settings
+            object {
+              id
+              nameSingular
+            }
+            morphRelations {
+              type
+              targetFieldMetadata {
+                id
+              }
+              targetObjectMetadata {
+                id
+              }
+              sourceFieldMetadata {
+                id
+              }
+              sourceObjectMetadata {
+                id
+              }
+            }
+          `,
+    expectToFail: false,
+  });
+
+  return createdFieldPerson as FieldMetadataEntity<FieldMetadataType.MORPH_RELATION> & {
+    morphRelations: RelationDTO[];
+  };
+};

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/create-one-object-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 CreateObjectInput } from 'src/engine/metadata-modules/object-metadata/dtos/create-object.input';
+
+export type CreateOneObjectFactoryInput = Omit<
+  CreateObjectInput,
+  'workspaceId' | 'dataSourceId'
+>;
+
+export const createOneObjectMetadataQueryFactory = ({
+  input,
+  gqlFields = 'id',
+}: PerformMetadataQueryParams<CreateOneObjectFactoryInput>) => ({
+  query: gql`
+        mutation CreateOneObjectMetadataItem($input: CreateOneObjectInput!) {
+          createOneObject(input: $input) {
+            ${gqlFields}
+        }
+      }
+      `,
+  variables: {
+    input: { object: input },
+  },
+});

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

@@ -0,0 +1,43 @@
+import {
+  type CreateOneObjectFactoryInput,
+  createOneObjectMetadataQueryFactory,
+} from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-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 ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
+
+export const createOneObjectMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+  token,
+}: PerformMetadataQueryParams<CreateOneObjectFactoryInput>): CommonResponseBody<{
+  createOneObject: ObjectMetadataDTO;
+}> => {
+  const graphqlOperation = createOneObjectMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Object Metadata creation should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'Object Metadata creation has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

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

@@ -0,0 +1,87 @@
+import { type CreateOneFieldFactoryInput } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata-query-factory.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { type FieldMetadataType } from 'twenty-shared/types';
+
+import { type RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';
+
+import { type FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
+import { type RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
+
+export const createRelationBetweenObjects = async <
+  T extends FieldMetadataType.RELATION | FieldMetadataType.MORPH_RELATION,
+>({
+  objectMetadataId,
+  targetObjectMetadataId,
+  type,
+  relationType,
+  name,
+  label,
+  isLabelSyncedWithName,
+  targetFieldLabel,
+  targetFieldIcon,
+}: {
+  objectMetadataId: string;
+  targetObjectMetadataId: string;
+  type: T;
+  relationType: RelationType;
+  name?: string;
+  label?: string;
+  isLabelSyncedWithName?: boolean;
+  targetFieldLabel?: string;
+  targetFieldIcon?: string;
+}) => {
+  const createFieldInput: CreateOneFieldFactoryInput = {
+    name: name || 'person',
+    label: label || 'person field',
+    type: type,
+    objectMetadataId: objectMetadataId,
+    isLabelSyncedWithName: isLabelSyncedWithName || false,
+    relationCreationPayload: {
+      targetObjectMetadataId: targetObjectMetadataId,
+      targetFieldLabel: targetFieldLabel || 'opportunity',
+      targetFieldIcon: targetFieldIcon || 'IconListOpportunity',
+      type: relationType,
+    },
+  };
+
+  const { data } = await createOneFieldMetadata<typeof type>({
+    input: createFieldInput,
+    gqlFields: `
+            id
+            name
+            label
+            isLabelSyncedWithName
+            settings
+            relation {
+              type
+              sourceObjectMetadata {
+                id
+                nameSingular
+                namePlural
+              }
+              targetObjectMetadata {
+                id
+                nameSingular
+                namePlural
+              }
+              sourceFieldMetadata {
+                id
+                name
+              }
+              targetFieldMetadata {
+                id
+                name
+              }
+            }
+            object {
+              id
+              nameSingular
+            }
+          `,
+    expectToFail: false,
+  });
+
+  return data.createOneField as unknown as FieldMetadataDTO<T> & {
+    relation: RelationDTO;
+  };
+};

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/delete-one-object-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 DeleteOneObjectFactoryInput = {
+  idToDelete: string;
+};
+
+export const deleteOneObjectMetadataQueryFactory = ({
+  input,
+  gqlFields = 'id',
+}: PerformMetadataQueryParams<DeleteOneObjectFactoryInput>) => ({
+  query: gql`
+        mutation DeleteOneObjectMetadataItem($idToDelete: UUID!) {
+          deleteOneObject(input: { id: $idToDelete }) {
+            ${gqlFields}
+        }
+      }
+      `,
+  variables: {
+    idToDelete: input.idToDelete,
+  },
+});

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

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

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/find-many-object-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 FindManyObjectMetadataFactoryInput = {
+  filter: object;
+  paging: object;
+};
+
+export const findManyObjectMetadataQueryFactory = ({
+  gqlFields = 'id',
+  input,
+}: PerformMetadataQueryParams<FindManyObjectMetadataFactoryInput>) => ({
+  query: gql`
+      query ObjectsMetadata($filter: ObjectFilter!, $paging: CursorPaging!) {
+        objects(filter: $filter, paging: $paging) {
+          edges {
+            node {
+              ${gqlFields}
+            }
+          }
+        }
+      }
+    `,
+  variables: {
+    filter: input.filter,
+    paging: input.paging,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata-with-indexes.util.ts

@@ -0,0 +1,83 @@
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+
+import { type FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
+import { type RelationDTO } from 'src/engine/metadata-modules/field-metadata/dtos/relation.dto';
+import { type IndexFieldMetadataDTO } from 'src/engine/metadata-modules/index-metadata/dtos/index-field-metadata.dto';
+import { type IndexMetadataDTO } from 'src/engine/metadata-modules/index-metadata/dtos/index-metadata.dto';
+import { type ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
+
+export const findManyObjectMetadataWithIndexes = async ({
+  expectToFail,
+}: {
+  expectToFail: boolean;
+}) => {
+  const { objects } = await findManyObjectMetadata({
+    expectToFail,
+    input: {
+      filter: {},
+      paging: {
+        first: 100,
+      },
+    },
+    gqlFields: `
+        id
+        nameSingular
+        universalIdentifier
+        fieldsList {
+          id
+          type
+          name
+          applicationId
+          description
+          icon
+          label
+          universalIdentifier
+          relation {
+            type
+            sourceObjectMetadata {
+              id
+              nameSingular
+              namePlural
+            }
+            targetObjectMetadata {
+              id
+              nameSingular
+              namePlural
+            }
+            sourceFieldMetadata {
+              id
+              name
+            }
+            targetFieldMetadata {
+              id
+              name
+            }
+          }
+        }
+        indexMetadataList {
+          name
+          isUnique
+          isCustom
+          indexType
+          indexFieldMetadataList {
+            id
+            fieldMetadataId
+            createdAt
+            updatedAt
+            order
+          }
+        }
+      `,
+  });
+
+  return objects as Array<
+    ObjectMetadataDTO & {
+      fieldsList: (FieldMetadataDTO & { relation: RelationDTO | null })[];
+      indexMetadataList: Array<
+        IndexMetadataDTO & {
+          indexFieldMetadataList: IndexFieldMetadataDTO[];
+        }
+      >;
+    }
+  >;
+};

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

@@ -0,0 +1,49 @@
+import {
+  type FindManyObjectMetadataFactoryInput,
+  findManyObjectMetadataQueryFactory,
+} from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-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';
+
+import { type BaseGraphQLError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
+import { type FieldMetadataDTO } from 'src/engine/metadata-modules/field-metadata/dtos/field-metadata.dto';
+import { type ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
+
+export const findManyObjectMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<FindManyObjectMetadataFactoryInput>): Promise<{
+  errors: BaseGraphQLError[];
+  objects: (ObjectMetadataDTO & { fieldsList?: FieldMetadataDTO[] })[];
+}> => {
+  const graphqlOperation = findManyObjectMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Object Metadata retrieval should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'Object Metadata retrieval has failed but should not',
+    });
+  }
+
+  return {
+    errors: response.body.errors,
+    objects: response.body.data.objects?.edges.map(
+      ({ node }: { node: unknown }) => node,
+    ),
+  };
+};

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/find-one-object-metadata-with-search-field-metadata-list.util.ts

@@ -0,0 +1,34 @@
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+
+import { type ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
+import { type SearchFieldMetadataDTO } from 'src/engine/metadata-modules/search-field-metadata/dtos/search-field-metadata.dto';
+
+export const findOneObjectMetadataWithSearchFieldMetadataList = async ({
+  objectMetadataId,
+}: {
+  objectMetadataId: string;
+}) => {
+  const { objects } = await findManyObjectMetadata({
+    expectToFail: false,
+    input: {
+      filter: { id: { eq: objectMetadataId } },
+      paging: { first: 1 },
+    },
+    gqlFields: `
+      id
+      labelIdentifierFieldMetadataId
+      searchFieldMetadataList {
+        id
+        fieldMetadataId
+        position
+      }
+    `,
+  });
+
+  return objects[0] as ObjectMetadataDTO & {
+    searchFieldMetadataList: Pick<
+      SearchFieldMetadataDTO,
+      'id' | 'fieldMetadataId' | 'position'
+    >[];
+  };
+};

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/generate-mock-create-object-metadata-input.ts

@@ -0,0 +1,15 @@
+import { type CreateObjectInput } from 'src/engine/metadata-modules/object-metadata/dtos/create-object.input';
+
+// TODO would tend to use faker
+export const getMockCreateObjectInput = (
+  overrides?: Partial<Omit<CreateObjectInput, 'workspaceId' | 'dataSourceId'>>,
+) => ({
+  namePlural: 'listingas',
+  nameSingular: 'listinga',
+  labelPlural: 'Listings',
+  labelSingular: 'Listing',
+  description: 'Listing object',
+  icon: 'IconListNumbers',
+  isLabelSyncedWithName: false,
+  ...overrides,
+});

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/set-object-readability.util.ts

@@ -0,0 +1,23 @@
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';
+import { type MetadataReadability } from 'twenty-shared/types';
+
+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+// Written straight to the table and pushed into the caches: the metadata API
+// refuses most levels, and an update through it would leave an override behind
+export const setObjectReadability = async (
+  objectMetadataId: string,
+  readability: MetadataReadability,
+) => {
+  await getCoreRepository<ObjectMetadataEntity>(ObjectMetadataEntity).update(
+    objectMetadataId,
+    { readability },
+  );
+
+  await getAppProviderByClassName<WorkspaceCacheService>(
+    'WorkspaceCacheService',
+  ).invalidateAndRecompute(SEED_APPLE_WORKSPACE_ID, ['flatObjectMetadataMaps']);
+};

packages/twenty-server/test/integration/metadata/suites/object-metadata/utils/update-one-object-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 UpdateObjectPayload } from 'src/engine/metadata-modules/object-metadata/dtos/update-object.input';
+
+export type UpdateOneObjectFactoryInput = {
+  idToUpdate: string;
+  updatePayload: UpdateObjectPayload;
+};
+
+export const updateOneObjectMetadataQueryFactory = ({
+  gqlFields = 'id',
+  input,
+}: PerformMetadataQueryParams<UpdateOneObjectFactoryInput>) => ({
+  query: gql`
+        mutation UpdateOneObjectMetadataItem($idToUpdate: UUID!, $updatePayload: UpdateObjectPayload!) {
+            updateOneObject(input: {id: $idToUpdate, update: $updatePayload}) {
+            ${gqlFields}
+        }
+      }
+      `,
+  variables: {
+    idToUpdate: input.idToUpdate,
+    updatePayload: input.updatePayload,
+  },
+});

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

@@ -0,0 +1,42 @@
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import {
+  type UpdateOneObjectFactoryInput,
+  updateOneObjectMetadataQueryFactory,
+} from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata-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 ObjectMetadataDTO } from 'src/engine/metadata-modules/object-metadata/dtos/object-metadata.dto';
+
+export const updateOneObjectMetadata = async ({
+  input,
+  gqlFields,
+  expectToFail,
+}: PerformMetadataQueryParams<UpdateOneObjectFactoryInput>): CommonResponseBody<{
+  updateOneObject: ObjectMetadataDTO;
+}> => {
+  const graphqlOperation = updateOneObjectMetadataQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Object Metadata update should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'Object Metadata update has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};