Skip to content

The open alternative to Salesforce, designed for AI.

Require CONNECTED_ACCOUNTS to add or reconnect a personal app connection (#28089)

nitin7134c0fe5930
diff --git a/packages/twenty-docs/developers/extend/apps/logic/connections.mdx b/packages/twenty-docs/developers/extend/apps/logic/connections.mdx
index f7850a629bf..6e33fa11d58 100644
--- a/packages/twenty-docs/developers/extend/apps/logic/connections.mdx
+++ b/packages/twenty-docs/developers/extend/apps/logic/connections.mdx
@@ -377,6 +377,8 @@ A provider has exactly one scope. If your app needs both a shared credential and
Twenty refuses a new connection whose scope does not match the provider's, including when your app changes its scope while a member is on the provider's consent screen. Changing `scope` in a later version does not move or delete existing connections: they keep their scope and can still be disconnected or reconnected.
+Adding or reconnecting a **Just for me** connection requires `CONNECTED_ACCOUNTS` permission, and adding or reconnecting a **Workspace shared** one requires `APPLICATIONS` permission. Reconnecting a **Workspace shared** connection as **Just for me** requires both.
+
Use the right connection for each handler:
```ts
diff --git a/packages/twenty-server/src/engine/core-modules/application/connection-provider/app-connection-access.service.ts b/packages/twenty-server/src/engine/core-modules/application/connection-provider/app-connection-access.service.ts
index d766aa05b69..668395554d3 100644
--- a/packages/twenty-server/src/engine/core-modules/application/connection-provider/app-connection-access.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/connection-provider/app-connection-access.service.ts
@@ -1,9 +1,8 @@
import { Injectable } from '@nestjs/common';
import { msg } from '@lingui/core/macro';
-import { ConnectedAccountProvider } from 'twenty-shared/types';
+import { PermissionFlagType } from 'twenty-shared/constants';
-import { getConnectedAccountAdministrationPermissionFlag } from 'src/engine/metadata-modules/connected-account/utils/get-connected-account-administration-permission-flag.util';
import {
PermissionsException,
PermissionsExceptionCode,
@@ -30,30 +29,30 @@ export class AppConnectionAccessService {
applicationId?: string;
agentId?: string;
}): Promise<void> {
- if (!isWorkspaceShared) {
- return;
- }
-
const hasPermission =
await this.permissionsService.userHasWorkspaceSettingPermission({
userWorkspaceId,
workspaceId,
- setting: getConnectedAccountAdministrationPermissionFlag(
- ConnectedAccountProvider.APP,
- ),
+ setting: isWorkspaceShared
+ ? PermissionFlagType.APPLICATIONS
+ : PermissionFlagType.CONNECTED_ACCOUNTS,
apiKeyId,
applicationId,
agentId,
});
- if (!hasPermission) {
- throw new PermissionsException(
- PermissionsExceptionMessage.PERMISSION_DENIED,
- PermissionsExceptionCode.PERMISSION_DENIED,
- {
- userFriendlyMessage: msg`You do not have permission to manage connections shared with the workspace. Please contact your workspace administrator for access.`,
- },
- );
+ if (hasPermission) {
+ return;
}
+
+ throw new PermissionsException(
+ PermissionsExceptionMessage.PERMISSION_DENIED,
+ PermissionsExceptionCode.PERMISSION_DENIED,
+ {
+ userFriendlyMessage: isWorkspaceShared
+ ? msg`You do not have permission to manage connections shared with the workspace. Please contact your workspace administrator for access.`
+ : msg`You do not have permission to connect accounts. Please contact your workspace administrator for access.`,
+ },
+ );
}
}
diff --git a/packages/twenty-server/src/engine/core-modules/application/connection-provider/connection-provider-oauth-flow.service.ts b/packages/twenty-server/src/engine/core-modules/application/connection-provider/connection-provider-oauth-flow.service.ts
index 76938d3048d..ec68f6ae6f7 100644
--- a/packages/twenty-server/src/engine/core-modules/application/connection-provider/connection-provider-oauth-flow.service.ts
+++ b/packages/twenty-server/src/engine/core-modules/application/connection-provider/connection-provider-oauth-flow.service.ts
@@ -109,11 +109,11 @@ export class ConnectionProviderOAuthFlowService {
reconnectTarget,
});
- await this.appConnectionAccessService.validateCallerCanManageConnection({
- isWorkspaceShared:
- scope === 'WORKSPACE' || reconnectTarget?.scope === 'WORKSPACE',
+ await this.validateCallerCanManageRequestedConnection({
workspaceId,
userWorkspaceId,
+ scope,
+ reconnectTarget,
});
const { clientId } =
@@ -188,6 +188,13 @@ export class ConnectionProviderOAuthFlowService {
reconnectTarget,
});
+ await this.validateCallerCanManageRequestedConnection({
+ workspaceId: statePayload.workspaceId,
+ userWorkspaceId: statePayload.userWorkspaceId,
+ scope: statePayload.scope,
+ reconnectTarget,
+ });
+
const { clientId, clientSecret } =
await this.oauthProviderService.getClientCredentials(provider);
@@ -250,6 +257,34 @@ export class ConnectionProviderOAuthFlowService {
};
}
+ private async validateCallerCanManageRequestedConnection({
+ workspaceId,
+ userWorkspaceId,
+ scope,
+ reconnectTarget,
+ }: {
+ workspaceId: string;
+ userWorkspaceId: string;
+ scope: ConnectedAccountScope;
+ reconnectTarget: ConnectedAccountEntity | null;
+ }): Promise<void> {
+ if (scope === 'WORKSPACE' || reconnectTarget?.scope === 'WORKSPACE') {
+ await this.appConnectionAccessService.validateCallerCanManageConnection({
+ isWorkspaceShared: true,
+ workspaceId,
+ userWorkspaceId,
+ });
+ }
+
+ if (scope === 'USER') {
+ await this.appConnectionAccessService.validateCallerCanManageConnection({
+ isWorkspaceShared: false,
+ workspaceId,
+ userWorkspaceId,
+ });
+ }
+ }
+
private async findReconnectTargetOrThrow({
connectionProviderId,
workspaceId,
diff --git a/packages/twenty-server/test/integration/metadata/suites/connection-provider/app-connection-connected-accounts-permission.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/connection-provider/app-connection-connected-accounts-permission.integration-spec.ts
new file mode 100644
index 00000000000..6cd6f6a260f
--- /dev/null
+++ b/packages/twenty-server/test/integration/metadata/suites/connection-provider/app-connection-connected-accounts-permission.integration-spec.ts
@@ -0,0 +1,231 @@
+import { http, HttpResponse } from 'msw';
+import request from 'supertest';
+import { buildBaseManifest } from 'test/integration/metadata/suites/application/utils/build-base-manifest.util';
+import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/suites/application/utils/cleanup-application-and-app-registration.util';
+import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';
+import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';
+import { generateTransientTokenResponse } from 'test/integration/utils/generate-transient-token.util';
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+import { setupHttpMock } from 'test/integration/utils/http-mock.util';
+import { waitForAllJobsToFinish } from 'test/integration/utils/wait-for-all-jobs-to-finish.util';
+import { assertIsDefinedOrThrow } from 'twenty-shared/utils';
+import { v4 } from 'uuid';
+import { z } from 'zod';
+
+import { type ConnectionProviderEntity } from 'src/engine/core-modules/application/connection-provider/connection-provider.entity';
+import { type AppOAuthStateJwtPayload } from 'src/engine/core-modules/auth/types/app-oauth-state-jwt-payload.type';
+import { JwtTokenTypeEnum } from 'src/engine/core-modules/auth/types/jwt-token-type.enum';
+import { type JwtWrapperService } from 'src/engine/core-modules/jwt/services/jwt-wrapper.service';
+import { plaintextStringSchema } from 'src/engine/core-modules/secret-encryption/branded-strings/plaintext-string.type';
+import { type SecretEncryptionService } from 'src/engine/core-modules/secret-encryption/secret-encryption.service';
+import { type ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+import { USER_WORKSPACE_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/core/utils/seed-user-workspaces.util';
+import { USER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/core/utils/seed-users.util';
+
+const APPLICATION_IDENTIFIER = v4();
+const PROVIDER_IDENTIFIER = v4();
+const AUTHORIZATION_ENDPOINT =
+ 'https://connected-accounts-permission.example.com/authorize';
+const TOKEN_ENDPOINT =
+ 'https://connected-accounts-permission.example.com/token';
+
+describe('app connection connected accounts permission', () => {
+ let provider: ConnectionProviderEntity;
+ let tokenExchanges: string[];
+
+ setupHttpMock(
+ http.post(TOKEN_ENDPOINT, async ({ request: tokenRequest }) => {
+ const { code } = z
+ .object({ code: z.string().min(1) })
+ .parse(await tokenRequest.json());
+
+ tokenExchanges.push(code);
+
+ return HttpResponse.json({
+ access_token: code,
+ refresh_token: `refresh-${code}`,
+ token_type: 'Bearer',
+ scope: 'read',
+ });
+ }),
+ );
+
+ const readAccounts = (): Promise<ConnectedAccountEntity[]> =>
+ globalThis.testDataSource.query(
+ 'SELECT * FROM core."connectedAccount" WHERE "connectionProviderId" = $1 ORDER BY "createdAt", id',
+ [provider.id],
+ );
+
+ const authorize = async (accessToken: string): Promise<URL> => {
+ const transient = await generateTransientTokenResponse({
+ token: accessToken,
+ });
+
+ expect(transient.errors).toBeUndefined();
+
+ const response = await request(`http://localhost:${APP_PORT}`)
+ .get('/auth/apps/authorize')
+ .query({
+ applicationId: provider.applicationId,
+ providerName: provider.name,
+ transientToken:
+ transient.data.generateTransientToken.transientToken.token,
+ scope: 'USER',
+ });
+
+ expect(response.status).toBe(302);
+
+ return new URL(response.headers.location);
+ };
+
+ const callback = async (state: string, code: string): Promise<URL> => {
+ const response = await request(`http://localhost:${APP_PORT}`)
+ .get('/auth/apps/callback')
+ .query({ state, code });
+
+ expect(response.status).toBe(302);
+ await waitForAllJobsToFinish();
+
+ return new URL(response.headers.location);
+ };
+
+ beforeAll(async () => {
+ await setupApplicationForSync({
+ applicationUniversalIdentifier: APPLICATION_IDENTIFIER,
+ name: 'Connected accounts permission integration',
+ description: 'User connections require the connected accounts permission',
+ sourcePath: 'connected-accounts-permission-integration',
+ });
+ jest.useRealTimers();
+
+ const { errors } = await syncApplication({
+ manifest: buildBaseManifest({
+ appId: APPLICATION_IDENTIFIER,
+ roleId: v4(),
+ overrides: {
+ connectionProviders: [
+ {
+ universalIdentifier: PROVIDER_IDENTIFIER,
+ name: 'connected-accounts-permission-provider',
+ displayName: 'Connected accounts permission provider',
+ type: 'oauth',
+ scope: 'USER',
+ oauth: {
+ authorizationEndpoint: AUTHORIZATION_ENDPOINT,
+ tokenEndpoint: TOKEN_ENDPOINT,
+ scopes: ['read'],
+ clientIdVariable: 'CLIENT_ID',
+ clientSecretVariable: 'CLIENT_SECRET',
+ },
+ },
+ ],
+ },
+ }),
+ });
+
+ expect(errors).toBeUndefined();
+ jest.useRealTimers();
+ [provider] = await globalThis.testDataSource.query(
+ 'SELECT * FROM core."connectionProvider" WHERE "universalIdentifier" = $1',
+ [PROVIDER_IDENTIFIER],
+ );
+ const encryption = getAppProviderByClassName<SecretEncryptionService>(
+ 'SecretEncryptionService',
+ );
+
+ for (const key of ['CLIENT_ID', 'CLIENT_SECRET']) {
+ await globalThis.testDataSource.query(
+ `INSERT INTO core."applicationRegistrationVariable" (key, "encryptedValue", "applicationRegistrationId")
+ SELECT $1, $2, "applicationRegistrationId" FROM core.application WHERE id = $3`,
+ [
+ key,
+ encryption.encryptVersioned(
+ plaintextStringSchema.parse(`test-${key}`),
+ ),
+ provider.applicationId,
+ ],
+ );
+ }
+ }, 120000);
+
+ beforeEach(() => {
+ tokenExchanges = [];
+ });
+
+ afterEach(async () => {
+ await globalThis.testDataSource.query(
+ 'DELETE FROM core."connectedAccount" WHERE "applicationId" = $1',
+ [provider.applicationId],
+ );
+ });
+
+ afterAll(async () => {
+ await cleanupApplicationAndAppRegistration({
+ applicationUniversalIdentifier: APPLICATION_IDENTIFIER,
+ });
+ });
+
+ it('refuses a guest without the connected accounts permission to start a user connection', async () => {
+ const redirect = await authorize(APPLE_PHIL_GUEST_ACCESS_TOKEN);
+
+ expect(redirect.origin).not.toBe(new URL(AUTHORIZATION_ENDPOINT).origin);
+ expect(redirect.searchParams.get('errorMessage')).toContain(
+ 'does not have permission',
+ );
+ });
+
+ it('lets a member with the connected accounts permission connect a user connection', async () => {
+ const authorizationUrl = await authorize(APPLE_JONY_MEMBER_ACCESS_TOKEN);
+
+ expect(authorizationUrl.origin).toBe(
+ new URL(AUTHORIZATION_ENDPOINT).origin,
+ );
+
+ const state = authorizationUrl.searchParams.get('state');
+
+ assertIsDefinedOrThrow(state);
+
+ const redirect = await callback(state, 'jony-code');
+ const connections = await readAccounts();
+
+ expect(redirect.searchParams.has('errorMessage')).toBe(false);
+ expect(tokenExchanges).toEqual(['jony-code']);
+ expect(connections).toHaveLength(1);
+ expect(connections[0]).toMatchObject({
+ scope: 'USER',
+ userWorkspaceId: USER_WORKSPACE_DATA_SEED_IDS.JONY,
+ });
+ });
+
+ it('refuses the callback for a member without the connected accounts permission', async () => {
+ const jwtWrapperService =
+ getAppProviderByClassName<JwtWrapperService>('JwtWrapperService');
+
+ const statePayload: AppOAuthStateJwtPayload = {
+ sub: provider.id,
+ type: JwtTokenTypeEnum.APP_OAUTH_STATE,
+ connectionProviderId: provider.id,
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ userId: USER_DATA_SEED_IDS.PHIL,
+ userWorkspaceId: USER_WORKSPACE_DATA_SEED_IDS.PHIL,
+ scope: 'USER',
+ visibility: 'user',
+ reconnectingConnectedAccountId: null,
+ redirectLocation: null,
+ codeVerifier: null,
+ };
+
+ const state = await jwtWrapperService.signAsyncOrThrow(statePayload, {
+ expiresIn: '10m',
+ });
+
+ const redirect = await callback(state, 'phil-code');
+
+ expect(redirect.searchParams.get('errorMessage')).toContain(
+ 'does not have permission',
+ );
+ expect(tokenExchanges).toEqual([]);
+ expect(await readAccounts()).toEqual([]);
+ });
+});
diff --git a/packages/twenty-server/test/integration/metadata/suites/connection-provider/app-connection-management-guards.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/connection-provider/app-connection-management-guards.integration-spec.ts
index cb7e1d40407..9484a853dad 100644
--- a/packages/twenty-server/test/integration/metadata/suites/connection-provider/app-connection-management-guards.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/connection-provider/app-connection-management-guards.integration-spec.ts
@@ -4,37 +4,53 @@ import { cleanupApplicationAndAppRegistration } from 'test/integration/metadata/
import { setupApplicationForSync } from 'test/integration/metadata/suites/application/utils/setup-application-for-sync.util';
import { syncApplication } from 'test/integration/metadata/suites/application/utils/sync-application.util';
import { findConnectionProvidersByApplication } from 'test/integration/metadata/suites/connection-provider/utils/find-connection-providers-by-application.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 { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';
+import { updateWorkspaceMemberRole } from 'test/integration/metadata/suites/role/utils/update-workspace-member-role.util';
import { makeMetadataApiRequestWithMemberRole } from 'test/integration/metadata/suites/utils/make-metadata-api-request-with-member-role.util';
-import { generateTransientToken } from 'test/integration/utils/generate-transient-token.util';
+import {
+ generateTransientToken,
+ generateTransientTokenResponse,
+} from 'test/integration/utils/generate-transient-token.util';
import { getDataOrThrow } from 'test/integration/utils/query-messaging.util';
import gql from 'graphql-tag';
+import { PermissionFlagType } from 'twenty-shared/constants';
import { ConnectedAccountProvider } from 'twenty-shared/types';
-import { isDefined } from 'twenty-shared/utils';
+import { assertIsDefinedOrThrow, isDefined } from 'twenty-shared/utils';
import { v4 as uuidv4 } from 'uuid';
import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
import { USER_WORKSPACE_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/core/utils/seed-user-workspaces.util';
+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';
const APP_ID = uuidv4();
const APP_ROLE_ID = uuidv4();
const APP_PROVIDER_ID = uuidv4();
+const APP_PERSONAL_PROVIDER_ID = uuidv4();
const SHARED_BY_TIM_ID = uuidv4();
const PRIVATE_OF_TIM_ID = uuidv4();
const PRIVATE_OF_JONY_ID = uuidv4();
+const PRIVATE_OF_PHIL_ID = uuidv4();
+const SHARED_ON_PERSONAL_PROVIDER_ID = uuidv4();
describe('app connection management guards (e2e)', () => {
let applicationDbId: string;
let providerDbId: string;
+ let personalProviderDbId: string;
const insertAppConnection = async ({
id,
scope,
userWorkspaceId,
+ connectionProviderId = providerDbId,
}: {
id: string;
scope: 'USER' | 'WORKSPACE';
userWorkspaceId: string;
+ connectionProviderId?: string;
}): Promise<void> => {
await globalThis.testDataSource.query(
`INSERT INTO core."connectedAccount"
@@ -49,7 +65,7 @@ describe('app connection management guards (e2e)', () => {
SEED_APPLE_WORKSPACE_ID,
userWorkspaceId,
applicationDbId,
- providerDbId,
+ connectionProviderId,
],
);
};
@@ -74,23 +90,39 @@ describe('app connection management guards (e2e)', () => {
return data.generateTransientToken.transientToken.token;
};
+ const generateGuestTransientToken = async (): Promise<string> => {
+ const { data, errors } = await generateTransientTokenResponse({
+ token: APPLE_PHIL_GUEST_ACCESS_TOKEN,
+ });
+
+ expect(errors).toBeUndefined();
+
+ return data.generateTransientToken.transientToken.token;
+ };
+
+ const transientTokenGenerators = {
+ admin: generateTransientToken,
+ member: generateMemberTransientToken,
+ guest: generateGuestTransientToken,
+ };
+
const startAuthorizeAndGetErrorMessage = async ({
reconnectingConnectedAccountId,
scope,
- asMember = false,
+ as = 'admin',
+ providerName = 'slack',
}: {
reconnectingConnectedAccountId?: string;
scope?: 'USER' | 'WORKSPACE';
- asMember?: boolean;
+ as?: keyof typeof transientTokenGenerators;
+ providerName?: string;
}): Promise<string> => {
const response = await request(`http://localhost:${APP_PORT}`)
.get('/auth/apps/authorize')
.query({
applicationId: applicationDbId,
- providerName: 'slack',
- transientToken: asMember
- ? await generateMemberTransientToken()
- : await generateTransientToken(),
+ providerName,
+ transientToken: await transientTokenGenerators[as](),
...(isDefined(reconnectingConnectedAccountId)
? { reconnectingConnectedAccountId }
: {}),
@@ -131,6 +163,20 @@ describe('app connection management guards (e2e)', () => {
clientSecretVariable: 'SLACK_CLIENT_SECRET',
},
},
+ {
+ universalIdentifier: APP_PERSONAL_PROVIDER_ID,
+ name: 'slack-personal',
+ displayName: 'Slack (personal)',
+ type: 'oauth',
+ scope: 'USER',
+ oauth: {
+ authorizationEndpoint: 'https://slack.com/oauth/v2/authorize',
+ tokenEndpoint: 'https://slack.com/api/oauth.v2.access',
+ scopes: ['chat:write'],
+ clientIdVariable: 'SLACK_CLIENT_ID',
+ clientSecretVariable: 'SLACK_CLIENT_SECRET',
+ },
+ },
],
},
}),
@@ -139,10 +185,18 @@ describe('app connection management guards (e2e)', () => {
jest.useRealTimers();
- const [provider] = await findConnectionProvidersByApplication(APP_ID);
+ const providers = await findConnectionProvidersByApplication(APP_ID);
+ const provider = providers.find(({ name }) => name === 'slack');
+ const personalProvider = providers.find(
+ ({ name }) => name === 'slack-personal',
+ );
+
+ assertIsDefinedOrThrow(provider);
+ assertIsDefinedOrThrow(personalProvider);
applicationDbId = provider.applicationId;
providerDbId = provider.id;
+ personalProviderDbId = personalProvider.id;
await insertAppConnection({
id: SHARED_BY_TIM_ID,
@@ -159,6 +213,17 @@ describe('app connection management guards (e2e)', () => {
scope: 'USER',
userWorkspaceId: USER_WORKSPACE_DATA_SEED_IDS.JONY,
});
+ await insertAppConnection({
+ id: PRIVATE_OF_PHIL_ID,
+ scope: 'USER',
+ userWorkspaceId: USER_WORKSPACE_DATA_SEED_IDS.PHIL,
+ });
+ await insertAppConnection({
+ id: SHARED_ON_PERSONAL_PROVIDER_ID,
+ scope: 'WORKSPACE',
+ userWorkspaceId: USER_WORKSPACE_DATA_SEED_IDS.TIM,
+ connectionProviderId: personalProviderDbId,
+ });
}, 180000);
afterAll(async () => {
@@ -195,7 +260,7 @@ describe('app connection management guards (e2e)', () => {
it('refuses a member without the Applications permission to reconnect a workspace-shared connection', async () => {
const errorMessage = await startAuthorizeAndGetErrorMessage({
reconnectingConnectedAccountId: SHARED_BY_TIM_ID,
- asMember: true,
+ as: 'member',
});
expect(errorMessage).toContain('does not have permission');
@@ -204,7 +269,7 @@ describe('app connection management guards (e2e)', () => {
it('refuses a member without the Applications permission to create a workspace-shared connection', async () => {
const errorMessage = await startAuthorizeAndGetErrorMessage({
scope: 'WORKSPACE',
- asMember: true,
+ as: 'member',
});
expect(errorMessage).toContain('does not have permission');
@@ -214,7 +279,7 @@ describe('app connection management guards (e2e)', () => {
const errorMessage = await startAuthorizeAndGetErrorMessage({
reconnectingConnectedAccountId: PRIVATE_OF_JONY_ID,
scope: 'WORKSPACE',
- asMember: true,
+ as: 'member',
});
expect(errorMessage).toContain('does not have permission');
@@ -223,10 +288,107 @@ describe('app connection management guards (e2e)', () => {
it('lets a member without the Applications permission reconnect their own private connection', async () => {
const errorMessage = await startAuthorizeAndGetErrorMessage({
reconnectingConnectedAccountId: PRIVATE_OF_JONY_ID,
- asMember: true,
+ as: 'member',
});
expect(errorMessage).not.toContain('Cannot reconnect connectedAccount');
expect(errorMessage).not.toContain('does not have permission');
});
+
+ it('refuses a guest without the Connected accounts permission to reconnect their own private connection', async () => {
+ const errorMessage = await startAuthorizeAndGetErrorMessage({
+ reconnectingConnectedAccountId: PRIVATE_OF_PHIL_ID,
+ as: 'guest',
+ });
+
+ expect(errorMessage).toContain('does not have permission');
+ });
+
+ it('refuses a member without the Applications permission to turn a workspace-shared connection into a private one', async () => {
+ const errorMessage = await startAuthorizeAndGetErrorMessage({
+ reconnectingConnectedAccountId: SHARED_ON_PERSONAL_PROVIDER_ID,
+ scope: 'USER',
+ as: 'member',
+ providerName: 'slack-personal',
+ });
+
+ expect(errorMessage).toContain('does not have permission');
+ });
+
+ describe('with the Applications permission and without the Connected accounts permission', () => {
+ let memberRoleId: string;
+ let applicationsOnlyRoleId: string;
+
+ beforeAll(async () => {
+ memberRoleId = (await findOneRoleByLabel({ label: 'Member' })).id;
+
+ const { data } = await createOneRole({
+ expectToFail: false,
+ input: {
+ label: 'App connection guards applications only',
+ canUpdateAllSettings: false,
+ canAccessAllTools: false,
+ canReadAllObjectRecords: true,
+ canUpdateAllObjectRecords: false,
+ canSoftDeleteAllObjectRecords: false,
+ canDestroyAllObjectRecords: false,
+ },
+ });
+
+ applicationsOnlyRoleId = data.createOneRole.id;
+
+ await upsertPermissionFlags({
+ expectToFail: false,
+ input: {
+ roleId: applicationsOnlyRoleId,
+ permissionFlagKeys: [PermissionFlagType.APPLICATIONS],
+ },
+ });
+
+ await updateWorkspaceMemberRole({
+ expectToFail: false,
+ input: {
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ roleId: applicationsOnlyRoleId,
+ },
+ });
+ }, 60000);
+
+ afterAll(async () => {
+ await updateWorkspaceMemberRole({
+ expectToFail: false,
+ input: {
+ workspaceMemberId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,
+ roleId: memberRoleId,
+ },
+ });
+
+ await deleteOneRole({
+ expectToFail: false,
+ input: { idToDelete: applicationsOnlyRoleId },
+ });
+ }, 60000);
+
+ it('lets the member reconnect a workspace-shared connection as shared', async () => {
+ const errorMessage = await startAuthorizeAndGetErrorMessage({
+ reconnectingConnectedAccountId: SHARED_BY_TIM_ID,
+ scope: 'WORKSPACE',
+ as: 'member',
+ });
+
+ expect(errorMessage).not.toContain('Cannot reconnect connectedAccount');
+ expect(errorMessage).not.toContain('does not have permission');
+ });
+
+ it('refuses the member to turn a workspace-shared connection into a private one', async () => {
+ const errorMessage = await startAuthorizeAndGetErrorMessage({
+ reconnectingConnectedAccountId: SHARED_ON_PERSONAL_PROVIDER_ID,
+ scope: 'USER',
+ as: 'member',
+ providerName: 'slack-personal',
+ });
+
+ expect(errorMessage).toContain('does not have permission');
+ });
+ });
});