The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
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.tsnew file mode 100644index 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.tsindex 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-cimport { 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.tsindex 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,