Refactor global datasource part 3 (#16447)

## Context
Following https://github.com/twentyhq/twenty/pull/16399
Now using the new global orm manager everywhere and returning a
GlobalDatasource/WorkspaceDatasource based on a feature flag.
This means we now need to wrap all our ORM calls within
executeInWorkspaceContext callback (at least for now) so the global
datasource can dynamically hydrate its context via the new store (the
global datasource does not store anything related to workspaces as it is
now a unique singleton). If feature flag is off it still uses local data
stored in the workspace datasource.

packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-item-delete-messages.job.ts

@@ -1,14 +1,15 @@
 import { Scope } from '@nestjs/common';
 
+import { MessageParticipantRole } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
 import { And, Any, ILike, In, Not, Or } from 'typeorm';
-import { MessageParticipantRole } from 'twenty-shared/types';
 
 import { type ObjectRecordCreateEvent } from 'src/engine/core-modules/event-emitter/types/object-record-create.event';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
 import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
 import { type MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
@@ -26,132 +27,141 @@ export type BlocklistItemDeleteMessagesJobData = WorkspaceEventBatch<
 export class BlocklistItemDeleteMessagesJob {
   constructor(
     private readonly threadCleanerService: MessagingMessageCleanerService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   @Process(BlocklistItemDeleteMessagesJob.name)
   async handle(data: BlocklistItemDeleteMessagesJobData): Promise<void> {
     const workspaceId = data.workspaceId;
 
-    const blocklistItemIds = data.events.map(
-      (eventPayload) => eventPayload.recordId,
-    );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const blocklistRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<BlocklistWorkspaceEntity>(
-        workspaceId,
-        'blocklist',
-      );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const blocklistItemIds = data.events.map(
+          (eventPayload) => eventPayload.recordId,
+        );
 
-    const blocklist = await blocklistRepository.find({
-      where: {
-        id: Any(blocklistItemIds),
-      },
-    });
-
-    const handlesToDeleteByWorkspaceMemberIdMap = blocklist.reduce(
-      (acc, blocklistItem) => {
-        const { handle, workspaceMemberId } = blocklistItem;
-
-        if (!acc.has(workspaceMemberId)) {
-          acc.set(workspaceMemberId, []);
-        }
-
-        if (!isDefined(handle)) {
-          return acc;
-        }
-
-        acc.get(workspaceMemberId)?.push(handle);
-
-        return acc;
-      },
-      new Map<string, string[]>(),
-    );
-
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
-
-    const messageChannelMessageAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelMessageAssociationWorkspaceEntity>(
-        workspaceId,
-        'messageChannelMessageAssociation',
-      );
-
-    for (const workspaceMemberId of handlesToDeleteByWorkspaceMemberIdMap.keys()) {
-      const handles =
-        handlesToDeleteByWorkspaceMemberIdMap.get(workspaceMemberId);
-
-      if (!handles) {
-        continue;
-      }
-
-      const rolesToDelete = [
-        MessageParticipantRole.FROM,
-        MessageParticipantRole.TO,
-      ] as const;
-
-      const messageChannels = await messageChannelRepository.find({
-        select: {
-          id: true,
-          handle: true,
-          connectedAccount: {
-            handleAliases: true,
-          },
-        },
-        where: {
-          connectedAccount: {
-            accountOwnerId: workspaceMemberId,
-          },
-        },
-        relations: ['connectedAccount'],
-      });
-
-      for (const messageChannel of messageChannels) {
-        const messageChannelHandles = [messageChannel.handle];
-
-        if (messageChannel.connectedAccount.handleAliases) {
-          messageChannelHandles.push(
-            ...messageChannel.connectedAccount.handleAliases.split(','),
+        const blocklistRepository =
+          await this.globalWorkspaceOrmManager.getRepository<BlocklistWorkspaceEntity>(
+            workspaceId,
+            'blocklist',
           );
-        }
 
-        const handleConditions = handles.map((handle) => {
-          const isHandleDomain = handle.startsWith('@');
-
-          return isHandleDomain
-            ? {
-                handle: And(
-                  Or(ILike(`%${handle}`), ILike(`%.${handle.slice(1)}`)),
-                  Not(In(messageChannelHandles)),
-                ),
-                role: In(rolesToDelete),
-              }
-            : { handle, role: In(rolesToDelete) };
+        const blocklist = await blocklistRepository.find({
+          where: {
+            id: Any(blocklistItemIds),
+          },
         });
 
-        const messageChannelMessageAssociationsToDelete =
-          await messageChannelMessageAssociationRepository.find({
-            where: {
-              messageChannelId: messageChannel.id,
-              message: {
-                messageParticipants: handleConditions,
+        const handlesToDeleteByWorkspaceMemberIdMap = blocklist.reduce(
+          (acc, blocklistItem) => {
+            const { handle, workspaceMemberId } = blocklistItem;
+
+            if (!acc.has(workspaceMemberId)) {
+              acc.set(workspaceMemberId, []);
+            }
+
+            if (!isDefined(handle)) {
+              return acc;
+            }
+
+            acc.get(workspaceMemberId)?.push(handle);
+
+            return acc;
+          },
+          new Map<string, string[]>(),
+        );
+
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        const messageChannelMessageAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+            workspaceId,
+            'messageChannelMessageAssociation',
+          );
+
+        for (const workspaceMemberId of handlesToDeleteByWorkspaceMemberIdMap.keys()) {
+          const handles =
+            handlesToDeleteByWorkspaceMemberIdMap.get(workspaceMemberId);
+
+          if (!handles) {
+            continue;
+          }
+
+          const rolesToDelete = [
+            MessageParticipantRole.FROM,
+            MessageParticipantRole.TO,
+          ] as const;
+
+          const messageChannels = await messageChannelRepository.find({
+            select: {
+              id: true,
+              handle: true,
+              connectedAccount: {
+                handleAliases: true,
               },
             },
+            where: {
+              connectedAccount: {
+                accountOwnerId: workspaceMemberId,
+              },
+            },
+            relations: ['connectedAccount'],
           });
 
-        if (messageChannelMessageAssociationsToDelete.length === 0) {
-          continue;
+          for (const messageChannel of messageChannels) {
+            const messageChannelHandles = [messageChannel.handle];
+
+            if (messageChannel.connectedAccount.handleAliases) {
+              messageChannelHandles.push(
+                ...messageChannel.connectedAccount.handleAliases.split(','),
+              );
+            }
+
+            const handleConditions = handles.map((handle) => {
+              const isHandleDomain = handle.startsWith('@');
+
+              return isHandleDomain
+                ? {
+                    handle: And(
+                      Or(ILike(`%${handle}`), ILike(`%.${handle.slice(1)}`)),
+                      Not(In(messageChannelHandles)),
+                    ),
+                    role: In(rolesToDelete),
+                  }
+                : { handle, role: In(rolesToDelete) };
+            });
+
+            const messageChannelMessageAssociationsToDelete =
+              await messageChannelMessageAssociationRepository.find({
+                where: {
+                  messageChannelId: messageChannel.id,
+                  message: {
+                    messageParticipants: handleConditions,
+                  },
+                },
+              });
+
+            if (messageChannelMessageAssociationsToDelete.length === 0) {
+              continue;
+            }
+
+            await messageChannelMessageAssociationRepository.delete(
+              messageChannelMessageAssociationsToDelete.map(({ id }) => id),
+            );
+          }
         }
 
-        await messageChannelMessageAssociationRepository.delete(
-          messageChannelMessageAssociationsToDelete.map(({ id }) => id),
+        await this.threadCleanerService.cleanOrphanMessagesAndThreads(
+          workspaceId,
         );
-      }
-    }
-
-    await this.threadCleanerService.cleanOrphanMessagesAndThreads(workspaceId);
+      },
+    );
   }
 }

packages/twenty-server/src/modules/messaging/blocklist-manager/jobs/messaging-blocklist-reimport-messages.job.ts

@@ -6,7 +6,8 @@ import { type ObjectRecordDeleteEvent } from 'src/engine/core-modules/event-emit
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
 import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
@@ -25,7 +26,7 @@ export type BlocklistReimportMessagesJobData = WorkspaceEventBatch<
 })
 export class BlocklistReimportMessagesJob {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingChannelSyncStatusService: MessageChannelSyncStatusService,
   ) {}
 
@@ -33,30 +34,39 @@ export class BlocklistReimportMessagesJob {
   async handle(data: BlocklistReimportMessagesJobData): Promise<void> {
     const workspaceId = data.workspaceId;
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    for (const eventPayload of data.events) {
-      const workspaceMemberId =
-        eventPayload.properties.before.workspaceMemberId;
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
 
-      const messageChannels = await messageChannelRepository.find({
-        select: ['id'],
-        where: {
-          connectedAccount: {
-            accountOwnerId: workspaceMemberId,
-          },
-          syncStage: Not(MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING),
-        },
-      });
+        for (const eventPayload of data.events) {
+          const workspaceMemberId =
+            eventPayload.properties.before.workspaceMemberId;
 
-      await this.messagingChannelSyncStatusService.resetAndMarkAsMessagesListFetchPending(
-        messageChannels.map((messageChannel) => messageChannel.id),
-        workspaceId,
-      );
-    }
+          const messageChannels = await messageChannelRepository.find({
+            select: ['id'],
+            where: {
+              connectedAccount: {
+                accountOwnerId: workspaceMemberId,
+              },
+              syncStage: Not(
+                MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
+              ),
+            },
+          });
+
+          await this.messagingChannelSyncStatusService.resetAndMarkAsMessagesListFetchPending(
+            messageChannels.map((messageChannel) => messageChannel.id),
+            workspaceId,
+          );
+        }
+      },
+    );
   }
 }

packages/twenty-server/src/modules/messaging/common/query-hooks/message/apply-messages-visibility-restrictions.service.spec.ts

@@ -2,7 +2,7 @@ import { Test, type TestingModule } from '@nestjs/testing';
 
 import { FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED } from 'twenty-shared/constants';
 
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { MessageChannelVisibility } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import { type MessageWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message.workspace-entity';
 
@@ -42,20 +42,21 @@ describe('ApplyMessagesVisibilityRestrictionsService', () => {
     findOneByOrFail: jest.fn(),
   };
 
-  const mockTwentyORMGlobalManager = {
-    getRepositoryForWorkspace: jest
+  const mockGlobalWorkspaceOrmManager = {
+    getRepository: jest.fn().mockImplementation((workspaceId, name) => {
+      if (name === 'messageChannelMessageAssociation') {
+        return mockMessageChannelMessageAssociationRepository;
+      }
+      if (name === 'connectedAccount') {
+        return mockConnectedAccountRepository;
+      }
+      if (name === 'workspaceMember') {
+        return mockWorkspaceMemberRepository;
+      }
+    }),
+    executeInWorkspaceContext: jest
       .fn()
-      .mockImplementation((workspaceId, name) => {
-        if (name === 'messageChannelMessageAssociation') {
-          return mockMessageChannelMessageAssociationRepository;
-        }
-        if (name === 'connectedAccount') {
-          return mockConnectedAccountRepository;
-        }
-        if (name === 'workspaceMember') {
-          return mockWorkspaceMemberRepository;
-        }
-      }),
+      .mockImplementation((_authContext: any, fn: () => any) => fn()),
   };
 
   beforeEach(async () => {
@@ -63,8 +64,8 @@ describe('ApplyMessagesVisibilityRestrictionsService', () => {
       providers: [
         ApplyMessagesVisibilityRestrictionsService,
         {
-          provide: TwentyORMGlobalManager,
-          useValue: mockTwentyORMGlobalManager,
+          provide: GlobalWorkspaceOrmManager,
+          useValue: mockGlobalWorkspaceOrmManager,
         },
       ],
     }).compile();

packages/twenty-server/src/modules/messaging/common/query-hooks/message/apply-messages-visibility-restrictions.service.ts

@@ -6,7 +6,8 @@ import { isDefined } from 'twenty-shared/utils';
 import { In } from 'typeorm';
 
 import { NotFoundError } from 'src/engine/core-modules/graphql/utils/graphql-errors.util';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { type MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
 import { MessageChannelVisibility } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
@@ -16,105 +17,117 @@ import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/sta
 @Injectable()
 export class ApplyMessagesVisibilityRestrictionsService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   public async applyMessagesVisibilityRestrictions(
     messages: MessageWorkspaceEntity[],
     workspaceId: string,
-    userId?: string, // undefined when request is made with api key
+    userId?: string,
   ) {
-    const messageChannelMessageAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelMessageAssociationWorkspaceEntity>(
-        workspaceId,
-        'messageChannelMessageAssociation',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageChannelMessagesAssociations =
-      await messageChannelMessageAssociationRepository.find({
-        where: {
-          messageId: In(messages.map((message) => message.id)),
-        },
-        relations: ['messageChannel'],
-      });
+    return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelMessageAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+            workspaceId,
+            'messageChannelMessageAssociation',
+          );
 
-    const connectedAccountRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<ConnectedAccountWorkspaceEntity>(
-        workspaceId,
-        'connectedAccount',
-      );
-
-    const workspaceMemberRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<WorkspaceMemberWorkspaceEntity>(
-        workspaceId,
-        'workspaceMember',
-      );
-
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const messageChannelMessageAssociations =
-        messageChannelMessagesAssociations.filter(
-          (association) => association.messageId === messages[i].id,
-        );
-
-      const messageChannels = messageChannelMessageAssociations
-        .map((association) => association.messageChannel)
-        .filter(
-          (channel): channel is NonNullable<typeof channel> => channel !== null,
-        );
-
-      if (messageChannels.length === 0) {
-        throw new NotFoundError('Associated message channels not found');
-      }
-
-      const messageChannelsGroupByVisibility = groupBy(
-        messageChannels,
-        (channel) => channel.visibility,
-      );
-
-      if (
-        messageChannelsGroupByVisibility[
-          MessageChannelVisibility.SHARE_EVERYTHING
-        ]
-      ) {
-        continue;
-      }
-
-      if (isDefined(userId)) {
-        const workspaceMember = await workspaceMemberRepository.findOneByOrFail(
-          {
-            userId,
-          },
-        );
-
-        const connectedAccounts = await connectedAccountRepository.find({
-          select: ['id'],
-          where: {
-            messageChannels: {
-              id: In(messageChannels.map((channel) => channel.id)),
+        const messageChannelMessagesAssociations =
+          await messageChannelMessageAssociationRepository.find({
+            where: {
+              messageId: In(messages.map((message) => message.id)),
             },
-            accountOwnerId: workspaceMember.id,
-          },
-        });
+            relations: ['messageChannel'],
+          });
 
-        if (connectedAccounts.length > 0) {
-          continue;
+        const connectedAccountRepository =
+          await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
+            workspaceId,
+            'connectedAccount',
+          );
+
+        const workspaceMemberRepository =
+          await this.globalWorkspaceOrmManager.getRepository<WorkspaceMemberWorkspaceEntity>(
+            workspaceId,
+            'workspaceMember',
+          );
+
+        for (let i = messages.length - 1; i >= 0; i--) {
+          const messageChannelMessageAssociations =
+            messageChannelMessagesAssociations.filter(
+              (association) => association.messageId === messages[i].id,
+            );
+
+          const messageChannels = messageChannelMessageAssociations
+            .map((association) => association.messageChannel)
+            .filter(
+              (channel): channel is NonNullable<typeof channel> =>
+                channel !== null,
+            );
+
+          if (messageChannels.length === 0) {
+            throw new NotFoundError('Associated message channels not found');
+          }
+
+          const messageChannelsGroupByVisibility = groupBy(
+            messageChannels,
+            (channel) => channel.visibility,
+          );
+
+          if (
+            messageChannelsGroupByVisibility[
+              MessageChannelVisibility.SHARE_EVERYTHING
+            ]
+          ) {
+            continue;
+          }
+
+          if (isDefined(userId)) {
+            const workspaceMember =
+              await workspaceMemberRepository.findOneByOrFail({
+                userId,
+              });
+
+            const connectedAccounts = await connectedAccountRepository.find({
+              select: ['id'],
+              where: {
+                messageChannels: {
+                  id: In(messageChannels.map((channel) => channel.id)),
+                },
+                accountOwnerId: workspaceMember.id,
+              },
+            });
+
+            if (connectedAccounts.length > 0) {
+              continue;
+            }
+          }
+
+          if (
+            messageChannelsGroupByVisibility[MessageChannelVisibility.SUBJECT]
+          ) {
+            messages[i].text = FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
+            continue;
+          }
+
+          if (
+            messageChannelsGroupByVisibility[MessageChannelVisibility.METADATA]
+          ) {
+            messages[i].subject =
+              FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
+            messages[i].text = FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
+            continue;
+          }
+
+          messages.splice(i, 1);
         }
-      }
 
-      if (messageChannelsGroupByVisibility[MessageChannelVisibility.SUBJECT]) {
-        messages[i].text = FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
-        continue;
-      }
-
-      if (messageChannelsGroupByVisibility[MessageChannelVisibility.METADATA]) {
-        messages[i].subject = FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
-        messages[i].text = FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
-        continue;
-      }
-
-      messages.splice(i, 1);
-    }
-
-    return messages;
+        return messages;
+      },
+    );
   }
 }

packages/twenty-server/src/modules/messaging/common/query-hooks/message/message-channel-update-one.pre-query.hook.ts

@@ -14,7 +14,8 @@ import {
 } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-runner.exception';
 import { type AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
 import { WorkspaceNotFoundDefaultError } from 'src/engine/core-modules/workspace/workspace.exception';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import {
   MessageChannelPendingGroupEmailsAction,
   MessageChannelSyncStage,
@@ -39,7 +40,7 @@ export class MessageChannelUpdateOnePreQueryHook
   );
 
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingProcessGroupEmailActionsService: MessagingProcessGroupEmailActionsService,
   ) {}
 
@@ -52,89 +53,97 @@ export class MessageChannelUpdateOnePreQueryHook
 
     assertIsDefinedOrThrow(workspace, WorkspaceNotFoundDefaultError);
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspace.id,
-        'messageChannel',
-      );
+    const systemAuthContext = buildSystemAuthContext(workspace.id);
 
-    const messageChannel = await messageChannelRepository.findOne({
-      where: { id: payload.id },
-    });
+    return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      systemAuthContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspace.id,
+            'messageChannel',
+          );
 
-    if (!isDefined(messageChannel)) {
-      throw new WorkspaceQueryRunnerException(
-        'Message channel not found',
-        WorkspaceQueryRunnerExceptionCode.DATA_NOT_FOUND,
-        {
-          userFriendlyMessage: msg`Message channel not found`,
-        },
-      );
-    }
+        const messageChannel = await messageChannelRepository.findOne({
+          where: { id: payload.id },
+        });
 
-    const isSyncOngoing = ONGOING_SYNC_STAGES.includes(
-      messageChannel.syncStage,
+        if (!isDefined(messageChannel)) {
+          throw new WorkspaceQueryRunnerException(
+            'Message channel not found',
+            WorkspaceQueryRunnerExceptionCode.DATA_NOT_FOUND,
+            {
+              userFriendlyMessage: msg`Message channel not found`,
+            },
+          );
+        }
+
+        const isSyncOngoing = ONGOING_SYNC_STAGES.includes(
+          messageChannel.syncStage,
+        );
+
+        const messageFolderRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
+            workspace.id,
+            'messageFolder',
+          );
+
+        const messageFoldersWithPendingActionCount =
+          await messageFolderRepository.count({
+            where: {
+              messageChannelId: messageChannel.id,
+              pendingSyncAction: Not(MessageFolderPendingSyncAction.NONE),
+            },
+          });
+
+        const hasPendingFolderActions =
+          messageFoldersWithPendingActionCount > 0;
+
+        const hasPendingGroupEmailsAction =
+          messageChannel.pendingGroupEmailsAction !==
+          MessageChannelPendingGroupEmailsAction.NONE;
+
+        if (
+          isSyncOngoing &&
+          (hasPendingFolderActions || hasPendingGroupEmailsAction)
+        ) {
+          throw new WorkspaceQueryRunnerException(
+            'Cannot update message channel while sync is ongoing with pending actions',
+            WorkspaceQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
+            {
+              userFriendlyMessage: msg`Cannot update message channel while sync is ongoing. Please wait for the sync to complete.`,
+            },
+          );
+        }
+
+        const hasCompletedConfiguration =
+          messageChannel.syncStage !==
+          MessageChannelSyncStage.PENDING_CONFIGURATION;
+
+        if (!hasCompletedConfiguration) {
+          this.logger.log(
+            `MessageChannelId: ${messageChannel.id} - Skipping pending action for message channel in PENDING_CONFIGURATION state`,
+          );
+
+          return payload;
+        }
+
+        const excludeGroupEmailsChanged =
+          isDefined(payload.data.excludeGroupEmails) &&
+          payload.data.excludeGroupEmails !== messageChannel.excludeGroupEmails;
+
+        if (excludeGroupEmailsChanged) {
+          await this.messagingProcessGroupEmailActionsService.markMessageChannelAsPendingGroupEmailsAction(
+            messageChannel,
+            workspace.id,
+            payload.data.excludeGroupEmails
+              ? MessageChannelPendingGroupEmailsAction.GROUP_EMAILS_DELETION
+              : MessageChannelPendingGroupEmailsAction.GROUP_EMAILS_IMPORT,
+          );
+        }
+
+        return payload;
+      },
     );
-
-    const messageFolderRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
-        workspace.id,
-        'messageFolder',
-      );
-
-    const messageFoldersWithPendingActionCount =
-      await messageFolderRepository.count({
-        where: {
-          messageChannelId: messageChannel.id,
-          pendingSyncAction: Not(MessageFolderPendingSyncAction.NONE),
-        },
-      });
-
-    const hasPendingFolderActions = messageFoldersWithPendingActionCount > 0;
-
-    const hasPendingGroupEmailsAction =
-      messageChannel.pendingGroupEmailsAction !==
-      MessageChannelPendingGroupEmailsAction.NONE;
-
-    if (
-      isSyncOngoing &&
-      (hasPendingFolderActions || hasPendingGroupEmailsAction)
-    ) {
-      throw new WorkspaceQueryRunnerException(
-        'Cannot update message channel while sync is ongoing with pending actions',
-        WorkspaceQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
-        {
-          userFriendlyMessage: msg`Cannot update message channel while sync is ongoing. Please wait for the sync to complete.`,
-        },
-      );
-    }
-
-    const hasCompletedConfiguration =
-      messageChannel.syncStage !==
-      MessageChannelSyncStage.PENDING_CONFIGURATION;
-
-    if (!hasCompletedConfiguration) {
-      this.logger.log(
-        `MessageChannelId: ${messageChannel.id} - Skipping pending action for message channel in PENDING_CONFIGURATION state`,
-      );
-
-      return payload;
-    }
-
-    const excludeGroupEmailsChanged =
-      isDefined(payload.data.excludeGroupEmails) &&
-      payload.data.excludeGroupEmails !== messageChannel.excludeGroupEmails;
-
-    if (excludeGroupEmailsChanged) {
-      await this.messagingProcessGroupEmailActionsService.markMessageChannelAsPendingGroupEmailsAction(
-        messageChannel,
-        workspace.id,
-        payload.data.excludeGroupEmails
-          ? MessageChannelPendingGroupEmailsAction.GROUP_EMAILS_DELETION
-          : MessageChannelPendingGroupEmailsAction.GROUP_EMAILS_IMPORT,
-      );
-    }
-
-    return payload;
   }
 }

packages/twenty-server/src/modules/messaging/common/services/message-channel-sync-status.service.ts

@@ -7,7 +7,8 @@ import { CacheStorageService } from 'src/engine/core-modules/cache-storage/servi
 import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
 import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';
 import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { AccountsToReconnectService } from 'src/modules/connected-account/services/accounts-to-reconnect.service';
 import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { AccountsToReconnectKeys } from 'src/modules/connected-account/types/accounts-to-reconnect-key-value.type';
@@ -27,7 +28,7 @@ export class MessageChannelSyncStatusService {
   constructor(
     @InjectCacheStorage(CacheStorageNamespace.ModuleMessaging)
     private readonly cacheStorage: CacheStorageService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly accountsToReconnectService: AccountsToReconnectService,
     private readonly metricsService: MetricsService,
   ) {}
@@ -41,16 +42,23 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
-      ...(!preserveSyncStageStartedAt ? { syncStageStartedAt: null } : {}),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
+          ...(!preserveSyncStageStartedAt ? { syncStageStartedAt: null } : {}),
+        });
+      },
+    );
   }
 
   public async markAsMessagesImportPending(
@@ -62,16 +70,23 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStage: MessageChannelSyncStage.MESSAGES_IMPORT_PENDING,
-      ...(!preserveSyncStageStartedAt ? { syncStageStartedAt: null } : {}),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStage: MessageChannelSyncStage.MESSAGES_IMPORT_PENDING,
+          ...(!preserveSyncStageStartedAt ? { syncStageStartedAt: null } : {}),
+        });
+      },
+    );
   }
 
   public async resetAndMarkAsMessagesListFetchPending(
@@ -88,30 +103,37 @@ export class MessageChannelSyncStatusService {
       );
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageFolderRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
-        workspaceId,
-        'messageFolder',
-      );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncCursor: '',
-      syncStageStartedAt: null,
-      throttleFailureCount: 0,
-      pendingGroupEmailsAction: MessageChannelPendingGroupEmailsAction.NONE,
-    });
+        const messageFolderRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
+            workspaceId,
+            'messageFolder',
+          );
 
