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

packages/twenty-server/test/integration/metadata/suites/role-permission-flag/__snapshots__/failing-permission-flag-upsert.integration-spec.ts.snap

@@ -0,0 +1,82 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Permission flag upsert should fail when permissionFlagKeys contains invalid enum value 1`] = `
+{
+  "extensions": {
+    "code": "BAD_USER_INPUT",
+    "subCode": "INVALID_SETTING_PERMISSIONS",
+    "userFriendlyMessage": "Some of the permissions you selected are not valid. Please try again with valid permission settings.",
+  },
+  "message": "Invalid permission setting (unknown value): INVALID_FLAG",
+  "name": "UserInputError",
+}
+`;
+
+exports[`Permission flag upsert should fail when role is not editable (system role) 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "rolePermissionFlag": [
+        {
+          "errors": [
+            {
+              "code": "ROLE_BELONGS_TO_ANOTHER_APPLICATION",
+              "message": "Cannot target a role owned by another application",
+              "userFriendlyMessage": "Cannot target a role owned by another application.",
+            },
+            {
+              "code": "ROLE_NOT_EDITABLE",
+              "message": "Role is not editable",
+              "userFriendlyMessage": "This role cannot be modified because it is a system role. Only custom roles can be edited.",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "permissionFlagUniversalIdentifier": Any<String>,
+            "roleUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "rolePermissionFlag",
+          "status": "fail",
+          "type": "create",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 rolePermissionFlag",
+    "summary": {
+      "rolePermissionFlag": 1,
+      "totalErrors": 1,
+    },
+    "userFriendlyMessage": "Cannot target a role owned by another application.",
+  },
+  "message": "Validation errors occurred while upserting permission flags",
+  "name": "GraphQLError",
+}
+`;
+
+exports[`Permission flag upsert should fail when roleId does not exist 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "ROLE_NOT_FOUND",
+    "userFriendlyMessage": "The role you are trying to modify could not be found.",
+  },
+  "message": "Role not found",
+  "name": "NotFoundError",
+}
+`;
+
+exports[`Permission flag upsert should fail when roleId is not a valid UUID 1`] = `
+{
+  "extensions": {
+    "code": "GRAPHQL_VALIDATION_FAILED",
+    "http": {
+      "status": 400,
+    },
+    "userFriendlyMessage": "An error occurred.",
+    "value": "invalid-uuid",
+  },
+  "message": "Invalid UUID: 'invalid-uuid'",
+  "name": "ValidationError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/role-permission-flag/failing-permission-flag-upsert.integration-spec.ts

@@ -0,0 +1,138 @@
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { upsertPermissionFlags } from 'test/integration/metadata/suites/role-permission-flag/utils/upsert-permission-flags.util';
+import { createOneRole } from 'test/integration/metadata/suites/role/utils/create-one-role.util';
+import { deleteOneRole } from 'test/integration/metadata/suites/role/utils/delete-one-role.util';
+import { findRoles } from 'test/integration/metadata/suites/role/utils/find-roles.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+import { PermissionFlagType } from 'twenty-shared/constants';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+import { isDefined } from 'twenty-shared/utils';
+import { v4 } from 'uuid';
+
+import { type UpsertPermissionFlagsInput } from 'src/engine/metadata-modules/role-permission-flag/dtos/upsert-permission-flags.input';
+
+type GlobalTestContext = {
+  editableRoleId: string;
+  nonEditableRoleId: string;
+};
+
+type TestContext = {
+  input: (globalContext: GlobalTestContext) => UpsertPermissionFlagsInput;
+};
+
+const failingRolePermissionFlagUpsertTestCases: EachTestingContext<TestContext>[] =
+  [
+    {
+      title: 'when roleId is not a valid UUID',
+      context: {
+        input: () => ({
+          roleId: 'invalid-uuid',
+          permissionFlagKeys: [PermissionFlagType.DATA_MODEL],
+        }),
+      },
+    },
+    {
+      title: 'when roleId does not exist',
+      context: {
+        input: () => ({
+          roleId: v4(),
+          permissionFlagKeys: [PermissionFlagType.DATA_MODEL],
+        }),
+      },
+    },
+    {
+      title: 'when role is not editable (system role)',
+      context: {
+        input: (globalContext) => ({
+          roleId: globalContext.nonEditableRoleId,
+          permissionFlagKeys: [PermissionFlagType.DATA_MODEL],
+        }),
+      },
+    },
+    {
+      title: 'when permissionFlagKeys contains invalid enum value',
+      context: {
+        input: (globalContext) => ({
+          roleId: globalContext.editableRoleId,
+          permissionFlagKeys: ['INVALID_FLAG' as PermissionFlagType],
+        }),
+      },
+    },
+  ];
+
+describe('Permission flag upsert should fail', () => {
+  let editableRoleId: string;
+  let nonEditableRoleId: string;
+
+  beforeAll(async () => {
+    const { data: roleData } = await createOneRole({
+      expectToFail: false,
+      input: {
+        label: 'Test Role For Permission Flag Failing',
+        description: 'Role for permission flag failing tests',
+        icon: 'IconSettings',
+        canUpdateAllSettings: false,
+        canAccessAllTools: true,
+        canReadAllObjectRecords: true,
+        canUpdateAllObjectRecords: false,
+        canSoftDeleteAllObjectRecords: false,
+        canDestroyAllObjectRecords: false,
+        canBeAssignedToUsers: true,
+        canBeAssignedToAgents: false,
+        canBeAssignedToApiKeys: false,
+      },
+    });
+
+    editableRoleId = roleData?.createOneRole?.id;
+    jestExpectToBeDefined(editableRoleId);
+
+    const { data: rolesData } = await findRoles({
+      expectToFail: false,
+      gqlFields: `
+        id
+        label
+        isEditable
+      `,
+    });
+
+    jestExpectToBeDefined(rolesData?.getRoles);
+    const adminRole = rolesData.getRoles.find(
+      (role: { label: string; isEditable: boolean }) =>
+        role.label === 'Admin' && role.isEditable === false,
+    );
+    jestExpectToBeDefined(adminRole);
+    nonEditableRoleId = adminRole.id;
+  });
+
+  afterAll(async () => {
+    if (isDefined(editableRoleId)) {
+      await deleteOneRole({
+        expectToFail: false,
+        input: { idToDelete: editableRoleId },
+      });
+    }
+  });
+
+  it.each(eachTestingContextFilter(failingRolePermissionFlagUpsertTestCases))(
+    '$title',
+    async ({ context }) => {
+      const globalContext: GlobalTestContext = {
+        editableRoleId: editableRoleId ?? '',
+        nonEditableRoleId: nonEditableRoleId ?? '',
+      };
+      const input = context.input(globalContext);
+
+      const { errors } = await upsertPermissionFlags({
+        expectToFail: true,
+        input,
+      });
+
+      expectOneNotInternalServerErrorSnapshot({
+        errors,
+      });
+    },
+  );
+});

packages/twenty-server/test/integration/metadata/suites/role-permission-flag/successful-permission-flag-upsert.integration-spec.ts

@@ -0,0 +1,118 @@
+import { upsertPermissionFlags } from 'test/integration/metadata/suites/role-permission-flag/utils/upsert-permission-flags.util';
+import { createOneRole } from 'test/integration/metadata/suites/role/utils/create-one-role.util';
+import { deleteOneRole } from 'test/integration/metadata/suites/role/utils/delete-one-role.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+import { PermissionFlagType } from 'twenty-shared/constants';
+
+describe('Permission flag upsert should succeed', () => {
+  let createdRoleId: string;
+
+  beforeAll(async () => {
+    const { data: roleData } = await createOneRole({
+      expectToFail: false,
+      input: {
+        label: 'Test Role For Permission Flag Success',
+        description: 'Role for permission flag successful tests',
+        icon: 'IconSettings',
+        canUpdateAllSettings: false,
+        canAccessAllTools: true,
+        canReadAllObjectRecords: true,
+        canUpdateAllObjectRecords: false,
+        canSoftDeleteAllObjectRecords: false,
+        canDestroyAllObjectRecords: false,
+        canBeAssignedToUsers: true,
+        canBeAssignedToAgents: false,
+        canBeAssignedToApiKeys: false,
+      },
+    });
+
+    const roleId = roleData?.createOneRole?.id;
+    jestExpectToBeDefined(roleId);
+    createdRoleId = roleId;
+  });
+
+  afterAll(async () => {
+    if (createdRoleId) {
+      await deleteOneRole({
+        expectToFail: false,
+        input: { idToDelete: createdRoleId },
+      });
+    }
+  });
+
+  it('should upsert with empty permissionFlagKeys', async () => {
+    const { data } = await upsertPermissionFlags({
+      expectToFail: false,
+      input: {
+        roleId: createdRoleId,
+        permissionFlagKeys: [],
+      },
+    });
+
+    expect(data?.upsertPermissionFlags).toEqual([]);
+  });
+
+  it('should upsert with one permission flag', async () => {
+    const { data } = await upsertPermissionFlags({
+      expectToFail: false,
+      input: {
+        roleId: createdRoleId,
+        permissionFlagKeys: [PermissionFlagType.DATA_MODEL],
+      },
+    });
+
+    expect(data?.upsertPermissionFlags).toHaveLength(1);
+    expect(data?.upsertPermissionFlags?.[0]).toMatchObject({
+      roleId: createdRoleId,
+      flag: PermissionFlagType.DATA_MODEL,
+    });
+    expect(data?.upsertPermissionFlags?.[0].id).toBeDefined();
+  });
+
+  it('should upsert with multiple permission flags', async () => {
+    const { data } = await upsertPermissionFlags({
+      expectToFail: false,
+      input: {
+        roleId: createdRoleId,
+        permissionFlagKeys: [
+          PermissionFlagType.DATA_MODEL,
+          PermissionFlagType.ROLES,
+          PermissionFlagType.VIEWS,
+        ],
+      },
+    });
+
+    expect(data?.upsertPermissionFlags).toHaveLength(3);
+    const flags = data?.upsertPermissionFlags?.map((pf) => pf.flag) ?? [];
+    expect(flags).toContain(PermissionFlagType.DATA_MODEL);
+    expect(flags).toContain(PermissionFlagType.ROLES);
+    expect(flags).toContain(PermissionFlagType.VIEWS);
+  });
+
+  it('should upsert to remove some flags (replace with subset)', async () => {
+    const { data } = await upsertPermissionFlags({
+      expectToFail: false,
+      input: {
+        roleId: createdRoleId,
+        permissionFlagKeys: [PermissionFlagType.DATA_MODEL],
+      },
+    });
+
+    expect(data?.upsertPermissionFlags).toHaveLength(1);
+    expect(data?.upsertPermissionFlags?.[0].flag).toBe(
+      PermissionFlagType.DATA_MODEL,
+    );
+  });
+
+  it('should upsert back to empty', async () => {
+    const { data } = await upsertPermissionFlags({
+      expectToFail: false,
+      input: {
+        roleId: createdRoleId,
+        permissionFlagKeys: [],
+      },
+    });
+
+    expect(data?.upsertPermissionFlags).toEqual([]);
+  });
+});

packages/twenty-server/test/integration/metadata/suites/role-permission-flag/utils/upsert-permission-flags-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';
+
+import { type UpsertPermissionFlagsInput } from 'src/engine/metadata-modules/role-permission-flag/dtos/upsert-permission-flags.input';
+
+export type UpsertPermissionFlagsFactoryInput = UpsertPermissionFlagsInput;
+
+const DEFAULT_ROLE_PERMISSION_FLAG_GQL_FIELDS = `
+  id
+  roleId
+  flag
+`;
+
+export const upsertPermissionFlagsQueryFactory = ({
+  input,
+  gqlFields = DEFAULT_ROLE_PERMISSION_FLAG_GQL_FIELDS,
+}: PerformMetadataQueryParams<UpsertPermissionFlagsFactoryInput>) => ({
+  query: gql`
+    mutation UpsertPermissionFlags($upsertPermissionFlagsInput: UpsertPermissionFlagsInput!) {
+      upsertPermissionFlags(upsertPermissionFlagsInput: $upsertPermissionFlagsInput) {
+        ${gqlFields}
+      }
+    }
+  `,
+  variables: {
+    upsertPermissionFlagsInput: input,
+  },
+});

packages/twenty-server/test/integration/metadata/suites/role-permission-flag/utils/upsert-permission-flags.util.ts

@@ -0,0 +1,43 @@
+import {
+  type UpsertPermissionFlagsFactoryInput,
+  upsertPermissionFlagsQueryFactory,
+} from 'test/integration/metadata/suites/role-permission-flag/utils/upsert-permission-flags-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 RolePermissionFlagDTO } from 'src/engine/metadata-modules/role-permission-flag/dtos/role-permission-flag.dto';
+
+export const upsertPermissionFlags = async ({
+  input,
+  gqlFields,
+  expectToFail = false,
+  token,
+}: PerformMetadataQueryParams<UpsertPermissionFlagsFactoryInput>): CommonResponseBody<{
+  upsertPermissionFlags: RolePermissionFlagDTO[];
+}> => {
+  const graphqlOperation = upsertPermissionFlagsQueryFactory({
+    input,
+    gqlFields,
+  });
+
+  const response = await makeMetadataAPIRequest(graphqlOperation, token);
+
+  if (expectToFail === true) {
+    warnIfNoErrorButExpectedToFail({
+      response,
+      errorMessage: 'Permission flags upsert should have failed but did not',
+    });
+  }
+
+  if (expectToFail === false) {
+    warnIfErrorButNotExpectedToFail({
+      response,
+      errorMessage: 'Permission flags upsert has failed but should not',
+    });
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};