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

packages/twenty-server/test/integration/metadata/suites/minimal-metadata/minimal-metadata-i18n.integration-spec.ts

@@ -0,0 +1,109 @@
+import request from 'supertest';
+
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+const client = request(`http://localhost:${APP_PORT}`);
+
+const minimalMetadataQuery = {
+  query: `
+    query MinimalMetadataI18n {
+      minimalMetadata {
+        objectMetadataItems {
+          nameSingular
+          labelSingular
+          labelPlural
+        }
+      }
+    }
+  `,
+};
+
+type MinimalObjectItem = {
+  nameSingular: string;
+  labelSingular: string;
+  labelPlural: string;
+};
+
+const updateWorkspaceMemberLocale = async (locale: string) => {
+  const response = await client
+    .post('/metadata')
+    .set('Authorization', `Bearer ${APPLE_JANE_ADMIN_ACCESS_TOKEN}`)
+    .send({
+      query: `
+        mutation UpdateWorkspaceMemberSettings(
+          $input: UpdateWorkspaceMemberSettingsInput!
+        ) {
+          updateWorkspaceMemberSettings(input: $input)
+        }
+      `,
+      variables: {
+        input: {
+          workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JANE,
+          update: { locale },
+        },
+      },
+    });
+
+  expect(response.body.errors).toBeUndefined();
+  expect(response.body.data.updateWorkspaceMemberSettings).toBe(true);
+};
+
+const queryMinimalMetadata = () =>
+  client
+    .post('/metadata')
+    .set('Authorization', `Bearer ${APPLE_JANE_ADMIN_ACCESS_TOKEN}`)
+    .send(minimalMetadataQuery);
+
+const findObjectByName = (
+  items: MinimalObjectItem[],
+  nameSingular: string,
+): MinimalObjectItem | undefined =>
+  items.find((item) => item.nameSingular === nameSingular);
+
+describe('minimalMetadata i18n', () => {
+  afterAll(async () => {
+    await updateWorkspaceMemberLocale('en');
+  });
+
+  it('should return English labels when user locale is en', async () => {
+    await updateWorkspaceMemberLocale('en');
+
+    const response = await queryMinimalMetadata();
+
+    expect(response.body.data).toBeDefined();
+    expect(response.body.errors).toBeUndefined();
+
+    const { objectMetadataItems } = response.body.data.minimalMetadata;
+    const company = findObjectByName(objectMetadataItems, 'company');
+
+    expect(company).toBeDefined();
+    expect(company!.labelSingular).toBe('Company');
+    expect(company!.labelPlural).toBe('Companies');
+  });
+
+  it('should return French labels when user locale is fr-FR', async () => {
+    await updateWorkspaceMemberLocale('fr-FR');
+
+    const response = await queryMinimalMetadata();
+
+    expect(response.body.data).toBeDefined();
+    expect(response.body.errors).toBeUndefined();
+
+    const { objectMetadataItems } = response.body.data.minimalMetadata;
+    const company = findObjectByName(objectMetadataItems, 'company');
+    const person = findObjectByName(objectMetadataItems, 'person');
+    const opportunity = findObjectByName(objectMetadataItems, 'opportunity');
+
+    expect(company).toBeDefined();
+    expect(company!.labelSingular).toBe('Entreprise');
+    expect(company!.labelPlural).toBe('Entreprises');
+
+    expect(person).toBeDefined();
+    expect(person!.labelSingular).toBe('Personne');
+    expect(person!.labelPlural).toBe('Personnes');
+
+    expect(opportunity).toBeDefined();
+    expect(opportunity!.labelSingular).toBe('Opportunité');
+    expect(opportunity!.labelPlural).toBe('Opportunités');
+  });
+});

packages/twenty-server/test/integration/metadata/suites/minimal-metadata/minimal-metadata.integration-spec.ts

