Skip to content

The open alternative to Salesforce, designed for AI.

Set Admin as the Twenty standard application default role (#28667)

Paul Rastoin340bb7a0a6fa
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 65729d3dce8..f1f1fef3a34 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
@@ -4,6 +4,7 @@ import { WorkspaceIteratorModule } from 'src/database/commands/command-runners/w
import { FileSettledAgentChatThreadsCommand } from 'src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792612809770-file-settled-agent-chat-threads.command';
import { DeleteConnectedAccountsOutsideProviderScopeCommand } from 'src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792675225627-delete-connected-accounts-outside-provider-scope.command';
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 { 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';
@@ -21,6 +22,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
FileSettledAgentChatThreadsCommand,
DeleteConnectedAccountsOutsideProviderScopeCommand,
AddAgentChatChannelsCommand,
+ BackfillStandardApplicationDefaultRoleCommand,
],
})
export class V2_51_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792741864752-backfill-standard-application-default-role.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792741864752-backfill-standard-application-default-role.command.ts
new file mode 100644
index 00000000000..d974655f177
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792741864752-backfill-standard-application-default-role.command.ts
@@ -0,0 +1,77 @@
+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 { ApplicationService } from 'src/engine/core-modules/application/application.service';
+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 { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
+
+@RegisteredWorkspaceCommand('2.51.0', 1792741864752)
+@Command({
+ name: 'upgrade:2-51:backfill-standard-application-default-role',
+ description:
+ 'Set Admin as the default role of the Twenty standard application',
+})
+export class BackfillStandardApplicationDefaultRoleCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly applicationService: ApplicationService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ options,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ const { twentyStandardFlatApplication } =
+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(
+ { workspaceId },
+ );
+
+ if (isDefined(twentyStandardFlatApplication.defaultRoleId)) {
+ return;
+ }
+
+ const { flatRoleMaps } = await this.workspaceCacheService.getOrRecompute(
+ workspaceId,
+ ['flatRoleMaps'],
+ );
+
+ const adminFlatRole = findFlatEntityByUniversalIdentifier({
+ universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
+ flatEntityMaps: flatRoleMaps,
+ });
+
+ // Without Admin the runtime fallback finds no role either, so behavior is unchanged
+ if (!isDefined(adminFlatRole)) {
+ this.logger.warn(
+ `Workspace ${workspaceId}: no Admin role, standard application default role left unset`,
+ );
+
+ return;
+ }
+
+ if (options.dryRun) {
+ this.logger.log(
+ `[DRY RUN] Workspace ${workspaceId}: would set Admin as the standard application default role`,
+ );
+
+ return;
+ }
+
+ await this.applicationService.update(twentyStandardFlatApplication.id, {
+ workspaceId,
+ defaultRoleId: adminFlatRole.id,
+ });
+
+ this.logger.log(
+ `Workspace ${workspaceId}: set Admin as the standard application default role`,
+ );
+ }
+}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/__tests__/2-51-workspace-command-1792741864752-backfill-standard-application-default-role.command.spec.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/__tests__/2-51-workspace-command-1792741864752-backfill-standard-application-default-role.command.spec.ts
new file mode 100644
index 00000000000..d610faf61c8
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-51/__tests__/2-51-workspace-command-1792741864752-backfill-standard-application-default-role.command.spec.ts
@@ -0,0 +1,96 @@
+import { type WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { BackfillStandardApplicationDefaultRoleCommand } from 'src/database/commands/upgrade-version-command/2-51/2-51-workspace-command-1792741864752-backfill-standard-application-default-role.command';
+import { type ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { type WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
+
+const WORKSPACE_ID = '20202020-0000-4000-8000-000000000001';
+const STANDARD_APPLICATION_ID = '20202020-0000-4000-8000-0000000000a1';
+const ADMIN_ROLE_ID = 'role-admin';
+
+describe('BackfillStandardApplicationDefaultRoleCommand', () => {
+ let standardApplicationDefaultRoleId: string | null;
+ let hasAdminRole: boolean;
+ let command: BackfillStandardApplicationDefaultRoleCommand;
+
+ beforeEach(() => {
+ standardApplicationDefaultRoleId = null;
+ hasAdminRole = true;
+
+ const workspaceCacheService = {
+ getOrRecompute: jest.fn(async () => ({
+ flatRoleMaps: {
+ byUniversalIdentifier: hasAdminRole
+ ? {
+ [STANDARD_ROLE.admin.universalIdentifier]: {
+ id: ADMIN_ROLE_ID,
+ universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
+ },
+ }
+ : {},
+ },
+ })),
+ } as unknown as WorkspaceCacheService;
+
+ const applicationService = {
+ findWorkspaceTwentyStandardAndCustomApplicationOrThrow: jest.fn(
+ async () => ({
+ twentyStandardFlatApplication: {
+ id: STANDARD_APPLICATION_ID,
+ defaultRoleId: standardApplicationDefaultRoleId,
+ },
+ }),
+ ),
+ update: jest.fn(
+ async (_id: string, { defaultRoleId }: { defaultRoleId: string }) => {
+ standardApplicationDefaultRoleId = defaultRoleId;
+ },
+ ),
+ } as unknown as ApplicationService;
+
+ command = new BackfillStandardApplicationDefaultRoleCommand(
+ {} as WorkspaceIteratorService,
+ workspaceCacheService,
+ applicationService,
+ );
+
+ jest.spyOn(command['logger'], 'log').mockImplementation();
+ jest.spyOn(command['logger'], 'warn').mockImplementation();
+ });
+
+ const run = (dryRun = false) =>
+ command.runOnWorkspace({
+ workspaceId: WORKSPACE_ID,
+ options: { dryRun },
+ index: 0,
+ total: 1,
+ });
+
+ it('sets Admin as the standard application default role', async () => {
+ await run();
+
+ expect(standardApplicationDefaultRoleId).toBe(ADMIN_ROLE_ID);
+ });
+
+ it('leaves a standard application that already has a default role alone', async () => {
+ standardApplicationDefaultRoleId = 'another-role';
+
+ await run();
+
+ expect(standardApplicationDefaultRoleId).toBe('another-role');
+ });
+
+ it('leaves the default role unset in a workspace without an Admin role', async () => {
+ hasAdminRole = false;
+
+ await expect(run()).resolves.toBeUndefined();
+
+ expect(standardApplicationDefaultRoleId).toBeNull();
+ });
+
+ it('writes nothing in dry-run mode', async () => {
+ await run(true);
+
+ expect(standardApplicationDefaultRoleId).toBeNull();
+ });
+});
diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/services/twenty-standard-application.service.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/services/twenty-standard-application.service.ts
index 12620336a0e..223fe2186d7 100644
--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/services/twenty-standard-application.service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/services/twenty-standard-application.service.ts
@@ -1,6 +1,13 @@
import { Injectable } from '@nestjs/common';
+import { isDefined } from 'twenty-shared/utils';
+
+import {
+ ApplicationException,
+ ApplicationExceptionCode,
+} from 'src/engine/core-modules/application/application.exception';
import { ApplicationService } from 'src/engine/core-modules/application/application.service';
+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';
import { MetadataFlatEntity } from 'src/engine/metadata-modules/flat-entity/types/metadata-flat-entity.type';
import { getMetadataFlatEntityMapsKey } from 'src/engine/metadata-modules/flat-entity/utils/get-metadata-flat-entity-maps-key.util';
import { findManyFlatEntityByUniversalIdentifierInUniversalFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-many-flat-entity-by-universal-identifier-in-universal-flat-entity-maps.util';
@@ -8,6 +15,7 @@ import { getSubFlatEntityMapsByApplicationIdsOrThrow } from 'src/engine/metadata
import { computeMissingInitialObjectViewOperations } from 'src/engine/metadata-modules/view/utils/compute-missing-initial-object-view-operations.util';
import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';
import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
import { TWENTY_STANDARD_ALL_METADATA_NAME } from 'src/engine/workspace-manager/twenty-standard-application/constants/twenty-standard-all-metadata-name.constant';
import { keepWorkspaceOwnedProperties } from 'src/engine/metadata-modules/flat-entity/utils/keep-workspace-owned-properties.util';
import { computeTwentyStandardApplicationAllFlatEntityMaps } from 'src/engine/workspace-manager/twenty-standard-application/utils/twenty-standard-application-all-flat-entity-maps.constant';
@@ -109,6 +117,13 @@ export class TwentyStandardApplicationService {
);
}
+ if (!isDefined(twentyStandardFlatApplication.defaultRoleId)) {
+ await this.setStandardApplicationDefaultRoleOrThrow({
+ workspaceId,
+ twentyStandardApplicationId: twentyStandardFlatApplication.id,
+ });
+ }
+
await this.seedStandardObjectInitialViewsOrThrow({
workspaceId,
standardObjectMetadataUniversalIdentifiers: Object.keys(
@@ -118,6 +133,36 @@ export class TwentyStandardApplicationService {
});
}
+ private async setStandardApplicationDefaultRoleOrThrow({
+ workspaceId,
+ twentyStandardApplicationId,
+ }: {
+ workspaceId: string;
+ twentyStandardApplicationId: string;
+ }): Promise<void> {
+ const { flatRoleMaps } = await this.workspaceCacheService.getOrRecompute(
+ workspaceId,
+ ['flatRoleMaps'],
+ );
+
+ const adminFlatRole = findFlatEntityByUniversalIdentifier({
+ universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
+ flatEntityMaps: flatRoleMaps,
+ });
+
+ if (!isDefined(adminFlatRole)) {
+ throw new ApplicationException(
+ `Could not find the Admin role in workspace ${workspaceId}`,
+ ApplicationExceptionCode.ENTITY_NOT_FOUND,
+ );
+ }
+
+ await this.applicationService.update(twentyStandardApplicationId, {
+ workspaceId,
+ defaultRoleId: adminFlatRole.id,
+ });
+ }
+
private async seedStandardObjectInitialViewsOrThrow({
workspaceId,
standardObjectMetadataUniversalIdentifiers,
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
new file mode 100644
index 00000000000..4ac11550f9d
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-automated-workflow-run-standard-application-default-role.integration-spec.ts
@@ -0,0 +1,133 @@
+import {
+ activateCoreWorkflowVersion,
+ createCoreWorkflow,
+ createCoreWorkflowVersionStep,
+ deleteCoreWorkflows,
+ updateCoreWorkflowVersionStep,
+ 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 { expectEventually } from 'test/integration/utils/expect-eventually.util';
+import { isDefined } from 'twenty-shared/utils';
+import { WorkflowActionType } from 'twenty-shared/workflow';
+
+import { STANDARD_ROLE } from 'src/engine/workspace-manager/twenty-standard-application/constants/standard-role.constant';
+
+type WorkflowRun = {
+ status: string;
+ state: {
+ stepInfos: Record<string, { result?: { totalCount?: number | string } }>;
+ };
+};
+
+const findWorkflowRuns = async (
+ coreWorkflowId: string,
+): Promise<WorkflowRun[]> => {
+ const response = await workflowGraphqlRequest(
+ `query WorkflowRuns($coreWorkflowId: UUID!) {
+ workflowRuns(filter: { coreWorkflowId: { eq: $coreWorkflowId } }) {
+ edges { node { status state } }
+ }
+ }`,
+ { coreWorkflowId },
+ );
+
+ expect(response.body.errors).toBeUndefined();
+
+ return response.body.data.workflowRuns.edges.map(
+ ({ node }: { node: WorkflowRun }) => node,
+ );
+};
+
+describe('An automated workflow run acts with the standard application default role', () => {
+ let coreWorkflowId: string | undefined;
+ let findCompaniesStepId: string;
+ let companyId: string | undefined;
+
+ beforeAll(async () => {
+ jest.useRealTimers();
+
+ const createdCoreWorkflow = await createCoreWorkflow({
+ name: 'Automated run with the standard application role',
+ });
+
+ coreWorkflowId = createdCoreWorkflow.coreWorkflowId;
+
+ const { coreWorkflowVersionId } = createdCoreWorkflow;
+
+ await updateCoreWorkflowVersionTrigger({
+ coreWorkflowVersionId,
+ trigger: {
+ name: 'Company is created',
+ type: 'DATABASE_EVENT',
+ settings: { eventName: 'company.created', outputSchema: {} },
+ nextStepIds: [],
+ position: { x: 0, y: 0 },
+ },
+ });
+
+ const findCompaniesStep = await createCoreWorkflowVersionStep({
+ coreWorkflowVersionId,
+ stepType: WorkflowActionType.FIND_RECORDS,
+ });
+
+ findCompaniesStepId = findCompaniesStep.id;
+
+ await updateCoreWorkflowVersionStep({
+ coreWorkflowVersionId,
+ step: {
+ ...findCompaniesStep,
+ settings: {
+ ...findCompaniesStep.settings,
+ input: { objectName: 'company', limit: 1 },
+ },
+ },
+ });
+
+ await activateCoreWorkflowVersion({ coreWorkflowVersionId });
+ });
+
+ afterAll(async () => {
+ if (isDefined(companyId)) {
+ await workflowGraphqlRequest(
+ 'mutation Destroy($id: UUID!) { destroyCompany(id: $id) { id } }',
+ { id: companyId },
+ );
+ }
+
+ if (isDefined(coreWorkflowId)) {
+ await deleteCoreWorkflows({ coreWorkflowIds: [coreWorkflowId] });
+ }
+ });
+
+ it('reads records with Admin as the standard application default role', async () => {
+ const standardApplicationDefaultRole =
+ await findStandardApplicationDefaultRole();
+
+ expect(standardApplicationDefaultRole?.universalIdentifier).toBe(
+ STANDARD_ROLE.admin.universalIdentifier,
+ );
+
+ const response = await workflowGraphqlRequest(
+ 'mutation { createCompany(data: { name: "Standard application role" }) { id } }',
+ );
+
+ expect(response.body.errors).toBeUndefined();
+ companyId = response.body.data.createCompany.id;
+
+ let workflowRun: WorkflowRun | undefined;
+
+ await expectEventually(async () => {
+ [workflowRun] = await findWorkflowRuns(coreWorkflowId as string);
+
+ expect(workflowRun?.status).toBe('COMPLETED');
+ });
+
+ expect(
+ Number(
+ workflowRun?.state.stepInfos[findCompaniesStepId]?.result?.totalCount,
+ ),
+ ).toBeGreaterThan(0);
+ });
+});
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
new file mode 100644
index 00000000000..d7120c06070
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/successful-new-workspace-standard-application-default-role.integration-spec.ts
@@ -0,0 +1,72 @@
+import { randomUUID } from 'crypto';
+
+import { findStandardApplicationDefaultRole } from 'test/integration/metadata/suites/application-default-role/utils/find-standard-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';
+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', () => {
+ 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 standard application the Admin role', async () => {
+ const standardApplicationDefaultRole =
+ await findStandardApplicationDefaultRole(accessToken);
+
+ expect(standardApplicationDefaultRole).toMatchObject({
+ label: 'Admin',
+ universalIdentifier: STANDARD_ROLE.admin.universalIdentifier,
+ });
+ });
+});
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
new file mode 100644
index 00000000000..727d9191cf2
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/application-default-role/utils/find-standard-application-default-role.util.ts
@@ -0,0 +1,24 @@
+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,
+ );
+};