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

packages/twenty-server/test/integration/graphql/suites/workspace/custom-application-translation.integration-spec.ts

@@ -0,0 +1,207 @@
+import { randomUUID } from 'crypto';
+
+import request from 'supertest';
+import { activateWorkspace } from 'test/integration/graphql/utils/activate-workspace.util';
+import { deleteUser } from 'test/integration/graphql/utils/delete-user.util';
+import { getAuthTokensFromLoginToken } from 'test/integration/graphql/utils/get-auth-tokens-from-login-token.util';
+import { getCurrentUser } from 'test/integration/graphql/utils/get-current-user.util';
+import { signUpInNewWorkspace } from 'test/integration/graphql/utils/sign-up-in-new-workspace.util';
+import { signUp } from 'test/integration/graphql/utils/sign-up.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+import { SOURCE_LOCALE } from 'twenty-shared/translations';
+import { isDefined } from 'twenty-shared/utils';
+
+import { generateMessageId } from 'twenty-shared/i18n';
+
+const client = request(`http://localhost:${APP_PORT}`);
+
+const SOURCE_LABEL_SINGULAR = 'My Robot';
+const SOURCE_LABEL_PLURAL = 'My Robots';
+const SOURCE_DESCRIPTION = 'A friendly robot';
+
+const TRANSLATED_LABEL_SINGULAR = 'Translated Robot';
+const TRANSLATED_LABEL_PLURAL = 'Translated Robots';
+const TRANSLATED_DESCRIPTION = 'Translated robot description';
+
+const CONTROL_LABEL_SINGULAR = 'My Gadget';
+const CONTROL_LABEL_PLURAL = 'My Gadgets';
+
+type ObjectNode = {
+  nameSingular: string;
+  labelSingular: string;
+  labelPlural: string;
+  description: string;
+};
+
+const queryObjects = (accessToken: string) =>
+  client
+    .post('/metadata')
+    .set('Authorization', `Bearer ${accessToken}`)
+    .send({
+      query: `
+        query CustomObjectsI18n {
+          objects(paging: { first: 200 }) {
+            edges {
+              node {
+                nameSingular
+                labelSingular
+                labelPlural
+                description
+              }
+            }
+          }
+        }
+      `,
+    });
+
+const findObjectByName = (
+  edges: Array<{ node: ObjectNode }>,
+  nameSingular: string,
+): ObjectNode | undefined =>
+  edges.find((edge) => edge.node.nameSingular === nameSingular)?.node;
+
+describe('custom application translation resolve path', () => {
+  let createdUserAccessToken: string | undefined;
+
+  afterEach(async () => {
+    if (!isDefined(createdUserAccessToken)) {
+      return;
+    }
+
+    await deleteUser({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+
+    createdUserAccessToken = undefined;
+  });
+
+  it('translates a custom object label from the application translation catalog, and falls back to the source label otherwise', async () => {
+    // A fresh workspace guarantees its Custom application registration has never
+    // had its translation catalog loaded, so the seeded row below is read
+    // straight from the database rather than from a warm (empty) cache.
+    const uniqueEmail = `test-custom-translation-${randomUUID()}@example.com`;
+
+    const { data: signUpData } = await signUp({
+      input: { email: uniqueEmail, password: 'Test123!@#' },
+      expectToFail: false,
+    });
+
+    createdUserAccessToken =
+      signUpData.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    await testDataSource.query(
+      'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+      [uniqueEmail],
+    );
+
+    const {
+      data: { signUpInNewWorkspace: signUpInNewWorkspaceData },
+    } = await signUpInNewWorkspace({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+
+    const {
+      data: { getAuthTokensFromLoginToken: authTokensData },
+    } = await getAuthTokensFromLoginToken({
+      origin: signUpInNewWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+      loginToken: signUpInNewWorkspaceData.loginToken.token,
+      expectToFail: false,
+    });
+
+    const workspaceAccessToken =
+      authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    await activateWorkspace({
+      accessToken: workspaceAccessToken,
+      expectToFail: false,
+    });
+
+    const {
+      data: { currentUser },
+    } = await getCurrentUser({
+      accessToken: workspaceAccessToken,
+      expectToFail: false,
+    });
+
+    jestExpectToBeDefined(currentUser.currentWorkspace);
+    const workspaceId = currentUser.currentWorkspace.id;
+    const workspaceCustomApplicationId =
+      currentUser.currentWorkspace.workspaceCustomApplicationId;
+
+    const [customApplicationRow] = await testDataSource.query(
+      `SELECT "applicationRegistrationId"
+         FROM core.application
+        WHERE id = $1 AND "workspaceId" = $2`,
+      [workspaceCustomApplicationId, workspaceId],
+    );
+
+    jestExpectToBeDefined(customApplicationRow);
+    const applicationRegistrationId =
+      customApplicationRow.applicationRegistrationId;
+
+    expect(applicationRegistrationId).toEqual(expect.any(String));
+
+    const messages = {
+      [generateMessageId(SOURCE_LABEL_SINGULAR, 'objectMetadata.labelSingular')]:
+        TRANSLATED_LABEL_SINGULAR,
+      [generateMessageId(SOURCE_LABEL_PLURAL, 'objectMetadata.labelPlural')]:
+        TRANSLATED_LABEL_PLURAL,
+      [generateMessageId(SOURCE_DESCRIPTION, 'objectMetadata.description')]:
+        TRANSLATED_DESCRIPTION,
+    };
+
+    await testDataSource.query(
+      `INSERT INTO core."applicationTranslation"
+         ("applicationRegistrationId", locale, messages)
+       VALUES ($1, $2, $3::jsonb)`,
+      [applicationRegistrationId, SOURCE_LOCALE, JSON.stringify(messages)],
+    );
+
+    await createOneObjectMetadata({
+      input: {
+        nameSingular: 'myRobot',
+        namePlural: 'myRobots',
+        labelSingular: SOURCE_LABEL_SINGULAR,
+        labelPlural: SOURCE_LABEL_PLURAL,
+        description: SOURCE_DESCRIPTION,
+        isLabelSyncedWithName: false,
+      },
+      token: workspaceAccessToken,
+      expectToFail: false,
+    });
+
+    await createOneObjectMetadata({
+      input: {
+        nameSingular: 'myGadget',
+        namePlural: 'myGadgets',
+        labelSingular: CONTROL_LABEL_SINGULAR,
+        labelPlural: CONTROL_LABEL_PLURAL,
+        isLabelSyncedWithName: false,
+      },
+      token: workspaceAccessToken,
+      expectToFail: false,
+    });
+
+    const response = await queryObjects(workspaceAccessToken);
+
+    expect(response.body.errors).toBeUndefined();
+
+    const edges = response.body.data.objects.edges;
+
+    const myRobot = findObjectByName(edges, 'myRobot');
+
+    jestExpectToBeDefined(myRobot);
+    expect(myRobot.labelSingular).toBe(TRANSLATED_LABEL_SINGULAR);
+    expect(myRobot.labelPlural).toBe(TRANSLATED_LABEL_PLURAL);
+    expect(myRobot.description).toBe(TRANSLATED_DESCRIPTION);
+
+    const myGadget = findObjectByName(edges, 'myGadget');
+
+    jestExpectToBeDefined(myGadget);
+    expect(myGadget.labelSingular).toBe(CONTROL_LABEL_SINGULAR);
+    expect(myGadget.labelPlural).toBe(CONTROL_LABEL_PLURAL);
+  });
+});

packages/twenty-server/test/integration/graphql/suites/workspace/successful-user-and-workspace-creation.integration-spec.ts

@@ -0,0 +1,464 @@
+import { randomUUID } from 'crypto';
+
+import { activateWorkspace } from 'test/integration/graphql/utils/activate-workspace.util';
+import { deleteUser } from 'test/integration/graphql/utils/delete-user.util';
+import { findManyApplications } from 'test/integration/graphql/utils/find-many-applications.util';
+import { getAuthTokensFromLoginToken } from 'test/integration/graphql/utils/get-auth-tokens-from-login-token.util';
+import { getCurrentUser } from 'test/integration/graphql/utils/get-current-user.util';
+import { getOnboardingStatus } from 'test/integration/graphql/utils/get-onboarding-status.util';
+import { signUpInNewWorkspace } from 'test/integration/graphql/utils/sign-up-in-new-workspace.util';
+import { skipSyncEmailOnboardingStep } from 'test/integration/graphql/utils/skip-sync-email-onboarding-step.util';
+import { signUp } from 'test/integration/graphql/utils/sign-up.util';
+import { createOneLogicFunction } from 'test/integration/metadata/suites/logic-function/utils/create-logic-function.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+import { isDefined } from 'twenty-shared/utils';
+import { WorkspaceActivationStatus } from 'twenty-shared/workspace';
+
+import { OnboardingStatus } from 'src/engine/core-modules/onboarding/enums/onboarding-status.enum';
+import { TWENTY_STANDARD_APPLICATION } from 'src/engine/workspace-manager/twenty-standard-application/constants/twenty-standard-applications';
+
+describe('Successful user and workspace creation', () => {
+  let createdUserAccessToken: string | undefined;
+
+  afterEach(async () => {
+    if (!isDefined(createdUserAccessToken)) {
+      return;
+    }
+
+    await deleteUser({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+  });
+
+  it('should sign up a new user and create a new workspace successfully', async () => {
+    const uniqueEmail = `test-${randomUUID()}@example.com`;
+
+    const { data } = await signUp({
+      input: {
+        email: uniqueEmail,
+        password: 'Test123!@#',
+      },
+
+      expectToFail: false,
+    });
+
+    createdUserAccessToken =
+      data.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    // Mark email as verified to bypass email verification requirement
+    await testDataSource.query(
+      'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+      [uniqueEmail],
+    );
+
+    const {
+      data: { signUpInNewWorkspace: signUpInNewWorkspaceData },
+    } = await signUpInNewWorkspace({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+
+    const {
+      data: { getAuthTokensFromLoginToken: authTokensData },
+    } = await getAuthTokensFromLoginToken({
+      origin: signUpInNewWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+      loginToken: signUpInNewWorkspaceData.loginToken.token,
+      expectToFail: false,
+    });
+
+    const newWorkspaceAccessToken =
+      authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    const {
+      data: { activateWorkspace: activateWorkspaceData },
+    } = await activateWorkspace({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    expect(activateWorkspaceData.activationStatus).toBe(
+      WorkspaceActivationStatus.ACTIVE,
+    );
+
+    const {
+      data: { currentUser: currentUserAfterActivation },
+    } = await getOnboardingStatus({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    expect(currentUserAfterActivation.onboardingStatus).toBe(
+      OnboardingStatus.SYNC_EMAIL,
+    );
+
+    await skipSyncEmailOnboardingStep({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    const {
+      data: { currentUser: currentUserAfterSyncEmailSkip },
+    } = await getOnboardingStatus({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    expect(currentUserAfterSyncEmailSkip.onboardingStatus).toBe(
+      OnboardingStatus.APPS_INSTALLATION,
+    );
+
+    const {
+      data: { currentUser },
+    } = await getCurrentUser({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    jestExpectToBeDefined(currentUser.currentWorkspace);
+    const { inviteHash: _, ...expectedCurrentWorkspace } =
+      activateWorkspaceData;
+
+    jestExpectToBeDefined(currentUser.currentWorkspace);
+    expect(currentUser.currentWorkspace).toMatchObject(
+      expectedCurrentWorkspace,
+    );
+
+    const {
+      data: { findManyApplications: findManyApplicationsData },
+    } = await findManyApplications({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    expect(findManyApplicationsData.length).toBe(2);
+    const twentyStandardApp = findManyApplicationsData.find(
+      (application) =>
+        application.universalIdentifier ===
+        TWENTY_STANDARD_APPLICATION.universalIdentifier,
+    );
+
+    jestExpectToBeDefined(twentyStandardApp);
+    const {
+      sourcePath: _sourcePath,
+      sourceType: _sourceType,
+      ...expectedStandardTwentyApplication
+    } = TWENTY_STANDARD_APPLICATION;
+
+    expect(twentyStandardApp).toMatchObject(expectedStandardTwentyApplication);
+
+    const workpsaceCustomApplication = findManyApplicationsData.find(
+      (application) =>
+        application.id ===
+        currentUser.currentWorkspace?.workspaceCustomApplicationId,
+    );
+
+    jestExpectToBeDefined(workpsaceCustomApplication);
+    expect(workpsaceCustomApplication.universalIdentifier).toEqual(
+      workpsaceCustomApplication.id,
+    );
+  });
+
+  it('should reclaim a stale ONGOING_CREATION workspace and activate it', async () => {
+    const uniqueEmail = `test-reclaim-${randomUUID()}@example.com`;
+
+    const { data } = await signUp({
+      input: {
+        email: uniqueEmail,
+        password: 'Test123!@#',
+      },
+      expectToFail: false,
+    });
+
+    createdUserAccessToken =
+      data.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    await testDataSource.query(
+      'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+      [uniqueEmail],
+    );
+
+    const {
+      data: { signUpInNewWorkspace: signUpInNewWorkspaceData },
+    } = await signUpInNewWorkspace({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+
+    const workspaceId = signUpInNewWorkspaceData.workspace.id;
+
+    const {
+      data: { getAuthTokensFromLoginToken: authTokensData },
+    } = await getAuthTokensFromLoginToken({
+      origin: signUpInNewWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+      loginToken: signUpInNewWorkspaceData.loginToken.token,
+      expectToFail: false,
+    });
+
+    const newWorkspaceAccessToken =
+      authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    // Simulate an activation attempt that was killed mid-flight: the workspace
+    // is stuck in ONGOING_CREATION with a stale updatedAt. A retry should
+    // reclaim the stale lock and finish activation.
+    await testDataSource.query(
+      `UPDATE core.workspace SET "activationStatus" = 'ONGOING_CREATION', "updatedAt" = now() - interval '10 minutes' WHERE id = $1`,
+      [workspaceId],
+    );
+
+    const {
+      data: { activateWorkspace: activateWorkspaceData },
+    } = await activateWorkspace({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    expect(activateWorkspaceData.activationStatus).toBe(
+      WorkspaceActivationStatus.ACTIVE,
+    );
+  });
+
+  it('should not reclaim a workspace whose activation is genuinely in progress', async () => {
+    const uniqueEmail = `test-fresh-ongoing-${randomUUID()}@example.com`;
+
+    const { data } = await signUp({
+      input: {
+        email: uniqueEmail,
+        password: 'Test123!@#',
+      },
+      expectToFail: false,
+    });
+
+    createdUserAccessToken =
+      data.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    await testDataSource.query(
+      'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+      [uniqueEmail],
+    );
+
+    const {
+      data: { signUpInNewWorkspace: signUpInNewWorkspaceData },
+    } = await signUpInNewWorkspace({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+
+    const workspaceId = signUpInNewWorkspaceData.workspace.id;
+
+    const {
+      data: { getAuthTokensFromLoginToken: authTokensData },
+    } = await getAuthTokensFromLoginToken({
+      origin: signUpInNewWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+      loginToken: signUpInNewWorkspaceData.loginToken.token,
+      expectToFail: false,
+    });
+
+    const newWorkspaceAccessToken =
+      authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    // A fresh ONGOING_CREATION lock means another activation is genuinely in
+    // progress, so a concurrent attempt must be rejected rather than reclaim it.
+    await testDataSource.query(
+      `UPDATE core.workspace SET "activationStatus" = 'ONGOING_CREATION', "updatedAt" = now() WHERE id = $1`,
+      [workspaceId],
+    );
+
+    const { errors } = await activateWorkspace({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: true,
+    });
+
+    expect(errors).toBeDefined();
+
+    // This workspace was never actually activated (no tenant schema/metadata),
+    // so the standard deleteUser teardown cannot operate on it. Skip the
+    // afterEach cleanup; the integration test database is reset per run.
+    createdUserAccessToken = undefined;
+  });
+
+  it('should be idempotent when re-activating an already-active workspace', async () => {
+    const uniqueEmail = `test-idempotent-${randomUUID()}@example.com`;
+
+    const { data } = await signUp({
+      input: {
+        email: uniqueEmail,
+        password: 'Test123!@#',
+      },
+      expectToFail: false,
+    });
+
+    createdUserAccessToken =
+      data.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    await testDataSource.query(
+      'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+      [uniqueEmail],
+    );
+
+    const {
+      data: { signUpInNewWorkspace: signUpInNewWorkspaceData },
+    } = await signUpInNewWorkspace({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+
+    const {
+      data: { getAuthTokensFromLoginToken: authTokensData },
+    } = await getAuthTokensFromLoginToken({
+      origin: signUpInNewWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+      loginToken: signUpInNewWorkspaceData.loginToken.token,
+      expectToFail: false,
+    });
+
+    const newWorkspaceAccessToken =
+      authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    await activateWorkspace({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    // A second activation (e.g. the client lost the first response and retried)
+    // must succeed idempotently instead of throwing "already being created".
+    const {
+      data: { activateWorkspace: secondActivation },
+    } = await activateWorkspace({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    expect(secondActivation.activationStatus).toBe(
+      WorkspaceActivationStatus.ACTIVE,
+    );
+  });
+
+  it('should suspend and soft-delete workspace when last user is deleted', async () => {
+    const uniqueEmail = `test-delete-${randomUUID()}@example.com`;
+
+    const { data } = await signUp({
+      input: {
+        email: uniqueEmail,
+        password: 'Test123!@#',
+      },
+      expectToFail: false,
+    });
+
+    createdUserAccessToken =
+      data.signUp.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    // Mark email as verified to bypass email verification requirement
+    await testDataSource.query(
+      'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+      [uniqueEmail],
+    );
+
+    const {
+      data: { signUpInNewWorkspace: signUpInNewWorkspaceData },
+    } = await signUpInNewWorkspace({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+
+    const workspaceId = signUpInNewWorkspaceData.workspace.id;
+
+    const {
+      data: { getAuthTokensFromLoginToken: authTokensData },
+    } = await getAuthTokensFromLoginToken({
+      origin: signUpInNewWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+      loginToken: signUpInNewWorkspaceData.loginToken.token,
+      expectToFail: false,
+    });
+
+    const newWorkspaceAccessToken =
+      authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+    await activateWorkspace({
+      accessToken: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    await createOneObjectMetadata({
+      input: {
+        nameSingular: 'workspaceEviction',
+        namePlural: 'workspaceEvictions',
+        labelPlural: 'whatevers',
+        labelSingular: 'whatever',
+        isLabelSyncedWithName: false,
+      },
+      token: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    await createOneLogicFunction({
+      input: {
+        name: 'test-function-for-deletion',
+        description: 'A test logic function for workspace deletion test',
+      },
+      token: newWorkspaceAccessToken,
+      expectToFail: false,
+    });
+
+    const workspaceBeforeDeletion = await testDataSource.query(
+      'SELECT * FROM core.workspace WHERE id = $1',
+      [workspaceId],
+    );
+
+    expect(workspaceBeforeDeletion).toHaveLength(1);
+
+    const tablesToVerify = [
+      'dataSource',
+      'objectMetadata',
+      'fieldMetadata',
+      'indexMetadata',
+      'searchFieldMetadata',
+      'role',
+      'roleTarget',
+      'objectPermission',
+      'fieldPermission',
+      'permissionFlag',
+      'rolePermissionFlag',
+      'logicFunction',
+      'agent',
+      'view',
+      'viewField',
+      'viewFilter',
+      'viewFilterGroup',
+      'viewGroup',
+      'viewSort',
+    ];
+
+    let totalRecordsBefore = 0;
+
+    for (const table of tablesToVerify) {
+      const result = await testDataSource.query(
+        `SELECT COUNT(*) as count FROM core."${table}" WHERE "workspaceId" = $1`,
+        [workspaceId],
+      );
+
+      totalRecordsBefore += parseInt(result[0].count);
+    }
+
+    expect(totalRecordsBefore).toBeGreaterThan(0);
+
+    await deleteUser({
+      accessToken: createdUserAccessToken,
+      expectToFail: false,
+    });
+
+    createdUserAccessToken = undefined;
+
+    const workspaceAfterDeletion = await testDataSource.query(
+      'SELECT * FROM core.workspace WHERE id = $1',
+      [workspaceId],
+    );
+
+    expect(workspaceAfterDeletion).toHaveLength(1);
+    expect(workspaceAfterDeletion[0].activationStatus).toBe(
+      WorkspaceActivationStatus.SUSPENDED,
+    );
+    expect(workspaceAfterDeletion[0].suspendedAt).not.toBeNull();
+    expect(workspaceAfterDeletion[0].deletedAt).not.toBeNull();
+  });
+});