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

packages/twenty-server/test/integration/rest/utils/make-rest-api-request.util.ts

@@ -0,0 +1,30 @@
+import request from 'supertest';
+
+export type RestAPIRequestMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+
+interface RestAPIRequestParams {
+  method: RestAPIRequestMethod;
+  path: string;
+  bearer?: string;
+  body?: any;
+}
+
+export const makeRestAPIRequest = ({
+  method,
+  path,
+  bearer = API_KEY_ACCESS_TOKEN,
+  body = {},
+}: RestAPIRequestParams) => {
+  const client = request(`http://localhost:${APP_PORT}`);
+
+  const req = client[method](`/rest${path}`).set(
+    'Authorization',
+    `Bearer ${bearer}`,
+  );
+
+  if (['post', 'patch', 'put'].includes(method)) {
+    req.set('Content-Type', 'application/json').send(JSON.stringify(body));
+  }
+
+  return req;
+};

packages/twenty-server/test/integration/rest/utils/metadata-rest-api.util.ts

@@ -0,0 +1,150 @@
+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 { 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 { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+export const NON_EXISTENT_UUID = '00000000-0000-4000-8000-000000000000';
+
+export const uniqueSuffix = (): string =>
+  Math.random().toString(36).slice(2, 10);
+
+export type CreateTestObjectInput = {
+  nameSingular: string;
+  namePlural: string;
+  labelSingular: string;
+  labelPlural: string;
+  icon: string;
+  isLabelSyncedWithName: boolean;
+};
+
+export const buildUniqueObjectInput = (): CreateTestObjectInput => {
+  const suffix = uniqueSuffix();
+
+  return {
+    nameSingular: `restTest${suffix}`,
+    namePlural: `restTest${suffix}s`,
+    labelSingular: `Rest Test ${suffix}`,
+    labelPlural: `Rest Tests ${suffix}`,
+    icon: 'IconTestPipe',
+    isLabelSyncedWithName: false,
+  };
+};
+
+export const createTestObjectViaGraphql = async (
+  overrides?: Partial<CreateTestObjectInput>,
+): Promise<{ id: string; input: CreateTestObjectInput }> => {
+  const input = { ...buildUniqueObjectInput(), ...overrides };
+  const { data, errors } = await createOneObjectMetadata({ input });
+
+  if (!data?.createOneObject?.id) {
+    throw new Error(
+      `Failed to create test object: ${JSON.stringify(errors ?? data)}`,
+    );
+  }
+
+  return { id: data.createOneObject.id, input };
+};
+
+export const cleanupTestObject = async (id: string): Promise<void> => {
+  try {
+    await updateOneObjectMetadata({
+      expectToFail: false,
+      input: { idToUpdate: id, updatePayload: { isActive: false } },
+    });
+    await deleteOneObjectMetadata({
+      input: { idToDelete: id },
+      expectToFail: false,
+    });
+  } catch {}
+};
+
+export type CreateTestFieldInput = {
+  objectMetadataId: string;
+  type: FieldMetadataType;
+  name: string;
+  label: string;
+  isLabelSyncedWithName: boolean;
+};
+
+export const buildUniqueFieldInput = (
+  objectMetadataId: string,
+): CreateTestFieldInput => {
+  const suffix = uniqueSuffix();
+
+  return {
+    objectMetadataId,
+    type: FieldMetadataType.TEXT,
+    name: `restTestField${suffix}`,
+    label: `Rest Test Field ${suffix}`,
+    isLabelSyncedWithName: false,
+  };
+};
+
+export const createTestFieldViaGraphql = async (
+  objectMetadataId: string,
+  overrides?: Partial<CreateTestFieldInput>,
+): Promise<{ id: string; input: CreateTestFieldInput }> => {
+  const input = { ...buildUniqueFieldInput(objectMetadataId), ...overrides };
+  const { data, errors } = await createOneFieldMetadata({ input });
+
+  if (!data?.createOneField?.id) {
+    throw new Error(
+      `Failed to create test field: ${JSON.stringify(errors ?? data)}`,
+    );
+  }
+
+  return { id: data.createOneField.id, input };
+};
+
+export const cleanupTestField = async (id: string): Promise<void> => {
+  try {
+    await deleteOneFieldMetadata({
+      input: { idToDelete: id },
+      expectToFail: false,
+    });
+  } catch {
+    // best-effort cleanup
+  }
+};
+
+export type MetadataListPageInfo = {
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+  startCursor: string | null;
+  endCursor: string | null;
+};
+
+export const extractMetadataListPayload = <T>(
+  body: Record<string, unknown>,
+  pluralKey: 'objects' | 'fields',
+): { items: T[]; pageInfo: MetadataListPageInfo; totalCount: number } => {
+  if (Array.isArray(body.data)) {
+    return {
+      items: body.data as T[],
+      pageInfo: body.pageInfo as MetadataListPageInfo,
+      totalCount: body.totalCount as number,
+    };
+  }
+  const data = body.data as Record<string, unknown>;
+
+  return {
+    items: (data[pluralKey] ?? []) as T[],
+    pageInfo: body.pageInfo as MetadataListPageInfo,
+    totalCount: body.totalCount as number,
+  };
+};
+
+export const extractMetadataItemPayload = <T>(
+  body: Record<string, unknown>,
+  legacyKey: string,
+): T => {
+  const data = body.data as Record<string, unknown> | undefined;
+
+  if (data && legacyKey in data) {
+    return data[legacyKey] as T;
+  }
+
+  return body as T;
+};

packages/twenty-server/test/integration/rest/utils/rest-test-assertions.util.ts

@@ -0,0 +1,78 @@
+export interface RestResponse<T = Record<string, unknown>> {
+  status: number;
+  body: T & {
+    error?: string;
+    errors?: string[] | Record<string, unknown>[];
+    message?: string;
+  };
+}
+
+export const assertRestApiSuccessfulResponse = <T = Record<string, unknown>>(
+  response: RestResponse<T>,
+  expectedStatus = 200,
+) => {
+  if (response.status !== expectedStatus) {
+    throw new Error(
+      `Expected status ${expectedStatus}, received ${response.status}: ${JSON.stringify(response.body)}`,
+    );
+  }
+
+  expect(response.status).toBe(expectedStatus);
+  expect(response.body).toBeDefined();
+
+  if (response.body.error || response.body.errors) {
+    throw new Error(
+      `Expected successful response but got errors: ${JSON.stringify(response.body)}`,
+    );
+  }
+};
+
+export const assertMetadataRestListResponse = <T>(
+  response: RestResponse<{
+    data: T[];
+    pageInfo: {
+      hasNextPage: boolean;
+      hasPreviousPage: boolean;
+      startCursor: string | null;
+      endCursor: string | null;
+    };
+    totalCount: number;
+  }>,
+): T[] => {
+  assertRestApiSuccessfulResponse(response);
+  expect(Array.isArray(response.body.data)).toBe(true);
+  expect(response.body.pageInfo).toEqual({
+    hasNextPage: expect.any(Boolean),
+    hasPreviousPage: expect.any(Boolean),
+    startCursor: response.body.data.length > 0 ? expect.any(String) : null,
+    endCursor: response.body.data.length > 0 ? expect.any(String) : null,
+  });
+  expect(response.body.totalCount).toEqual(expect.any(Number));
+
+  return response.body.data;
+};
+
+export const assertRestApiErrorResponse = <T = Record<string, unknown>>(
+  response: RestResponse<T>,
+  expectedStatus = 400,
+  expectedErrorMessage?: string,
+) => {
+  expect(response.status).toBe(expectedStatus);
+
+  if (expectedErrorMessage && response.body.message) {
+    expect(response.body.message).toContain(expectedErrorMessage);
+  }
+};
+
+export const assertRestApiErrorNotFoundResponse = (
+  response: RestResponse<{ statusCode: number; messages: [] }>,
+  expectedStatus = 404,
+  expectedErrorMessage?: string,
+) => {
+  expect(response.status).toBe(expectedStatus);
+  expect(response.body.statusCode).toBe(expectedStatus);
+
+  if (expectedErrorMessage && response.body.message) {
+    expect(response.body.message).toContain(expectedErrorMessage);
+  }
+};

packages/twenty-server/test/integration/rest/utils/view-rest-api.util.ts

@@ -0,0 +1,294 @@
+import { makeRestAPIRequest } from 'test/integration/rest/utils/make-rest-api-request.util';
+import { generateRecordName } from 'test/integration/utils/generate-record-name';
+import {
+  ViewOpenRecordIn,
+  ViewType,
+  ViewVisibility,
+} from 'twenty-shared/types';
+
+import { type ViewFieldEntity } from 'src/engine/metadata-modules/view-field/entities/view-field.entity';
+import { type ViewFilterGroupEntity } from 'src/engine/metadata-modules/view-filter-group/entities/view-filter-group.entity';
+import { type ViewFilterEntity } from 'src/engine/metadata-modules/view-filter/entities/view-filter.entity';
+import { type ViewGroupEntity } from 'src/engine/metadata-modules/view-group/entities/view-group.entity';
+import { type ViewSortEntity } from 'src/engine/metadata-modules/view-sort/entities/view-sort.entity';
+import { type ViewEntity } from 'src/engine/metadata-modules/view/entities/view.entity';
+
+export const findViewByIdWithRestApi = async (
+  viewId: string,
+): Promise<ViewEntity | null> => {
+  const response = await makeRestAPIRequest({
+    method: 'get',
+    path: `/metadata/views/${viewId}`,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  });
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  return response.body;
+};
+
+export const findViewFilterWithRestApi = async (
+  viewFilterId: string,
+): Promise<ViewFilterEntity | null> => {
+  const response = await makeRestAPIRequest({
+    method: 'get',
+    path: `/metadata/viewFilters/${viewFilterId}`,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  });
+
+  if (response.status === 404) {
+    return null;
+  }
+
+  return response.body;
+};
+
+export const createTestViewWithRestApi = async (
+  params: {
+    objectMetadataId: string;
+  } & Partial<Omit<ViewEntity, 'objectMetadataId'>>,
+): Promise<ViewEntity> => {
+  const { objectMetadataId, name, ...restParams } = params;
+  const viewData = {
+    name: name || generateRecordName('Test View'),
+    objectMetadataId,
+    icon: 'IconTable',
+    type: ViewType.TABLE,
+    key: null,
+    position: 0,
+    isCompact: false,
+    openRecordIn: ViewOpenRecordIn.SIDE_PANEL,
+    visibility: ViewVisibility.WORKSPACE,
+    ...restParams,
+  };
+
+  const response = await makeRestAPIRequest({
+    method: 'post',
+    path: '/metadata/views',
+    body: viewData,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  });
+
+  if (response.status !== 201) {
+    throw new Error(
+      `Failed to create test view: ${response.status} - ${JSON.stringify(response.body)}`,
+    );
+  }
+
+  return response.body;
+};
+
+export const createTestViewFieldWithRestApi = async (
+  params: {
+    viewId: string;
+    fieldMetadataId: string;
+  } & Partial<Omit<ViewFieldEntity, 'viewId' | 'fieldMetadataId'>>,
+): Promise<ViewFieldEntity> => {
+  const { viewId, fieldMetadataId, ...restParams } = params;
+  const viewFieldData = {
+    viewId,
+    fieldMetadataId,
+    position: 0,
+    isVisible: true,
+    size: 150,
+    ...restParams,
+  };
+
+  const response = await makeRestAPIRequest({
+    method: 'post',
+    path: '/metadata/viewFields',
+    body: viewFieldData,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  });
+
+  if (response.status !== 201) {
+    throw new Error(
+      `Failed to create test view field: ${response.status} - ${JSON.stringify(response.body)}`,
+    );
+  }
+
+  return response.body;
+};
+
+export const createTestViewFilterWithRestApi = async (
+  params: {
+    viewId: string;
+    fieldMetadataId: string;
+  } & Partial<Omit<ViewFilterEntity, 'viewId' | 'fieldMetadataId'>>,
+): Promise<ViewFilterEntity> => {
+  const { viewId, fieldMetadataId, operand, value, ...restParams } = params;
+  const viewFilterData = {
+    viewId,
+    fieldMetadataId,
+    operand: operand || 'Is',
+    value: value || 'test-value',
+    ...restParams,
+  };
+
+  const response = await makeRestAPIRequest({
+    method: 'post',
+    path: '/metadata/viewFilters',
+    body: viewFilterData,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  });
+
+  if (response.status !== 201) {
+    throw new Error(
+      `Failed to create test view filter: ${response.status} - ${JSON.stringify(response.body)}`,
+    );
+  }
+
+  return response.body;
+};
+
+export const createTestViewSortWithRestApi = async (
+  params: {
+    viewId: string;
+    fieldMetadataId: string;
+  } & Partial<Omit<ViewSortEntity, 'viewId' | 'fieldMetadataId'>>,
+): Promise<ViewSortEntity> => {
+  const { viewId, fieldMetadataId, direction, ...restParams } = params;
+  const viewSortData = {
+    viewId,
+    fieldMetadataId,
+    direction: direction || 'ASC',
+    ...restParams,
+  };
+
+  const response = await makeRestAPIRequest({
+    method: 'post',
+    path: '/metadata/viewSorts',
+    body: viewSortData,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  });
+
+  if (response.status !== 201) {
+    throw new Error(
+      `Failed to create test view sort: ${response.status} - ${JSON.stringify(response.body)}`,
+    );
+  }
+
+  return response.body;
+};
+
+export const createTestViewGroupWithRestApi = async (
+  params: {
+    viewId: string;
+    fieldMetadataId: string;
+  } & Partial<Omit<ViewGroupEntity, 'viewId' | 'fieldMetadataId'>>,
+): Promise<ViewGroupEntity> => {
+  const { viewId, fieldMetadataId, fieldValue, ...restParams } = params;
+  const viewGroupData = {
+    viewId,
+    fieldMetadataId,
+    isVisible: true,
+    fieldValue: fieldValue || 'test-group-value',
+    position: 0,
+    ...restParams,
+  };
+
+  const response = await makeRestAPIRequest({
+    method: 'post',
+    path: '/metadata/viewGroups',
+    body: viewGroupData,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  });
+
+  if (response.status !== 201) {
+    throw new Error(
+      `Failed to create test view group: ${response.status} - ${JSON.stringify(response.body)}`,
+    );
+  }
+
+  return response.body;
+};
+
+export const createTestViewFilterGroupWithRestApi = async (
+  params: {
+    viewId: string;
+  } & Partial<Omit<ViewFilterGroupEntity, 'viewId'>>,
+): Promise<ViewFilterGroupEntity> => {
+  const { viewId, logicalOperator, ...restParams } = params;
+  const viewFilterGroupData = {
+    viewId,
+    logicalOperator: logicalOperator || 'AND',
+    ...restParams,
+  };
+
+  const response = await makeRestAPIRequest({
+    method: 'post',
+    path: '/metadata/viewFilterGroups',
+    body: viewFilterGroupData,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  });
+
+  if (response.status !== 201) {
+    throw new Error(
+      `Failed to create test view filter group: ${response.status} - ${JSON.stringify(response.body)}`,
+    );
+  }
+
+  return response.body;
+};
+
+export const deleteTestViewWithRestApi = async (
+  viewId: string,
+): Promise<void> => {
+  await makeRestAPIRequest({
+    method: 'delete',
+    path: `/metadata/views/${viewId}`,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  }).catch(() => {});
+};
+
+export const deleteTestViewFieldWithRestApi = async (
+  viewFieldId: string,
+): Promise<void> => {
+  await makeRestAPIRequest({
+    method: 'delete',
+    path: `/metadata/viewFields/${viewFieldId}`,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  }).catch(() => {});
+};
+
+export const deleteTestViewFilterWithRestApi = async (
+  viewFilterId: string,
+): Promise<void> => {
+  await makeRestAPIRequest({
+    method: 'delete',
+    path: `/metadata/viewFilters/${viewFilterId}`,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  }).catch(() => {});
+};
+
+export const deleteTestViewSortWithRestApi = async (
+  viewSortId: string,
+): Promise<void> => {
+  await makeRestAPIRequest({
+    method: 'delete',
+    path: `/metadata/viewSorts/${viewSortId}`,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  }).catch(() => {});
+};
+
+export const deleteTestViewGroupWithRestApi = async (
+  viewGroupId: string,
+): Promise<void> => {
+  await makeRestAPIRequest({
+    method: 'delete',
+    path: `/metadata/viewGroups/${viewGroupId}`,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  }).catch(() => {});
+};
+
+export const deleteTestViewFilterGroupWithRestApi = async (
+  viewFilterGroupId: string,
+): Promise<void> => {
+  await makeRestAPIRequest({
+    method: 'delete',
+    path: `/metadata/viewFilterGroups/${viewFilterGroupId}`,
+    bearer: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+  }).catch(() => {});
+};