@@ -0,0 +1,131 @@
+import gql from 'graphql-tag';
+import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+
+const FIND_MINIMAL_METADATA_QUERY = gql`
+  query FindMinimalMetadata {
+    minimalMetadata {
+      objectMetadataItems {
+        id
+        nameSingular
+        namePlural
+        labelSingular
+        labelPlural
+        icon
+        isActive
+        isSystem
+        isRemote
+      }
+      views {
+        id
+        type
+        key
+        objectMetadataId
+      }
+      collectionHashes {
+        collectionName
+        hash
+      }
+    }
+  }
+`;
+
+describe('minimalMetadata', () => {
+  it('should return objectMetadataItems, views, and collectionHashes', async () => {
+    const response = await makeMetadataAPIRequest({
+      query: FIND_MINIMAL_METADATA_QUERY,
+    });
+
+    expect(response.body.errors).toBeUndefined();
+
+    const { minimalMetadata } = response.body.data;
+
+    expect(minimalMetadata).toBeDefined();
+    expect(Array.isArray(minimalMetadata.objectMetadataItems)).toBe(true);
+    expect(Array.isArray(minimalMetadata.views)).toBe(true);
+    expect(Array.isArray(minimalMetadata.collectionHashes)).toBe(true);
+  });
+
+  it('should return properly shaped objectMetadataItems', async () => {
+    const response = await makeMetadataAPIRequest({
+      query: FIND_MINIMAL_METADATA_QUERY,
+    });
+
+    const { objectMetadataItems } = response.body.data.minimalMetadata;
+
+    expect(objectMetadataItems.length).toBeGreaterThan(0);
+
+    for (const item of objectMetadataItems) {
+      expect(item).toMatchObject({
+        id: expect.any(String),
+        nameSingular: expect.any(String),
+        namePlural: expect.any(String),
+        labelSingular: expect.any(String),
+        labelPlural: expect.any(String),
+        isActive: true,
+        isSystem: expect.any(Boolean),
+        isRemote: expect.any(Boolean),
+      });
+    }
+  });
+
+  it('should return properly shaped views', async () => {
+    const response = await makeMetadataAPIRequest({
+      query: FIND_MINIMAL_METADATA_QUERY,
+    });
+
+    const { views } = response.body.data.minimalMetadata;
+
+    expect(views.length).toBeGreaterThan(0);
+
+    for (const view of views) {
+      expect(view).toMatchObject({
+        id: expect.any(String),
+        type: expect.any(String),
+        objectMetadataId: expect.any(String),
+      });
+    }
+  });
+
+  it('should return properly shaped collectionHashes', async () => {
+    const response = await makeMetadataAPIRequest({
+      query: FIND_MINIMAL_METADATA_QUERY,
+    });
+
+    const { collectionHashes } = response.body.data.minimalMetadata;
+
+    expect(collectionHashes.length).toBeGreaterThan(0);
+
+    for (const collectionHash of collectionHashes) {
+      expect(collectionHash).toMatchObject({
+        collectionName: expect.any(String),
+        hash: expect.any(String),
+      });
+    }
+  });
+
+  it('should include well-known standard objects', async () => {
+    const response = await makeMetadataAPIRequest({
+      query: FIND_MINIMAL_METADATA_QUERY,
+    });
+
+    const { objectMetadataItems } = response.body.data.minimalMetadata;
+
+    const objectNames = objectMetadataItems.map(
+      (item: { namePlural: string }) => item.namePlural,
+    );
+
+    expect(objectNames).toContain('people');
+    expect(objectNames).toContain('companies');
+    expect(objectNames).toContain('opportunities');
+  });
+
+  it('should reject requests with an invalid token', async () => {
+    const response = await makeMetadataAPIRequest(
+      { query: FIND_MINIMAL_METADATA_QUERY },
+      INVALID_ACCESS_TOKEN,
+    );
+
+    expect(response.body.errors).toBeDefined();
+    expect(response.body.errors.length).toBeGreaterThan(0);
+  });
+});