-    await messageFolderRepository.update(
-      { messageChannelId: In(messageChannelIds) },
-      {
-        syncCursor: '',
-        pendingSyncAction: MessageFolderPendingSyncAction.NONE,
+        await messageChannelRepository.update(messageChannelIds, {
+          syncCursor: '',
+          syncStageStartedAt: null,
+          throttleFailureCount: 0,
+          pendingGroupEmailsAction: MessageChannelPendingGroupEmailsAction.NONE,
+        });
+
+        await messageFolderRepository.update(
+          { messageChannelId: In(messageChannelIds) },
+          {
+            syncCursor: '',
+            pendingSyncAction: MessageFolderPendingSyncAction.NONE,
+          },
+        );
       },
     );
 
@@ -126,15 +148,22 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStageStartedAt: null,
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStageStartedAt: null,
+        });
+      },
+    );
   }
 
   public async markAsMessagesListFetchScheduled(
@@ -145,17 +174,24 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_SCHEDULED,
-      syncStatus: MessageChannelSyncStatus.ONGOING,
-      syncStageStartedAt: new Date().toISOString(),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_SCHEDULED,
+          syncStatus: MessageChannelSyncStatus.ONGOING,
+          syncStageStartedAt: new Date().toISOString(),
+        });
+      },
+    );
   }
 
   public async markAsMessagesListFetchOngoing(
@@ -166,16 +202,23 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_ONGOING,
-      syncStatus: MessageChannelSyncStatus.ONGOING,
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_ONGOING,
+          syncStatus: MessageChannelSyncStatus.ONGOING,
+        });
+      },
+    );
   }
 
   public async markAsCompletedAndMarkAsMessagesListFetchPending(
@@ -186,19 +229,26 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStatus: MessageChannelSyncStatus.ACTIVE,
-      syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
-      throttleFailureCount: 0,
-      syncStageStartedAt: null,
-      syncedAt: new Date().toISOString(),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStatus: MessageChannelSyncStatus.ACTIVE,
+          syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
+          throttleFailureCount: 0,
+          syncStageStartedAt: null,
+          syncedAt: new Date().toISOString(),
+        });
+      },
+    );
 
     await this.metricsService.batchIncrementCounter({
       key: MetricsKeys.MessageChannelSyncJobActive,
@@ -214,15 +264,22 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStage: MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED,
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStage: MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED,
+        });
+      },
+    );
   }
 
   public async markAsMessagesImportOngoing(
@@ -233,16 +290,23 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStage: MessageChannelSyncStage.MESSAGES_IMPORT_ONGOING,
-      syncStageStartedAt: new Date().toISOString(),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStage: MessageChannelSyncStage.MESSAGES_IMPORT_ONGOING,
+          syncStageStartedAt: new Date().toISOString(),
+        });
+      },
+    );
   }
 
   public async markAsFailed(
@@ -256,57 +320,66 @@ export class MessageChannelSyncStatusService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(messageChannelIds, {
-      syncStage: MessageChannelSyncStage.FAILED,
-      syncStatus: syncStatus,
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
 
-    const metricsKey =
-      syncStatus === MessageChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS
-        ? MetricsKeys.MessageChannelSyncJobFailedInsufficientPermissions
-        : MetricsKeys.MessageChannelSyncJobFailedUnknown;
+        await messageChannelRepository.update(messageChannelIds, {
+          syncStage: MessageChannelSyncStage.FAILED,
+          syncStatus: syncStatus,
+        });
 
-    await this.metricsService.batchIncrementCounter({
-      key: metricsKey,
-      eventIds: messageChannelIds,
-    });
+        const metricsKey =
+          syncStatus ===
+          MessageChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS
+            ? MetricsKeys.MessageChannelSyncJobFailedInsufficientPermissions
+            : MetricsKeys.MessageChannelSyncJobFailedUnknown;
 
-    if (
-      syncStatus === MessageChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS
-    ) {
-      const connectedAccountRepository =
-        await this.twentyORMGlobalManager.getRepositoryForWorkspace<ConnectedAccountWorkspaceEntity>(
-          workspaceId,
-          'connectedAccount',
-        );
+        await this.metricsService.batchIncrementCounter({
+          key: metricsKey,
+          eventIds: messageChannelIds,
+        });
 
-      const messageChannels = await messageChannelRepository.find({
-        select: ['id', 'connectedAccountId'],
-        where: { id: Any(messageChannelIds) },
-      });
+        if (
+          syncStatus ===
+          MessageChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS
+        ) {
+          const connectedAccountRepository =
+            await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
+              workspaceId,
+              'connectedAccount',
+            );
 
-      const connectedAccountIds = messageChannels.map(
-        (messageChannel) => messageChannel.connectedAccountId,
-      );
+          const messageChannels = await messageChannelRepository.find({
+            select: ['id', 'connectedAccountId'],
+            where: { id: Any(messageChannelIds) },
+          });
 
-      await connectedAccountRepository.update(
-        { id: Any(connectedAccountIds) },
-        {
-          authFailedAt: new Date(),
-        },
-      );
+          const connectedAccountIds = messageChannels.map(
+            (messageChannel) => messageChannel.connectedAccountId,
+          );
 
-      await this.addToAccountsToReconnect(
-        messageChannels.map((messageChannel) => messageChannel.id),
-        workspaceId,
-      );
-    }
+          await connectedAccountRepository.update(
+            { id: Any(connectedAccountIds) },
+            {
+              authFailedAt: new Date(),
+            },
+          );
+
+          await this.addToAccountsToReconnect(
+            messageChannels.map((messageChannel) => messageChannel.id),
+            workspaceId,
+          );
+        }
+      },
+    );
   }
 
   private async addToAccountsToReconnect(
@@ -318,7 +391,7 @@ export class MessageChannelSyncStatusService {
     }
 
     const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
+      await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
         workspaceId,
         'messageChannel',
       );

packages/twenty-server/src/modules/messaging/message-cleaner/commands/messaging-message-clearner-remove-orphans.command.ts

