Skip to content

The open alternative to Salesforce, designed for AI.

fix(messaging): resolve an app channel's connectedAccount for app contexts (#25942)

Félix Malfaitf1001eeb38c8
diff --git a/packages/twenty-server/src/engine/metadata-modules/message-channel/resolvers/__tests__/message-channel.resolver.spec.ts b/packages/twenty-server/src/engine/metadata-modules/message-channel/resolvers/__tests__/message-channel.resolver.spec.ts
new file mode 100644
index 00000000000..bce5658b9ac
--- /dev/null
+++ b/packages/twenty-server/src/engine/metadata-modules/message-channel/resolvers/__tests__/message-channel.resolver.spec.ts
@@ -0,0 +1,208 @@
+import { MessageChannelType } from 'twenty-shared/types';
+
+import { type FlatApplication } from 'src/engine/core-modules/application/types/flat-application.type';
+import { type ConnectedAccountEntity } from 'src/engine/metadata-modules/connected-account/entities/connected-account.entity';
+import { type WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
+import { type MessageChannelDTO } from 'src/engine/metadata-modules/message-channel/dtos/message-channel.dto';
+import { MessageChannelResolver } from 'src/engine/metadata-modules/message-channel/resolvers/message-channel.resolver';
+
+const WORKSPACE_ID = '33333333-3333-4333-8333-333333333333';
+const APPLICATION_ID = '44444444-4444-4444-8444-444444444444';
+const CONNECTED_ACCOUNT_ID = '55555555-5555-4555-8555-555555555555';
+const USER_WORKSPACE_ID = '66666666-6666-4666-8666-666666666666';
+
+describe('MessageChannelResolver connectedAccount', () => {
+ const workspace = { id: WORKSPACE_ID } as WorkspaceEntity;
+ const application = { id: APPLICATION_ID } as FlatApplication;
+
+ const anAppChannel = (): MessageChannelDTO =>
+ ({
+ id: 'channel-id',
+ type: MessageChannelType.APP,
+ connectedAccountId: CONNECTED_ACCOUNT_ID,
+ }) as MessageChannelDTO;
+
+ const buildResolver = ({
+ reachableConnectedAccount = null,
+ }: {
+ reachableConnectedAccount?: Partial<ConnectedAccountEntity> | null;
+ } = {}) => {
+ const connectedAccountMetadataService = {
+ findById: jest.fn().mockResolvedValue({ id: CONNECTED_ACCOUNT_ID }),
+ findByIdAndUserWorkspaceId: jest
+ .fn()
+ .mockResolvedValue({ id: CONNECTED_ACCOUNT_ID }),
+ };
+ const applicationMessageChannelsService = {
+ findReachableConnectedAccount: jest
+ .fn()
+ .mockResolvedValue(reachableConnectedAccount),
+ };
+
+ const resolver = new MessageChannelResolver(
+ {} as never,
+ connectedAccountMetadataService as never,
+ applicationMessageChannelsService as never,
+ {} as never,
+ {} as never,
+ );
+
+ return {
+ resolver,
+ connectedAccountMetadataService,
+ applicationMessageChannelsService,
+ };
+ };
+
+ // Before this branch existed the decorator threw for a run with no user —
+ // telling an app that "API keys are not supported", which is not even the
+ // right diagnosis — so a cron, webhook or install hook could not read the
+ // connection behind a channel its own application owns.
+ it('resolves an app-owned connection for a run with nobody behind it', async () => {
+ const { resolver, applicationMessageChannelsService } = buildResolver({
+ reachableConnectedAccount: { id: CONNECTED_ACCOUNT_ID },
+ });
+
+ const account = await resolver.connectedAccount(
+ anAppChannel(),
+ workspace,
+ undefined,
+ application,
+ );
+
+ expect(account).toMatchObject({ id: CONNECTED_ACCOUNT_ID });
+ expect(
+ applicationMessageChannelsService.findReachableConnectedAccount,
+ ).toHaveBeenCalledTimes(1);
+ expect(
+ applicationMessageChannelsService.findReachableConnectedAccount,
+ ).toHaveBeenCalledWith({
+ applicationId: APPLICATION_ID,
+ workspaceId: WORKSPACE_ID,
+ requestUserWorkspaceId: null,
+ connectedAccountId: CONNECTED_ACCOUNT_ID,
+ });
+ });
+
+ // Reachability is the app-facing predicate's answer, not this resolver's:
+ // it already refuses a connection owned by another application, and one
+ // that is private to a different member than the caller.
+ it('returns null when the predicate says the caller cannot reach it', async () => {
+ const { resolver } = buildResolver({ reachableConnectedAccount: null });
+
+ expect(
+ await resolver.connectedAccount(
+ anAppChannel(),
+ workspace,
+ USER_WORKSPACE_ID,
+ application,
+ ),
+ ).toBeNull();
+ });
+
+ // The user behind an APPLICATION_ACCESS token still has to be honoured, so
+ // it is forwarded rather than dropped once an application is present.
+ it('forwards the request user when a member triggered the run', async () => {
+ const { resolver, applicationMessageChannelsService } = buildResolver({
+ reachableConnectedAccount: { id: CONNECTED_ACCOUNT_ID },
+ });
+
+ await resolver.connectedAccount(
+ anAppChannel(),
+ workspace,
+ USER_WORKSPACE_ID,
+ application,
+ );
+
+ expect(
+ applicationMessageChannelsService.findReachableConnectedAccount,
+ ).toHaveBeenCalledTimes(1);
+ expect(
+ applicationMessageChannelsService.findReachableConnectedAccount,
+ ).toHaveBeenCalledWith(
+ expect.objectContaining({ requestUserWorkspaceId: USER_WORKSPACE_ID }),
+ );
+ });
+
+ // An APPLICATION_ACCESS token can carry a user, and such a request can be
+ // handed an EMAIL channel. Claiming those here sent the member's own mailbox
+ // through a predicate that only matches APP connections, so a connection
+ // they are entitled to see came back null.
+ it('leaves an email channel on user ownership even in an application context', async () => {
+ const {
+ resolver,
+ connectedAccountMetadataService,
+ applicationMessageChannelsService,
+ } = buildResolver();
+
+ const account = await resolver.connectedAccount(
+ {
+ ...anAppChannel(),
+ type: MessageChannelType.EMAIL,
+ } as MessageChannelDTO,
+ workspace,
+ USER_WORKSPACE_ID,
+ application,
+ );
+
+ expect(account).toMatchObject({ id: CONNECTED_ACCOUNT_ID });
+ expect(
+ applicationMessageChannelsService.findReachableConnectedAccount,
+ ).not.toHaveBeenCalled();
+ expect(
+ connectedAccountMetadataService.findByIdAndUserWorkspaceId,
+ ).toHaveBeenCalledTimes(1);
+ });
+
+ it('leaves the email path on user ownership when no application is calling', async () => {
+ const {
+ resolver,
+ connectedAccountMetadataService,
+ applicationMessageChannelsService,
+ } = buildResolver();
+
+ await resolver.connectedAccount(
+ {
+ ...anAppChannel(),
+ type: MessageChannelType.EMAIL,
+ } as MessageChannelDTO,
+ workspace,
+ USER_WORKSPACE_ID,
+ undefined,
+ );
+
+ expect(
+ connectedAccountMetadataService.findByIdAndUserWorkspaceId,
+ ).toHaveBeenCalledTimes(1);
+ expect(
+ connectedAccountMetadataService.findByIdAndUserWorkspaceId,
+ ).toHaveBeenCalledWith({
+ id: CONNECTED_ACCOUNT_ID,
+ userWorkspaceId: USER_WORKSPACE_ID,
+ workspaceId: WORKSPACE_ID,
+ });
+ expect(
+ applicationMessageChannelsService.findReachableConnectedAccount,
+ ).not.toHaveBeenCalled();
+ });
+
+ it('leaves the EMAIL_GROUP bypass alone', async () => {
+ const { resolver, connectedAccountMetadataService } = buildResolver();
+
+ await resolver.connectedAccount(
+ {
+ ...anAppChannel(),
+ type: MessageChannelType.EMAIL_GROUP,
+ } as MessageChannelDTO,
+ workspace,
+ USER_WORKSPACE_ID,
+ undefined,
+ );
+
+ expect(connectedAccountMetadataService.findById).toHaveBeenCalledTimes(1);
+ expect(connectedAccountMetadataService.findById).toHaveBeenCalledWith({
+ id: CONNECTED_ACCOUNT_ID,
+ workspaceId: WORKSPACE_ID,
+ });
+ });
+});
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 c97df4e5a2d..33063cd164c 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
@@ -29,6 +29,7 @@ import { UpdateMessageChannelInput } from 'src/engine/metadata-modules/message-c
import { type MessageChannelEntity } from 'src/engine/metadata-modules/message-channel/entities/message-channel.entity';
import { MessageChannelGraphqlApiExceptionInterceptor } from 'src/engine/metadata-modules/message-channel/interceptors/message-channel-graphql-api-exception.interceptor';
import { MessageChannelMetadataService } from 'src/engine/metadata-modules/message-channel/message-channel-metadata.service';
+import { ApplicationMessageChannelsService } from 'src/engine/metadata-modules/message-channel/services/application-message-channels.service';
import {
MessageChannelException,
MessageChannelExceptionCode,
@@ -49,6 +50,7 @@ export class MessageChannelResolver {
constructor(
private readonly messageChannelMetadataService: MessageChannelMetadataService,
private readonly connectedAccountMetadataService: ConnectedAccountMetadataService,
+ private readonly applicationMessageChannelsService: ApplicationMessageChannelsService,
@InjectRepository(MessageFolderEntity)
private readonly messageFolderRepository: Repository<MessageFolderEntity>,
private readonly messagingProcessGroupEmailActionsService: MessagingProcessGroupEmailActionsService,
@@ -60,7 +62,8 @@ export class MessageChannelResolver {
async connectedAccount(
@Parent() messageChannel: MessageChannelDTO,
@AuthWorkspace() workspace: WorkspaceEntity,
- @AuthUserWorkspaceId() userWorkspaceId: string,
+ @AuthUserWorkspaceId({ allowUndefined: true }) userWorkspaceId?: string,
+ @AuthApplication({ allowUndefined: true }) application?: FlatApplication,
): Promise<ConnectedAccountPublicDTO | null> {
if (messageChannel.type === MessageChannelType.EMAIL_GROUP) {
const account = await this.connectedAccountMetadataService.findById({
@@ -71,6 +74,33 @@ export class MessageChannelResolver {
return buildPublicConnectedAccount(account);
}
+ // An app channel's connection belongs to the application, not to a member,
+ // so there is no userWorkspaceId to resolve it through on a cron, webhook
+ // or install hook. Reachability is delegated rather than re-derived: the
+ // same predicate the app-facing channel API gates on also decides this,
+ // including the boundary that stops one member reaching another's private
+ // connection through the app.
+ if (
+ isDefined(application) &&
+ messageChannel.type === MessageChannelType.APP
+ ) {
+ const account =
+ await this.applicationMessageChannelsService.findReachableConnectedAccount(
+ {
+ applicationId: application.id,
+ workspaceId: workspace.id,
+ requestUserWorkspaceId: userWorkspaceId ?? null,
+ connectedAccountId: messageChannel.connectedAccountId,
+ },
+ );
+
+ return isDefined(account) ? buildPublicConnectedAccount(account) : null;
+ }
+
+ if (!isDefined(userWorkspaceId)) {
+ return null;
+ }
+
const account =
await this.connectedAccountMetadataService.findByIdAndUserWorkspaceId({
id: messageChannel.connectedAccountId,
diff --git a/packages/twenty-server/src/engine/metadata-modules/message-channel/services/application-message-channels.service.ts b/packages/twenty-server/src/engine/metadata-modules/message-channel/services/application-message-channels.service.ts
index 96f444cb44b..658c8edefa0 100644
--- a/packages/twenty-server/src/engine/metadata-modules/message-channel/services/application-message-channels.service.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/message-channel/services/application-message-channels.service.ts
@@ -285,7 +285,11 @@ export class ApplicationMessageChannelsService {
}
}
- private async findReachableConnectedAccount({
+ // Public because the shared MessageChannelResolver resolves an app channel's
+ // connectedAccount field through it: the app-facing reachability rule —
+ // owned by this application, and not another member's private connection —
+ // must have exactly one implementation.
+ async findReachableConnectedAccount({
applicationId,
workspaceId,
requestUserWorkspaceId,