Skip to content

The open alternative to Salesforce, designed for AI.

Fix shared connected account permissions and visibility (#25777)

neo773ed61031c0dd3
diff --git a/packages/twenty-front/src/modules/activities/emails/hooks/__tests__/useReplyConnectedAccount.test.ts b/packages/twenty-front/src/modules/activities/emails/hooks/__tests__/useReplyConnectedAccount.test.ts
index 937e79bc601..a04d247479f 100644
--- a/packages/twenty-front/src/modules/activities/emails/hooks/__tests__/useReplyConnectedAccount.test.ts
+++ b/packages/twenty-front/src/modules/activities/emails/hooks/__tests__/useReplyConnectedAccount.test.ts
@@ -71,6 +71,26 @@ describe('useReplyConnectedAccount', () => {
});
});
+ it('returns a workspace-shared mailbox the caller does not own', () => {
+ stubQueries(
+ [{ id: 'channel-group', connectedAccountId: 'account-group' }],
+ [
+ {
+ id: 'account-group',
+ handle: '[email protected]',
+ provider: ConnectedAccountProvider.EMAIL_GROUP,
+ },
+ ],
+ );
+
+ const { result } = renderHook(() =>
+ useReplyConnectedAccount('channel-group'),
+ );
+
+ expect(result.current.connectedAccountId).toBe('account-group');
+ expect(result.current.connectedAccountHandle).toBe('[email protected]');
+ });
+
it('returns null when the thread channel is not accessible to the current user', () => {
stubQueries(
[{ id: 'channel-google', connectedAccountId: 'account-google' }],
diff --git a/packages/twenty-front/src/modules/object-record/record-show/components/__stories__/PageLayoutRecordPageRendererEmailThread.stories.tsx b/packages/twenty-front/src/modules/object-record/record-show/components/__stories__/PageLayoutRecordPageRendererEmailThread.stories.tsx
index ee89b557372..8f542dd6e1f 100644
--- a/packages/twenty-front/src/modules/object-record/record-show/components/__stories__/PageLayoutRecordPageRendererEmailThread.stories.tsx
+++ b/packages/twenty-front/src/modules/object-record/record-show/components/__stories__/PageLayoutRecordPageRendererEmailThread.stories.tsx
@@ -34,6 +34,21 @@ const PARTICIPANT_ID = '20202020-0000-4000-8000-00000000par1';
const ASSOCIATION_ID = '20202020-0000-4000-8000-00000000ass1';
const MESSAGE_CHANNEL_ID = '20202020-0000-4000-8000-00000000cha1';
const CONNECTED_ACCOUNT_ID = '20202020-0000-4000-8000-00000000acc1';
+const SHARED_CONNECTED_ACCOUNT_ID = '20202020-0000-4000-8000-00000000acc2';
+
+const ownConnectedAccount = {
+ __typename: 'ConnectedAccount',
+ id: CONNECTED_ACCOUNT_ID,
+ handle: '[email protected]',
+ provider: 'google',
+};
+
+const workspaceSharedConnectedAccount = {
+ __typename: 'ConnectedAccount',
+ id: SHARED_CONNECTED_ACCOUNT_ID,
+ handle: '[email protected]',
+ provider: 'email_group',
+};
const PAGE_LAYOUT_ID = 'email-thread-record-layout';
const PAGE_LAYOUT_TAB_ID = 'email-thread-record-tab';
@@ -139,6 +154,72 @@ const emailThreadPageLayoutWidget = {
deletedAt: null,
};
+const threadContentHandlers = [
+ graphql.query('FindOneMessageThread', () =>
+ HttpResponse.json({
+ data: { messageThread: { __typename: 'MessageThread', id: THREAD_ID } },
+ }),
+ ),
+ graphql.query('FindManyMessages', () =>
+ HttpResponse.json({
+ data: { messages: buildConnection('Message', [threadMessage]) },
+ }),
+ ),
+ graphql.query('FindManyMessageParticipants', () =>
+ HttpResponse.json({
+ data: {
+ messageParticipants: buildConnection('MessageParticipant', [
+ senderParticipant,
+ ]),
+ },
+ }),
+ ),
+ graphql.query('FindManyMessageChannelMessageAssociations', () =>
+ HttpResponse.json({
+ data: {
+ messageChannelMessageAssociations: buildConnection(
+ 'MessageChannelMessageAssociation',
+ [
+ {
+ __typename: 'MessageChannelMessageAssociation',
+ id: ASSOCIATION_ID,
+ messageId: MESSAGE_ID,
+ messageChannelId: MESSAGE_CHANNEL_ID,
+ messageThreadExternalId: 'thread-external-id',
+ messageExternalId: 'message-external-id',
+ },
+ ],
+ ),
+ },
+ }),
+ ),
+];
+
+const buildThreadConnectedAccountHandlers = (connectedAccount: {
+ id: string;
+ handle: string;
+ provider: string;
+}) => [
+ graphql.query('MyConnectedAccounts', () =>
+ HttpResponse.json({
+ data: { myConnectedAccounts: [connectedAccount] },
+ }),
+ ),
+ graphql.query('MyMessageChannels', () =>
+ HttpResponse.json({
+ data: {
+ myMessageChannels: [
+ {
+ __typename: 'MessageChannel',
+ id: MESSAGE_CHANNEL_ID,
+ connectedAccountId: connectedAccount.id,
+ },
+ ],
+ },
+ }),
+ ),
+];
+
// The mocked minimal metadata ships no page layouts, so the record page has no
// layout to render until this seeds one holding the email thread widget.
const SeedEmailThreadPageLayoutEffect = () => {
@@ -207,75 +288,8 @@ const meta: Meta<EmailThreadStoryArgs> = {
layout: 'fullscreen',
msw: {
handlers: [
- graphql.query('FindOneMessageThread', () =>
- HttpResponse.json({
- data: {
- messageThread: { __typename: 'MessageThread', id: THREAD_ID },
- },
- }),
- ),
- graphql.query('FindManyMessages', () =>
- HttpResponse.json({
- data: {
- messages: buildConnection('Message', [threadMessage]),
- },
- }),
- ),
- graphql.query('FindManyMessageParticipants', () =>
- HttpResponse.json({
- data: {
- messageParticipants: buildConnection('MessageParticipant', [
- senderParticipant,
- ]),
- },
- }),
- ),
- graphql.query('FindManyMessageChannelMessageAssociations', () =>
- HttpResponse.json({
- data: {
- messageChannelMessageAssociations: buildConnection(
- 'MessageChannelMessageAssociation',
- [
- {
- __typename: 'MessageChannelMessageAssociation',
- id: ASSOCIATION_ID,
- messageId: MESSAGE_ID,
- messageChannelId: MESSAGE_CHANNEL_ID,
- messageThreadExternalId: 'thread-external-id',
- messageExternalId: 'message-external-id',
- },
- ],
- ),
- },
- }),
- ),
- graphql.query('MyConnectedAccounts', () =>
- HttpResponse.json({
- data: {
- myConnectedAccounts: [
- {
- __typename: 'ConnectedAccount',
- id: CONNECTED_ACCOUNT_ID,
- handle: '[email protected]',
- provider: 'google',
- },
- ],
- },
- }),
- ),
- graphql.query('MyMessageChannels', () =>
- HttpResponse.json({
- data: {
- myMessageChannels: [
- {
- __typename: 'MessageChannel',
- id: MESSAGE_CHANNEL_ID,
- connectedAccountId: CONNECTED_ACCOUNT_ID,
- },
- ],
- },
- }),
- ),
+ ...threadContentHandlers,
+ ...buildThreadConnectedAccountHandlers(ownConnectedAccount),
graphqlMocks.handlers,
],
},
@@ -307,3 +321,30 @@ export const ReplyOpensComposerInSidePanel: Story = {
expect(canvas.queryByText(/invalid configuration/i)).toBeNull();
},
};
+
+export const ReplyIsOfferedOnAWorkspaceSharedMailbox: Story = {
+ parameters: {
+ msw: {
+ handlers: [
+ ...threadContentHandlers,
+ ...buildThreadConnectedAccountHandlers(workspaceSharedConnectedAccount),
+ graphqlMocks.handlers,
+ ],
+ },
+ },
+ play: async ({ canvasElement }) => {
+ const canvas = within(canvasElement);
+
+ const replyButton = await canvas.findByRole(
+ 'button',
+ { name: /reply/i },
+ { timeout: 20000 },
+ );
+
+ await userEvent.click(replyButton);
+
+ await expect(
+ await canvas.findByRole('button', { name: /send/i }, { timeout: 20000 }),
+ ).toBeVisible();
+ },
+};
diff --git a/packages/twenty-server/src/engine/metadata-modules/calendar-channel/calendar-channel-metadata.service.ts b/packages/twenty-server/src/engine/metadata-modules/calendar-channel/calendar-channel-metadata.service.ts
index 85116fa16ca..4406e0d50e9 100644
--- a/packages/twenty-server/src/engine/metadata-modules/calendar-channel/calendar-channel-metadata.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/calendar-channel/calendar-channel-metadata.service.ts
@@ -60,7 +60,7 @@ export class CalendarChannelMetadataService {
userWorkspaceId: string;
workspaceId: string;
}): Promise<CalendarChannelDTO[]> {
- await this.connectedAccountMetadataService.verifyOwnership({
+ await this.connectedAccountMetadataService.verifyUsableByCaller({
id: connectedAccountId,
userWorkspaceId,
workspaceId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/connected-account/connected-account-metadata.service.ts b/packages/twenty-server/src/engine/metadata-modules/connected-account/connected-account-metadata.service.ts
index cec865ca5cc..fc30aa45c0a 100644
--- a/packages/twenty-server/src/engine/metadata-modules/connected-account/connected-account-metadata.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/connected-account/connected-account-metadata.service.ts
@@ -3,8 +3,10 @@ import { InjectRepository } from '@nestjs/typeorm';
import { In, IsNull, Repository } from 'typeorm';
+import { PermissionFlagType } from 'twenty-shared/constants';
import { ConnectedAccountProvider, EmailOperation } from 'twenty-shared/types';
import {
+ assertUnreachable,
canConnectedAccountPerformEmailOperation,
getEmailProvidersForOperation,
isDefined,
@@ -28,6 +30,7 @@ import { isConnectedAccountUsableByCaller } from 'src/engine/metadata-modules/co
import { MESSAGE_CHANNEL_DELETED_EVENT } from 'src/engine/metadata-modules/message-channel/constants/message-channel-deleted.constant';
import { MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
import { type MessageChannelDeletedEvent } from 'src/engine/metadata-modules/message-channel/types/message-channel-deleted.type';
+import { PermissionsService } from 'src/engine/metadata-modules/permissions/permissions.service';
import { WorkspaceEventEmitter } from 'src/engine/workspace-event-emitter/workspace-event-emitter';
@Injectable()
@@ -43,6 +46,7 @@ export class ConnectedAccountMetadataService {
private readonly messageChannelRepository: Repository<MessageChannelEntity>,
private readonly appOAuthRevokeService: AppOAuthRevokeService,
private readonly connectionProviderLifecycleHookService: ConnectionProviderLifecycleHookService,
+ private readonly permissionsService: PermissionsService,
private readonly workspaceEventEmitter: WorkspaceEventEmitter,
) {}
@@ -91,16 +95,32 @@ export class ConnectedAccountMetadataService {
);
}
- async findByUserWorkspaceId({
+ async findUsableByCaller({
userWorkspaceId,
workspaceId,
}: {
userWorkspaceId: string;
workspaceId: string;
}): Promise<ConnectedAccountEntity[]> {
- return this.repository.find({
- where: { userWorkspaceId, workspaceId },
+ const accounts = await this.repository.find({
+ where: buildConnectedAccountUsableByCallerWhere({
+ baseWhere: { workspaceId },
+ userWorkspaceId,
+ }),
+ order: { createdAt: 'ASC', id: 'ASC' },
});
+
+ const ownedAccounts = accounts.filter(
+ (account) => account.userWorkspaceId === userWorkspaceId,
+ );
+
+ const activeSharedAccountsOwnedByOthers = accounts.filter(
+ (account) =>
+ account.userWorkspaceId !== userWorkspaceId &&
+ !isDefined(account.archivedAt),
+ );
+
+ return [...ownedAccounts, ...activeSharedAccountsOwnedByOthers];
}
async findApplicationConnectedAccountsUsableByCaller({
@@ -170,7 +190,7 @@ export class ConnectedAccountMetadataService {
});
}
- async verifyOwnership({
+ async verifyUsableByCaller({
id,
userWorkspaceId,
workspaceId,
@@ -179,22 +199,76 @@ export class ConnectedAccountMetadataService {
userWorkspaceId: string;
workspaceId: string;
}): Promise<ConnectedAccountEntity> {
- const connectedAccount = await this.repository.findOne({
- where: { id, workspaceId },
- });
+ const connectedAccount = await this.findByIdOrThrow({ id, workspaceId });
- if (!connectedAccount) {
+ if (
+ !isConnectedAccountUsableByCaller({ connectedAccount, userWorkspaceId })
+ ) {
throw new ConnectedAccountException(
- `Connected account ${id} not found`,
- ConnectedAccountExceptionCode.CONNECTED_ACCOUNT_NOT_FOUND,
+ `Connected account ${id} is not usable by user workspace ${userWorkspaceId}`,
+ ConnectedAccountExceptionCode.CONNECTED_ACCOUNT_OWNERSHIP_VIOLATION,
);
}
- if (
- !isConnectedAccountUsableByCaller({ connectedAccount, userWorkspaceId })
- ) {
+ return connectedAccount;
+ }
+
+ async isAdministrableByCaller({
+ connectedAccount,
+ userWorkspaceId,
+ workspaceId,
+ applicationId,
+ }: {
+ connectedAccount: Pick<
+ ConnectedAccountEntity,
+ 'visibility' | 'userWorkspaceId'
+ >;
+ userWorkspaceId: string;
+ workspaceId: string;
+ applicationId?: string;
+ }): Promise<boolean> {
+ if (connectedAccount.userWorkspaceId === userWorkspaceId) {
+ return true;
+ }
+
+ switch (connectedAccount.visibility) {
+ case 'workspace':
+ return this.permissionsService.userHasWorkspaceSettingPermission({
+ userWorkspaceId,
+ workspaceId,
+ applicationId,
+ setting: PermissionFlagType.WORKSPACE,
+ });
+ case 'user':
+ return false;
+ default:
+ return assertUnreachable(connectedAccount.visibility);
+ }
+ }
+
+ async verifyAdministrableByCaller({
+ id,
+ userWorkspaceId,
+ workspaceId,
+ applicationId,
+ }: {
+ id: string;
+ userWorkspaceId: string;
+ workspaceId: string;
+ applicationId?: string;
+ }): Promise<ConnectedAccountEntity> {
+ const connectedAccount = await this.findByIdOrThrow({ id, workspaceId });
+
+ const isAdministrableByCaller = await this.isAdministrableByCaller({
+ connectedAccount,
+ userWorkspaceId,
+ workspaceId,
+ applicationId,
+ });
+
+ if (!isAdministrableByCaller) {
throw new ConnectedAccountException(
- `Connected account ${id} does not belong to user workspace ${userWorkspaceId}`,
+ `Connected account ${id} cannot be administered by user workspace ${userWorkspaceId}`,
ConnectedAccountExceptionCode.CONNECTED_ACCOUNT_OWNERSHIP_VIOLATION,
);
}
@@ -202,6 +276,27 @@ export class ConnectedAccountMetadataService {
return connectedAccount;
}
+ private async findByIdOrThrow({
+ id,
+ workspaceId,
+ }: {
+ id: string;
+ workspaceId: string;
+ }): Promise<ConnectedAccountEntity> {
+ const connectedAccount = await this.repository.findOne({
+ where: { id, workspaceId },
+ });
+
+ if (!isDefined(connectedAccount)) {
+ throw new ConnectedAccountException(
+ `Connected account ${id} not found`,
+ ConnectedAccountExceptionCode.CONNECTED_ACCOUNT_NOT_FOUND,
+ );
+ }
+
+ return connectedAccount;
+ }
+
async getUserConnectedAccountIds({
userWorkspaceId,
workspaceId,
@@ -223,7 +318,7 @@ export class ConnectedAccountMetadataService {
workspaceId: string;
}): Promise<string[]> {
const accounts = await this.repository.find({
- where: { workspaceId, visibility: 'workspace' },
+ where: { workspaceId, visibility: 'workspace', archivedAt: IsNull() },
select: ['id'],
});
diff --git a/packages/twenty-server/src/engine/metadata-modules/connected-account/resolvers/connected-account.resolver.ts b/packages/twenty-server/src/engine/metadata-modules/connected-account/resolvers/connected-account.resolver.ts
index 11d49da6210..429d2940706 100644
--- a/packages/twenty-server/src/engine/metadata-modules/connected-account/resolvers/connected-account.resolver.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/connected-account/resolvers/connected-account.resolver.ts
@@ -5,9 +5,12 @@ import { PermissionFlagType } from 'twenty-shared/constants';
import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';
import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import { CustomPermissionGuard } from 'src/engine/guards/custom-permission.guard';
import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
@@ -33,7 +36,7 @@ export class ConnectedAccountResolver {
@AuthUserWorkspaceId() userWorkspaceId: string,
): Promise<ConnectedAccountPublicDTO[]> {
const accounts =
- await this.connectedAccountMetadataService.findByUserWorkspaceId({
+ await this.connectedAccountMetadataService.findUsableByCaller({
userWorkspaceId,
workspaceId: workspace.id,
});
@@ -65,16 +68,18 @@ export class ConnectedAccountResolver {
}
@Mutation(() => ConnectedAccountPublicDTO)
- @UseGuards(NoPermissionGuard)
+ @UseGuards(CustomPermissionGuard)
async deleteConnectedAccount(
@Args('id', { type: () => UUIDScalarType }) id: string,
@AuthWorkspace() workspace: WorkspaceEntity,
@AuthUserWorkspaceId() userWorkspaceId: string,
+ @AuthApplication({ allowUndefined: true }) application?: FlatApplication,
): Promise<ConnectedAccountPublicDTO> {
- await this.connectedAccountMetadataService.verifyOwnership({
+ await this.connectedAccountMetadataService.verifyAdministrableByCaller({
id,
userWorkspaceId,
workspaceId: workspace.id,
+ applicationId: application?.id,
});
const deleted = await this.connectedAccountMetadataService.delete({
diff --git a/packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel-metadata.service.ts b/packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel-metadata.service.ts
index 0710a898b09..919080e29fd 100644
--- a/packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel-metadata.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/message-channel/message-channel-metadata.service.ts
@@ -86,7 +86,7 @@ export class MessageChannelMetadataService {
userWorkspaceId: string;
workspaceId: string;
}): Promise<MessageChannelDTO[]> {
- await this.connectedAccountMetadataService.verifyOwnership({
+ await this.connectedAccountMetadataService.verifyUsableByCaller({
id: connectedAccountId,
userWorkspaceId,
workspaceId,
@@ -133,7 +133,7 @@ export class MessageChannelMetadataService {
return this.repository.findOne({ where: { id, workspaceId } });
}
- async verifyOwnership({
+ async verifyUsableByCaller({
id,
userWorkspaceId,
workspaceId,
@@ -142,16 +142,29 @@ export class MessageChannelMetadataService {
userWorkspaceId: string;
workspaceId: string;
}): Promise<MessageChannelEntity> {
- const messageChannel = await this.repository.findOne({
- where: { id, workspaceId },
+ const messageChannel = await this.findByIdOrThrow({ id, workspaceId });
+
+ await this.connectedAccountMetadataService.verifyUsableByCaller({
+ id: messageChannel.connectedAccountId,
+ userWorkspaceId,
+ workspaceId,
});
- if (!messageChannel) {
- throw new MessageChannelException(
- `Message channel ${id} not found`,
- MessageChannelExceptionCode.MESSAGE_CHANNEL_NOT_FOUND,
- );
- }
+ return messageChannel;
+ }
+
+ async verifyAdministrableByCaller({
+ id,
+ userWorkspaceId,
+ workspaceId,
+ applicationId,
+ }: {
+ id: string;
+ userWorkspaceId: string;
+ workspaceId: string;
+ applicationId?: string;
+ }): Promise<MessageChannelEntity> {
+ const messageChannel = await this.findByIdOrThrow({ id, workspaceId });
const connectedAccount =
await this.connectedAccountMetadataService.findById({
@@ -159,19 +172,24 @@ export class MessageChannelMetadataService {
workspaceId,
});
- if (connectedAccount?.visibility === 'workspace') {
- return messageChannel;
+ if (!isDefined(connectedAccount)) {
+ throw new MessageChannelException(
+ `Connected account ${messageChannel.connectedAccountId} of message channel ${id} not found`,
+ MessageChannelExceptionCode.MESSAGE_CHANNEL_NOT_FOUND,
+ );
}
- const userAccountIds =
- await this.connectedAccountMetadataService.getUserConnectedAccountIds({
+ const isAdministrableByCaller =
+ await this.connectedAccountMetadataService.isAdministrableByCaller({
+ connectedAccount,
userWorkspaceId,
workspaceId,
+ applicationId,
});
- if (!userAccountIds.includes(messageChannel.connectedAccountId)) {
+ if (!isAdministrableByCaller) {
throw new MessageChannelException(
- `Message channel ${id} does not belong to user workspace ${userWorkspaceId}`,
+ `Message channel ${id} cannot be administered by user workspace ${userWorkspaceId}`,
MessageChannelExceptionCode.MESSAGE_CHANNEL_OWNERSHIP_VIOLATION,
);
}
@@ -179,6 +197,27 @@ export class MessageChannelMetadataService {
return messageChannel;
}
+ private async findByIdOrThrow({
+ id,
+ workspaceId,
+ }: {
+ id: string;
+ workspaceId: string;
+ }): Promise<MessageChannelEntity> {
+ const messageChannel = await this.repository.findOne({
+ where: { id, workspaceId },
+ });
+
+ if (!isDefined(messageChannel)) {
+ throw new MessageChannelException(
+ `Message channel ${id} not found`,
+ MessageChannelExceptionCode.MESSAGE_CHANNEL_NOT_FOUND,
+ );
+ }
+
+ return messageChannel;
+ }
+
async create(
data: Partial<MessageChannelEntity> & {
workspaceId: string;
@@ -365,7 +404,7 @@ export class MessageChannelMetadataService {
userWorkspaceId: string;
workspaceId: string;
}): Promise<MessageChannelDTO> {
- const messageChannel = await this.verifyOwnership({
+ const messageChannel = await this.verifyAdministrableByCaller({
id,
userWorkspaceId,
workspaceId,
@@ -405,7 +444,7 @@ export class MessageChannelMetadataService {
userWorkspaceId: string;
workspaceId: string;
}): Promise<MessageChannelDTO> {
- const messageChannel = await this.verifyOwnership({
+ const messageChannel = await this.verifyAdministrableByCaller({
id,
userWorkspaceId,
workspaceId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/message-channel/resolvers/message-channel.resolver.ts b/packages/twenty-server/src/engine/metadata-modules/message-channel/resolvers/message-channel.resolver.ts
index c67c930099b..4a1ae0ffb9f 100644
--- a/packages/twenty-server/src/engine/metadata-modules/message-channel/resolvers/message-channel.resolver.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/message-channel/resolvers/message-channel.resolver.ts
@@ -10,9 +10,12 @@ import { Not, Repository } from 'typeorm';
import { MetadataResolver } from 'src/engine/api/graphql/graphql-config/decorators/metadata-resolver.decorator';
import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
import { buildPublicConnectedAccount } from 'src/engine/metadata-modules/connected-account/utils/build-public-connected-account.util';
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { AuthApplication } from 'src/engine/decorators/auth/auth-application.decorator';
import { AuthUserWorkspaceId } from 'src/engine/decorators/auth/auth-user-workspace-id.decorator';
import { AuthWorkspace } from 'src/engine/decorators/auth/auth-workspace.decorator';
+import { CustomPermissionGuard } from 'src/engine/guards/custom-permission.guard';
import { NoPermissionGuard } from 'src/engine/guards/no-permission.guard';
import { SettingsPermissionGuard } from 'src/engine/guards/settings-permission.guard';
import { WorkspaceAuthGuard } from 'src/engine/guards/workspace-auth.guard';
@@ -106,17 +109,19 @@ export class MessageChannelResolver {
}
@Mutation(() => MessageChannelDTO)
- @UseGuards(NoPermissionGuard)
+ @UseGuards(CustomPermissionGuard)
async updateMessageChannel(
@Args('input') input: UpdateMessageChannelInput,
@AuthWorkspace() workspace: WorkspaceEntity,
@AuthUserWorkspaceId() userWorkspaceId: string,
+ @AuthApplication({ allowUndefined: true }) application?: FlatApplication,
): Promise<MessageChannelDTO> {
const messageChannel =
- await this.messageChannelMetadataService.verifyOwnership({
+ await this.messageChannelMetadataService.verifyAdministrableByCaller({
id: input.id,
userWorkspaceId,
workspaceId: workspace.id,
+ applicationId: application?.id,
});
const isSyncOngoing =
diff --git a/packages/twenty-server/src/engine/metadata-modules/message-folder/message-folder-metadata.service.ts b/packages/twenty-server/src/engine/metadata-modules/message-folder/message-folder-metadata.service.ts
index 8d6e98174e6..339a3e002f0 100644
--- a/packages/twenty-server/src/engine/metadata-modules/message-folder/message-folder-metadata.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/message-folder/message-folder-metadata.service.ts
@@ -66,7 +66,7 @@ export class MessageFolderMetadataService {
userWorkspaceId: string;
workspaceId: string;
}): Promise<MessageFolderDTO[]> {
- await this.messageChannelMetadataService.verifyOwnership({
+ await this.messageChannelMetadataService.verifyUsableByCaller({
id: messageChannelId,
userWorkspaceId,
workspaceId,
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-metadata-entities.util.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-metadata-entities.util.ts
index 0ef104d0189..47e4dc6b83e 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-metadata-entities.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/core/utils/seed-metadata-entities.util.ts
@@ -32,6 +32,8 @@ const YC_CONNECTED_ACCOUNT_IDS = {
PHIL: '30303030-cafc-4323-908d-e5b42ad69fdf',
JANE: '30303030-b5c7-46f0-bf5c-3f4e4b3f7c1a',
JANE_DELETABLE: '30303030-d1e5-4a8f-9c3b-7f6d5e4c3b2a',
+ JONY_SHARED: '30303030-c7b4-4f1a-8e2d-6b9a0f3c5d18',
+ TIM_SHARED_ARCHIVED: '30303030-e3a9-4d76-b0c1-5f8e2a7d4c93',
SUPPORT_GROUP: '30303030-5a1e-4b2c-9d3e-100000000001',
CONTACT_GROUP: '30303030-5a1e-4b2c-9d3e-100000000002',
};
@@ -126,6 +128,8 @@ const seedConnectedAccounts = async ({
handle: '[email protected]',
provider: 'google',
userWorkspaceId: ids.userWorkspaceIds.TIM,
+ visibility: 'user',
+ archivedAt: null,
workspaceId,
},
{
@@ -133,6 +137,8 @@ const seedConnectedAccounts = async ({
handle: '[email protected]',
provider: 'google',
userWorkspaceId: ids.userWorkspaceIds.JONY,
+ visibility: 'user',
+ archivedAt: null,
workspaceId,
},
{
@@ -140,6 +146,8 @@ const seedConnectedAccounts = async ({
handle: '[email protected]',
provider: 'google',
userWorkspaceId: ids.userWorkspaceIds.PHIL,
+ visibility: 'user',
+ archivedAt: null,
workspaceId,
},
{
@@ -147,6 +155,8 @@ const seedConnectedAccounts = async ({
handle: '[email protected]',
provider: 'google',
userWorkspaceId: ids.userWorkspaceIds.JANE,
+ visibility: 'user',
+ archivedAt: null,
workspaceId,
},
{
@@ -154,6 +164,26 @@ const seedConnectedAccounts = async ({
handle: '[email protected]',
provider: 'google',
userWorkspaceId: ids.userWorkspaceIds.JANE,
+ visibility: 'user',
+ archivedAt: null,
+ workspaceId,
+ },
+ {
+ id: ids.connectedAccountIds.JONY_SHARED,
+ handle: '[email protected]',
+ provider: 'app',
+ userWorkspaceId: ids.userWorkspaceIds.JONY,
+ visibility: 'workspace',
+ archivedAt: null,
+ workspaceId,
+ },
+ {
+ id: ids.connectedAccountIds.TIM_SHARED_ARCHIVED,
+ handle: '[email protected]',
+ provider: 'app',
+ userWorkspaceId: ids.userWorkspaceIds.TIM,
+ visibility: 'workspace',
+ archivedAt: new Date().toISOString(),
workspaceId,
},
{
@@ -161,6 +191,8 @@ const seedConnectedAccounts = async ({
handle: `support@${emailGroupDomains.verified}`,
provider: 'email_group',
userWorkspaceId: ids.userWorkspaceIds.TIM,
+ visibility: 'workspace',
+ archivedAt: null,
workspaceId,
},
{
@@ -168,6 +200,8 @@ const seedConnectedAccounts = async ({
handle: `contact@${emailGroupDomains.pending}`,
provider: 'email_group',
userWorkspaceId: ids.userWorkspaceIds.TIM,
+ visibility: 'workspace',
+ archivedAt: null,
workspaceId,
},
];
@@ -180,6 +214,8 @@ const seedConnectedAccounts = async ({
'handle',
'provider',
'userWorkspaceId',
+ 'visibility',
+ 'archivedAt',
'workspaceId',
])
.orIgnore()
diff --git a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/constants/connected-account-data-seeds.constant.ts b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/constants/connected-account-data-seeds.constant.ts
index 4df39dd4aa1..154e69852eb 100644
--- a/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/constants/connected-account-data-seeds.constant.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/dev-seeder/data/constants/connected-account-data-seeds.constant.ts
@@ -33,6 +33,8 @@ export const CONNECTED_ACCOUNT_DATA_SEED_IDS = {
PHIL: '20202020-cafc-4323-908d-e5b42ad69fdf',
JANE: '20202020-b5c7-46f0-bf5c-3f4e4b3f7c1a',
JANE_DELETABLE: '20202020-d1e5-4a8f-9c3b-7f6d5e4c3b2a',
+ JONY_SHARED: '20202020-c7b4-4f1a-8e2d-6b9a0f3c5d18',
+ TIM_SHARED_ARCHIVED: '20202020-e3a9-4d76-b0c1-5f8e2a7d4c93',
SUPPORT_GROUP: '20202020-5a1e-4b2c-9d3e-100000000001',
CONTACT_GROUP: '20202020-5a1e-4b2c-9d3e-100000000002',
};
diff --git a/packages/twenty-server/src/modules/calendar/calendar-event-creation-manager/resolvers/create-calendar-event.resolver.ts b/packages/twenty-server/src/modules/calendar/calendar-event-creation-manager/resolvers/create-calendar-event.resolver.ts
index 3d3666a141e..d5b31fa0130 100644
--- a/packages/twenty-server/src/modules/calendar/calendar-event-creation-manager/resolvers/create-calendar-event.resolver.ts
+++ b/packages/twenty-server/src/modules/calendar/calendar-event-creation-manager/resolvers/create-calendar-event.resolver.ts
@@ -46,7 +46,7 @@ export class CreateCalendarEventResolver {
@AuthUserWorkspaceId() userWorkspaceId: string,
): Promise<CreateCalendarEventOutputDTO> {
try {
- await this.connectedAccountMetadataService.verifyOwnership({
+ await this.connectedAccountMetadataService.verifyUsableByCaller({
id: input.connectedAccountId,
userWorkspaceId,
workspaceId: workspace.id,
diff --git a/packages/twenty-server/src/modules/connected-account/channel-sync/channel-sync.resolver.ts b/packages/twenty-server/src/modules/connected-account/channel-sync/channel-sync.resolver.ts
index ef9ddb86317..6560ff34190 100644
--- a/packages/twenty-server/src/modules/connected-account/channel-sync/channel-sync.resolver.ts
+++ b/packages/twenty-server/src/modules/connected-account/channel-sync/channel-sync.resolver.ts
@@ -34,7 +34,7 @@ export class ChannelSyncResolver {
@AuthWorkspace() workspace: WorkspaceEntity,
@AuthUserWorkspaceId() userWorkspaceId: string,
): Promise<ChannelSyncSuccessDTO> {
- await this.connectedAccountMetadataService.verifyOwnership({
+ await this.connectedAccountMetadataService.verifyUsableByCaller({
id: connectedAccountId,
userWorkspaceId,
workspaceId: workspace.id,
diff --git a/packages/twenty-server/src/modules/messaging/message-outbound-manager/resolvers/send-email.resolver.ts b/packages/twenty-server/src/modules/messaging/message-outbound-manager/resolvers/send-email.resolver.ts
index 5f6acabac3c..b98857eec7c 100644
--- a/packages/twenty-server/src/modules/messaging/message-outbound-manager/resolvers/send-email.resolver.ts
+++ b/packages/twenty-server/src/modules/messaging/message-outbound-manager/resolvers/send-email.resolver.ts
@@ -51,7 +51,7 @@ export class SendEmailResolver {
@AuthUserWorkspaceId() userWorkspaceId: string,
): Promise<SendEmailOutputDTO> {
try {
- await this.connectedAccountMetadataService.verifyOwnership({
+ await this.connectedAccountMetadataService.verifyUsableByCaller({
id: input.connectedAccountId,
userWorkspaceId,
workspaceId: workspace.id,
diff --git a/packages/twenty-server/test/integration/email-tool/suites/email-composer-connected-account.integration-spec.ts b/packages/twenty-server/test/integration/email-tool/suites/email-composer-connected-account.integration-spec.ts
index ed8b5c6e339..e4c663d9753 100644
--- a/packages/twenty-server/test/integration/email-tool/suites/email-composer-connected-account.integration-spec.ts
+++ b/packages/twenty-server/test/integration/email-tool/suites/email-composer-connected-account.integration-spec.ts
@@ -54,6 +54,16 @@ const setVisibility = async (
);
};
+const getWorkspaceSharedConnectedAccountIds = async (): Promise<string[]> => {
+ const rows = await global.testDataSource.query(
+ `SELECT id FROM core."connectedAccount"
+ WHERE "workspaceId" = $1 AND visibility = 'workspace'`,
+ [WORKSPACE_ID],
+ );
+
+ return rows.map((row: { id: string }) => row.id);
+};
+
const insertConnectedAccount = async ({
id,
provider,
@@ -377,16 +387,29 @@ describe('EmailComposerService connected account resolution (integration)', () =
});
it('throws rather than composing from a colleague account', async () => {
- await expect(
- service.composeEmail({
- parameters: baseParams,
- context: {
- workspaceId: WORKSPACE_ID,
- userWorkspaceId: UNKNOWN_USER_WORKSPACE_ID,
- },
- operation: EmailOperation.SEND,
- }),
- ).rejects.toThrow('available for user workspace');
+ const sharedConnectedAccountIds =
+ await getWorkspaceSharedConnectedAccountIds();
+
+ for (const connectedAccountId of sharedConnectedAccountIds) {
+ await setVisibility(connectedAccountId, 'user');
+ }
+
+ try {
+ await expect(
+ service.composeEmail({
+ parameters: baseParams,
+ context: {
+ workspaceId: WORKSPACE_ID,
+ userWorkspaceId: UNKNOWN_USER_WORKSPACE_ID,
+ },
+ operation: EmailOperation.SEND,
+ }),
+ ).rejects.toThrow('available for user workspace');
+ } finally {
+ for (const connectedAccountId of sharedConnectedAccountIds) {
+ await setVisibility(connectedAccountId, 'workspace');
+ }
+ }
});
it('takes the first workspace account when there is no caller (workflow run)', async () => {
diff --git a/packages/twenty-server/test/integration/metadata/suites/connected-account/connected-account-resolver.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/connected-account/connected-account-resolver.integration-spec.ts
index 8a565016775..e2be0f093d1 100644
--- a/packages/twenty-server/test/integration/metadata/suites/connected-account/connected-account-resolver.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/connected-account/connected-account-resolver.integration-spec.ts
@@ -1,11 +1,12 @@
import { gql } from 'graphql-tag';
+import { makeMetadataAPIRequestWithMemberRole } from 'test/integration/metadata/suites/utils/make-metadata-api-request-with-member-role.util';
import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
import { CONNECTED_ACCOUNT_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/connected-account-data-seeds.constant';
describe('connectedAccountResolver (e2e)', () => {
describe('myConnectedAccounts', () => {
- it('should return only the current user connected accounts', async () => {
+ it('should not return another user private connected account', async () => {
const response = await makeMetadataAPIRequest({
query: gql`
query MyConnectedAccounts {
@@ -28,6 +29,116 @@ describe('connectedAccountResolver (e2e)', () => {
expect(accountIds).not.toContain(CONNECTED_ACCOUNT_DATA_SEED_IDS.JONY);
});
+ it('should return a workspace-shared account owned by someone else', async () => {
+ const response = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ query MyConnectedAccounts {
+ myConnectedAccounts {
+ id
+ handle
+ }
+ }
+ `,
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors).toBeUndefined();
+
+ const accountIds = response.body.data.myConnectedAccounts.map(
+ (account: { id: string }) => account.id,
+ );
+
+ expect(accountIds).toContain(
+ CONNECTED_ACCOUNT_DATA_SEED_IDS.SUPPORT_GROUP,
+ );
+ });
+
+ it('should not offer an archived workspace-shared account to other members', async () => {
+ const response = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ query MyConnectedAccounts {
+ myConnectedAccounts {
+ id
+ }
+ }
+ `,
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors).toBeUndefined();
+
+ const accountIds = response.body.data.myConnectedAccounts.map(
+ (account: { id: string }) => account.id,
+ );
+
+ expect(accountIds).not.toContain(
+ CONNECTED_ACCOUNT_DATA_SEED_IDS.TIM_SHARED_ARCHIVED,
+ );
+ });
+
+ it('should list the caller own accounts before workspace-shared ones', async () => {
+ const response = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ query MyConnectedAccounts {
+ myConnectedAccounts {
+ id
+ }
+ }
+ `,
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors).toBeUndefined();
+
+ const accountIds = response.body.data.myConnectedAccounts.map(
+ (account: { id: string }) => account.id,
+ );
+
+ expect(
+ accountIds.indexOf(CONNECTED_ACCOUNT_DATA_SEED_IDS.JONY),
+ ).toBeLessThan(
+ accountIds.indexOf(CONNECTED_ACCOUNT_DATA_SEED_IDS.SUPPORT_GROUP),
+ );
+ });
+
+ it('should resolve the account of every message channel the caller can see', async () => {
+ const channelsResponse = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ query MyMessageChannels {
+ myMessageChannels {
+ id
+ connectedAccountId
+ }
+ }
+ `,
+ });
+
+ const accountsResponse = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ query MyConnectedAccounts {
+ myConnectedAccounts {
+ id
+ }
+ }
+ `,
+ });
+
+ expect(channelsResponse.body.errors).toBeUndefined();
+ expect(accountsResponse.body.errors).toBeUndefined();
+
+ const accountIds = accountsResponse.body.data.myConnectedAccounts.map(
+ (account: { id: string }) => account.id,
+ );
+ const channelAccountIds =
+ channelsResponse.body.data.myMessageChannels.map(
+ (messageChannel: { connectedAccountId: string }) =>
+ messageChannel.connectedAccountId,
+ );
+
+ expect(channelAccountIds.length).toBeGreaterThan(0);
+ expect(accountIds).toEqual(expect.arrayContaining(channelAccountIds));
+ });
+
it('should not return sensitive fields', async () => {
const response = await makeMetadataAPIRequest({
query: gql`
@@ -117,5 +228,78 @@ describe('connectedAccountResolver (e2e)', () => {
expect(response.status).toBe(200);
expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
});
+
+ it('should deny a member deleting a workspace-shared account owned by someone else', async () => {
+ const response = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ mutation DeleteConnectedAccount($id: UUID!) {
+ deleteConnectedAccount(id: $id) {
+ id
+ }
+ }
+ `,
+ variables: { id: CONNECTED_ACCOUNT_DATA_SEED_IDS.SUPPORT_GROUP },
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
+ });
+
+ it('should keep a denied member able to use the workspace-shared account', async () => {
+ const response = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ query MyMessageChannels($connectedAccountId: UUID) {
+ myMessageChannels(connectedAccountId: $connectedAccountId) {
+ id
+ }
+ }
+ `,
+ variables: {
+ connectedAccountId: CONNECTED_ACCOUNT_DATA_SEED_IDS.SUPPORT_GROUP,
+ },
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.myMessageChannels.length).toBeGreaterThan(0);
+ });
+
+ it('should allow a member deleting a workspace-shared account they own', async () => {
+ const response = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ mutation DeleteConnectedAccount($id: UUID!) {
+ deleteConnectedAccount(id: $id) {
+ id
+ }
+ }
+ `,
+ variables: { id: CONNECTED_ACCOUNT_DATA_SEED_IDS.JONY_SHARED },
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.deleteConnectedAccount.id).toBe(
+ CONNECTED_ACCOUNT_DATA_SEED_IDS.JONY_SHARED,
+ );
+ });
+
+ it('should allow an admin deleting a workspace-shared account', async () => {
+ const response = await makeMetadataAPIRequest({
+ query: gql`
+ mutation DeleteConnectedAccount($id: UUID!) {
+ deleteConnectedAccount(id: $id) {
+ id
+ }
+ }
+ `,
+ variables: { id: CONNECTED_ACCOUNT_DATA_SEED_IDS.CONTACT_GROUP },
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors).toBeUndefined();
+ expect(response.body.data.deleteConnectedAccount.id).toBe(
+ CONNECTED_ACCOUNT_DATA_SEED_IDS.CONTACT_GROUP,
+ );
+ });
});
});
diff --git a/packages/twenty-server/test/integration/metadata/suites/message-channel/message-channel-resolver.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/message-channel/message-channel-resolver.integration-spec.ts
index b38a210015f..15f8ced00ac 100644
--- a/packages/twenty-server/test/integration/metadata/suites/message-channel/message-channel-resolver.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/message-channel/message-channel-resolver.integration-spec.ts
@@ -1,4 +1,5 @@
import { gql } from 'graphql-tag';
+import { makeMetadataAPIRequestWithMemberRole } from 'test/integration/metadata/suites/utils/make-metadata-api-request-with-member-role.util';
import { makeMetadataAPIRequest } from 'test/integration/metadata/suites/utils/make-metadata-api-request.util';
import { CONNECTED_ACCOUNT_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/connected-account-data-seeds.constant';
@@ -74,6 +75,41 @@ describe('messageChannelResolver (e2e)', () => {
expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
});
+ it('should hide the channels of an archived workspace-shared account from other members', async () => {
+ await global.testDataSource.query(
+ `UPDATE core."connectedAccount" SET "archivedAt" = now() WHERE id = $1`,
+ [CONNECTED_ACCOUNT_DATA_SEED_IDS.SUPPORT_GROUP],
+ );
+
+ try {
+ const response = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ query MyMessageChannels {
+ myMessageChannels {
+ id
+ }
+ }
+ `,
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors).toBeUndefined();
+
+ const channelIds = response.body.data.myMessageChannels.map(
+ (channel: { id: string }) => channel.id,
+ );
+
+ expect(channelIds).not.toContain(
+ MESSAGE_CHANNEL_DATA_SEED_IDS.SUPPORT_GROUP,
+ );
+ } finally {
+ await global.testDataSource.query(
+ `UPDATE core."connectedAccount" SET "archivedAt" = NULL WHERE id = $1`,
+ [CONNECTED_ACCOUNT_DATA_SEED_IDS.SUPPORT_GROUP],
+ );
+ }
+ });
+
it('should not return syncCursor', async () => {
const response = await makeMetadataAPIRequest({
query: gql`
@@ -137,5 +173,26 @@ describe('messageChannelResolver (e2e)', () => {
expect(response.status).toBe(200);
expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
});
+
+ it('should deny a member updating a workspace-shared group channel', async () => {
+ const response = await makeMetadataAPIRequestWithMemberRole({
+ query: gql`
+ mutation UpdateMessageChannel($input: UpdateMessageChannelInput!) {
+ updateMessageChannel(input: $input) {
+ id
+ }
+ }
+ `,
+ variables: {
+ input: {
+ id: MESSAGE_CHANNEL_DATA_SEED_IDS.SUPPORT_GROUP,
+ update: { excludeGroupEmails: true },
+ },
+ },
+ });
+
+ expect(response.status).toBe(200);
+ expect(response.body.errors?.[0]?.extensions?.code).toBe('FORBIDDEN');
+ });
});
});