Skip to content

The open alternative to Salesforce, designed for AI.

Give the workspace custom application its own default role (#28538)

Paul Rastoin75635284cb31
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-upgrade-version-command.module.ts
index 23b8a1e8a6f..c314b4db08b 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-upgrade-version-command.module.ts
@@ -6,6 +6,7 @@ import { DeleteConnectedAccountsOutsideProviderScopeCommand } from 'src/database
import { AddAgentChatChannelsCommand } from 'src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792686629823-add-agent-chat-channels.command';
import { BackfillStandardApplicationDefaultRoleCommand } from 'src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792741864752-backfill-standard-application-default-role.command';
import { MigrateRichTextToTiptapCommand } from 'src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792748448862-migrate-rich-text-to-tiptap.command';
+import { BackfillWorkspaceCustomApplicationDefaultRoleCommand } from 'src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792755720300-backfill-workspace-custom-application-default-role.command';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
import { ConnectedAccountMetadataModule } from 'src/engine/metadata-modules/connected-account/connected-account-metadata.module';
import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
@@ -25,6 +26,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
AddAgentChatChannelsCommand,
BackfillStandardApplicationDefaultRoleCommand,
MigrateRichTextToTiptapCommand,
+ BackfillWorkspaceCustomApplicationDefaultRoleCommand,
],
})
export class V2_51_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792755720300-backfill-workspace-custom-application-default-role.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792755720300-backfill-workspace-custom-application-default-role.command.ts
new file mode 100644
index 00000000000..c9c7dc34595
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792755720300-backfill-workspace-custom-application-default-role.command.ts
@@ -0,0 +1,136 @@
+import { Command } from 'nest-commander';
+import { isDefined } from 'twenty-shared/utils';
+
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { getAvailableRoleLabel } from 'src/database/commands/upgrade-version-command/2-51/utils/get-available-role-label.util';
+import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER } from 'src/engine/core-modules/application/constants/workspace-custom-application-role.constant';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
+import { type FlatRole } from 'src/engine/metadata-modules/flat-role/types/flat-role.type';
+import { buildWorkspaceCustomApplicationFlatRole } from 'src/engine/metadata-modules/flat-role/utils/build-workspace-custom-application-flat-role.util';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { WorkspaceMigrationBuilderException } from 'src/engine/workspace-manager/workspace-migration/exceptions/workspace-migration-builder-exception';
+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+
+@RegisteredWorkspaceCommand('2.51.0', 1792755720300)
+@Command({
+ name: 'upgrade:2-51:backfill-workspace-custom-application-default-role',
+ description:
+ 'Give the workspace custom application its own default role',
+})
+export class BackfillWorkspaceCustomApplicationDefaultRoleCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly applicationService: ApplicationService,
+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ options,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ const { workspaceCustomFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ if (isDefined(workspaceCustomFlatApplication.defaultRoleId)) {
+ return;
+ }
+
+ const { flatRoleMaps } = await this.workspaceCacheService.getOrRecompute(
+ workspaceId,
+ ['flatRoleMaps'],
+ );
+
+ const existingCustomApplicationFlatRole =
+ findFlatEntityByUniversalIdentifier({
+ universalIdentifier:
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER,
+ flatEntityMaps: flatRoleMaps,
+ });
+
+ if (options.dryRun) {
+ this.logger.log(
+ `[DRY RUN] Workspace ${workspaceId}: would ${isDefined(existingCustomApplicationFlatRole) ? 'reuse' : 'create'} the workspace custom application role`,
+ );
+
+ return;
+ }
+
+ const customApplicationFlatRole =
+ existingCustomApplicationFlatRole ??
+ (await this.createWorkspaceCustomApplicationRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ takenLabels: Object.values(flatRoleMaps.byUniversalIdentifier)
+ .filter(isDefined)
+ .map(({ label }) => label),
+ }));
+
+ await this.applicationService.update(workspaceCustomFlatApplication.id, {
+ workspaceId,
+ defaultRoleId: customApplicationFlatRole.id,
+ });
+
+ this.logger.log(
+ `Workspace ${workspaceId}: set role ${customApplicationFlatRole.id} as the workspace custom application default role`,
+ );
+ }
+
+ private async createWorkspaceCustomApplicationRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ takenLabels,
+ }: {
+ workspaceId: string;
+ workspaceCustomFlatApplication: FlatApplication;
+ takenLabels: string[];
+ }): Promise<FlatRole> {
+ const definitionFlatRole = buildWorkspaceCustomApplicationFlatRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ });
+
+ const flatRoleToCreate: FlatRole = {
+ ...definitionFlatRole,
+ label: getAvailableRoleLabel({
+ preferredLabel: definitionFlatRole.label,
+ takenLabels,
+ }),
+ };
+
+ const result =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+ {
+ allFlatEntityOperationByMetadataName: {
+ role: {
+ flatEntityToCreate: [flatRoleToCreate],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+ },
+ },
+ workspaceId,
+ isSystemBuild: true,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ },
+ );
+
+ if (result.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ result,
+ `Failed to create the workspace custom application role in workspace ${workspaceId}`,
+ );
+ }
+
+ return flatRoleToCreate;
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/__tests__/2-51-workspace-command-1792755720300-backfill-workspace-custom-application-default-role.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/__tests__/2-51-workspace-command-1792755720300-backfill-workspace-custom-application-default-role.command.spec.ts
new file mode 100644
index 00000000000..4b744d54b78
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/__tests__/2-51-workspace-command-1792755720300-backfill-workspace-custom-application-default-role.command.spec.ts
@@ -0,0 +1,180 @@
+import { type WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { BackfillWorkspaceCustomApplicationDefaultRoleCommand } from 'src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792755720300-backfill-workspace-custom-application-default-role.command';
+import { type ApplicationService } from 'src/engine/core-modules/application/application.service';
+import {
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_LABEL,
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER,
+} from 'src/engine/core-modules/application/constants/workspace-custom-application-role.constant';
+import { type FlatRole } from 'src/engine/metadata-modules/flat-role/types/flat-role.type';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { type WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+
+const WORKSPACE_ID = '20202020-0000-4000-8000-000000000001';
+const CUSTOM_APPLICATION_ID = '20202020-0000-4000-8000-0000000000a2';
+
+type RoleMigrationArgs = {
+ allFlatEntityOperationByMetadataName: {
+ role: { flatEntityToCreate: FlatRole[] };
+ };
+ isSystemBuild: boolean;
+ applicationUniversalIdentifier: string;
+};
+
+const buildExistingRole = (label: string): FlatRole =>
+ ({
+ id: `role-${label}`,
+ universalIdentifier: `universal-${label}`,
+ label,
+ }) as FlatRole;
+
+describe('BackfillWorkspaceCustomApplicationDefaultRoleCommand', () => {
+ let customApplicationDefaultRoleId: string | null;
+ let roles: FlatRole[];
+ let migrationCalls: RoleMigrationArgs[];
+ let command: BackfillWorkspaceCustomApplicationDefaultRoleCommand;
+
+ const getCustomApplicationRole = () =>
+ roles.find(
+ (role) =>
+ role.universalIdentifier ===
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER,
+ );
+
+ beforeEach(() => {
+ customApplicationDefaultRoleId = null;
+ roles = [buildExistingRole('Admin'), buildExistingRole('Member')];
+ migrationCalls = [];
+
+ const workspaceCacheService = {
+ getOrRecompute: jest.fn(async () => ({
+ flatRoleMaps: {
+ byUniversalIdentifier: Object.fromEntries(
+ roles.map((role) => [role.universalIdentifier, role]),
+ ),
+ },
+ })),
+ } as unknown as WorkspaceCacheService;
+
+ const applicationService = {
+ findWorkspaceTwentyStandardAndCustomApplicationOrThrow: jest.fn(
+ async () => ({
+ workspaceCustomFlatApplication: {
+ id: CUSTOM_APPLICATION_ID,
+ universalIdentifier: CUSTOM_APPLICATION_ID,
+ defaultRoleId: customApplicationDefaultRoleId,
+ },
+ }),
+ ),
+ update: jest.fn(
+ async (_id: string, { defaultRoleId }: { defaultRoleId: string }) => {
+ customApplicationDefaultRoleId = defaultRoleId;
+ },
+ ),
+ } as unknown as ApplicationService;
+
+ const workspaceMigrationValidateBuildAndRunService = {
+ validateBuildAndRunWorkspaceMigration: jest.fn(
+ async (args: RoleMigrationArgs) => {
+ migrationCalls.push(args);
+ roles = [
+ ...roles,
+ ...args.allFlatEntityOperationByMetadataName.role
+ .flatEntityToCreate,
+ ];
+
+ return { status: 'success' };
+ },
+ ),
+ } as unknown as WorkspaceMigrationValidateBuildAndRunService;
+
+ command = new BackfillWorkspaceCustomApplicationDefaultRoleCommand(
+ {} as WorkspaceIteratorService,
+ workspaceCacheService,
+ applicationService,
+ workspaceMigrationValidateBuildAndRunService,
+ );
+
+ jest.spyOn(command['logger'], 'log').mockImplementation();
+ });
+
+ const run = (dryRun = false) =>
+ command.runOnWorkspace({
+ workspaceId: WORKSPACE_ID,
+ options: { dryRun },
+ index: 0,
+ total: 1,
+ });
+
+ it('creates a locked, Admin-equivalent role owned by the custom application and sets it as its default role', async () => {
+ await run();
+
+ const customApplicationRole = getCustomApplicationRole();
+
+ expect(customApplicationRole).toMatchObject({
+ label: WORKSPACE_CUSTOM_APPLICATION_ROLE_LABEL,
+ applicationId: CUSTOM_APPLICATION_ID,
+ isEditable: false,
+ canUpdateAllSettings: true,
+ canAccessAllTools: true,
+ canAccessAllAgentChatChannels: true,
+ canReadAllObjectRecords: true,
+ canUpdateAllObjectRecords: true,
+ canSoftDeleteAllObjectRecords: true,
+ canDestroyAllObjectRecords: true,
+ canBeAssignedToUsers: false,
+ canBeAssignedToAgents: false,
+ canBeAssignedToApiKeys: false,
+ });
+ expect(customApplicationDefaultRoleId).toBe(customApplicationRole?.id);
+ expect(migrationCalls).toMatchObject([
+ {
+ isSystemBuild: true,
+ applicationUniversalIdentifier: CUSTOM_APPLICATION_ID,
+ },
+ ]);
+ });
+
+ it('changes nothing on a second run', async () => {
+ await run();
+
+ const rolesAfterFirstRun = [...roles];
+ const defaultRoleIdAfterFirstRun = customApplicationDefaultRoleId;
+
+ migrationCalls = [];
+
+ await run();
+
+ expect(migrationCalls).toEqual([]);
+ expect(roles).toEqual(rolesAfterFirstRun);
+ expect(customApplicationDefaultRoleId).toBe(defaultRoleIdAfterFirstRun);
+ });
+
+ it('leaves a custom application that already has a default role alone', async () => {
+ customApplicationDefaultRoleId = 'role-Member';
+
+ await run();
+
+ expect(customApplicationDefaultRoleId).toBe('role-Member');
+ expect(getCustomApplicationRole()).toBeUndefined();
+ });
+
+ it('picks a free label when a role already uses the default one', async () => {
+ roles.push(
+ buildExistingRole(WORKSPACE_CUSTOM_APPLICATION_ROLE_LABEL),
+ buildExistingRole(`${WORKSPACE_CUSTOM_APPLICATION_ROLE_LABEL} 2`),
+ );
+
+ await run();
+
+ expect(getCustomApplicationRole()?.label).toBe(
+ `${WORKSPACE_CUSTOM_APPLICATION_ROLE_LABEL} 3`,
+ );
+ });
+
+ it('writes nothing in dry-run mode', async () => {
+ await run(true);
+
+ expect(migrationCalls).toEqual([]);
+ expect(customApplicationDefaultRoleId).toBeNull();
+ });
+});
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/utils/get-available-role-label.util.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/utils/get-available-role-label.util.ts
new file mode 100644
index 00000000000..30943bc927e
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/utils/get-available-role-label.util.ts
@@ -0,0 +1,15 @@
+export const getAvailableRoleLabel = ({
+ preferredLabel,
+ takenLabels,
+}: {
+ preferredLabel: string;
+ takenLabels: string[];
+}): string => {
+ let label = preferredLabel;
+
+ for (let suffix = 2; takenLabels.includes(label); suffix++) {
+ label = `${preferredLabel} ${suffix}`;
+ }
+
+ return label;
+};
diff --git a/packages/twenty-server/src/engine/core-modules/application/constants/workspace-custom-application-role.constant.ts b/packages/twenty-server/src/engine/core-modules/application/constants/workspace-custom-application-role.constant.ts
new file mode 100644
index 00000000000..f44ea1beec1
--- /dev/null
+++ b/packages/twenty-server/src/engine/core-modules/application/constants/workspace-custom-application-role.constant.ts
@@ -0,0 +1,5 @@
+export const WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER =
+ 'b5b505e2-8834-457f-a301-f1f4694fe365';
+
+export const WORKSPACE_CUSTOM_APPLICATION_ROLE_LABEL =
+ 'Workspace Custom Application';
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-role/utils/__tests__/build-workspace-custom-application-flat-role.util.spec.ts b/packages/twenty-server/src/engine/metadata-modules/flat-role/utils/__tests__/build-workspace-custom-application-flat-role.util.spec.ts
new file mode 100644
index 00000000000..c0caf918aad
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-role/utils/__tests__/build-workspace-custom-application-flat-role.util.spec.ts
@@ -0,0 +1,64 @@
+import { WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER } from 'src/engine/core-modules/application/constants/workspace-custom-application-role.constant';
+import { buildWorkspaceCustomApplicationFlatRole } from 'src/engine/metadata-modules/flat-role/utils/build-workspace-custom-application-flat-role.util';
+import { STANDARD_FLAT_ROLE_METADATA_BUILDERS_BY_ROLE_NAME } from 'src/engine/workspace-manager/twenty-standard-application/utils/role-metadata/create-standard-flat-role-metadata.util';
+import { type CreateStandardRoleArgs } from 'src/engine/workspace-manager/twenty-standard-application/utils/role-metadata/create-standard-role-flat-metadata.util';
+
+const WORKSPACE_ID = '20202020-0000-4000-8000-000000000000';
+const CUSTOM_APPLICATION = {
+ id: '20202020-0000-4000-8000-0000000000a2',
+ universalIdentifier: '20202020-0000-4000-8000-0000000000a2',
+};
+
+describe('buildWorkspaceCustomApplicationFlatRole', () => {
+ const customApplicationRole = buildWorkspaceCustomApplicationFlatRole({
+ workspaceId: WORKSPACE_ID,
+ workspaceCustomFlatApplication: CUSTOM_APPLICATION,
+ });
+
+ const adminRole = STANDARD_FLAT_ROLE_METADATA_BUILDERS_BY_ROLE_NAME.admin({
+ workspaceId: WORKSPACE_ID,
+ twentyStandardApplicationId: '20202020-0000-4000-8000-0000000000a1',
+ now: '2026-01-01T00:00:00.000Z',
+ } as Omit<CreateStandardRoleArgs, 'context'>);
+
+ it('is owned by the custom application', () => {
+ expect(customApplicationRole).toMatchObject({
+ universalIdentifier:
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER,
+ applicationId: CUSTOM_APPLICATION.id,
+ applicationUniversalIdentifier: CUSTOM_APPLICATION.universalIdentifier,
+ workspaceId: WORKSPACE_ID,
+ });
+ });
+
+ it('grants the same permissions as Admin', () => {
+ expect(customApplicationRole).toMatchObject({
+ canUpdateAllSettings: adminRole.canUpdateAllSettings,
+ canAccessAllTools: adminRole.canAccessAllTools,
+ canAccessAllAgentChatChannels: adminRole.canAccessAllAgentChatChannels,
+ canReadAllObjectRecords: adminRole.canReadAllObjectRecords,
+ canUpdateAllObjectRecords: adminRole.canUpdateAllObjectRecords,
+ canSoftDeleteAllObjectRecords: adminRole.canSoftDeleteAllObjectRecords,
+ canDestroyAllObjectRecords: adminRole.canDestroyAllObjectRecords,
+ });
+ });
+
+ it('is locked and assignable to nobody', () => {
+ expect(customApplicationRole).toMatchObject({
+ isEditable: false,
+ canBeAssignedToUsers: false,
+ canBeAssignedToAgents: false,
+ canBeAssignedToApiKeys: false,
+ });
+ });
+
+ it('uses the given label', () => {
+ expect(
+ buildWorkspaceCustomApplicationFlatRole({
+ workspaceId: WORKSPACE_ID,
+ workspaceCustomFlatApplication: CUSTOM_APPLICATION,
+ label: 'Another label',
+ }).label,
+ ).toBe('Another label');
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-role/utils/build-workspace-custom-application-flat-role.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-role/utils/build-workspace-custom-application-flat-role.util.ts
new file mode 100644
index 00000000000..b17d0c6d4b9
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-role/utils/build-workspace-custom-application-flat-role.util.ts
@@ -0,0 +1,62 @@
+import { v4 } from 'uuid';
+
+import {
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_LABEL,
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER,
+} from 'src/engine/core-modules/application/constants/workspace-custom-application-role.constant';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
+import { type FlatRole } from 'src/engine/metadata-modules/flat-role/types/flat-role.type';
+
+export const buildWorkspaceCustomApplicationFlatRole = ({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ label = WORKSPACE_CUSTOM_APPLICATION_ROLE_LABEL,
+}: {
+ workspaceId: string;
+ workspaceCustomFlatApplication: Pick<
+ FlatApplication,
+ 'id' | 'universalIdentifier'
+ >;
+ label?: string;
+}): FlatRole => {
+ const now = new Date().toISOString();
+
+ return {
+ id: v4(),
+ universalIdentifier: WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER,
+ label,
+ description: 'Default role of the workspace custom application',
+ icon: 'IconApps',
+ isEditable: false,
+ canUpdateAllSettings: true,
+ canAccessAllTools: true,
+ canAccessAllAgentChatChannels: true,
+ canReadAllObjectRecords: true,
+ canUpdateAllObjectRecords: true,
+ canSoftDeleteAllObjectRecords: true,
+ canDestroyAllObjectRecords: true,
+ canBeAssignedToUsers: false,
+ canBeAssignedToAgents: false,
+ canBeAssignedToApiKeys: false,
+ workspaceId,
+ createdAt: now,
+ updatedAt: now,
+ applicationId: workspaceCustomFlatApplication.id,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ roleTargetIds: [],
+ roleTargetUniversalIdentifiers: [],
+ objectPermissionIds: [],
+ rolePermissionFlagIds: [],
+ objectPermissionUniversalIdentifiers: [],
+ rolePermissionFlagUniversalIdentifiers: [],
+ fieldPermissionIds: [],
+ fieldPermissionUniversalIdentifiers: [],
+ rowLevelPermissionPredicateIds: [],
+ rowLevelPermissionPredicateUniversalIdentifiers: [],
+ rowLevelPermissionPredicateGroupIds: [],
+ rowLevelPermissionPredicateGroupUniversalIdentifiers: [],
+ agentChatChannelRoleIds: [],
+ agentChatChannelRoleUniversalIdentifiers: [],
+ };
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/role/__tests__/role.service.spec.ts b/packages/twenty-server/src/engine/metadata-modules/role/__tests__/role.service.spec.ts
new file mode 100644
index 00000000000..2e0b20ab99c
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/role/__tests__/role.service.spec.ts
@@ -0,0 +1,126 @@
+import { type ApiKeyRoleService } from 'src/engine/core-modules/api-key/services/api-key-role.service';
+import { type ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER } from 'src/engine/core-modules/application/constants/workspace-custom-application-role.constant';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
+import { createEmptyFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/constant/create-empty-flat-entity-maps.constant';
+import { type WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
+import { addFlatEntityToFlatEntityMapsOrThrow } from 'src/engine/metadata-modules/flat-entity/utils/add-flat-entity-to-flat-entity-maps-or-throw.util';
+import { buildWorkspaceCustomApplicationFlatRole } from 'src/engine/metadata-modules/flat-role/utils/build-workspace-custom-application-flat-role.util';
+import { RoleService } from 'src/engine/metadata-modules/role/role.service';
+import { type WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';
+
+const WORKSPACE_ID = 'workspace-id';
+
+const workspaceCustomFlatApplication = {
+ id: 'workspace-custom-application-id',
+ universalIdentifier: 'workspace-custom-application-id',
+ defaultRoleId: null,
+} as FlatApplication;
+
+const existingFlatRole = buildWorkspaceCustomApplicationFlatRole({
+ workspaceId: WORKSPACE_ID,
+ workspaceCustomFlatApplication,
+});
+
+const buildRoleService = ({
+ hasExistingRole,
+}: {
+ hasExistingRole: boolean;
+}) => {
+ const validateBuildAndRunWorkspaceMigration = jest
+ .fn()
+ .mockResolvedValue({ status: 'success' });
+ const updateApplication = jest.fn().mockResolvedValue(undefined);
+ const flatRoleMaps = hasExistingRole
+ ? addFlatEntityToFlatEntityMapsOrThrow({
+ flatEntity: existingFlatRole,
+ flatEntityMaps: createEmptyFlatEntityMaps(),
+ })
+ : createEmptyFlatEntityMaps();
+
+ const roleService = new RoleService(
+ {
+ validateBuildAndRunWorkspaceMigration,
+ } as unknown as WorkspaceMigrationValidateBuildAndRunService,
+ {
+ getOrRecomputeManyOrAllFlatEntityMaps: jest
+ .fn()
+ .mockResolvedValue({ flatRoleMaps }),
+ } as unknown as WorkspaceManyOrAllFlatEntityMapsCacheService,
+ {} as never,
+ { update: updateApplication } as unknown as ApplicationService,
+ {} as ApiKeyRoleService,
+ );
+
+ return {
+ roleService,
+ validateBuildAndRunWorkspaceMigration,
+ updateApplication,
+ };
+};
+
+describe('RoleService.createWorkspaceCustomApplicationRole', () => {
+ it('creates the role and sets it as the custom application default role', async () => {
+ const {
+ roleService,
+ validateBuildAndRunWorkspaceMigration,
+ updateApplication,
+ } = buildRoleService({ hasExistingRole: false });
+
+ await roleService.createWorkspaceCustomApplicationRole({
+ workspaceId: WORKSPACE_ID,
+ workspaceCustomFlatApplication,
+ });
+
+ const [[{ allFlatEntityOperationByMetadataName }]] =
+ validateBuildAndRunWorkspaceMigration.mock.calls;
+ const [createdFlatRole] =
+ allFlatEntityOperationByMetadataName.role.flatEntityToCreate;
+
+ expect(createdFlatRole.universalIdentifier).toBe(
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER,
+ );
+ expect(updateApplication).toHaveBeenCalledWith(
+ workspaceCustomFlatApplication.id,
+ { workspaceId: WORKSPACE_ID, defaultRoleId: createdFlatRole.id },
+ );
+ });
+
+ it('reuses the role a failed activation already created', async () => {
+ const {
+ roleService,
+ validateBuildAndRunWorkspaceMigration,
+ updateApplication,
+ } = buildRoleService({ hasExistingRole: true });
+
+ await roleService.createWorkspaceCustomApplicationRole({
+ workspaceId: WORKSPACE_ID,
+ workspaceCustomFlatApplication,
+ });
+
+ expect(validateBuildAndRunWorkspaceMigration).not.toHaveBeenCalled();
+ expect(updateApplication).toHaveBeenCalledWith(
+ workspaceCustomFlatApplication.id,
+ { workspaceId: WORKSPACE_ID, defaultRoleId: existingFlatRole.id },
+ );
+ });
+
+ it('changes nothing once the role is the custom application default role', async () => {
+ const {
+ roleService,
+ validateBuildAndRunWorkspaceMigration,
+ updateApplication,
+ } = buildRoleService({ hasExistingRole: true });
+
+ await roleService.createWorkspaceCustomApplicationRole({
+ workspaceId: WORKSPACE_ID,
+ workspaceCustomFlatApplication: {
+ ...workspaceCustomFlatApplication,
+ defaultRoleId: existingFlatRole.id,
+ },
+ });
+
+ expect(validateBuildAndRunWorkspaceMigration).not.toHaveBeenCalled();
+ expect(updateApplication).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-server/src/engine/metadata-modules/role/role.service.ts b/packages/twenty-server/src/engine/metadata-modules/role/role.service.ts
index 22436bf09d6..1fce5e71a99 100644
--- a/packages/twenty-server/src/engine/metadata-modules/role/role.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/role/role.service.ts
@@ -8,6 +8,7 @@ import { Repository } from 'typeorm';
import { ApiKeyRoleService } from 'src/engine/core-modules/api-key/services/api-key-role.service';
import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER } from 'src/engine/core-modules/application/constants/workspace-custom-application-role.constant';
import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
import { WorkspaceManyOrAllFlatEntityMapsCacheService } from 'src/engine/metadata-modules/flat-entity/services/workspace-many-or-all-flat-entity-maps-cache.service';
@@ -17,6 +18,7 @@ import { findFlatEntityByIdInFlatEntityMapsOrThrow } from 'src/engine/metadata-m
import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
import { findManyFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-id-in-flat-entity-maps.util';
import { type FlatRole } from 'src/engine/metadata-modules/flat-role/types/flat-role.type';
+import { buildWorkspaceCustomApplicationFlatRole } from 'src/engine/metadata-modules/flat-role/utils/build-workspace-custom-application-flat-role.util';
import { fromCreateRoleInputToFlatRoleToCreate } from 'src/engine/metadata-modules/flat-role/utils/from-create-role-input-to-flat-role-to-create.util';
import { fromDeleteRoleInputToFlatRoleOrThrow } from 'src/engine/metadata-modules/flat-role/utils/from-delete-role-input-to-flat-role-or-throw.util';
import { fromUpdateRoleInputToFlatRoleToUpdateOrThrow } from 'src/engine/metadata-modules/flat-role/utils/from-update-role-input-to-flat-role-to-update-or-throw.util';
@@ -488,6 +490,84 @@ export class RoleService {
});
}
+ public async createWorkspaceCustomApplicationRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ }: {
+ workspaceId: string;
+ workspaceCustomFlatApplication: FlatApplication;
+ }): Promise<void> {
+ const { flatRoleMaps } =
+ await this.flatEntityMapsCacheService.getOrRecomputeManyOrAllFlatEntityMaps(
+ {
+ workspaceId,
+ flatMapsKeys: ['flatRoleMaps'],
+ },
+ );
+
+ // Workspace activation is retried after a failure, so the role may already exist
+ const existingFlatRole = findFlatEntityByUniversalIdentifier({
+ universalIdentifier:
+ WORKSPACE_CUSTOM_APPLICATION_ROLE_UNIVERSAL_IDENTIFIER,
+ flatEntityMaps: flatRoleMaps,
+ });
+
+ const roleId =
+ existingFlatRole?.id ??
+ (await this.createWorkspaceCustomApplicationFlatRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ }));
+
+ if (workspaceCustomFlatApplication.defaultRoleId === roleId) {
+ return;
+ }
+
+ await this.applicationService.update(workspaceCustomFlatApplication.id, {
+ workspaceId,
+ defaultRoleId: roleId,
+ });
+ }
+
+ private async createWorkspaceCustomApplicationFlatRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ }: {
+ workspaceId: string;
+ workspaceCustomFlatApplication: FlatApplication;
+ }): Promise<string> {
+ const flatRoleToCreate = buildWorkspaceCustomApplicationFlatRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ });
+
+ const validateAndBuildResult =
+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(
+ {
+ allFlatEntityOperationByMetadataName: {
+ role: {
+ flatEntityToCreate: [flatRoleToCreate],
+ flatEntityToDelete: [],
+ flatEntityToUpdate: [],
+ },
+ },
+ workspaceId,
+ isSystemBuild: true,
+ applicationUniversalIdentifier:
+ workspaceCustomFlatApplication.universalIdentifier,
+ },
+ );
+
+ if (validateAndBuildResult.status === 'fail') {
+ throw new WorkspaceMigrationBuilderException(
+ validateAndBuildResult,
+ 'Multiple validation errors occurred while creating the workspace custom application role',
+ );
+ }
+
+ return flatRoleToCreate.id;
+ }
+
public async createGuestRole({
workspaceId,
ownerFlatApplication,
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/services/dev-seeder-permissions.service.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/services/dev-seeder-permissions.service.ts
index b2a5b09a79b..5f37c42bfaf 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/services/dev-seeder-permissions.service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/services/dev-seeder-permissions.service.ts
@@ -184,6 +184,11 @@ export class DevSeederPermissionsService {
workspaceId: string;
workspaceCustomFlatApplication: FlatApplication;
}): Promise<RoleDTO> {
+ await this.roleService.createWorkspaceCustomApplicationRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ });
+
const memberRole = await this.roleService.createMemberRole({
workspaceId,
ownerFlatApplication: workspaceCustomFlatApplication,
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-manager.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-manager.service.ts
index cdd4f00f45f..f35716278ef 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-manager.service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-manager.service.ts
@@ -82,6 +82,11 @@ export class WorkspaceManagerService {
},
);
+ await this.roleService.createWorkspaceCustomApplicationRole({
+ workspaceId,
+ workspaceCustomFlatApplication,
+ });
+
await this.setupDefaultRoles({
workspaceId,
userId,
diff --git a/packages/twenty-server/test/integration/ai/suites/agent-run-wait.integration-spec.ts b/packages/twenty-server/test/integration/ai/suites/agent-run-wait.integration-spec.ts
index 5df5f5a4e76..91baa39be91 100644
--- a/packages/twenty-server/test/integration/ai/suites/agent-run-wait.integration-spec.ts
+++ b/packages/twenty-server/test/integration/ai/suites/agent-run-wait.integration-spec.ts
@@ -100,6 +100,17 @@ const findCallerRoleId = async (roleTargetId: string): Promise<string> => {
return roleId;
};
+const findApplicationDefaultRoleId = async (
+ applicationId: string,
+): Promise<string> => {
+ const [{ defaultRoleId }] = await global.testDataSource.query(
+ `SELECT "defaultRoleId" FROM core.application WHERE id = $1`,
+ [applicationId],
+ );
+
+ return defaultRoleId;
+};
+
const findTurnStatuses = async (threadId: string) =>
(
await global.testDataSource.query(
@@ -492,6 +503,8 @@ describe('agent runs that wait (integration)', () => {
const agentRunRoleIds = {
[callerRoleSource]: await findCallerRoleId(roleTargetId),
+ applicationRoleId:
+ await findApplicationDefaultRoleId(agentApplicationId),
};
expect(
diff --git a/packages/twenty-server/test/integration/metadata/suites/application-default-role/failing-application-default-role-mutations.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application-default-role/failing-application-default-role-mutations.integration-spec.ts
new file mode 100644
index 00000000000..82fce21547f
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/failing-application-default-role-mutations.integration-spec.ts
@@ -0,0 +1,299 @@
+import gql from 'graphql-tag';
+import { executeToolThroughMcp } from 'test/integration/ai/utils/execute-tool-through-mcp.util';
+import { TEST_AI_MODEL_ID } from 'test/integration/constants/test-ai-model-ids.constants';
+import { createOneAgent } from 'test/integration/metadata/suites/agent/utils/create-one-agent.util';
+import { deleteOneAgent } from 'test/integration/metadata/suites/agent/utils/delete-one-agent.util';
+import {
+ findApplicationDefaultRole,
+ findWorkspaceCustomApplicationId,
+} from 'test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util';
+import { upsertFieldPermissions } from 'test/integration/metadata/suites/field-permission/utils/upsert-field-permissions.util';
+import { findManyObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/find-many-object-metadata.util';
+import { upsertObjectPermissions } from 'test/integration/metadata/suites/object-permission/utils/upsert-object-permissions.util';
+import { upsertPermissionFlags } from 'test/integration/metadata/suites/role-permission-flag/utils/upsert-permission-flags.util';
+import { deleteOneRole } from 'test/integration/metadata/suites/role/utils/delete-one-role.util';
+import { updateOneRole } from 'test/integration/metadata/suites/role/utils/update-one-role.util';
+import { updateWorkspaceMemberRole } from 'test/integration/metadata/suites/role/utils/update-workspace-member-role.util';
+import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+import { jestExpectToBeDefined } from 'test/utils/jest-expect-to-be-defined.util.test';
+import { PermissionFlagType } from 'twenty-shared/constants';
+
+import { API_KEY_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/api-key-data-seeds.constant';
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
+
+const ROLE_STATE_GQL_FIELDS = `
+ id
+ label
+ description
+ icon
+ isEditable
+ canUpdateAllSettings
+ canAccessAllTools
+ canAccessAllAgentChatChannels
+ canReadAllObjectRecords
+ canUpdateAllObjectRecords
+ canSoftDeleteAllObjectRecords
+ canDestroyAllObjectRecords
+ canBeAssignedToUsers
+ canBeAssignedToAgents
+ canBeAssignedToApiKeys
+ workspaceMembers { id }
+ agents { id }
+ apiKeys { id }
+ permissionFlags { flag }
+ objectPermissions { objectMetadataId }
+ fieldPermissions { fieldMetadataId }
+ rowLevelPermissionPredicates { id }
+ rowLevelPermissionPredicateGroups { id }
+`;
+
+const readCustomApplicationRoleState = async () =>
+ findApplicationDefaultRole({
+ input: { id: await findWorkspaceCustomApplicationId() },
+ gqlFields: ROLE_STATE_GQL_FIELDS,
+ });
+
+describe('A workspace Admin member cannot change the custom application role', () => {
+ let customApplicationRoleId: string;
+ let companyObjectMetadataId: string;
+ let companyNameFieldMetadataId: string;
+ let agentId: string;
+
+ beforeAll(async () => {
+ const customApplicationRole = await readCustomApplicationRoleState();
+
+ jestExpectToBeDefined(customApplicationRole);
+ customApplicationRoleId = customApplicationRole.id;
+
+ const { objects } = await findManyObjectMetadata({
+ expectToFail: false,
+ input: { filter: {}, paging: { first: 1000 } },
+ gqlFields: `
+ id
+ nameSingular
+ fieldsList {
+ id
+ name
+ }
+ `,
+ });
+ const companyObjectMetadata = objects.find(
+ (object: { nameSingular: string }) => object.nameSingular === 'company',
+ );
+
+ jestExpectToBeDefined(companyObjectMetadata);
+ companyObjectMetadataId = companyObjectMetadata.id;
+ const companyNameFieldMetadata = companyObjectMetadata.fieldsList?.find(
+ (field: { name: string }) => field.name === 'name',
+ );
+
+ jestExpectToBeDefined(companyNameFieldMetadata);
+ companyNameFieldMetadataId = companyNameFieldMetadata.id;
+
+ const { data } = await createOneAgent({
+ expectToFail: false,
+ input: {
+ label: 'Application default role assignment probe',
+ prompt: 'Answer what you are asked',
+ modelId: TEST_AI_MODEL_ID,
+ },
+ });
+
+ agentId = data.createOneAgent.id;
+ });
+
+ afterAll(async () => {
+ await deleteOneAgent({ expectToFail: false, input: { id: agentId } });
+ });
+
+ describe('custom application role', () => {
+ let roleStateBefore: Awaited<
+ ReturnType<typeof readCustomApplicationRoleState>
+ >;
+ const roleId = () => customApplicationRoleId;
+
+ beforeAll(async () => {
+ roleStateBefore = await readCustomApplicationRoleState();
+ });
+
+ afterAll(async () => {
+ expect(await readCustomApplicationRoleState()).toEqual(roleStateBefore);
+ });
+
+ it('refuses updateOneRole', async () => {
+ const { errors } = await updateOneRole({
+ expectToFail: true,
+ input: {
+ idToUpdate: roleId(),
+ updatePayload: { label: 'Renamed application role' },
+ },
+ });
+
+ expect(errors?.[0]?.extensions?.code).toBeDefined();
+ expect(JSON.stringify(errors)).toMatch(
+ /not editable|cannot be assigned/i,
+ );
+ });
+
+ it('refuses deleteOneRole', async () => {
+ const { errors } = await deleteOneRole({
+ expectToFail: true,
+ input: { idToDelete: roleId() },
+ });
+
+ expect(errors?.[0]?.extensions?.code).toBeDefined();
+ expect(JSON.stringify(errors)).toMatch(
+ /not editable|cannot be assigned/i,
+ );
+ });
+
+ it('refuses object permissions', async () => {
+ const { errors } = await upsertObjectPermissions({
+ expectToFail: true,
+ input: {
+ roleId: roleId(),
+ objectPermissions: [
+ {
+ objectMetadataId: companyObjectMetadataId,
+ canReadObjectRecords: true,
+ canUpdateObjectRecords: false,
+ },
+ ],
+ },
+ });
+
+ expect(errors?.[0]?.extensions?.code).toBeDefined();
+ expect(JSON.stringify(errors)).toMatch(
+ /not editable|cannot be assigned/i,
+ );
+ });
+
+ it('refuses field permissions', async () => {
+ const { errors } = await upsertFieldPermissions({
+ expectToFail: true,
+ input: {
+ roleId: roleId(),
+ fieldPermissions: [
+ {
+ objectMetadataId: companyObjectMetadataId,
+ fieldMetadataId: companyNameFieldMetadataId,
+ canReadFieldValue: false,
+ canUpdateFieldValue: false,
+ },
+ ],
+ },
+ });
+
+ expect(errors?.[0]?.extensions?.code).toBeDefined();
+ expect(JSON.stringify(errors)).toMatch(
+ /not editable|cannot be assigned/i,
+ );
+ });
+
+ it('refuses permission flags', async () => {
+ const { errors } = await upsertPermissionFlags({
+ expectToFail: true,
+ input: {
+ roleId: roleId(),
+ permissionFlagKeys: [PermissionFlagType.WORKFLOWS],
+ },
+ });
+
+ expect(errors?.[0]?.extensions?.code).toBeDefined();
+ expect(JSON.stringify(errors)).toMatch(
+ /not editable|cannot be assigned/i,
+ );
+ });
+
+ it('refuses assigning it to a member', async () => {
+ const { errors } = await updateWorkspaceMemberRole({
+ expectToFail: true,
+ input: {
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ roleId: roleId(),
+ },
+ });
+
+ expect(errors?.[0]?.extensions?.code).toBeDefined();
+ expect(JSON.stringify(errors)).toMatch(
+ /not editable|cannot be assigned/i,
+ );
+ });
+
+ it('refuses assigning it to an API key', async () => {
+ const response = await makeMetadataApiRequest({
+ query: gql`
+ mutation AssignRoleToApiKey($apiKeyId: UUID!, $roleId: UUID!) {
+ assignRoleToApiKey(apiKeyId: $apiKeyId, roleId: $roleId)
+ }
+ `,
+ variables: { apiKeyId: API_KEY_DATA_SEED_IDS.ID_1, roleId: roleId() },
+ });
+
+ expect(JSON.stringify(response.body.errors)).toMatch(
+ /cannot be assigned/i,
+ );
+ });
+
+ it('refuses assigning it to an agent', async () => {
+ const response = await makeMetadataApiRequest({
+ query: gql`
+ mutation AssignRoleToAgent($agentId: UUID!, $roleId: UUID!) {
+ assignRoleToAgent(agentId: $agentId, roleId: $roleId)
+ }
+ `,
+ variables: { agentId, roleId: roleId() },
+ });
+
+ expect(JSON.stringify(response.body.errors)).toMatch(
+ /cannot be assigned/i,
+ );
+ });
+
+ it.each([
+ {
+ toolName: 'update_role',
+ toolArguments: () => ({
+ roleId: roleId(),
+ update: { label: 'Renamed application role' },
+ }),
+ },
+ {
+ toolName: 'delete_role',
+ toolArguments: () => ({ roleId: roleId() }),
+ },
+ {
+ toolName: 'upsert_object_permissions',
+ toolArguments: () => ({
+ roleId: roleId(),
+ objectPermissions: [
+ {
+ objectMetadataId: companyObjectMetadataId,
+ canReadObjectRecords: true,
+ canUpdateObjectRecords: false,
+ },
+ ],
+ }),
+ },
+ {
+ toolName: 'assign_role_to_workspace_member',
+ toolArguments: () => ({
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ roleId: roleId(),
+ }),
+ },
+ ])(
+ 'refuses the $toolName role tool',
+ async ({ toolName, toolArguments }) => {
+ const output = await executeToolThroughMcp({
+ toolName,
+ toolArguments: toolArguments(),
+ token: APPLE_JANE_ADMIN_ACCESS_TOKEN,
+ });
+
+ expect(output.success).toBe(false);
+ expect(output.error).toMatch(/not editable|cannot be assigned/);
+ },
+ );
+ });
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-automated-workflow-run-standard-application-default-role.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-automated-workflow-run-standard-application-default-role.integration-spec.ts
index 4ac11550f9d..faf1c002310 100644
--- a/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-automated-workflow-run-standard-application-default-role.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-automated-workflow-run-standard-application-default-role.integration-spec.ts
@@ -7,11 +7,12 @@ import {
updateCoreWorkflowVersionTrigger,
} from 'test/integration/graphql/suites/workflow/utils/core-workflow.util';
import { workflowGraphqlRequest } from 'test/integration/graphql/suites/workflow/utils/workflow-graphql-request.util';
-import { findStandardApplicationDefaultRole } from 'test/integration/metadata/suites/application-default-role/utils/find-standard-application-default-role.util';
+import { findApplicationDefaultRole } from 'test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util';
import { expectEventually } from 'test/integration/utils/expect-eventually.util';
import { isDefined } from 'twenty-shared/utils';
import { WorkflowActionType } from 'twenty-shared/workflow';
+import { TWENTY_STANDARD_APPLICATION } from 'src/engine/workspace-manager/twenty-standard-application/constants/twenty-standard-applications';
import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
type WorkflowRun = {
@@ -102,8 +103,11 @@ describe('An automated workflow run acts with the standard application default r
});
it('reads records with Admin as the standard application default role', async () => {
- const standardApplicationDefaultRole =
- await findStandardApplicationDefaultRole();
+ const standardApplicationDefaultRole = await findApplicationDefaultRole({
+ input: {
+ universalIdentifier: TWENTY_STANDARD_APPLICATION.universalIdentifier,
+ },
+ });
expect(standardApplicationDefaultRole?.universalIdentifier).toBe(
STANDARD_ROLE.admin.universalIdentifier,
diff --git a/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-new-workspace-custom-application-default-role.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-new-workspace-custom-application-default-role.integration-spec.ts
new file mode 100644
index 00000000000..2337e3af837
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-new-workspace-custom-application-default-role.integration-spec.ts
@@ -0,0 +1,96 @@
+import { randomUUID } from 'crypto';
+
+import {
+ findApplicationDefaultRole,
+ findWorkspaceCustomApplicationId,
+} from 'test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util';
+import { activateWorkspace } from 'test/integration/graphql/utils/activate-workspace.util';
+import { getAuthTokensFromLoginToken } from 'test/integration/graphql/utils/get-auth-tokens-from-login-token.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 { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
+
+const ADMIN_PERMISSIONS = {
+ isEditable: false,
+ canUpdateAllSettings: true,
+ canAccessAllTools: true,
+ canAccessAllAgentChatChannels: true,
+ canReadAllObjectRecords: true,
+ canUpdateAllObjectRecords: true,
+ canSoftDeleteAllObjectRecords: true,
+ canDestroyAllObjectRecords: true,
+};
+
+const UNASSIGNABLE_ROLE = {
+ canBeAssignedToUsers: false,
+ canBeAssignedToAgents: false,
+ canBeAssignedToApiKeys: false,
+};
+
+describe('A new workspace gives the custom application its own default role', () => {
+ let workspaceId: string | undefined;
+ let accessToken: string;
+
+ beforeAll(async () => {
+ jest.useRealTimers();
+
+ const email = `test-${randomUUID()}@example.com`;
+ const { data: signUpData } = await signUp({
+ input: { email, password: 'Test123!@#' },
+ expectToFail: false,
+ });
+
+ await globalThis.testDataSource.query(
+ 'UPDATE core."user" SET "isEmailVerified" = true WHERE email = $1',
+ [email],
+ );
+
+ const {
+ data: { signUpInNewWorkspace: newWorkspaceData },
+ } = await signUpInNewWorkspace({
+ accessToken:
+ signUpData.signUp.tokens.accessOrWorkspaceAgnosticToken.token,
+ expectToFail: false,
+ });
+
+ workspaceId = newWorkspaceData.workspace.id;
+
+ const {
+ data: { getAuthTokensFromLoginToken: authTokensData },
+ } = await getAuthTokensFromLoginToken({
+ origin: newWorkspaceData.workspace.workspaceUrls.subdomainUrl,
+ loginToken: newWorkspaceData.loginToken.token,
+ expectToFail: false,
+ });
+
+ accessToken = authTokensData.tokens.accessOrWorkspaceAgnosticToken.token;
+
+ await activateWorkspace({ accessToken, expectToFail: false });
+ });
+
+ afterAll(async () => {
+ if (isDefined(workspaceId)) {
+ await getAppProviderByClassName<WorkspaceService>(
+ 'WorkspaceService',
+ ).deleteWorkspace(workspaceId);
+ }
+ });
+
+ it('gives the custom application a locked, Admin-equivalent role it owns and nobody can be assigned', async () => {
+ const customApplicationId =
+ await findWorkspaceCustomApplicationId(accessToken);
+ const customApplicationDefaultRole = await findApplicationDefaultRole({
+ input: { id: customApplicationId },
+ token: accessToken,
+ });
+
+ expect(customApplicationDefaultRole).toMatchObject({
+ ...ADMIN_PERMISSIONS,
+ ...UNASSIGNABLE_ROLE,
+ applicationId: customApplicationId,
+ });
+ });
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-new-workspace-standard-application-default-role.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-new-workspace-standard-application-default-role.integration-spec.ts
index d7120c06070..6b6aa11ef71 100644
--- a/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-new-workspace-standard-application-default-role.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-new-workspace-standard-application-default-role.integration-spec.ts
@@ -1,6 +1,6 @@
import { randomUUID } from 'crypto';
-import { findStandardApplicationDefaultRole } from 'test/integration/metadata/suites/application-default-role/utils/find-standard-application-default-role.util';
+import { findApplicationDefaultRole } from 'test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util';
import { activateWorkspace } from 'test/integration/graphql/utils/activate-workspace.util';
import { getAuthTokensFromLoginToken } from 'test/integration/graphql/utils/get-auth-tokens-from-login-token.util';
import { signUpInNewWorkspace } from 'test/integration/graphql/utils/sign-up-in-new-workspace.util';
@@ -9,6 +9,7 @@ import { getAppProviderByClassName } from 'test/integration/utils/get-app-provid
import { isDefined } from 'twenty-shared/utils';
import { type WorkspaceService } from 'src/engine/core-modules/workspace/services/workspace.service';
+import { TWENTY_STANDARD_APPLICATION } from 'src/engine/workspace-manager/twenty-standard-application/constants/twenty-standard-applications';
import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
describe('A new workspace gives the standard application Admin as default role', () => {
@@ -61,8 +62,12 @@ describe('A new workspace gives the standard application Admin as default role',
});
it('gives the standard application the Admin role', async () => {
- const standardApplicationDefaultRole =
- await findStandardApplicationDefaultRole(accessToken);
+ const standardApplicationDefaultRole = await findApplicationDefaultRole({
+ input: {
+ universalIdentifier: TWENTY_STANDARD_APPLICATION.universalIdentifier,
+ },
+ token: accessToken,
+ });
expect(standardApplicationDefaultRole).toMatchObject({
label: 'Admin',
diff --git a/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-workspace-custom-application-token-role.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-workspace-custom-application-token-role.integration-spec.ts
new file mode 100644
index 00000000000..8b818d76a4d
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-workspace-custom-application-token-role.integration-spec.ts
@@ -0,0 +1,41 @@
+import gql from 'graphql-tag';
+import { findWorkspaceCustomApplicationId } from 'test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util';
+import { makeGraphqlApiRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';
+import { generateApplicationTokenPair } from 'test/integration/utils/generate-application-token-pair.util';
+
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+describe('The workspace custom application acts with its own default role', () => {
+ let customApplicationToken: string;
+
+ beforeAll(async () => {
+ const { applicationAccessToken } = await generateApplicationTokenPair({
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ applicationId: await findWorkspaceCustomApplicationId(),
+ });
+
+ customApplicationToken = applicationAccessToken.token;
+ });
+
+ it('reads records with its own application token, as a workspace logic function does', async () => {
+ const response = await makeGraphqlApiRequest(
+ {
+ query: gql`
+ query Companies {
+ companies(first: 5) {
+ edges {
+ node {
+ id
+ }
+ }
+ }
+ }
+ `,
+ },
+ customApplicationToken,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.companies.edges.length).toBeGreaterThan(0);
+ });
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util.ts b/packages/twenty-server/test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util.ts
new file mode 100644
index 00000000000..4f88d7c41ce
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/utils/find-application-default-role.util.ts
@@ -0,0 +1,75 @@
+import gql from 'graphql-tag';
+import { findOneApplication } from 'test/integration/metadata/suites/application/utils/find-one-application.util';
+import { type FindOneApplicationFactoryInput } from 'test/integration/metadata/suites/application/utils/find-one-application-query-factory.util';
+import { findRoles } from 'test/integration/metadata/suites/role/utils/find-roles.util';
+import { makeMetadataApiRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
+
+const APPLICATION_DEFAULT_ROLE_GQL_FIELDS = `
+ id
+ label
+ universalIdentifier
+ applicationId
+ isEditable
+ canUpdateAllSettings
+ canAccessAllTools
+ canAccessAllAgentChatChannels
+ canReadAllObjectRecords
+ canUpdateAllObjectRecords
+ canSoftDeleteAllObjectRecords
+ canDestroyAllObjectRecords
+ canBeAssignedToUsers
+ canBeAssignedToAgents
+ canBeAssignedToApiKeys
+`;
+
+export const findWorkspaceCustomApplicationId = async (
+ token?: string,
+): Promise<string> => {
+ const response = await makeMetadataApiRequest(
+ {
+ query: gql`
+ query CurrentWorkspaceCustomApplication {
+ currentUser {
+ currentWorkspace {
+ workspaceCustomApplication {
+ id
+ }
+ }
+ }
+ }
+ `,
+ },
+ token,
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data.currentUser.currentWorkspace
+ .workspaceCustomApplication.id;
+};
+
+export const findApplicationDefaultRole = async ({
+ input,
+ gqlFields = APPLICATION_DEFAULT_ROLE_GQL_FIELDS,
+ token,
+}: {
+ input: FindOneApplicationFactoryInput;
+ gqlFields?: string;
+ token?: string;
+}) => {
+ const { data: applicationData } = await findOneApplication({
+ input,
+ gqlFields: 'id defaultRoleId',
+ expectToFail: false,
+ token,
+ });
+ const { data: rolesData } = await findRoles({
+ gqlFields,
+ expectToFail: false,
+ token,
+ });
+
+ return rolesData.getRoles.find(
+ ({ id }) => id === applicationData.findOneApplication.defaultRoleId,
+ );
+};
diff --git a/packages/twenty-server/test/integration/metadata/suites/application-default-role/utils/find-standard-application-default-role.util.ts b/packages/twenty-server/test/integration/metadata/suites/application-default-role/utils/find-standard-application-default-role.util.ts
deleted file mode 100644
index 727d9191cf2..00000000000
--- a/packages/twenty-server/test/integration/metadata/suites/application-default-role/utils/find-standard-application-default-role.util.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { findOneApplication } from 'test/integration/metadata/suites/application/utils/find-one-application.util';
-import { findRoles } from 'test/integration/metadata/suites/role/utils/find-roles.util';
-
-import { TWENTY_STANDARD_APPLICATION } from 'src/engine/workspace-manager/twenty-standard-application/constants/twenty-standard-applications';
-
-export const findStandardApplicationDefaultRole = async (token?: string) => {
- const { data: applicationData } = await findOneApplication({
- input: {
- universalIdentifier: TWENTY_STANDARD_APPLICATION.universalIdentifier,
- },
- gqlFields: 'id defaultRoleId',
- expectToFail: false,
- token,
- });
- const { data: rolesData } = await findRoles({
- gqlFields: 'id label universalIdentifier isEditable',
- expectToFail: false,
- token,
- });
-
- return rolesData.getRoles.find(
- ({ id }) => id === applicationData.findOneApplication.defaultRoleId,
- );
-};