@@ -7,7 +7,7 @@ import { ActiveOrSuspendedWorkspacesMigrationCommandRunner } from 'src/database/
 import { RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspaces-migration.command-runner';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
 import { DataSourceService } from 'src/engine/metadata-modules/data-source/data-source.service';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { MessagingMessageCleanerService } from 'src/modules/messaging/message-cleaner/services/messaging-message-cleaner.service';
 
 @Command({
@@ -18,11 +18,11 @@ export class MessagingMessageCleanerRemoveOrphansCommand extends ActiveOrSuspend
   constructor(
     @InjectRepository(WorkspaceEntity)
     protected readonly workspaceRepository: Repository<WorkspaceEntity>,
-    protected readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    protected readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingMessageCleanerService: MessagingMessageCleanerService,
     protected readonly dataSourceService: DataSourceService,
   ) {
-    super(workspaceRepository, twentyORMGlobalManager, dataSourceService);
+    super(workspaceRepository, globalWorkspaceOrmManager, dataSourceService);
   }
 
   override async runOnWorkspace({

packages/twenty-server/src/modules/messaging/message-cleaner/commands/messaging-reset-channel.command.ts

@@ -3,7 +3,8 @@ import { Logger } from '@nestjs/common';
 import { Command, CommandRunner, Option } from 'nest-commander';
 import { isDefined } from 'twenty-shared/utils';
 
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import { type MessageChannelWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import { MessagingMessageCleanerService } from 'src/modules/messaging/message-cleaner/services/messaging-message-cleaner.service';
@@ -22,7 +23,7 @@ export class MessagingResetChannelCommand extends CommandRunner {
   private readonly logger = new Logger(MessagingResetChannelCommand.name);
 
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingChannelSyncStatusService: MessageChannelSyncStatusService,
     private readonly messagingMessageCleanerService: MessagingMessageCleanerService,
   ) {
@@ -35,44 +36,53 @@ export class MessagingResetChannelCommand extends CommandRunner {
   ): Promise<void> {
     const { workspaceId, messageChannelId } = options;
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    this.logger.log(
-      `No message channel ID provided, resetting all message channels in workspace ${workspaceId}`,
-    );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
 
-    const messageChannels = await messageChannelRepository.find({
-      where: {
-        ...(isDefined(messageChannelId) ? { id: messageChannelId } : {}),
+        this.logger.log(
+          `No message channel ID provided, resetting all message channels in workspace ${workspaceId}`,
+        );
+
+        const messageChannels = await messageChannelRepository.find({
+          where: {
+            ...(isDefined(messageChannelId) ? { id: messageChannelId } : {}),
+          },
+        });
+
+        if (messageChannels.length === 0) {
+          this.logger.log(
+            `No message channels found in workspace ${workspaceId}`,
+          );
+
+          return;
+        }
+
+        this.logger.log(
+          `Found ${messageChannels.length} message channels to reset`,
+        );
+
+        for (const messageChannel of messageChannels) {
+          await this.messagingChannelSyncStatusService.resetAndMarkAsMessagesListFetchPending(
+            [messageChannel.id],
+            workspaceId,
+          );
+          await this.messagingMessageCleanerService.cleanOrphanMessagesAndThreads(
+            workspaceId,
+          );
+        }
+
+        this.logger.log(
+          `Successfully reset all ${messageChannels.length} message channels in workspace ${workspaceId}`,
+        );
       },
-    });
-
-    if (messageChannels.length === 0) {
-      this.logger.log(`No message channels found in workspace ${workspaceId}`);
-
-      return;
-    }
-
-    this.logger.log(
-      `Found ${messageChannels.length} message channels to reset`,
-    );
-
-    for (const messageChannel of messageChannels) {
-      await this.messagingChannelSyncStatusService.resetAndMarkAsMessagesListFetchPending(
-        [messageChannel.id],
-        workspaceId,
-      );
-      await this.messagingMessageCleanerService.cleanOrphanMessagesAndThreads(
-        workspaceId,
-      );
-    }
-
-    this.logger.log(
-      `Successfully reset all ${messageChannels.length} message channels in workspace ${workspaceId}`,
     );
   }
 

packages/twenty-server/src/modules/messaging/message-cleaner/services/messaging-message-cleaner.service.ts

@@ -4,7 +4,8 @@ import chunk from 'lodash.chunk';
 import { In, IsNull } from 'typeorm';
 
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
 import { type MessageThreadWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-thread.workspace-entity';
 import { type MessageWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message.workspace-entity';
@@ -14,7 +15,7 @@ import { deleteUsingPagination } from 'src/modules/messaging/message-cleaner/uti
 export class MessagingMessageCleanerService {
   private readonly logger = new Logger(MessagingMessageCleanerService.name);
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   async deleteMessagesChannelMessageAssociationsAndRelatedOrphans({
@@ -26,183 +27,199 @@ export class MessagingMessageCleanerService {
     messageExternalIds: string[];
     messageChannelId: string;
   }) {
-    const messageRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageWorkspaceEntity>(
-        workspaceId,
-        'message',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageChannelMessageAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelMessageAssociationWorkspaceEntity>(
-        workspaceId,
-        'messageChannelMessageAssociation',
-      );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageWorkspaceEntity>(
+            workspaceId,
+            'message',
+          );
 
-    const messageThreadRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageThreadWorkspaceEntity>(
-        workspaceId,
-        'messageThread',
-      );
+        const messageChannelMessageAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+            workspaceId,
+            'messageChannelMessageAssociation',
+          );
 
-    const messageExternalIdsChunks = chunk(messageExternalIds, 500);
+        const messageThreadRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageThreadWorkspaceEntity>(
+            workspaceId,
+            'messageThread',
+          );
 
-    for (const messageExternalIdsChunk of messageExternalIdsChunks) {
-      const messageChannelMessageAssociationsToDelete =
-        await messageChannelMessageAssociationRepository.find({
-          where: {
-            messageExternalId: In(messageExternalIdsChunk),
-            messageChannelId,
-          },
-        });
+        const messageExternalIdsChunks = chunk(messageExternalIds, 500);
 
-      if (messageChannelMessageAssociationsToDelete.length <= 0) {
-        continue;
-      }
+        for (const messageExternalIdsChunk of messageExternalIdsChunks) {
+          const messageChannelMessageAssociationsToDelete =
+            await messageChannelMessageAssociationRepository.find({
+              where: {
+                messageExternalId: In(messageExternalIdsChunk),
+                messageChannelId,
+              },
+            });
 
-      await messageChannelMessageAssociationRepository.delete(
-        messageChannelMessageAssociationsToDelete.map(({ id }) => id),
-      );
+          if (messageChannelMessageAssociationsToDelete.length <= 0) {
+            continue;
+          }
 
-      this.logger.log(
-        `WorkspaceId: ${workspaceId} Deleting ${messageChannelMessageAssociationsToDelete.length} message channel message associations`,
-      );
+          await messageChannelMessageAssociationRepository.delete(
+            messageChannelMessageAssociationsToDelete.map(({ id }) => id),
+          );
 
-      const orphanMessages = await messageRepository.find({
-        where: {
-          id: In(
-            messageChannelMessageAssociationsToDelete.map(
-              ({ messageId }) => messageId,
-            ),
-          ),
-          messageChannelMessageAssociations: {
-            id: IsNull(),
-          },
-        },
-      });
+          this.logger.log(
+            `WorkspaceId: ${workspaceId} Deleting ${messageChannelMessageAssociationsToDelete.length} message channel message associations`,
+          );
 
-      if (orphanMessages.length <= 0) {
-        continue;
-      }
+          const orphanMessages = await messageRepository.find({
+            where: {
+              id: In(
+                messageChannelMessageAssociationsToDelete.map(
+                  ({ messageId }) => messageId,
+                ),
+              ),
+              messageChannelMessageAssociations: {
+                id: IsNull(),
+              },
+            },
+          });
 
-      this.logger.log(
-        `WorkspaceId: ${workspaceId} Deleting ${orphanMessages.length} orphan messages`,
-      );
+          if (orphanMessages.length <= 0) {
+            continue;
+          }
 
-      await messageRepository.delete(orphanMessages.map(({ id }) => id));
+          this.logger.log(
+            `WorkspaceId: ${workspaceId} Deleting ${orphanMessages.length} orphan messages`,
+          );
 
-      const orphanMessageThreads = await messageThreadRepository.find({
-        where: {
-          id: In(orphanMessages.map(({ messageThreadId }) => messageThreadId)),
-          messages: {
-            id: IsNull(),
-          },
-        },
-      });
+          await messageRepository.delete(orphanMessages.map(({ id }) => id));
 
-      if (orphanMessageThreads.length <= 0) {
-        continue;
-      }
+          const orphanMessageThreads = await messageThreadRepository.find({
+            where: {
+              id: In(
+                orphanMessages.map(({ messageThreadId }) => messageThreadId),
+              ),
+              messages: {
+                id: IsNull(),
+              },
+            },
+          });
 
-      this.logger.log(
-        `WorkspaceId: ${workspaceId} Deleting ${orphanMessageThreads.length} orphan message threads`,
-      );
+          if (orphanMessageThreads.length <= 0) {
+            continue;
+          }
 
-      await messageThreadRepository.delete(
-        orphanMessageThreads.map(({ id }) => id),
-      );
-    }
+          this.logger.log(
+            `WorkspaceId: ${workspaceId} Deleting ${orphanMessageThreads.length} orphan message threads`,
+          );
+
+          await messageThreadRepository.delete(
+            orphanMessageThreads.map(({ id }) => id),
+          );
+        }
+      },
+    );
   }
 
   public async cleanOrphanMessagesAndThreads(workspaceId: string) {
-    const messageThreadRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageThreadWorkspaceEntity>(
-        workspaceId,
-        'messageThread',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageWorkspaceEntity>(
-        workspaceId,
-        'message',
-      );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageThreadRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageThreadWorkspaceEntity>(
+            workspaceId,
+            'messageThread',
+          );
 
-    const workspaceDataSource =
-      await this.twentyORMGlobalManager.getDataSourceForWorkspace({
-        workspaceId,
-      });
+        const messageRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageWorkspaceEntity>(
+            workspaceId,
+            'message',
+          );
 
-    await workspaceDataSource.transaction(
-      async (transactionManager: WorkspaceEntityManager) => {
-        await deleteUsingPagination(
-          workspaceId,
-          500,
-          async (
-            limit: number,
-            offset: number,
-            _workspaceId: string,
-            transactionManager: WorkspaceEntityManager,
-          ) => {
-            const nonAssociatedMessages = await messageRepository.find(
-              {
-                where: {
-                  messageChannelMessageAssociations: {
-                    id: IsNull(),
+        const workspaceDataSource =
+          await this.globalWorkspaceOrmManager.getDataSourceForWorkspace(
+            workspaceId,
+          );
+
+        await workspaceDataSource.transaction(
+          async (transactionManager: WorkspaceEntityManager) => {
+            await deleteUsingPagination(
+              workspaceId,
+              500,
+              async (
+                limit: number,
+                offset: number,
+                _workspaceId: string,
+                transactionManager: WorkspaceEntityManager,
+              ) => {
+                const nonAssociatedMessages = await messageRepository.find(
+                  {
+                    where: {
+                      messageChannelMessageAssociations: {
+                        id: IsNull(),
+                      },
+                    },
+                    take: limit,
+                    skip: offset,
+                    relations: ['messageChannelMessageAssociations'],
                   },
-                },
-                take: limit,
-                skip: offset,
-                relations: ['messageChannelMessageAssociations'],
+                  transactionManager,
+                );
+
+                return nonAssociatedMessages.map(({ id }) => id);
+              },
+              async (
+                ids: string[],
+                workspaceId: string,
+                transactionManager?: WorkspaceEntityManager,
+              ) => {
+                this.logger.log(
+                  `WorkspaceId: ${workspaceId} Deleting ${ids.length} messages from message cleaner`,
+                );
+                await messageRepository.delete(ids, transactionManager);
               },
               transactionManager,
             );
 
-            return nonAssociatedMessages.map(({ id }) => id);
-          },
-          async (
-            ids: string[],
-            workspaceId: string,
-            transactionManager?: WorkspaceEntityManager,
-          ) => {
-            this.logger.log(
-              `WorkspaceId: ${workspaceId} Deleting ${ids.length} messages from message cleaner`,
-            );
-            await messageRepository.delete(ids, transactionManager);
-          },
-          transactionManager,
-        );
-
-        await deleteUsingPagination(
-          workspaceId,
-          500,
-          async (
-            limit: number,
-            offset: number,
-            _workspaceId: string,
-            transactionManager?: WorkspaceEntityManager,
-          ) => {
-            const orphanThreads = await messageThreadRepository.find(
-              {
-                where: {
-                  messages: {
-                    id: IsNull(),
+            await deleteUsingPagination(
+              workspaceId,
+              500,
+              async (
+                limit: number,
+                offset: number,
+                _workspaceId: string,
+                transactionManager?: WorkspaceEntityManager,
+              ) => {
+                const orphanThreads = await messageThreadRepository.find(
+                  {
+                    where: {
+                      messages: {
+                        id: IsNull(),
+                      },
+                    },
+                    take: limit,
+                    skip: offset,
                   },
-                },
-                take: limit,
-                skip: offset,
+                  transactionManager,
+                );
+
+                return orphanThreads.map(({ id }) => id);
+              },
+              async (
+                ids: string[],
+                _workspaceId: string,
+                transactionManager?: WorkspaceEntityManager,
+              ) => {
+                await messageThreadRepository.delete(ids, transactionManager);
               },
               transactionManager,
             );
-
-            return orphanThreads.map(({ id }) => id);
           },
-          async (
-            ids: string[],
-            _workspaceId: string,
-            transactionManager?: WorkspaceEntityManager,
-          ) => {
-            await messageThreadRepository.delete(ids, transactionManager);
-          },
-          transactionManager,
         );
       },
     );

packages/twenty-server/src/modules/messaging/message-folder-manager/query-hooks/message-folder-update-one.pre-query.hook.ts

@@ -12,7 +12,8 @@ import {
 } from 'src/engine/api/graphql/workspace-query-runner/workspace-query-runner.exception';
 import { type AuthContext } from 'src/engine/core-modules/auth/types/auth-context.type';
 import { WorkspaceNotFoundDefaultError } from 'src/engine/core-modules/workspace/workspace.exception';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import {
   MessageFolderImportPolicy,
   type MessageChannelWorkspaceEntity,
@@ -24,7 +25,7 @@ export class MessageFolderUpdateOnePreQueryHook
   implements WorkspacePreQueryHookInstance
 {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   async execute(
@@ -36,68 +37,75 @@ export class MessageFolderUpdateOnePreQueryHook
 
     assertIsDefinedOrThrow(workspace, WorkspaceNotFoundDefaultError);
 
-    const messageFolderRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
-        workspace.id,
-        'messageFolder',
-      );
+    const systemAuthContext = buildSystemAuthContext(workspace.id);
 
-    const messageFolder = await messageFolderRepository.findOne({
-      where: { id: payload.id },
-    });
+    return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      systemAuthContext,
+      async () => {
+        const messageFolderRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
+            workspace.id,
+            'messageFolder',
+          );
 
-    if (!messageFolder) {
-      throw new WorkspaceQueryRunnerException(
-        'Message folder not found',
-        WorkspaceQueryRunnerExceptionCode.DATA_NOT_FOUND,
-        {
-          userFriendlyMessage: msg`Message folder not found`,
-        },
-      );
-    }
+        const messageFolder = await messageFolderRepository.findOne({
+          where: { id: payload.id },
+        });
 
-    if (payload.data.isSynced !== false) {
-      return payload;
-    }
+        if (!messageFolder) {
+          throw new WorkspaceQueryRunnerException(
+            'Message folder not found',
+            WorkspaceQueryRunnerExceptionCode.DATA_NOT_FOUND,
+            {
+              userFriendlyMessage: msg`Message folder not found`,
+            },
+          );
+        }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspace.id,
-        'messageChannel',
-      );
+        if (payload.data.isSynced !== false) {
+          return payload;
+        }
 
-    const messageChannel = await messageChannelRepository.findOne({
-      where: { id: messageFolder.messageChannelId },
-    });
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspace.id,
+            'messageChannel',
+          );
 
-    if (
-      messageChannel?.messageFolderImportPolicy !==
-      MessageFolderImportPolicy.SELECTED_FOLDERS
-    ) {
-      return payload;
-    }
+        const messageChannel = await messageChannelRepository.findOne({
+          where: { id: messageFolder.messageChannelId },
+        });
 
-    const syncedFoldersCount = await messageFolderRepository.count({
-      where: {
-        messageChannelId: messageFolder.messageChannelId,
-        isSynced: true,
+        if (
+          messageChannel?.messageFolderImportPolicy !==
+          MessageFolderImportPolicy.SELECTED_FOLDERS
+        ) {
+          return payload;
+        }
+
+        const syncedFoldersCount = await messageFolderRepository.count({
+          where: {
+            messageChannelId: messageFolder.messageChannelId,
+            isSynced: true,
+          },
+        });
+
+        if (
+          isDefined(syncedFoldersCount) &&
+          isNumber(syncedFoldersCount) &&
+          syncedFoldersCount <= 1
+        ) {
+          throw new WorkspaceQueryRunnerException(
+            'Cannot unsync the last folder when folder import policy is set to selected folders',
+            WorkspaceQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
+            {
+              userFriendlyMessage: msg`At least one folder must be synced.`,
+            },
+          );
+        }
+
+        return payload;
       },
-    });
-
-    if (
-      isDefined(syncedFoldersCount) &&
-      isNumber(syncedFoldersCount) &&
-      syncedFoldersCount <= 1
-    ) {
-      throw new WorkspaceQueryRunnerException(
-        'Cannot unsync the last folder when folder import policy is set to selected folders',
-        WorkspaceQueryRunnerExceptionCode.INVALID_QUERY_INPUT,
-        {
-          userFriendlyMessage: msg`At least one folder must be synced.`,
-        },
-      );
-    }
-
-    return payload;
+    );
   }
 }

packages/twenty-server/src/modules/messaging/message-folder-manager/services/sync-message-folders.service.ts

@@ -9,8 +9,9 @@ import { v4 } from 'uuid';
 import { MessageFolder } from 'src/modules/messaging/message-folder-manager/interfaces/message-folder-driver.interface';
 
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type MessageChannelWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import {
   MessageFolderPendingSyncAction,
@@ -52,7 +53,7 @@ type MessageFolderToUpdate = Partial<
 @Injectable()
 export class SyncMessageFoldersService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly gmailGetAllFoldersService: GmailGetAllFoldersService,
     private readonly microsoftGetAllFoldersService: MicrosoftGetAllFoldersService,
     private readonly imapGetAllFoldersService: ImapGetAllFoldersService,
@@ -61,17 +62,24 @@ export class SyncMessageFoldersService {
   async syncMessageFolders(input: SyncMessageFoldersInput): Promise<void> {
     const { workspaceId, messageChannel, manager } = input;
 
-    const folders = await this.discoverAllFolders(
-      messageChannel.connectedAccount,
-      messageChannel,
-    );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await this.upsertDiscoveredFolders({
-      workspaceId,
-      messageChannelId: messageChannel.id,
-      folders,
-      manager,
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const folders = await this.discoverAllFolders(
+          messageChannel.connectedAccount,
+          messageChannel,
+        );
+
+        await this.upsertDiscoveredFolders({
+          workspaceId,
+          messageChannelId: messageChannel.id,
+          folders,
+          manager,
+        });
+      },
+    );
   }
 
   private async upsertDiscoveredFolders({
@@ -86,7 +94,7 @@ export class SyncMessageFoldersService {
     manager: WorkspaceEntityManager;
   }): Promise<void> {
     const messageFolderRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
+      await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
         workspaceId,
         'messageFolder',
       );

packages/twenty-server/src/modules/messaging/message-import-manager/jobs/messaging-message-list-fetch.job.ts

@@ -3,7 +3,8 @@ import { Scope } from '@nestjs/common';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { isThrottled } from 'src/modules/connected-account/utils/is-throttled';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import {
@@ -30,7 +31,7 @@ export class MessagingMessageListFetchJob {
   constructor(
     private readonly messagingMessageListFetchService: MessagingMessageListFetchService,
     private readonly messagingMonitoringService: MessagingMonitoringService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messageImportErrorHandlerService: MessageImportExceptionHandlerService,
     private readonly messageChannelSyncStatusService: MessageChannelSyncStatusService,
   ) {}
@@ -45,77 +46,84 @@ export class MessagingMessageListFetchJob {
       workspaceId,
     });
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageChannel = await messageChannelRepository.findOne({
-      where: {
-        id: messageChannelId,
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        const messageChannel = await messageChannelRepository.findOne({
+          where: {
+            id: messageChannelId,
+          },
+          relations: ['connectedAccount', 'messageFolders'],
+        });
+
+        if (!messageChannel) {
+          await this.messagingMonitoringService.track({
+            eventName: 'message_list_fetch_job.error.message_channel_not_found',
+            messageChannelId,
+            workspaceId,
+          });
+
+          return;
+        }
+
+        if (
+          messageChannel.syncStage !==
+          MessageChannelSyncStage.MESSAGE_LIST_FETCH_SCHEDULED
+        ) {
+          return;
+        }
+
+        try {
+          if (
+            isThrottled(
+              messageChannel.syncStageStartedAt,
+              messageChannel.throttleFailureCount,
+            )
+          ) {
+            await this.messageChannelSyncStatusService.markAsMessagesListFetchPending(
+              [messageChannel.id],
+              workspaceId,
+              true,
+            );
+
+            return;
+          }
+
+          await this.messagingMonitoringService.track({
+            eventName: 'message_list_fetch.started',
+            workspaceId,
+            connectedAccountId: messageChannel.connectedAccount.id,
+            messageChannelId: messageChannel.id,
+          });
+
+          await this.messagingMessageListFetchService.processMessageListFetch(
+            messageChannel,
+            workspaceId,
+          );
+
+          await this.messagingMonitoringService.track({
+            eventName: 'message_list_fetch.completed',
+            workspaceId,
+            connectedAccountId: messageChannel.connectedAccount.id,
+            messageChannelId: messageChannel.id,
+          });
+        } catch (error) {
+          await this.messageImportErrorHandlerService.handleDriverException(
+            error,
+            MessageImportSyncStep.MESSAGE_LIST_FETCH,
+            messageChannel,
+            workspaceId,
+          );
+        }
       },
-      relations: ['connectedAccount', 'messageFolders'],
-    });
-
-    if (!messageChannel) {
-      await this.messagingMonitoringService.track({
-        eventName: 'message_list_fetch_job.error.message_channel_not_found',
-        messageChannelId,
-        workspaceId,
-      });
-
-      return;
-    }
-
-    if (
-      messageChannel.syncStage !==
-      MessageChannelSyncStage.MESSAGE_LIST_FETCH_SCHEDULED
-    ) {
-      return;
-    }
-
-    try {
-      if (
-        isThrottled(
-          messageChannel.syncStageStartedAt,
-          messageChannel.throttleFailureCount,
-        )
-      ) {
-        await this.messageChannelSyncStatusService.markAsMessagesListFetchPending(
-          [messageChannel.id],
-          workspaceId,
-          true,
-        );
-
-        return;
-      }
-
-      await this.messagingMonitoringService.track({
-        eventName: 'message_list_fetch.started',
-        workspaceId,
-        connectedAccountId: messageChannel.connectedAccount.id,
-        messageChannelId: messageChannel.id,
-      });
-
-      await this.messagingMessageListFetchService.processMessageListFetch(
-        messageChannel,
-        workspaceId,
-      );
-
-      await this.messagingMonitoringService.track({
-        eventName: 'message_list_fetch.completed',
-        workspaceId,
-        connectedAccountId: messageChannel.connectedAccount.id,
-        messageChannelId: messageChannel.id,
-      });
-    } catch (error) {
-      await this.messageImportErrorHandlerService.handleDriverException(
-        error,
-        MessageImportSyncStep.MESSAGE_LIST_FETCH,
-        messageChannel,
-        workspaceId,
-      );
-    }
+    );
   }
 }

packages/twenty-server/src/modules/messaging/message-import-manager/jobs/messaging-messages-import.job.ts

@@ -3,7 +3,8 @@ import { Scope } from '@nestjs/common';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { isThrottled } from 'src/modules/connected-account/utils/is-throttled';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import {
@@ -12,6 +13,7 @@ import {
 } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import { MessagingMessagesImportService } from 'src/modules/messaging/message-import-manager/services/messaging-messages-import.service';
 import { MessagingMonitoringService } from 'src/modules/messaging/monitoring/services/messaging-monitoring.service';
+
 export type MessagingMessagesImportJobData = {
   messageChannelId: string;
   workspaceId: string;
@@ -26,7 +28,7 @@ export class MessagingMessagesImportJob {
     private readonly messagingMessagesImportService: MessagingMessagesImportService,
     private readonly messagingMonitoringService: MessagingMonitoringService,
     private readonly messageChannelSyncStatusService: MessageChannelSyncStatusService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   @Process(MessagingMessagesImportJob.name)
@@ -39,59 +41,66 @@ export class MessagingMessagesImportJob {
       messageChannelId,
     });
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageChannel = await messageChannelRepository.findOne({
-      where: {
-        id: messageChannelId,
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        const messageChannel = await messageChannelRepository.findOne({
+          where: {
+            id: messageChannelId,
+          },
+          relations: ['connectedAccount'],
+        });
+
+        if (!messageChannel) {
+          await this.messagingMonitoringService.track({
+            eventName: 'messages_import.error.message_channel_not_found',
+            messageChannelId,
+            workspaceId,
+          });
+
+          return;
+        }
+
+        if (!messageChannel?.isSyncEnabled) {
+          return;
+        }
+
+        if (
+          messageChannel.syncStage !==
+          MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED
+        ) {
+          return;
+        }
+
+        if (
+          isThrottled(
+            messageChannel.syncStageStartedAt,
+            messageChannel.throttleFailureCount,
+          )
+        ) {
+          await this.messageChannelSyncStatusService.markAsMessagesImportPending(
+            [messageChannel.id],
+            workspaceId,
+            true,
+          );
+
+          return;
+        }
+
+        await this.messagingMessagesImportService.processMessageBatchImport(
+          messageChannel,
+          messageChannel.connectedAccount,
+          workspaceId,
+        );
       },
-      relations: ['connectedAccount'],
-    });
-
-    if (!messageChannel) {
-      await this.messagingMonitoringService.track({
-        eventName: 'messages_import.error.message_channel_not_found',
-        messageChannelId,
-        workspaceId,
-      });
-
-      return;
-    }
-
-    if (!messageChannel?.isSyncEnabled) {
-      return;
-    }
-
-    if (
-      messageChannel.syncStage !==
-      MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED
-    ) {
-      return;
-    }
-
-    if (
-      isThrottled(
-        messageChannel.syncStageStartedAt,
-        messageChannel.throttleFailureCount,
-      )
-    ) {
-      await this.messageChannelSyncStatusService.markAsMessagesImportPending(
-        [messageChannel.id],
-        workspaceId,
-        true,
-      );
-
-      return;
-    }
-
-    await this.messagingMessagesImportService.processMessageBatchImport(
-      messageChannel,
-      messageChannel.connectedAccount,
-      workspaceId,
     );
   }
 }

packages/twenty-server/src/modules/messaging/message-import-manager/jobs/messaging-ongoing-stale.job.ts

@@ -5,7 +5,8 @@ import { In } from 'typeorm';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import {
   MessageChannelSyncStage,
@@ -24,7 +25,7 @@ export type MessagingOngoingStaleJobData = {
 export class MessagingOngoingStaleJob {
   private readonly logger = new Logger(MessagingOngoingStaleJob.name);
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messageChannelSyncStatusService: MessageChannelSyncStatusService,
   ) {}
 
@@ -32,58 +33,65 @@ export class MessagingOngoingStaleJob {
   async handle(data: MessagingOngoingStaleJobData): Promise<void> {
     const { workspaceId } = data;
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageChannels = await messageChannelRepository.find({
-      where: {
-        syncStage: In([
-          MessageChannelSyncStage.MESSAGES_IMPORT_ONGOING,
-          MessageChannelSyncStage.MESSAGE_LIST_FETCH_ONGOING,
-          MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED,
-          MessageChannelSyncStage.MESSAGE_LIST_FETCH_SCHEDULED,
-        ]),
-      },
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
 
-    for (const messageChannel of messageChannels) {
-      if (
-        messageChannel.syncStageStartedAt &&
-        isSyncStale(messageChannel.syncStageStartedAt)
-      ) {
-        await this.messageChannelSyncStatusService.resetSyncStageStartedAt(
-          [messageChannel.id],
-          workspaceId,
-        );
+        const messageChannels = await messageChannelRepository.find({
+          where: {
+            syncStage: In([
+              MessageChannelSyncStage.MESSAGES_IMPORT_ONGOING,
+              MessageChannelSyncStage.MESSAGE_LIST_FETCH_ONGOING,
+              MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED,
+              MessageChannelSyncStage.MESSAGE_LIST_FETCH_SCHEDULED,
+            ]),
+          },
+        });
 
-        switch (messageChannel.syncStage) {
-          case MessageChannelSyncStage.MESSAGE_LIST_FETCH_ONGOING:
-          case MessageChannelSyncStage.MESSAGE_LIST_FETCH_SCHEDULED:
-            this.logger.log(
-              `Sync for message channel ${messageChannel.id} and workspace ${workspaceId} is stale. Setting sync stage to MESSAGE_LIST_FETCH_PENDING`,
-            );
-            await this.messageChannelSyncStatusService.markAsMessagesListFetchPending(
+        for (const messageChannel of messageChannels) {
+          if (
+            messageChannel.syncStageStartedAt &&
+            isSyncStale(messageChannel.syncStageStartedAt)
+          ) {
+            await this.messageChannelSyncStatusService.resetSyncStageStartedAt(
               [messageChannel.id],
               workspaceId,
             );
-            break;
-          case MessageChannelSyncStage.MESSAGES_IMPORT_ONGOING:
-          case MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED:
-            this.logger.log(
-              `Sync for message channel ${messageChannel.id} and workspace ${workspaceId} is stale. Setting sync stage to MESSAGES_IMPORT_PENDING`,
-            );
-            await this.messageChannelSyncStatusService.markAsMessagesImportPending(
-              [messageChannel.id],
-              workspaceId,
-            );
-            break;
-          default:
-            break;
+
+            switch (messageChannel.syncStage) {
+              case MessageChannelSyncStage.MESSAGE_LIST_FETCH_ONGOING:
+              case MessageChannelSyncStage.MESSAGE_LIST_FETCH_SCHEDULED:
+                this.logger.log(
+                  `Sync for message channel ${messageChannel.id} and workspace ${workspaceId} is stale. Setting sync stage to MESSAGE_LIST_FETCH_PENDING`,
+                );
+                await this.messageChannelSyncStatusService.markAsMessagesListFetchPending(
+                  [messageChannel.id],
+                  workspaceId,
+                );
+                break;
+              case MessageChannelSyncStage.MESSAGES_IMPORT_ONGOING:
+              case MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED:
+                this.logger.log(
+                  `Sync for message channel ${messageChannel.id} and workspace ${workspaceId} is stale. Setting sync stage to MESSAGES_IMPORT_PENDING`,
+                );
+                await this.messageChannelSyncStatusService.markAsMessagesImportPending(
+                  [messageChannel.id],
+                  workspaceId,
+                );
+                break;
+              default:
+                break;
+            }
+          }
         }
-      }
-    }
+      },
+    );
   }
 }

packages/twenty-server/src/modules/messaging/message-import-manager/jobs/messaging-relaunch-failed-message-channel.job.ts

@@ -3,7 +3,8 @@ import { Scope } from '@nestjs/common';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import {
   MessageChannelSyncStage,
   MessageChannelSyncStatus,
@@ -21,42 +22,49 @@ export type MessagingRelaunchFailedMessageChannelJobData = {
 })
 export class MessagingRelaunchFailedMessageChannelJob {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   @Process(MessagingRelaunchFailedMessageChannelJob.name)
   async handle(data: MessagingRelaunchFailedMessageChannelJobData) {
     const { workspaceId, messageChannelId } = data;
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-        { shouldBypassPermissionChecks: true },
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageChannel = await messageChannelRepository.findOne({
-      where: {
-        id: messageChannelId,
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+            { shouldBypassPermissionChecks: true },
+          );
+
+        const messageChannel = await messageChannelRepository.findOne({
+          where: {
+            id: messageChannelId,
+          },
+          relations: {
+            connectedAccount: {
+              accountOwner: true,
+            },
+          },
+        });
+
+        if (
+          !messageChannel ||
+          messageChannel.syncStage !== MessageChannelSyncStage.FAILED ||
+          messageChannel.syncStatus !== MessageChannelSyncStatus.FAILED_UNKNOWN
+        ) {
+          return;
+        }
+
+        await messageChannelRepository.update(messageChannelId, {
+          syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
+          syncStatus: MessageChannelSyncStatus.ACTIVE,
+        });
       },
-      relations: {
-        connectedAccount: {
-          accountOwner: true,
-        },
-      },
-    });
-
-    if (
-      !messageChannel ||
-      messageChannel.syncStage !== MessageChannelSyncStage.FAILED ||
-      messageChannel.syncStatus !== MessageChannelSyncStatus.FAILED_UNKNOWN
-    ) {
-      return;
-    }
-
-    await messageChannelRepository.update(messageChannelId, {
-      syncStage: MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
-      syncStatus: MessageChannelSyncStatus.ACTIVE,
-    });
+    );
   }
 }

packages/twenty-server/src/modules/messaging/message-import-manager/services/__tests__/messaging-message-list-fetch.service.spec.ts

@@ -4,7 +4,7 @@ import { ConnectedAccountProvider } from 'twenty-shared/types';
 
 import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
 import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import { type MessageChannelWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import { type MessageFolderWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-folder.workspace-entity';
@@ -24,7 +24,7 @@ describe('MessagingMessageListFetchService', () => {
   let messagingGetMessageListService: MessagingGetMessageListService;
   let messagingAccountAuthenticationService: MessagingAccountAuthenticationService;
   let messageChannelSyncStatusService: MessageChannelSyncStatusService;
-  let twentyORMGlobalManager: TwentyORMGlobalManager;
+  let globalWorkspaceOrmManager: GlobalWorkspaceOrmManager;
   let messagingCursorService: MessagingCursorService;
 
   let mockMicrosoftMessageChannel: MessageChannelWorkspaceEntity;
@@ -196,21 +196,23 @@ describe('MessagingMessageListFetchService', () => {
           },
         },
         {
-          provide: TwentyORMGlobalManager,
+          provide: GlobalWorkspaceOrmManager,
           useValue: {
             getDataSourceForWorkspace: jest.fn().mockResolvedValue({
               manager: {},
             }),
-            getRepositoryForWorkspace: jest
+            executeInWorkspaceContext: jest
               .fn()
-              .mockImplementation((workspaceId, name) => {
-                if (name === 'messageChannelMessageAssociation') {
-                  return mockMessageChannelMessageAssociationRepository;
-                }
-                if (name === 'messageFolder') {
-                  return mockMessageFolderRepository;
-                }
-              }),
+
+              .mockImplementation((_authContext: any, fn: () => any) => fn()),
+            getRepository: jest.fn().mockImplementation((workspaceId, name) => {
+              if (name === 'messageChannelMessageAssociation') {
+                return mockMessageChannelMessageAssociationRepository;
+              }
+              if (name === 'messageFolder') {
+                return mockMessageFolderRepository;
+              }
+            }),
           },
         },
         {
@@ -275,8 +277,8 @@ describe('MessagingMessageListFetchService', () => {
       module.get<MessageChannelSyncStatusService>(
         MessageChannelSyncStatusService,
       );
-    twentyORMGlobalManager = module.get<TwentyORMGlobalManager>(
-      TwentyORMGlobalManager,
+    globalWorkspaceOrmManager = module.get<GlobalWorkspaceOrmManager>(
+      GlobalWorkspaceOrmManager,
     );
     messagingCursorService = module.get<MessagingCursorService>(
       MessagingCursorService,
@@ -320,9 +322,10 @@ describe('MessagingMessageListFetchService', () => {
       ],
     );
 
-    expect(
-      twentyORMGlobalManager.getRepositoryForWorkspace,
-    ).toHaveBeenCalledWith(workspaceId, 'messageChannelMessageAssociation');
+    expect(globalWorkspaceOrmManager.getRepository).toHaveBeenCalledWith(
+      workspaceId,
+      'messageChannelMessageAssociation',
+    );
 
     expect(messagingCursorService.updateCursor).toHaveBeenCalledWith(
       {
@@ -380,9 +383,10 @@ describe('MessagingMessageListFetchService', () => {
       ],
     );
 
-    expect(
-      twentyORMGlobalManager.getRepositoryForWorkspace,
-    ).toHaveBeenCalledWith(workspaceId, 'messageChannelMessageAssociation');
+    expect(globalWorkspaceOrmManager.getRepository).toHaveBeenCalledWith(
+      workspaceId,
+      'messageChannelMessageAssociation',
+    );
 
     expect(messagingCursorService.updateCursor).toHaveBeenCalledWith(
       {

packages/twenty-server/src/modules/messaging/message-import-manager/services/__tests__/messaging-messages-import.service.spec.ts

@@ -5,7 +5,7 @@ import { ConnectedAccountProvider } from 'twenty-shared/types';
 
 import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
 import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { BlocklistRepository } from 'src/modules/blocklist/repositories/blocklist.repository';
 import { EmailAliasManagerService } from 'src/modules/connected-account/email-alias-manager/services/email-alias-manager.service';
 import { ConnectedAccountRefreshTokensService } from 'src/modules/connected-account/refresh-tokens-manager/services/connected-account-refresh-tokens.service';
@@ -106,11 +106,14 @@ describe('MessagingMessagesImportService', () => {
         },
       },
       {
-        provide: TwentyORMGlobalManager,
+        provide: GlobalWorkspaceOrmManager,
         useValue: {
-          getRepositoryForWorkspace: jest.fn().mockResolvedValue({
+          getRepository: jest.fn().mockResolvedValue({
             update: jest.fn().mockResolvedValue(undefined),
           }),
+          executeInWorkspaceContext: jest
+            .fn()
+            .mockImplementation((_authContext: any, fn: () => any) => fn()),
         },
       },
       {

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-cursor.service.ts

@@ -1,13 +1,14 @@
 import { Injectable } from '@nestjs/common';
 
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type MessageChannelWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import { type MessageFolderWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-folder.workspace-entity';
 
 @Injectable()
 export class MessagingCursorService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   public async updateCursor(
@@ -16,50 +17,57 @@ export class MessagingCursorService {
     workspaceId: string,
     folderId?: string,
   ) {
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
-    const folderRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
-        workspaceId,
-        'messageFolder',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    if (!folderId) {
-      await messageChannelRepository.update(
-        {
-          id: messageChannel.id,
-        },
-        {
-          throttleFailureCount: 0,
-          syncStageStartedAt: null,
-          syncCursor:
-            !messageChannel.syncCursor ||
-            nextSyncCursor > messageChannel.syncCursor
-              ? nextSyncCursor
-              : messageChannel.syncCursor,
-        },
-      );
-    } else {
-      await folderRepository.update(
-        {
-          id: folderId,
-        },
-        {
-          syncCursor: nextSyncCursor,
-        },
-      );
-      await messageChannelRepository.update(
-        {
-          id: messageChannel.id,
-        },
-        {
-          throttleFailureCount: 0,
-          syncStageStartedAt: null,
-        },
-      );
-    }
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+        const folderRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
+            workspaceId,
+            'messageFolder',
+          );
+
+        if (!folderId) {
+          await messageChannelRepository.update(
+            {
+              id: messageChannel.id,
+            },
+            {
+              throttleFailureCount: 0,
+              syncStageStartedAt: null,
+              syncCursor:
+                !messageChannel.syncCursor ||
+                nextSyncCursor > messageChannel.syncCursor
+                  ? nextSyncCursor
+                  : messageChannel.syncCursor,
+            },
+          );
+        } else {
+          await folderRepository.update(
+            {
+              id: folderId,
+            },
+            {
+              syncCursor: nextSyncCursor,
+            },
+          );
+          await messageChannelRepository.update(
+            {
+              id: messageChannel.id,
+            },
+            {
+              throttleFailureCount: 0,
+              syncStageStartedAt: null,
+            },
+          );
+        }
+      },
+    );
   }
 }

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-delete-group-email-messages.service.ts

@@ -1,10 +1,11 @@
 import { Injectable, Logger } from '@nestjs/common';
 
 import chunk from 'lodash.chunk';
-import { isDefined } from 'twenty-shared/utils';
 import { MessageParticipantRole } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';
 
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
 import { MessagingMessageCleanerService } from 'src/modules/messaging/message-cleaner/services/messaging-message-cleaner.service';
 import { isGroupEmail } from 'src/modules/messaging/message-import-manager/utils/is-group-email';
@@ -24,7 +25,7 @@ export class MessagingDeleteGroupEmailMessagesService {
   );
 
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingMessageCleanerService: MessagingMessageCleanerService,
   ) {}
 
@@ -36,92 +37,99 @@ export class MessagingDeleteGroupEmailMessagesService {
       `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannelId} - Deleting messages from group email addresses`,
     );
 
-    const messageChannelMessageAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelMessageAssociationWorkspaceEntity>(
-        workspaceId,
-        'messageChannelMessageAssociation',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    let offset = 0;
-    let totalDeletedCount = 0;
-
-    while (true) {
-      const batch = await messageChannelMessageAssociationRepository
-        .createQueryBuilder('mcma')
-        .select('mcma.messageId', 'messageId')
-        .addSelect('mcma.messageExternalId', 'messageExternalId')
-        .addSelect('participant.handle', 'participantHandle')
-        .innerJoin('mcma.message', 'message')
-        .innerJoin(
-          'message.messageParticipants',
-          'participant',
-          'participant.role = :role',
-          { role: MessageParticipantRole.FROM },
-        )
-        .where('mcma.messageChannelId = :messageChannelId', {
-          messageChannelId,
-        })
-        .skip(offset)
-        .take(MESSAGE_CHANNEL_MESSAGE_ASSOCIATION_BATCH_SIZE)
-        .getRawMany<MessageBatchRawResult>();
-
-      if (batch.length === 0) {
-        break;
-      }
-
-      const groupEmailRecords = batch.filter(
-        (record) =>
-          isDefined(record.participantHandle) &&
-          isGroupEmail(record.participantHandle),
-      );
-
-      if (groupEmailRecords.length > 0) {
-        const uniqueMessageIds = new Set(
-          groupEmailRecords.map((r) => r.messageId),
-        );
-
-        const messageExternalIdsToDelete = batch
-          .filter((record) => uniqueMessageIds.has(record.messageId))
-          .map((record) => record.messageExternalId)
-          .filter(isDefined);
-
-        if (messageExternalIdsToDelete.length > 0) {
-          const messageExternalIdsChunks = chunk(
-            messageExternalIdsToDelete,
-            200,
+    return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelMessageAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+            workspaceId,
+            'messageChannelMessageAssociation',
           );
 
-          for (const messageExternalIdsChunk of messageExternalIdsChunks) {
-            await this.messagingMessageCleanerService.deleteMessagesChannelMessageAssociationsAndRelatedOrphans(
-              {
-                workspaceId,
-                messageExternalIds: messageExternalIdsChunk,
-                messageChannelId,
-              },
+        let offset = 0;
+        let totalDeletedCount = 0;
+
+        while (true) {
+          const batch = await messageChannelMessageAssociationRepository
+            .createQueryBuilder('mcma')
+            .select('mcma.messageId', 'messageId')
+            .addSelect('mcma.messageExternalId', 'messageExternalId')
+            .addSelect('participant.handle', 'participantHandle')
+            .innerJoin('mcma.message', 'message')
+            .innerJoin(
+              'message.messageParticipants',
+              'participant',
+              'participant.role = :role',
+              { role: MessageParticipantRole.FROM },
+            )
+            .where('mcma.messageChannelId = :messageChannelId', {
+              messageChannelId,
+            })
+            .skip(offset)
+            .take(MESSAGE_CHANNEL_MESSAGE_ASSOCIATION_BATCH_SIZE)
+            .getRawMany<MessageBatchRawResult>();
+
+          if (batch.length === 0) {
+            break;
+          }
+
+          const groupEmailRecords = batch.filter(
+            (record) =>
+              isDefined(record.participantHandle) &&
+              isGroupEmail(record.participantHandle),
+          );
+
+          if (groupEmailRecords.length > 0) {
+            const uniqueMessageIds = new Set(
+              groupEmailRecords.map((r) => r.messageId),
             );
 
-            totalDeletedCount += messageExternalIdsChunk.length;
+            const messageExternalIdsToDelete = batch
+              .filter((record) => uniqueMessageIds.has(record.messageId))
+              .map((record) => record.messageExternalId)
+              .filter(isDefined);
 
-            this.logger.log(
-              `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannelId} - Deleted ${messageExternalIdsChunk.length} group email messages`,
-            );
+            if (messageExternalIdsToDelete.length > 0) {
+              const messageExternalIdsChunks = chunk(
+                messageExternalIdsToDelete,
+                200,
+              );
+
+              for (const messageExternalIdsChunk of messageExternalIdsChunks) {
+                await this.messagingMessageCleanerService.deleteMessagesChannelMessageAssociationsAndRelatedOrphans(
+                  {
+                    workspaceId,
+                    messageExternalIds: messageExternalIdsChunk,
+                    messageChannelId,
+                  },
+                );
+
+                totalDeletedCount += messageExternalIdsChunk.length;
+
+                this.logger.log(
+                  `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannelId} - Deleted ${messageExternalIdsChunk.length} group email messages`,
+                );
+              }
+            }
+          }
+
+          if (batch.length < MESSAGE_CHANNEL_MESSAGE_ASSOCIATION_BATCH_SIZE) {
+            break;
+          }
+
+          if (groupEmailRecords.length === 0) {
+            offset += MESSAGE_CHANNEL_MESSAGE_ASSOCIATION_BATCH_SIZE;
           }
         }
-      }
 
-      if (batch.length < MESSAGE_CHANNEL_MESSAGE_ASSOCIATION_BATCH_SIZE) {
-        break;
-      }
+        this.logger.log(
+          `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannelId} - Completed deleting ${totalDeletedCount} group email messages`,
+        );
 
-      if (groupEmailRecords.length === 0) {
-        offset += MESSAGE_CHANNEL_MESSAGE_ASSOCIATION_BATCH_SIZE;
-      }
-    }
-
-    this.logger.log(
-      `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannelId} - Completed deleting ${totalDeletedCount} group email messages`,
+        return totalDeletedCount;
+      },
     );
-
-    return totalDeletedCount;
   }
 }

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-import-exception-handler.service.ts

@@ -5,7 +5,8 @@ import {
   type TwentyORMException,
   TwentyORMExceptionCode,
 } from 'src/engine/twenty-orm/exceptions/twenty-orm.exception';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import {
   MessageChannelSyncStatus,
@@ -27,7 +28,7 @@ export enum MessageImportSyncStep {
 @Injectable()
 export class MessageImportExceptionHandlerService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messageChannelSyncStatusService: MessageChannelSyncStatusService,
     private readonly exceptionHandlerService: ExceptionHandlerService,
   ) {}
@@ -148,18 +149,25 @@ export class MessageImportExceptionHandlerService {
       return;
     }
 
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.increment(
-      { id: messageChannel.id },
-      'throttleFailureCount',
-      1,
-      undefined,
-      ['throttleFailureCount', 'id'],
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        await messageChannelRepository.increment(
+          { id: messageChannel.id },
+          'throttleFailureCount',
+          1,
+          undefined,
+          ['throttleFailureCount', 'id'],
+        );
+      },
     );
 
     switch (syncStep) {

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-message-list-fetch.service.ts

@@ -8,7 +8,9 @@ import { In, MoreThanOrEqual } from 'typeorm';
 import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decorators/cache-storage.decorator';
 import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
 import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
 import { type MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
 import {
@@ -43,7 +45,7 @@ export class MessagingMessageListFetchService {
     @InjectCacheStorage(CacheStorageNamespace.ModuleMessaging)
     private readonly cacheStorage: CacheStorageService,
     private readonly messageChannelSyncStatusService: MessageChannelSyncStatusService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingGetMessageListService: MessagingGetMessageListService,
     private readonly messageImportErrorHandlerService: MessageImportExceptionHandlerService,
     private readonly messagingMessageCleanerService: MessagingMessageCleanerService,
@@ -59,264 +61,275 @@ export class MessagingMessageListFetchService {
     messageChannel: MessageChannelWorkspaceEntity,
     workspaceId: string,
   ) {
-    try {
-      const pendingGroupEmailActionsProcessed =
-        await this.processPendingGroupEmailActions(messageChannel, workspaceId);
+    const authContext = buildSystemAuthContext(workspaceId);
 
-      const pendingFolderActionsProcessed =
-        await this.processPendingFolderActions(messageChannel, workspaceId);
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        try {
+          const pendingGroupEmailActionsProcessed =
+            await this.processPendingGroupEmailActions(
+              messageChannel,
+              workspaceId,
+            );
 
-      await this.messageChannelSyncStatusService.markAsMessagesListFetchOngoing(
-        [messageChannel.id],
-        workspaceId,
-      );
+          const pendingFolderActionsProcessed =
+            await this.processPendingFolderActions(messageChannel, workspaceId);
 
-      this.logger.log(
-        `messageChannelId: ${messageChannel.id} Processing message list fetch`,
-      );
-
-      const messageChannelRepository =
-        await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-          workspaceId,
-          'messageChannel',
-        );
-
-      const freshMessageChannel =
-        pendingGroupEmailActionsProcessed || pendingFolderActionsProcessed
-          ? await messageChannelRepository.findOne({
-              where: {
-                id: messageChannel.id,
-              },
-              relations: ['connectedAccount', 'messageFolders'],
-            })
-          : messageChannel;
-
-      if (!isDefined(freshMessageChannel)) {
-        this.logger.error(
-          `error processing message list fetch: messageChannelId: ${messageChannel.id} Message channel not found`,
-        );
-
-        return;
-      }
-
-      const { accessToken, refreshToken } =
-        await this.messagingAccountAuthenticationService.validateAndRefreshConnectedAccountAuthentication(
-          {
-            connectedAccount: freshMessageChannel.connectedAccount,
+          await this.messageChannelSyncStatusService.markAsMessagesListFetchOngoing(
+            [messageChannel.id],
             workspaceId,
-            messageChannelId: freshMessageChannel.id,
-          },
-        );
+          );
 
-      const messageChannelWithFreshTokens = {
-        ...freshMessageChannel,
-        connectedAccount: {
-          ...freshMessageChannel.connectedAccount,
-          accessToken,
-          refreshToken,
-        },
-      };
+          this.logger.log(
+            `messageChannelId: ${messageChannel.id} Processing message list fetch`,
+          );
 
-      const datasource =
-        await this.twentyORMGlobalManager.getDataSourceForWorkspace({
-          workspaceId,
-        });
+          const messageChannelRepository =
+            await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+              workspaceId,
+              'messageChannel',
+            );
 
-      await this.syncMessageFoldersService.syncMessageFolders({
-        workspaceId,
-        messageChannel: messageChannelWithFreshTokens,
-        manager: datasource.manager,
-      });
+          const freshMessageChannel =
+            pendingGroupEmailActionsProcessed || pendingFolderActionsProcessed
+              ? await messageChannelRepository.findOne({
+                  where: {
+                    id: messageChannel.id,
+                  },
+                  relations: ['connectedAccount', 'messageFolders'],
+                })
+              : messageChannel;
 
-      const messageFolderRepository =
-        await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
-          workspaceId,
-          'messageFolder',
-        );
+          if (!isDefined(freshMessageChannel)) {
+            this.logger.error(
+              `error processing message list fetch: messageChannelId: ${messageChannel.id} Message channel not found`,
+            );
 
-      const messageFolders = await messageFolderRepository.find({
-        where: {
-          messageChannelId: freshMessageChannel.id,
-          pendingSyncAction: MessageFolderPendingSyncAction.NONE,
-        },
-      });
+            return;
+          }
 
-      const messageFoldersToSync =
-        messageChannelWithFreshTokens.messageFolderImportPolicy ===
-        MessageFolderImportPolicy.ALL_FOLDERS
-          ? messageFolders
-          : messageFolders.filter((folder) => folder.isSynced);
+          const { accessToken, refreshToken } =
+            await this.messagingAccountAuthenticationService.validateAndRefreshConnectedAccountAuthentication(
+              {
+                connectedAccount: freshMessageChannel.connectedAccount,
+                workspaceId,
+                messageChannelId: freshMessageChannel.id,
+              },
+            );
 
-      const messageLists =
-        await this.messagingGetMessageListService.getMessageLists(
-          messageChannelWithFreshTokens,
-          messageFoldersToSync,
-        );
+          const messageChannelWithFreshTokens = {
+            ...freshMessageChannel,
+            connectedAccount: {
+              ...freshMessageChannel.connectedAccount,
+              accessToken,
+              refreshToken,
+            },
+          };
 
-      await this.cacheStorage.del(
-        `messages-to-import:${workspaceId}:${freshMessageChannel.id}`,
-      );
+          const datasource =
+            await this.globalWorkspaceOrmManager.getDataSourceForWorkspace(
+              workspaceId,
+            );
 
-      const messageExternalIds = messageLists.flatMap(
-        (messageList) => messageList.messageExternalIds,
-      );
+          await this.syncMessageFoldersService.syncMessageFolders({
+            workspaceId,
+            messageChannel: messageChannelWithFreshTokens,
+            manager: datasource.manager as WorkspaceEntityManager,
+          });
 
-      const messageExternalIdsToDelete = messageLists.flatMap(
-        (messageList) => messageList.messageExternalIdsToDelete,
-      );
+          const messageFolderRepository =
+            await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
+              workspaceId,
+              'messageFolder',
+            );
 
-      const isFullSync =
-        messageLists.every(
-          (messageList) => !isNonEmptyString(messageList.previousSyncCursor),
-        ) && !isNonEmptyString(freshMessageChannel.syncCursor);
-
-      let totalMessagesToImportCount = 0;
-
-      this.logger.log(
-        `messageChannelId: ${freshMessageChannel.id} Is full sync: ${isFullSync} and toImportCount: ${messageExternalIds.length}, toDeleteCount: ${messageExternalIdsToDelete.length}, cursors: ${messageLists.map(
-          (messageList) => {
-            messageList.nextSyncCursor;
-          },
-        )}`,
-      );
-
-      const messageChannelMessageAssociationRepository =
-        await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelMessageAssociationWorkspaceEntity>(
-          workspaceId,
-          'messageChannelMessageAssociation',
-        );
-
-      const messageExternalIdsChunks = chunk(messageExternalIds, 200);
-
-      for (const [
-        index,
-        messageExternalIdsChunk,
-      ] of messageExternalIdsChunks.entries()) {
-        const existingMessageChannelMessageAssociations =
-          await messageChannelMessageAssociationRepository.find({
+          const messageFolders = await messageFolderRepository.find({
             where: {
               messageChannelId: freshMessageChannel.id,
-              messageExternalId: In(messageExternalIdsChunk),
+              pendingSyncAction: MessageFolderPendingSyncAction.NONE,
             },
           });
 
-        const existingMessageChannelMessageAssociationsExternalIds =
-          existingMessageChannelMessageAssociations.map(
-            (messageChannelMessageAssociation) =>
-              messageChannelMessageAssociation.messageExternalId,
+          const messageFoldersToSync =
+            messageChannelWithFreshTokens.messageFolderImportPolicy ===
+            MessageFolderImportPolicy.ALL_FOLDERS
+              ? messageFolders
+              : messageFolders.filter((folder) => folder.isSynced);
+
+          const messageLists =
+            await this.messagingGetMessageListService.getMessageLists(
+              messageChannelWithFreshTokens,
+              messageFoldersToSync,
+            );
+
+          await this.cacheStorage.del(
+            `messages-to-import:${workspaceId}:${freshMessageChannel.id}`,
           );
 
-        const messageExternalIdsToImport = messageExternalIdsChunk.filter(
-          (messageExternalId) =>
-            !existingMessageChannelMessageAssociationsExternalIds.includes(
-              messageExternalId,
-            ),
-        );
+          const messageExternalIds = messageLists.flatMap(
+            (messageList) => messageList.messageExternalIds,
+          );
+
+          const messageExternalIdsToDelete = messageLists.flatMap(
+            (messageList) => messageList.messageExternalIdsToDelete,
+          );
+
+          const isFullSync =
+            messageLists.every(
+              (messageList) =>
+                !isNonEmptyString(messageList.previousSyncCursor),
+            ) && !isNonEmptyString(freshMessageChannel.syncCursor);
+
+          let totalMessagesToImportCount = 0;
 
-        if (messageExternalIdsToImport.length) {
           this.logger.log(
-            `messageChannelId: ${freshMessageChannel.id} Adding ${messageExternalIdsToImport.length} message external ids to import in batch ${index + 1}`,
+            `messageChannelId: ${freshMessageChannel.id} Is full sync: ${isFullSync} and toImportCount: ${messageExternalIds.length}, toDeleteCount: ${messageExternalIdsToDelete.length}, cursors: ${messageLists.map(
+              (messageList) => {
+                messageList.nextSyncCursor;
+              },
+            )}`,
           );
 
-          totalMessagesToImportCount += messageExternalIdsToImport.length;
-
-          await this.cacheStorage.setAdd(
-            `messages-to-import:${workspaceId}:${messageChannelWithFreshTokens.id}`,
-            messageExternalIdsToImport,
-            ONE_WEEK_IN_MILLISECONDS,
-          );
-        }
-      }
-
-      for (const messageList of messageLists) {
-        const { nextSyncCursor, folderId } = messageList;
-
-        await this.messagingCursorService.updateCursor(
-          messageChannelWithFreshTokens,
-          nextSyncCursor,
-          workspaceId,
-          folderId,
-        );
-      }
-
-      const fullSyncMessageChannelMessageAssociationsToDelete = isFullSync
-        ? await this.computeFullSyncMessageChannelMessageAssociationsToDelete(
-            freshMessageChannel,
-            messageExternalIds,
-            workspaceId,
-          )
-        : [];
-
-      const allMessageExternalIdsToDelete = [
-        ...messageExternalIdsToDelete,
-        ...fullSyncMessageChannelMessageAssociationsToDelete.map(
-          (messageChannelMessageAssociation) =>
-            messageChannelMessageAssociation.messageExternalId,
-        ),
-      ];
-
-      if (allMessageExternalIdsToDelete.length) {
-        this.logger.log(
-          `messageChannelId: ${freshMessageChannel.id} Deleting ${allMessageExternalIdsToDelete.length} message channel message associations`,
-        );
-
-        const toDeleteChunks = chunk(allMessageExternalIdsToDelete, 200);
-
-        for (const [index, toDeleteChunk] of toDeleteChunks.entries()) {
-          this.logger.log(
-            `messageChannelId: ${freshMessageChannel.id} Deleting ${toDeleteChunk.length} message channel message associations in batch ${index + 1}`,
-          );
-
-          await this.messagingMessageCleanerService.deleteMessagesChannelMessageAssociationsAndRelatedOrphans(
-            {
+          const messageChannelMessageAssociationRepository =
+            await this.globalWorkspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
               workspaceId,
-              messageExternalIds: toDeleteChunk.filter((messageExternalId) =>
-                isNonEmptyString(messageExternalId),
-              ),
-              messageChannelId: messageChannelWithFreshTokens.id,
+              'messageChannelMessageAssociation',
+            );
+
+          const messageExternalIdsChunks = chunk(messageExternalIds, 200);
+
+          for (const [
+            index,
+            messageExternalIdsChunk,
+          ] of messageExternalIdsChunks.entries()) {
+            const existingMessageChannelMessageAssociations =
+              await messageChannelMessageAssociationRepository.find({
+                where: {
+                  messageChannelId: freshMessageChannel.id,
+                  messageExternalId: In(messageExternalIdsChunk),
+                },
+              });
+
+            const existingMessageChannelMessageAssociationsExternalIds =
+              existingMessageChannelMessageAssociations.map(
+                (messageChannelMessageAssociation) =>
+                  messageChannelMessageAssociation.messageExternalId,
+              );
+
+            const messageExternalIdsToImport = messageExternalIdsChunk.filter(
+              (messageExternalId) =>
+                !existingMessageChannelMessageAssociationsExternalIds.includes(
+                  messageExternalId,
+                ),
+            );
+
+            if (messageExternalIdsToImport.length) {
+              this.logger.log(
+                `messageChannelId: ${freshMessageChannel.id} Adding ${messageExternalIdsToImport.length} message external ids to import in batch ${index + 1}`,
+              );
+
+              totalMessagesToImportCount += messageExternalIdsToImport.length;
+
+              await this.cacheStorage.setAdd(
+                `messages-to-import:${workspaceId}:${messageChannelWithFreshTokens.id}`,
+                messageExternalIdsToImport,
+                ONE_WEEK_IN_MILLISECONDS,
+              );
+            }
+          }
+
+          for (const messageList of messageLists) {
+            const { nextSyncCursor, folderId } = messageList;
+
+            await this.messagingCursorService.updateCursor(
+              messageChannelWithFreshTokens,
+              nextSyncCursor,
+              workspaceId,
+              folderId,
+            );
+          }
+
+          const fullSyncMessageChannelMessageAssociationsToDelete = isFullSync
+            ? await this.computeFullSyncMessageChannelMessageAssociationsToDelete(
+                freshMessageChannel,
+                messageExternalIds,
+                workspaceId,
+              )
+            : [];
+
+          const allMessageExternalIdsToDelete = [
+            ...messageExternalIdsToDelete,
+            ...fullSyncMessageChannelMessageAssociationsToDelete.map(
+              (messageChannelMessageAssociation) =>
+                messageChannelMessageAssociation.messageExternalId,
+            ),
+          ];
+
+          if (allMessageExternalIdsToDelete.length) {
+            this.logger.log(
+              `messageChannelId: ${freshMessageChannel.id} Deleting ${allMessageExternalIdsToDelete.length} message channel message associations`,
+            );
+
+            const toDeleteChunks = chunk(allMessageExternalIdsToDelete, 200);
+
+            for (const [index, toDeleteChunk] of toDeleteChunks.entries()) {
+              this.logger.log(
+                `messageChannelId: ${freshMessageChannel.id} Deleting ${toDeleteChunk.length} message channel message associations in batch ${index + 1}`,
+              );
+
+              await this.messagingMessageCleanerService.deleteMessagesChannelMessageAssociationsAndRelatedOrphans(
+                {
+                  workspaceId,
+                  messageExternalIds: toDeleteChunk.filter(
+                    (messageExternalId) => isNonEmptyString(messageExternalId),
+                  ),
+                  messageChannelId: messageChannelWithFreshTokens.id,
+                },
+              );
+            }
+          }
+
+          this.logger.log(
+            `messageChannelId: ${freshMessageChannel.id} Total messages to import count: ${totalMessagesToImportCount}`,
+          );
+
+          if (totalMessagesToImportCount === 0) {
+            await this.messageChannelSyncStatusService.markAsCompletedAndMarkAsMessagesListFetchPending(
+              [messageChannelWithFreshTokens.id],
+              workspaceId,
+            );
+
+            return;
+          }
+
+          this.logger.log(
+            `messageChannelId: ${freshMessageChannel.id} Scheduling direct messages import`,
+          );
+
+          await this.messageChannelSyncStatusService.markAsMessagesImportScheduled(
+            [messageChannelWithFreshTokens.id],
+            workspaceId,
+          );
+
+          await this.messagingMessagesImportService.processMessageBatchImport(
+            {
+              ...messageChannelWithFreshTokens,
+              syncStage: MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED,
             },
+            messageChannelWithFreshTokens.connectedAccount,
+            workspaceId,
+          );
+        } catch (error) {
+          await this.messageImportErrorHandlerService.handleDriverException(
+            error,
+            MessageImportSyncStep.MESSAGE_LIST_FETCH,
+            messageChannel,
+            workspaceId,
           );
         }
-      }
-
-      this.logger.log(
-        `messageChannelId: ${freshMessageChannel.id} Total messages to import count: ${totalMessagesToImportCount}`,
-      );
-
-      if (totalMessagesToImportCount === 0) {
-        await this.messageChannelSyncStatusService.markAsCompletedAndMarkAsMessagesListFetchPending(
-          [messageChannelWithFreshTokens.id],
-          workspaceId,
-        );
-
-        return;
-      }
-
-      this.logger.log(
-        `messageChannelId: ${freshMessageChannel.id} Scheduling direct messages import`,
-      );
-
-      await this.messageChannelSyncStatusService.markAsMessagesImportScheduled(
-        [messageChannelWithFreshTokens.id],
-        workspaceId,
-      );
-
-      await this.messagingMessagesImportService.processMessageBatchImport(
-        {
-          ...messageChannelWithFreshTokens,
-          syncStage: MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED,
-        },
-        messageChannelWithFreshTokens.connectedAccount,
-        workspaceId,
-      );
-    } catch (error) {
-      await this.messageImportErrorHandlerService.handleDriverException(
-        error,
-        MessageImportSyncStep.MESSAGE_LIST_FETCH,
-        messageChannel,
-        workspaceId,
-      );
-    }
+      },
+    );
   }
 
   private async processPendingGroupEmailActions(
@@ -350,7 +363,7 @@ export class MessagingMessageListFetchService {
     workspaceId: string,
   ): Promise<boolean> {
     const messageFolderRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
+      await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
         workspaceId,
         'messageFolder',
       );
@@ -385,7 +398,7 @@ export class MessagingMessageListFetchService {
     workspaceId: string,
   ) {
     const messageChannelMessageAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelMessageAssociationWorkspaceEntity>(
+      await this.globalWorkspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
         workspaceId,
         'messageChannelMessageAssociation',
       );

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-message.service.ts

@@ -5,7 +5,8 @@ import { In } from 'typeorm';
 import { v4 } from 'uuid';
 
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
 import { type MessageThreadWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-thread.workspace-entity';
 import { type MessageWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message.workspace-entity';
@@ -39,7 +40,7 @@ export class MessagingMessageService {
   private readonly logger = new Logger(MessagingMessageService.name);
 
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   public async saveMessagesWithinTransaction(
@@ -51,183 +52,200 @@ export class MessagingMessageService {
     createdMessages: Partial<MessageWorkspaceEntity>[];
     messageExternalIdsAndIdsMap: Map<string, string>;
   }> {
-    const messageChannelMessageAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelMessageAssociationWorkspaceEntity>(
-        workspaceId,
-        'messageChannelMessageAssociation',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const messageRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageWorkspaceEntity>(
-        workspaceId,
-        'message',
-      );
+    return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelMessageAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+            workspaceId,
+            'messageChannelMessageAssociation',
+          );
 
-    const messageThreadRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageThreadWorkspaceEntity>(
-        workspaceId,
-        'messageThread',
-      );
+        const messageRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageWorkspaceEntity>(
+            workspaceId,
+            'message',
+          );
 
-    const messageAccumulatorMap = new Map<string, MessageAccumulator>();
+        const messageThreadRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageThreadWorkspaceEntity>(
+            workspaceId,
+            'messageThread',
+          );
 
-    const existingMessagesInDB = await messageRepository.find({
-      where: {
-        headerMessageId: In(messages.map((message) => message.headerMessageId)),
-      },
-    });
+        const messageAccumulatorMap = new Map<string, MessageAccumulator>();
 
-    const messageChannelMessageAssociationsReferencingMessageThread =
-      await messageChannelMessageAssociationRepository.find(
-        {
+        const existingMessagesInDB = await messageRepository.find({
           where: {
-            messageThreadExternalId: In(
-              messages.map((message) => message.messageThreadExternalId),
+            headerMessageId: In(
+              messages.map((message) => message.headerMessageId),
             ),
-            messageChannelId,
           },
-          relations: ['message'],
-        },
-        transactionManager,
-      );
+        });
 
-    const existingMessageChannelMessageAssociations =
-      await messageChannelMessageAssociationRepository.find({
-        where: {
-          messageId: In(existingMessagesInDB.map((message) => message.id)),
-          messageChannelId,
-        },
-      });
+        const messageChannelMessageAssociationsReferencingMessageThread =
+          await messageChannelMessageAssociationRepository.find(
+            {
+              where: {
+                messageThreadExternalId: In(
+                  messages.map((message) => message.messageThreadExternalId),
+                ),
+                messageChannelId,
+              },
+              relations: ['message'],
+            },
+            transactionManager,
+          );
 
-    await this.enrichMessageAccumulatorWithExistingMessages(
-      messages,
-      messageAccumulatorMap,
-      existingMessagesInDB,
-    );
+        const existingMessageChannelMessageAssociations =
+          await messageChannelMessageAssociationRepository.find({
+            where: {
+              messageId: In(existingMessagesInDB.map((message) => message.id)),
+              messageChannelId,
+            },
+          });
 
-    await this.enrichMessageAccumulatorWithExistingMessageThreadIds(
-      messages,
-      messageAccumulatorMap,
-      messageChannelMessageAssociationsReferencingMessageThread,
-      workspaceId,
-    );
-
-    await this.enrichMessageAccumulatorWithExistingMessageChannelMessageAssociations(
-      messages,
-      messageAccumulatorMap,
-      existingMessageChannelMessageAssociations,
-    );
-
-    await this.enrichMessageAccumulatorWithMessageThreadToCreate(
-      messages,
-      messageAccumulatorMap,
-    );
-
-    for (const message of messages) {
-      const messageAccumulator = messageAccumulatorMap.get(message.externalId);
-
-      if (!isDefined(messageAccumulator)) {
-        throw new Error(
-          `Message accumulator should reference the message, this should never happen`,
+        await this.enrichMessageAccumulatorWithExistingMessages(
+          messages,
+          messageAccumulatorMap,
+          existingMessagesInDB,
         );
-      }
 
-      const messageThreadId =
-        messageAccumulator.threadToCreate?.id ??
-        messageAccumulator.existingThreadInDB?.id;
-
-      if (!isDefined(messageThreadId)) {
-        throw new Error(
-          `Message thread id should be defined, either in the threadToCreate or existingThreadInDB`,
+        await this.enrichMessageAccumulatorWithExistingMessageThreadIds(
+          messages,
+          messageAccumulatorMap,
+          messageChannelMessageAssociationsReferencingMessageThread,
+          workspaceId,
         );
-      }
 
-      let newOrExistingMessageId: string;
+        await this.enrichMessageAccumulatorWithExistingMessageChannelMessageAssociations(
+          messages,
+          messageAccumulatorMap,
+          existingMessageChannelMessageAssociations,
+        );
 
-      if (!isDefined(messageAccumulator.existingMessageInDB)) {
-        newOrExistingMessageId = v4();
+        await this.enrichMessageAccumulatorWithMessageThreadToCreate(
+          messages,
+          messageAccumulatorMap,
+        );
 
-        const messageToCreate = {
-          id: newOrExistingMessageId,
-          headerMessageId: message.headerMessageId,
-          subject: message.subject,
-          receivedAt: message.receivedAt,
-          text: message.text,
-          messageThreadId,
-        };
+        for (const message of messages) {
+          const messageAccumulator = messageAccumulatorMap.get(
+            message.externalId,
+          );
 
-        messageAccumulator.messageToCreate = messageToCreate;
-      } else {
-        newOrExistingMessageId = messageAccumulator.existingMessageInDB.id;
-      }
+          if (!isDefined(messageAccumulator)) {
+            throw new Error(
+              `Message accumulator should reference the message, this should never happen`,
+            );
+          }
 
-      if (
-        !isDefined(
-          messageAccumulator.existingMessageChannelMessageAssociationInDB,
+          const messageThreadId =
+            messageAccumulator.threadToCreate?.id ??
+            messageAccumulator.existingThreadInDB?.id;
+
+          if (!isDefined(messageThreadId)) {
+            throw new Error(
+              `Message thread id should be defined, either in the threadToCreate or existingThreadInDB`,
+            );
+          }
+
+          let newOrExistingMessageId: string;
+
+          if (!isDefined(messageAccumulator.existingMessageInDB)) {
+            newOrExistingMessageId = v4();
+
+            const messageToCreate = {
+              id: newOrExistingMessageId,
+              headerMessageId: message.headerMessageId,
+              subject: message.subject,
+              receivedAt: message.receivedAt,
+              text: message.text,
+              messageThreadId,
+            };
+
+            messageAccumulator.messageToCreate = messageToCreate;
+          } else {
+            newOrExistingMessageId = messageAccumulator.existingMessageInDB.id;
+          }
+
+          if (
+            !isDefined(
+              messageAccumulator.existingMessageChannelMessageAssociationInDB,
+            )
+          ) {
+            messageAccumulator.messageChannelMessageAssociationToCreate = {
+              messageChannelId,
+              messageId: newOrExistingMessageId,
+              messageExternalId: message.externalId,
+              messageThreadExternalId: message.messageThreadExternalId,
+              direction: message.direction,
+            };
+
+            messageAccumulatorMap.set(message.externalId, messageAccumulator);
+          }
+        }
+
+        const messageThreadsToCreate = Array.from(
+          messageAccumulatorMap.values(),
         )
-      ) {
-        messageAccumulator.messageChannelMessageAssociationToCreate = {
-          messageChannelId,
-          messageId: newOrExistingMessageId,
-          messageExternalId: message.externalId,
-          messageThreadExternalId: message.messageThreadExternalId,
-          direction: message.direction,
+          .map((accumulator) => accumulator.threadToCreate)
+          .filter(isDefined);
+
+        await messageThreadRepository.insert(
+          messageThreadsToCreate,
+          transactionManager,
+        );
+
+        const messagesToCreate = Array.from(messageAccumulatorMap.values())
+          .map((accumulator) => accumulator.messageToCreate)
+          .filter(isDefined);
+
+        await messageRepository.insert(messagesToCreate, transactionManager);
+
+        const messageChannelMessageAssociationsToCreate = Array.from(
+          messageAccumulatorMap.values(),
+        )
+          .map(
+            (accumulator) =>
+              accumulator.messageChannelMessageAssociationToCreate,
+          )
+          .filter(isDefined);
+
+        await messageChannelMessageAssociationRepository.insert(
+          messageChannelMessageAssociationsToCreate,
+          transactionManager,
+        );
+
+        const messageExternalIdsAndIdsMap = new Map<string, string>();
+
+        for (const [
+          externalId,
+          accumulator,
+        ] of messageAccumulatorMap.entries()) {
+          if (isDefined(accumulator.messageToCreate)) {
+            messageExternalIdsAndIdsMap.set(
+              externalId,
+              accumulator.messageToCreate.id,
+            );
+          }
+
+          if (isDefined(accumulator.existingMessageInDB)) {
+            messageExternalIdsAndIdsMap.set(
+              externalId,
+              accumulator.existingMessageInDB.id,
+            );
+          }
+        }
+
+        return {
+          createdMessages: messagesToCreate,
+          messageExternalIdsAndIdsMap,
         };
-
-        messageAccumulatorMap.set(message.externalId, messageAccumulator);
-      }
-    }
-
-    const messageThreadsToCreate = Array.from(messageAccumulatorMap.values())
-      .map((accumulator) => accumulator.threadToCreate)
-      .filter(isDefined);
-
-    await messageThreadRepository.insert(
-      messageThreadsToCreate,
-      transactionManager,
+      },
     );
-
-    const messagesToCreate = Array.from(messageAccumulatorMap.values())
-      .map((accumulator) => accumulator.messageToCreate)
-      .filter(isDefined);
-
-    await messageRepository.insert(messagesToCreate, transactionManager);
-
-    const messageChannelMessageAssociationsToCreate = Array.from(
-      messageAccumulatorMap.values(),
-    )
-      .map(
-        (accumulator) => accumulator.messageChannelMessageAssociationToCreate,
-      )
-      .filter(isDefined);
-
-    await messageChannelMessageAssociationRepository.insert(
-      messageChannelMessageAssociationsToCreate,
-      transactionManager,
-    );
-
-    const messageExternalIdsAndIdsMap = new Map<string, string>();
-
-    for (const [externalId, accumulator] of messageAccumulatorMap.entries()) {
-      if (isDefined(accumulator.messageToCreate)) {
-        messageExternalIdsAndIdsMap.set(
-          externalId,
-          accumulator.messageToCreate.id,
-        );
-      }
-
-      if (isDefined(accumulator.existingMessageInDB)) {
-        messageExternalIdsAndIdsMap.set(
-          externalId,
-          accumulator.existingMessageInDB.id,
-        );
-      }
-    }
-
-    return {
-      createdMessages: messagesToCreate,
-      messageExternalIdsAndIdsMap,
-    };
   }
 
   private async enrichMessageAccumulatorWithExistingMessages(
@@ -307,11 +325,6 @@ export class MessagingMessageService {
         existingThreadIdInDBIfMessageIsExistingInDB !==
           existingThreadIdInDBIfMessageIsReferencedInMessageChannelMessageAssociation
       ) {
-        // TODO: this can be handled better
-        // If we find a messageThreadId different on the existingMessage (found by messageHeaderId which is cross channel)
-        // And on the the one associatied to the messageThreadExternalId (found by which is channel specific)
-        // this means that we have to channels that have imported messages separately and that this message is the first connection between the two channels
-        // we should merge messageThreads
         this.logger.warn(
           `
           WorkspaceId: ${workspaceId} /

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-messages-import.service.ts

@@ -6,7 +6,8 @@ import { InjectCacheStorage } from 'src/engine/core-modules/cache-storage/decora
 import { CacheStorageService } from 'src/engine/core-modules/cache-storage/services/cache-storage.service';
 import { CacheStorageNamespace } from 'src/engine/core-modules/cache-storage/types/cache-storage-namespace.enum';
 import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { BlocklistRepository } from 'src/modules/blocklist/repositories/blocklist.repository';
 import { BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
 import { EmailAliasManagerService } from 'src/modules/connected-account/email-alias-manager/services/email-alias-manager.service';
@@ -30,6 +31,7 @@ import {
 import { MessagingSaveMessagesAndEnqueueContactCreationService } from 'src/modules/messaging/message-import-manager/services/messaging-save-messages-and-enqueue-contact-creation.service';
 import { filterEmails } from 'src/modules/messaging/message-import-manager/utils/filter-emails.util';
 import { MessagingMonitoringService } from 'src/modules/messaging/monitoring/services/messaging-monitoring.service';
+
 @Injectable()
 export class MessagingMessagesImportService {
   private readonly logger = new Logger(MessagingMessagesImportService.name);
@@ -43,7 +45,7 @@ export class MessagingMessagesImportService {
     @InjectObjectMetadataRepository(BlocklistWorkspaceEntity)
     private readonly blocklistRepository: BlocklistRepository,
     private readonly emailAliasManagerService: EmailAliasManagerService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingGetMessagesService: MessagingGetMessagesService,
     private readonly messageImportErrorHandlerService: MessageImportExceptionHandlerService,
     private readonly messagingAccountAuthenticationService: MessagingAccountAuthenticationService,
@@ -56,162 +58,171 @@ export class MessagingMessagesImportService {
   ) {
     let messageIdsToFetch: string[] = [];
 
-    try {
-      if (
-        messageChannel.syncStage !==
-        MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED
-      ) {
-        return;
-      }
+    const authContext = buildSystemAuthContext(workspaceId);
 
-      await this.messagingMonitoringService.track({
-        eventName: 'messages_import.started',
-        workspaceId,
-        connectedAccountId: messageChannel.connectedAccountId,
-        messageChannelId: messageChannel.id,
-      });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        try {
+          if (
+            messageChannel.syncStage !==
+            MessageChannelSyncStage.MESSAGES_IMPORT_SCHEDULED
+          ) {
+            return;
+          }
 
-      await this.messageChannelSyncStatusService.markAsMessagesImportOngoing(
-        [messageChannel.id],
-        workspaceId,
-      );
-
-      const { accessToken, refreshToken } =
-        await this.messagingAccountAuthenticationService.validateAndRefreshConnectedAccountAuthentication(
-          {
-            connectedAccount,
+          await this.messagingMonitoringService.track({
+            eventName: 'messages_import.started',
             workspaceId,
+            connectedAccountId: messageChannel.connectedAccountId,
             messageChannelId: messageChannel.id,
-          },
-        );
+          });
 
-      const connectedAccountWithFreshTokens = {
-        ...connectedAccount,
-        accessToken,
-        refreshToken,
-      };
+          await this.messageChannelSyncStatusService.markAsMessagesImportOngoing(
+            [messageChannel.id],
+            workspaceId,
+          );
 
-      await this.emailAliasManagerService.refreshHandleAliases(
-        connectedAccountWithFreshTokens,
-        workspaceId,
-      );
+          const { accessToken, refreshToken } =
+            await this.messagingAccountAuthenticationService.validateAndRefreshConnectedAccountAuthentication(
+              {
+                connectedAccount,
+                workspaceId,
+                messageChannelId: messageChannel.id,
+              },
+            );
 
-      messageIdsToFetch = await this.cacheStorage.setPop(
-        `messages-to-import:${workspaceId}:${messageChannel.id}`,
-        MESSAGING_GMAIL_USERS_MESSAGES_GET_BATCH_SIZE,
-      );
+          const connectedAccountWithFreshTokens = {
+            ...connectedAccount,
+            accessToken,
+            refreshToken,
+          };
 
-      if (!messageIdsToFetch?.length) {
-        await this.messageChannelSyncStatusService.markAsCompletedAndMarkAsMessagesListFetchPending(
-          [messageChannel.id],
-          workspaceId,
-        );
+          await this.emailAliasManagerService.refreshHandleAliases(
+            connectedAccountWithFreshTokens,
+            workspaceId,
+          );
 
-        return await this.trackMessageImportCompleted(
-          messageChannel,
-          workspaceId,
-        );
-      }
+          messageIdsToFetch = await this.cacheStorage.setPop(
+            `messages-to-import:${workspaceId}:${messageChannel.id}`,
+            MESSAGING_GMAIL_USERS_MESSAGES_GET_BATCH_SIZE,
+          );
 
-      const allMessages = await this.messagingGetMessagesService.getMessages(
-        messageIdsToFetch,
-        connectedAccountWithFreshTokens,
-      );
+          if (!messageIdsToFetch?.length) {
+            await this.messageChannelSyncStatusService.markAsCompletedAndMarkAsMessagesListFetchPending(
+              [messageChannel.id],
+              workspaceId,
+            );
 
-      const blocklist = await this.blocklistRepository.getByWorkspaceMemberId(
-        connectedAccountWithFreshTokens.accountOwnerId,
-        workspaceId,
-      );
+            return await this.trackMessageImportCompleted(
+              messageChannel,
+              workspaceId,
+            );
+          }
 
-      if (!isDefined(messageChannel.handle)) {
-        throw new MessageImportDriverException(
-          'Message channel handle is required',
-          MessageImportDriverExceptionCode.CHANNEL_MISCONFIGURED,
-        );
-      }
+          const allMessages =
+            await this.messagingGetMessagesService.getMessages(
+              messageIdsToFetch,
+              connectedAccountWithFreshTokens,
+            );
 
-      if (!isDefined(connectedAccountWithFreshTokens.handleAliases)) {
-        throw new MessageImportDriverException(
-          'Message channel handle is required',
-          MessageImportDriverExceptionCode.CHANNEL_MISCONFIGURED,
-        );
-      }
+          const blocklist =
+            await this.blocklistRepository.getByWorkspaceMemberId(
+              connectedAccountWithFreshTokens.accountOwnerId,
+              workspaceId,
+            );
 
-      const messagesToSave = filterEmails(
-        messageChannel.handle,
-        [...connectedAccountWithFreshTokens.handleAliases.split(',')],
-        allMessages,
-        blocklist
-          .map((blocklistItem) => blocklistItem.handle)
-          .filter(isDefined),
-        messageChannel.excludeGroupEmails,
-      );
+          if (!isDefined(messageChannel.handle)) {
+            throw new MessageImportDriverException(
+              'Message channel handle is required',
+              MessageImportDriverExceptionCode.CHANNEL_MISCONFIGURED,
+            );
+          }
 
-      if (messagesToSave.length > 0) {
-        await this.saveMessagesAndEnqueueContactCreationService.saveMessagesAndEnqueueContactCreation(
-          messagesToSave,
-          messageChannel,
-          connectedAccountWithFreshTokens,
-          workspaceId,
-        );
-      }
+          if (!isDefined(connectedAccountWithFreshTokens.handleAliases)) {
+            throw new MessageImportDriverException(
+              'Message channel handle is required',
+              MessageImportDriverExceptionCode.CHANNEL_MISCONFIGURED,
+            );
+          }
 
-      if (
-        messageIdsToFetch.length < MESSAGING_GMAIL_USERS_MESSAGES_GET_BATCH_SIZE
-      ) {
-        await this.messageChannelSyncStatusService.markAsCompletedAndMarkAsMessagesListFetchPending(
-          [messageChannel.id],
-          workspaceId,
-        );
-      } else {
-        await this.messageChannelSyncStatusService.markAsMessagesImportPending(
-          [messageChannel.id],
-          workspaceId,
-        );
-      }
+          const messagesToSave = filterEmails(
+            messageChannel.handle,
+            [...connectedAccountWithFreshTokens.handleAliases.split(',')],
+            allMessages,
+            blocklist
+              .map((blocklistItem) => blocklistItem.handle)
+              .filter(isDefined),
+            messageChannel.excludeGroupEmails,
+          );
 
-      const messageChannelRepository =
-        await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-          workspaceId,
-          'messageChannel',
-        );
+          if (messagesToSave.length > 0) {
+            await this.saveMessagesAndEnqueueContactCreationService.saveMessagesAndEnqueueContactCreation(
+              messagesToSave,
+              messageChannel,
+              connectedAccountWithFreshTokens,
+              workspaceId,
+            );
+          }
 
-      await messageChannelRepository.update(
-        {
-          id: messageChannel.id,
-        },
-        {
-          throttleFailureCount: 0,
-          syncStageStartedAt: null,
-        },
-      );
+          if (
+            messageIdsToFetch.length <
+            MESSAGING_GMAIL_USERS_MESSAGES_GET_BATCH_SIZE
+          ) {
+            await this.messageChannelSyncStatusService.markAsCompletedAndMarkAsMessagesListFetchPending(
+              [messageChannel.id],
+              workspaceId,
+            );
+          } else {
+            await this.messageChannelSyncStatusService.markAsMessagesImportPending(
+              [messageChannel.id],
+              workspaceId,
+            );
+          }
 
-      return await this.trackMessageImportCompleted(
-        messageChannel,
-        workspaceId,
-      );
-    } catch (error) {
-      // TODO: remove this log once we catch better the error codes
-      this.logger.error(
-        `Error (${error.code}) importing messages for workspace ${workspaceId.slice(0, 8)} and account ${connectedAccount.id.slice(0, 8)}: ${error.message} - ${error.body}`,
-      );
-      await this.cacheStorage.setAdd(
-        `messages-to-import:${workspaceId}:${messageChannel.id}`,
-        messageIdsToFetch,
-      );
+          const messageChannelRepository =
+            await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+              workspaceId,
+              'messageChannel',
+            );
 
-      await this.messageImportErrorHandlerService.handleDriverException(
-        error,
-        MessageImportSyncStep.MESSAGES_IMPORT_ONGOING,
-        messageChannel,
-        workspaceId,
-      );
+          await messageChannelRepository.update(
+            {
+              id: messageChannel.id,
+            },
+            {
+              throttleFailureCount: 0,
+              syncStageStartedAt: null,
+            },
+          );
 
-      return await this.trackMessageImportCompleted(
-        messageChannel,
-        workspaceId,
-      );
-    }
+          return await this.trackMessageImportCompleted(
+            messageChannel,
+            workspaceId,
+          );
+        } catch (error) {
+          this.logger.error(
+            `Error (${error.code}) importing messages for workspace ${workspaceId.slice(0, 8)} and account ${connectedAccount.id.slice(0, 8)}: ${error.message} - ${error.body}`,
+          );
+          await this.cacheStorage.setAdd(
+            `messages-to-import:${workspaceId}:${messageChannel.id}`,
+            messageIdsToFetch,
+          );
+
+          await this.messageImportErrorHandlerService.handleDriverException(
+            error,
+            MessageImportSyncStep.MESSAGES_IMPORT_ONGOING,
+            messageChannel,
+            workspaceId,
+          );
+
+          return await this.trackMessageImportCompleted(
+            messageChannel,
+            workspaceId,
+          );
+        }
+      },
+    );
   }
 
   private async trackMessageImportCompleted(

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-process-folder-actions.service.ts

@@ -4,7 +4,8 @@ import { isDefined } from 'twenty-shared/utils';
 import { In } from 'typeorm';
 
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type MessageChannelWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import {
   MessageFolderPendingSyncAction,
@@ -19,7 +20,7 @@ export class MessagingProcessFolderActionsService {
   );
 
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingDeleteFolderMessagesService: MessagingDeleteFolderMessagesService,
   ) {}
 
@@ -86,41 +87,48 @@ export class MessagingProcessFolderActionsService {
     }
 
     if (processedFolderIds.length > 0 || folderIdsToDelete.length > 0) {
-      const workspaceDataSource =
-        await this.twentyORMGlobalManager.getDataSourceForWorkspace({
-          workspaceId,
-        });
+      const authContext = buildSystemAuthContext(workspaceId);
 
-      await workspaceDataSource?.transaction(
-        async (transactionManager: WorkspaceEntityManager) => {
-          const messageFolderRepository =
-            await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
+      await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+        authContext,
+        async () => {
+          const workspaceDataSource =
+            await this.globalWorkspaceOrmManager.getDataSourceForWorkspace(
               workspaceId,
-              'messageFolder',
             );
 
-          if (processedFolderIds.length > 0) {
-            await messageFolderRepository.update(
-              { id: In(processedFolderIds) },
-              { pendingSyncAction: MessageFolderPendingSyncAction.NONE },
-              transactionManager,
-            );
+          await workspaceDataSource?.transaction(
+            async (transactionManager: WorkspaceEntityManager) => {
+              const messageFolderRepository =
+                await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
+                  workspaceId,
+                  'messageFolder',
+                );
 
-            this.logger.log(
-              `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Reset pendingSyncAction to NONE for ${processedFolderIds.length} folders`,
-            );
-          }
+              if (processedFolderIds.length > 0) {
+                await messageFolderRepository.update(
+                  { id: In(processedFolderIds) },
+                  { pendingSyncAction: MessageFolderPendingSyncAction.NONE },
+                  transactionManager,
+                );
 
-          if (folderIdsToDelete.length > 0) {
-            await messageFolderRepository.delete(
-              { id: In(folderIdsToDelete) },
-              transactionManager,
-            );
+                this.logger.log(
+                  `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Reset pendingSyncAction to NONE for ${processedFolderIds.length} folders`,
+                );
+              }
 
-            this.logger.log(
-              `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Deleted ${folderIdsToDelete.length} folders`,
-            );
-          }
+              if (folderIdsToDelete.length > 0) {
+                await messageFolderRepository.delete(
+                  { id: In(folderIdsToDelete) },
+                  transactionManager,
+                );
+
+                this.logger.log(
+                  `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Deleted ${folderIdsToDelete.length} folders`,
+                );
+              }
+            },
+          );
         },
       );
     }

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-process-group-email-actions.service.ts

@@ -3,7 +3,8 @@ import { Injectable, Logger } from '@nestjs/common';
 import { isDefined } from 'twenty-shared/utils';
 
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import {
   MessageChannelPendingGroupEmailsAction,
   MessageChannelWorkspaceEntity,
@@ -18,7 +19,7 @@ export class MessagingProcessGroupEmailActionsService {
   );
 
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly messagingDeleteGroupEmailMessagesService: MessagingDeleteGroupEmailMessagesService,
   ) {}
 
@@ -27,19 +28,26 @@ export class MessagingProcessGroupEmailActionsService {
     workspaceId: string,
     pendingGroupEmailsAction: MessageChannelPendingGroupEmailsAction,
   ): Promise<void> {
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await messageChannelRepository.update(
-      { id: messageChannel.id },
-      { pendingGroupEmailsAction },
-    );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
 
-    this.logger.log(
-      `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Marked message channel as pending group emails action: ${pendingGroupEmailsAction}`,
+        await messageChannelRepository.update(
+          { id: messageChannel.id },
+          { pendingGroupEmailsAction },
+        );
+
+        this.logger.log(
+          `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Marked message channel as pending group emails action: ${pendingGroupEmailsAction}`,
+        );
+      },
     );
   }
 
@@ -60,56 +68,63 @@ export class MessagingProcessGroupEmailActionsService {
       `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Processing group email action: ${pendingGroupEmailsAction}`,
     );
 
-    const workspaceDataSource =
-      await this.twentyORMGlobalManager.getDataSourceForWorkspace({
-        workspaceId,
-      });
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await workspaceDataSource?.transaction(
-      async (transactionManager: WorkspaceEntityManager) => {
-        try {
-          const messageChannelRepository =
-            await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-              workspaceId,
-              'messageChannel',
-            );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const workspaceDataSource =
+          await this.globalWorkspaceOrmManager.getDataSourceForWorkspace(
+            workspaceId,
+          );
 
-          switch (pendingGroupEmailsAction) {
-            case MessageChannelPendingGroupEmailsAction.GROUP_EMAILS_DELETION:
-              await this.handleGroupEmailsDeletion(
-                workspaceId,
-                messageChannel.id,
+        await workspaceDataSource?.transaction(
+          async (transactionManager: WorkspaceEntityManager) => {
+            try {
+              const messageChannelRepository =
+                await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+                  workspaceId,
+                  'messageChannel',
+                );
+
+              switch (pendingGroupEmailsAction) {
+                case MessageChannelPendingGroupEmailsAction.GROUP_EMAILS_DELETION:
+                  await this.handleGroupEmailsDeletion(
+                    workspaceId,
+                    messageChannel.id,
+                    transactionManager,
+                  );
+                  break;
+                case MessageChannelPendingGroupEmailsAction.GROUP_EMAILS_IMPORT:
+                  await this.handleGroupEmailsImport(
+                    workspaceId,
+                    messageChannel.id,
+                    transactionManager,
+                  );
+                  break;
+              }
+
+              await messageChannelRepository.update(
+                { id: messageChannel.id },
+                {
+                  pendingGroupEmailsAction:
+                    MessageChannelPendingGroupEmailsAction.NONE,
+                },
                 transactionManager,
               );
-              break;
-            case MessageChannelPendingGroupEmailsAction.GROUP_EMAILS_IMPORT:
-              await this.handleGroupEmailsImport(
-                workspaceId,
-                messageChannel.id,
-                transactionManager,
+
+              this.logger.log(
+                `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Reset pendingGroupEmailsAction to NONE`,
               );
-              break;
-          }
-
-          await messageChannelRepository.update(
-            { id: messageChannel.id },
-            {
-              pendingGroupEmailsAction:
-                MessageChannelPendingGroupEmailsAction.NONE,
-            },
-            transactionManager,
-          );
-
-          this.logger.log(
-            `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Reset pendingGroupEmailsAction to NONE`,
-          );
-        } catch (error) {
-          this.logger.error(
-            `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Error processing group email action: ${error.message}`,
-            error.stack,
-          );
-          throw error;
-        }
+            } catch (error) {
+              this.logger.error(
+                `WorkspaceId: ${workspaceId}, MessageChannelId: ${messageChannel.id} - Error processing group email action: ${error.message}`,
+                error.stack,
+              );
+              throw error;
+            }
+          },
+        );
       },
     );
   }
@@ -161,7 +176,7 @@ export class MessagingProcessGroupEmailActionsService {
     transactionManager: WorkspaceEntityManager;
   }) {
     const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
+      await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
         workspaceId,
         'messageChannel',
       );
@@ -175,7 +190,7 @@ export class MessagingProcessGroupEmailActionsService {
     );
 
     const messageFolderRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageFolderWorkspaceEntity>(
+      await this.globalWorkspaceOrmManager.getRepository<MessageFolderWorkspaceEntity>(
         workspaceId,
         'messageFolder',
       );

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-save-messages-and-enqueue-contact-creation.service.spec.ts

@@ -7,7 +7,7 @@ import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queu
 import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
 import { getQueueToken } from 'src/engine/core-modules/message-queue/utils/get-queue-token.util';
 import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
 import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import { CreateCompanyAndContactJob } from 'src/modules/contact-creation-manager/jobs/create-company-and-contact.job';
 import { MessageDirection } from 'src/modules/messaging/common/enums/message-direction.enum';
@@ -152,11 +152,14 @@ describe('MessagingSaveMessagesAndEnqueueContactCreationService', () => {
           },
         },
         {
-          provide: TwentyORMGlobalManager,
+          provide: GlobalWorkspaceOrmManager,
           useValue: {
             getDataSourceForWorkspace: jest
               .fn()
               .mockResolvedValue(datasourceInstance),
+            executeInWorkspaceContext: jest
+              .fn()
+              .mockImplementation((_authContext: any, fn: () => any) => fn()),
           },
         },
       ],

packages/twenty-server/src/modules/messaging/message-import-manager/services/messaging-save-messages-and-enqueue-contact-creation.service.ts

@@ -6,7 +6,8 @@ import { InjectMessageQueue } from 'src/engine/core-modules/message-queue/decora
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { MessageQueueService } from 'src/engine/core-modules/message-queue/services/message-queue.service';
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
 import {
   CreateCompanyAndContactJob,
@@ -32,7 +33,7 @@ export class MessagingSaveMessagesAndEnqueueContactCreationService {
     private readonly messageQueueService: MessageQueueService,
     private readonly messageService: MessagingMessageService,
     private readonly messageParticipantService: MessagingMessageParticipantService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   async saveMessagesAndEnqueueContactCreation(
@@ -42,76 +43,88 @@ export class MessagingSaveMessagesAndEnqueueContactCreationService {
     workspaceId: string,
   ) {
     const handleAliases = connectedAccount.handleAliases?.split(',') || [];
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const workspaceDataSource =
-      await this.twentyORMGlobalManager.getDataSourceForWorkspace({
-        workspaceId,
-      });
+    const participantsWithMessageId =
+      await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+        authContext,
+        async () => {
+          const workspaceDataSource =
+            await this.globalWorkspaceOrmManager.getDataSourceForWorkspace(
+              workspaceId,
+            );
 
-    const participantsWithMessageId = await workspaceDataSource?.transaction(
-      async (transactionManager: WorkspaceEntityManager) => {
-        const { messageExternalIdsAndIdsMap } =
-          await this.messageService.saveMessagesWithinTransaction(
-            messagesToSave,
-            messageChannel.id,
-            transactionManager,
-            workspaceId,
+          return workspaceDataSource?.transaction(
+            async (transactionManager: WorkspaceEntityManager) => {
+              const { messageExternalIdsAndIdsMap } =
+                await this.messageService.saveMessagesWithinTransaction(
+                  messagesToSave,
+                  messageChannel.id,
+                  transactionManager,
+                  workspaceId,
+                );
+
+              const participantsWithMessageId: (ParticipantWithMessageId & {
+                shouldCreateContact: boolean;
+              })[] = messagesToSave.flatMap((message) => {
+                const messageId = messageExternalIdsAndIdsMap.get(
+                  message.externalId,
+                );
+
+                return messageId
+                  ? message.participants.map((participant: Participant) => {
+                      const fromHandle =
+                        message.participants.find(
+                          (p) => p.role === MessageParticipantRole.FROM,
+                        )?.handle || '';
+
+                      const isMessageSentByConnectedAccount =
+                        handleAliases.includes(fromHandle) ||
+                        fromHandle === connectedAccount.handle;
+
+                      const isParticipantConnectedAccount =
+                        handleAliases.includes(participant.handle) ||
+                        participant.handle === connectedAccount.handle;
+
+                      const isExcludedByNonProfessionalEmails =
+                        messageChannel.excludeNonProfessionalEmails &&
+                        !isWorkEmail(participant.handle);
+
+                      const shouldCreateContact =
+                        !!participant.handle &&
+                        !isParticipantConnectedAccount &&
+                        !isExcludedByNonProfessionalEmails &&
+                        (messageChannel.contactAutoCreationPolicy ===
+                          MessageChannelContactAutoCreationPolicy.SENT_AND_RECEIVED ||
+                          (messageChannel.contactAutoCreationPolicy ===
+                            MessageChannelContactAutoCreationPolicy.SENT &&
+                            isMessageSentByConnectedAccount));
+
+                      return {
+                        ...participant,
+                        messageId,
+                        shouldCreateContact,
+                      };
+                    })
+                  : [];
+              });
+
+              await this.messageParticipantService.saveMessageParticipants(
+                participantsWithMessageId,
+                workspaceId,
+                transactionManager,
+              );
+
+              return participantsWithMessageId;
+            },
           );
+        },
+      );
 
-        const participantsWithMessageId: (ParticipantWithMessageId & {
-          shouldCreateContact: boolean;
-        })[] = messagesToSave.flatMap((message) => {
-          const messageId = messageExternalIdsAndIdsMap.get(message.externalId);
-
-          return messageId
-            ? message.participants.map((participant: Participant) => {
-                const fromHandle =
-                  message.participants.find(
-                    (p) => p.role === MessageParticipantRole.FROM,
-                  )?.handle || '';
-
-                const isMessageSentByConnectedAccount =
-                  handleAliases.includes(fromHandle) ||
-                  fromHandle === connectedAccount.handle;
-
-                const isParticipantConnectedAccount =
-                  handleAliases.includes(participant.handle) ||
-                  participant.handle === connectedAccount.handle;
-
-                const isExcludedByNonProfessionalEmails =
-                  messageChannel.excludeNonProfessionalEmails &&
-                  !isWorkEmail(participant.handle);
-
-                const shouldCreateContact =
-                  !!participant.handle &&
-                  !isParticipantConnectedAccount &&
-                  !isExcludedByNonProfessionalEmails &&
-                  (messageChannel.contactAutoCreationPolicy ===
-                    MessageChannelContactAutoCreationPolicy.SENT_AND_RECEIVED ||
-                    (messageChannel.contactAutoCreationPolicy ===
-                      MessageChannelContactAutoCreationPolicy.SENT &&
-                      isMessageSentByConnectedAccount));
-
-                return {
-                  ...participant,
-                  messageId,
-                  shouldCreateContact,
-                };
-              })
-            : [];
-        });
-
-        await this.messageParticipantService.saveMessageParticipants(
-          participantsWithMessageId,
-          workspaceId,
-          transactionManager,
-        );
-
-        return participantsWithMessageId;
-      },
-    );
-
-    if (messageChannel.isContactAutoCreationEnabled) {
+    if (
+      messageChannel.isContactAutoCreationEnabled &&
+      participantsWithMessageId
+    ) {
       const contactsToCreate = participantsWithMessageId.filter(
         (participant) => participant.shouldCreateContact,
       );

packages/twenty-server/src/modules/messaging/message-participant-manager/services/messaging-message-participant.service.ts

@@ -3,7 +3,8 @@ import { Injectable } from '@nestjs/common';
 import { In } from 'typeorm';
 
 import { type WorkspaceEntityManager } from 'src/engine/twenty-orm/entity-manager/workspace-entity-manager';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { MatchParticipantService } from 'src/modules/match-participant/match-participant.service';
 import { type MessageParticipantWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-participant.workspace-entity';
 import { type ParticipantWithMessageId } from 'src/modules/messaging/message-import-manager/drivers/gmail/types/gmail-message.type';
@@ -11,7 +12,7 @@ import { type ParticipantWithMessageId } from 'src/modules/messaging/message-imp
 @Injectable()
 export class MessagingMessageParticipantService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly matchParticipantService: MatchParticipantService<MessageParticipantWorkspaceEntity>,
   ) {}
 
@@ -20,55 +21,62 @@ export class MessagingMessageParticipantService {
     workspaceId: string,
     transactionManager?: WorkspaceEntityManager,
   ): Promise<void> {
-    const messageParticipantRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageParticipantWorkspaceEntity>(
-        workspaceId,
-        'messageParticipant',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const existingParticipantsBasedOnMessageIds =
-      await messageParticipantRepository.find({
-        where: {
-          messageId: In(
-            participants.map((participant) => participant.messageId),
-          ),
-        },
-      });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageParticipantRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageParticipantWorkspaceEntity>(
+            workspaceId,
+            'messageParticipant',
+          );
 
-    const participantsToCreate: Pick<
-      MessageParticipantWorkspaceEntity,
-      'messageId' | 'handle' | 'displayName' | 'role'
-    >[] = participants
-      .filter(
-        (participant) =>
-          !existingParticipantsBasedOnMessageIds.find(
-            (existingParticipant) =>
-              existingParticipant.messageId === participant.messageId &&
-              existingParticipant.handle === participant.handle &&
-              existingParticipant.displayName === participant.displayName &&
-              existingParticipant.role === participant.role,
-          ),
-      )
-      .map((participant) => {
-        return {
-          messageId: participant.messageId,
-          handle: participant.handle,
-          displayName: participant.displayName,
-          role: participant.role,
-        };
-      });
+        const existingParticipantsBasedOnMessageIds =
+          await messageParticipantRepository.find({
+            where: {
+              messageId: In(
+                participants.map((participant) => participant.messageId),
+              ),
+            },
+          });
 
-    const createdParticipants = await messageParticipantRepository.insert(
-      participantsToCreate,
-      transactionManager,
+        const participantsToCreate: Pick<
+          MessageParticipantWorkspaceEntity,
+          'messageId' | 'handle' | 'displayName' | 'role'
+        >[] = participants
+          .filter(
+            (participant) =>
+              !existingParticipantsBasedOnMessageIds.find(
+                (existingParticipant) =>
+                  existingParticipant.messageId === participant.messageId &&
+                  existingParticipant.handle === participant.handle &&
+                  existingParticipant.displayName === participant.displayName &&
+                  existingParticipant.role === participant.role,
+              ),
+          )
+          .map((participant) => {
+            return {
+              messageId: participant.messageId,
+              handle: participant.handle,
+              displayName: participant.displayName,
+              role: participant.role,
+            };
+          });
+
+        const createdParticipants = await messageParticipantRepository.insert(
+          participantsToCreate,
+          transactionManager,
+        );
+
+        await this.matchParticipantService.matchParticipants({
+          participants: createdParticipants.raw ?? [],
+          objectMetadataName: 'messageParticipant',
+          transactionManager,
+          matchWith: 'workspaceMemberAndPerson',
+          workspaceId,
+        });
+      },
     );
-
-    await this.matchParticipantService.matchParticipants({
-      participants: createdParticipants.raw ?? [],
-      objectMetadataName: 'messageParticipant',
-      transactionManager,
-      matchWith: 'workspaceMemberAndPerson',
-      workspaceId,
-    });
   }
 }

packages/twenty-server/src/modules/messaging/monitoring/crons/jobs/messaging-message-channel-sync-status-monitoring.cron.job.ts

@@ -10,7 +10,8 @@ import { Process } from 'src/engine/core-modules/message-queue/decorators/proces
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
 import { WorkspaceEntity } from 'src/engine/core-modules/workspace/workspace.entity';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type MessageChannelWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
 import { MessagingMonitoringService } from 'src/modules/messaging/monitoring/services/messaging-monitoring.service';
 
@@ -23,7 +24,7 @@ export class MessagingMessageChannelSyncStatusMonitoringCronJob {
     @InjectRepository(WorkspaceEntity)
     private readonly workspaceRepository: Repository<WorkspaceEntity>,
     private readonly messagingMonitoringService: MessagingMonitoringService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly exceptionHandlerService: ExceptionHandlerService,
   ) {}
 
@@ -46,29 +47,36 @@ export class MessagingMessageChannelSyncStatusMonitoringCronJob {
 
     for (const activeWorkspace of activeWorkspaces) {
       try {
-        const messageChannelRepository =
-          await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-            activeWorkspace.id,
-            'messageChannel',
-          );
-        const messageChannels = await messageChannelRepository.find({
-          select: ['id', 'syncStatus', 'connectedAccountId'],
-        });
+        const authContext = buildSystemAuthContext(activeWorkspace.id);
 
-        for (const messageChannel of messageChannels) {
-          if (!messageChannel.syncStatus) {
-            continue;
-          }
-          await this.messagingMonitoringService.track({
-            eventName: `message_channel.monitoring.sync_status.${snakeCase(
-              messageChannel.syncStatus,
-            )}`,
-            workspaceId: activeWorkspace.id,
-            connectedAccountId: messageChannel.connectedAccountId,
-            messageChannelId: messageChannel.id,
-            message: messageChannel.syncStatus,
-          });
-        }
+        await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+          authContext,
+          async () => {
+            const messageChannelRepository =
+              await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+                activeWorkspace.id,
+                'messageChannel',
+              );
+            const messageChannels = await messageChannelRepository.find({
+              select: ['id', 'syncStatus', 'connectedAccountId'],
+            });
+
+            for (const messageChannel of messageChannels) {
+              if (!messageChannel.syncStatus) {
+                continue;
+              }
+              await this.messagingMonitoringService.track({
+                eventName: `message_channel.monitoring.sync_status.${snakeCase(
+                  messageChannel.syncStatus,
+                )}`,
+                workspaceId: activeWorkspace.id,
+                connectedAccountId: messageChannel.connectedAccountId,
+                messageChannelId: messageChannel.id,
+                message: messageChannel.syncStatus,
+              });
+            }
+          },
+        );
       } catch (error) {
         this.exceptionHandlerService.captureExceptions([error], {
           workspace: {