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/calendar/blocklist-manager/jobs/blocklist-item-delete-calendar-events.job.ts

@@ -7,7 +7,8 @@ import { type ObjectRecordCreateEvent } 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 { CalendarEventCleanerService } from 'src/modules/calendar/calendar-event-cleaner/services/calendar-event-cleaner.service';
@@ -24,7 +25,7 @@ export type BlocklistItemDeleteCalendarEventsJobData = WorkspaceEventBatch<
 })
 export class BlocklistItemDeleteCalendarEventsJob {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly calendarEventCleanerService: CalendarEventCleanerService,
   ) {}
 
@@ -32,121 +33,128 @@ export class BlocklistItemDeleteCalendarEventsJob {
   async handle(data: BlocklistItemDeleteCalendarEventsJobData): 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 calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
-
-    const calendarChannelEventAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelEventAssociationWorkspaceEntity>(
-        workspaceId,
-        'calendarChannelEventAssociation',
-      );
-
-    for (const workspaceMemberId of handlesToDeleteByWorkspaceMemberIdMap.keys()) {
-      const handles =
-        handlesToDeleteByWorkspaceMemberIdMap.get(workspaceMemberId);
-
-      if (!handles) {
-        continue;
-      }
-
-      const calendarChannels = await calendarChannelRepository.find({
-        select: {
-          id: true,
-          handle: true,
-          connectedAccount: {
-            handleAliases: true,
-          },
-        },
-        where: {
-          connectedAccount: {
-            accountOwnerId: workspaceMemberId,
-          },
-        },
-        relations: ['connectedAccount'],
-      });
-
-      for (const calendarChannel of calendarChannels) {
-        const calendarChannelHandles = [calendarChannel.handle];
-
-        if (calendarChannel.connectedAccount.handleAliases) {
-          calendarChannelHandles.push(
-            ...calendarChannel.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(calendarChannelHandles)),
-                ),
-              }
-            : { handle };
+        const blocklist = await blocklistRepository.find({
+          where: {
+            id: Any(blocklistItemIds),
+          },
         });
 
-        const calendarEventsAssociationsToDelete =
-          await calendarChannelEventAssociationRepository.find({
-            where: {
-              calendarChannelId: calendarChannel.id,
-              calendarEvent: {
-                calendarEventParticipants: 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 calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        const calendarChannelEventAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelEventAssociationWorkspaceEntity>(
+            workspaceId,
+            'calendarChannelEventAssociation',
+          );
+
+        for (const workspaceMemberId of handlesToDeleteByWorkspaceMemberIdMap.keys()) {
+          const handles =
+            handlesToDeleteByWorkspaceMemberIdMap.get(workspaceMemberId);
+
+          if (!handles) {
+            continue;
+          }
+
+          const calendarChannels = await calendarChannelRepository.find({
+            select: {
+              id: true,
+              handle: true,
+              connectedAccount: {
+                handleAliases: true,
               },
             },
+            where: {
+              connectedAccount: {
+                accountOwnerId: workspaceMemberId,
+              },
+            },
+            relations: ['connectedAccount'],
           });
 
-        if (calendarEventsAssociationsToDelete.length === 0) {
-          continue;
+          for (const calendarChannel of calendarChannels) {
+            const calendarChannelHandles = [calendarChannel.handle];
+
+            if (calendarChannel.connectedAccount.handleAliases) {
+              calendarChannelHandles.push(
+                ...calendarChannel.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(calendarChannelHandles)),
+                    ),
+                  }
+                : { handle };
+            });
+
+            const calendarEventsAssociationsToDelete =
+              await calendarChannelEventAssociationRepository.find({
+                where: {
+                  calendarChannelId: calendarChannel.id,
+                  calendarEvent: {
+                    calendarEventParticipants: handleConditions,
+                  },
+                },
+              });
+
+            if (calendarEventsAssociationsToDelete.length === 0) {
+              continue;
+            }
+
+            await calendarChannelEventAssociationRepository.delete(
+              calendarEventsAssociationsToDelete.map(({ id }) => id),
+            );
+          }
         }
 
-        await calendarChannelEventAssociationRepository.delete(
-          calendarEventsAssociationsToDelete.map(({ id }) => id),
+        await this.calendarEventCleanerService.cleanWorkspaceCalendarEvents(
+          workspaceId,
         );
-      }
-    }
-
-    await this.calendarEventCleanerService.cleanWorkspaceCalendarEvents(
-      workspaceId,
+      },
     );
   }
 }

packages/twenty-server/src/modules/calendar/blocklist-manager/jobs/blocklist-reimport-calendar-events.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 { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/services/calendar-channel-sync-status.service';
@@ -25,7 +26,7 @@ export type BlocklistReimportCalendarEventsJobData = WorkspaceEventBatch<
 })
 export class BlocklistReimportCalendarEventsJob {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly calendarChannelSyncStatusService: CalendarChannelSyncStatusService,
   ) {}
 
@@ -33,32 +34,39 @@ export class BlocklistReimportCalendarEventsJob {
   async handle(data: BlocklistReimportCalendarEventsJobData): Promise<void> {
     const workspaceId = data.workspaceId;
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    for (const eventPayload of data.events) {
-      const workspaceMemberId =
-        eventPayload.properties.before.workspaceMemberId;
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
 
-      const calendarChannels = await calendarChannelRepository.find({
-        select: ['id'],
-        where: {
-          connectedAccount: {
-            accountOwnerId: workspaceMemberId,
-          },
-          syncStage: Not(
-            CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
-          ),
-        },
-      });
+        for (const eventPayload of data.events) {
+          const workspaceMemberId =
+            eventPayload.properties.before.workspaceMemberId;
 
-      await this.calendarChannelSyncStatusService.resetAndMarkAsCalendarEventListFetchPending(
-        calendarChannels.map((calendarChannel) => calendarChannel.id),
-        workspaceId,
-      );
-    }
+          const calendarChannels = await calendarChannelRepository.find({
+            select: ['id'],
+            where: {
+              connectedAccount: {
+                accountOwnerId: workspaceMemberId,
+              },
+              syncStage: Not(
+                CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
+              ),
+            },
+          });
+
+          await this.calendarChannelSyncStatusService.resetAndMarkAsCalendarEventListFetchPending(
+            calendarChannels.map((calendarChannel) => calendarChannel.id),
+            workspaceId,
+          );
+        }
+      },
+    );
   }
 }

packages/twenty-server/src/modules/calendar/calendar-event-cleaner/services/calendar-event-cleaner.service.ts

@@ -2,40 +2,49 @@ import { Injectable } from '@nestjs/common';
 
 import { Any, IsNull } from 'typeorm';
 
-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 { deleteUsingPagination } from 'src/modules/messaging/message-cleaner/utils/delete-using-pagination.util';
 
 @Injectable()
 export class CalendarEventCleanerService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   public async cleanWorkspaceCalendarEvents(workspaceId: string) {
-    const calendarEventRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace(
-        workspaceId,
-        'calendarEvent',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await deleteUsingPagination(
-      workspaceId,
-      500,
-      async (limit, offset) => {
-        const nonAssociatedCalendarEvents = await calendarEventRepository.find({
-          where: {
-            calendarChannelEventAssociations: {
-              id: IsNull(),
-            },
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarEventRepository =
+          await this.globalWorkspaceOrmManager.getRepository(
+            workspaceId,
+            'calendarEvent',
+          );
+
+        await deleteUsingPagination(
+          workspaceId,
+          500,
+          async (limit, offset) => {
+            const nonAssociatedCalendarEvents =
+              await calendarEventRepository.find({
+                where: {
+                  calendarChannelEventAssociations: {
+                    id: IsNull(),
+                  },
+                },
+                take: limit,
+                skip: offset,
+              });
+
+            return nonAssociatedCalendarEvents.map(({ id }) => id);
           },
-          take: limit,
-          skip: offset,
-        });
-
-        return nonAssociatedCalendarEvents.map(({ id }) => id);
-      },
-      async (ids) => {
-        await calendarEventRepository.delete({ id: Any(ids) });
+          async (ids) => {
+            await calendarEventRepository.delete({ id: Any(ids) });
+          },
+        );
       },
     );
   }

packages/twenty-server/src/modules/calendar/calendar-event-import-manager/jobs/calendar-event-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 { CalendarFetchEventsService } from 'src/modules/calendar/calendar-event-import-manager/services/calendar-fetch-events.service';
 import { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/services/calendar-channel-sync-status.service';
 import {
@@ -23,7 +24,7 @@ export type CalendarEventListFetchJobData = {
 })
 export class CalendarEventListFetchJob {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly calendarChannelSyncStatusService: CalendarChannelSyncStatusService,
     private readonly calendarFetchEventsService: CalendarFetchEventsService,
   ) {}
@@ -32,50 +33,57 @@ export class CalendarEventListFetchJob {
   async handle(data: CalendarEventListFetchJobData): Promise<void> {
     const { workspaceId, calendarChannelId } = data;
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const calendarChannel = await calendarChannelRepository.findOne({
-      where: {
-        id: calendarChannelId,
-        isSyncEnabled: true,
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        const calendarChannel = await calendarChannelRepository.findOne({
+          where: {
+            id: calendarChannelId,
+            isSyncEnabled: true,
+          },
+          relations: ['connectedAccount'],
+        });
+
+        if (!calendarChannel) {
+          return;
+        }
+
+        if (
+          calendarChannel.syncStage !==
+          CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_SCHEDULED
+        ) {
+          return;
+        }
+
+        if (
+          isThrottled(
+            calendarChannel.syncStageStartedAt,
+            calendarChannel.throttleFailureCount,
+          )
+        ) {
+          await this.calendarChannelSyncStatusService.markAsCalendarEventListFetchPending(
+            [calendarChannel.id],
+            workspaceId,
+            true,
+          );
+
+          return;
+        }
+
+        await this.calendarFetchEventsService.fetchCalendarEvents(
+          calendarChannel,
+          calendarChannel.connectedAccount,
+          workspaceId,
+        );
       },
-      relations: ['connectedAccount'],
-    });
-
-    if (!calendarChannel) {
-      return;
-    }
-
-    if (
-      calendarChannel.syncStage !==
-      CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_SCHEDULED
-    ) {
-      return;
-    }
-
-    if (
-      isThrottled(
-        calendarChannel.syncStageStartedAt,
-        calendarChannel.throttleFailureCount,
-      )
-    ) {
-      await this.calendarChannelSyncStatusService.markAsCalendarEventListFetchPending(
-        [calendarChannel.id],
-        workspaceId,
-        true,
-      );
-
-      return;
-    }
-
-    await this.calendarFetchEventsService.fetchCalendarEvents(
-      calendarChannel,
-      calendarChannel.connectedAccount,
-      workspaceId,
     );
   }
 }

packages/twenty-server/src/modules/calendar/calendar-event-import-manager/jobs/calendar-events-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 { CalendarEventsImportService } from 'src/modules/calendar/calendar-event-import-manager/services/calendar-events-import.service';
 import { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/services/calendar-channel-sync-status.service';
 import {
@@ -25,56 +26,63 @@ export class CalendarEventsImportJob {
   constructor(
     private readonly calendarEventsImportService: CalendarEventsImportService,
     private readonly calendarChannelSyncStatusService: CalendarChannelSyncStatusService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   @Process(CalendarEventsImportJob.name)
   async handle(data: CalendarEventsImportJobData): Promise<void> {
     const { calendarChannelId, workspaceId } = data;
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
-    const calendarChannel = await calendarChannelRepository.findOne({
-      where: {
-        id: calendarChannelId,
-        isSyncEnabled: true,
+    const authContext = buildSystemAuthContext(workspaceId);
+
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+        const calendarChannel = await calendarChannelRepository.findOne({
+          where: {
+            id: calendarChannelId,
+            isSyncEnabled: true,
+          },
+          relations: ['connectedAccount'],
+        });
+
+        if (!calendarChannel?.isSyncEnabled) {
+          return;
+        }
+
+        if (
+          calendarChannel.syncStage !==
+          CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_SCHEDULED
+        ) {
+          return;
+        }
+
+        if (
+          isThrottled(
+            calendarChannel.syncStageStartedAt,
+            calendarChannel.throttleFailureCount,
+          )
+        ) {
+          await this.calendarChannelSyncStatusService.markAsCalendarEventsImportPending(
+            [calendarChannel.id],
+            workspaceId,
+            true,
+          );
+
+          return;
+        }
+
+        await this.calendarEventsImportService.processCalendarEventsImport(
+          calendarChannel,
+          calendarChannel.connectedAccount,
+          workspaceId,
+        );
       },
-      relations: ['connectedAccount'],
-    });
-
-    if (!calendarChannel?.isSyncEnabled) {
-      return;
-    }
-
-    if (
-      calendarChannel.syncStage !==
-      CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_SCHEDULED
-    ) {
-      return;
-    }
-
-    if (
-      isThrottled(
-        calendarChannel.syncStageStartedAt,
-        calendarChannel.throttleFailureCount,
-      )
-    ) {
-      await this.calendarChannelSyncStatusService.markAsCalendarEventsImportPending(
-        [calendarChannel.id],
-        workspaceId,
-        true,
-      );
-
-      return;
-    }
-
-    await this.calendarEventsImportService.processCalendarEventsImport(
-      calendarChannel,
-      calendarChannel.connectedAccount,
-      workspaceId,
     );
   }
 }

packages/twenty-server/src/modules/calendar/calendar-event-import-manager/jobs/calendar-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 { isSyncStale } from 'src/modules/calendar/calendar-event-import-manager/utils/is-sync-stale.util';
 import { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/services/calendar-channel-sync-status.service';
 import {
@@ -24,7 +25,7 @@ export type CalendarOngoingStaleJobData = {
 export class CalendarOngoingStaleJob {
   private readonly logger = new Logger(CalendarOngoingStaleJob.name);
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly calendarChannelSyncStatusService: CalendarChannelSyncStatusService,
   ) {}
 
@@ -32,58 +33,65 @@ export class CalendarOngoingStaleJob {
   async handle(data: CalendarOngoingStaleJobData): Promise<void> {
     const { workspaceId } = data;
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const calendarChannels = await calendarChannelRepository.find({
-      where: {
-        syncStage: In([
-          CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_ONGOING,
-          CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_ONGOING,
-          CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_SCHEDULED,
-          CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_SCHEDULED,
-        ]),
-      },
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
 
-    for (const calendarChannel of calendarChannels) {
-      if (
-        calendarChannel.syncStageStartedAt &&
-        isSyncStale(calendarChannel.syncStageStartedAt)
-      ) {
-        await this.calendarChannelSyncStatusService.resetSyncStageStartedAt(
-          [calendarChannel.id],
-          workspaceId,
-        );
+        const calendarChannels = await calendarChannelRepository.find({
+          where: {
+            syncStage: In([
+              CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_ONGOING,
+              CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_ONGOING,
+              CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_SCHEDULED,
+              CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_SCHEDULED,
+            ]),
+          },
+        });
 
-        switch (calendarChannel.syncStage) {
-          case CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_ONGOING:
-          case CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_SCHEDULED:
-            this.logger.log(
-              `Sync for calendar channel ${calendarChannel.id} and workspace ${workspaceId} is stale. Setting sync stage to CALENDAR_EVENT_LIST_FETCH_PENDING`,
-            );
-            await this.calendarChannelSyncStatusService.markAsCalendarEventListFetchPending(
+        for (const calendarChannel of calendarChannels) {
+          if (
+            calendarChannel.syncStageStartedAt &&
+            isSyncStale(calendarChannel.syncStageStartedAt)
+          ) {
+            await this.calendarChannelSyncStatusService.resetSyncStageStartedAt(
               [calendarChannel.id],
               workspaceId,
             );
-            break;
-          case CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_ONGOING:
-          case CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_SCHEDULED:
-            this.logger.log(
-              `Sync for calendar channel ${calendarChannel.id} and workspace ${workspaceId} is stale. Setting sync stage to CALENDAR_EVENTS_IMPORT_PENDING`,
-            );
-            await this.calendarChannelSyncStatusService.markAsCalendarEventsImportPending(
-              [calendarChannel.id],
-              workspaceId,
-            );
-            break;
-          default:
-            break;
+
+            switch (calendarChannel.syncStage) {
+              case CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_ONGOING:
+              case CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_SCHEDULED:
+                this.logger.log(
+                  `Sync for calendar channel ${calendarChannel.id} and workspace ${workspaceId} is stale. Setting sync stage to CALENDAR_EVENT_LIST_FETCH_PENDING`,
+                );
+                await this.calendarChannelSyncStatusService.markAsCalendarEventListFetchPending(
+                  [calendarChannel.id],
+                  workspaceId,
+                );
+                break;
+              case CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_ONGOING:
+              case CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_SCHEDULED:
+                this.logger.log(
+                  `Sync for calendar channel ${calendarChannel.id} and workspace ${workspaceId} is stale. Setting sync stage to CALENDAR_EVENTS_IMPORT_PENDING`,
+                );
+                await this.calendarChannelSyncStatusService.markAsCalendarEventsImportPending(
+                  [calendarChannel.id],
+                  workspaceId,
+                );
+                break;
+              default:
+                break;
+            }
+          }
         }
-      }
-    }
+      },
+    );
   }
 }

packages/twenty-server/src/modules/calendar/calendar-event-import-manager/jobs/calendar-relaunch-failed-calendar-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 {
   CalendarChannelSyncStage,
   CalendarChannelSyncStatus,
@@ -21,42 +22,50 @@ export type CalendarRelaunchFailedCalendarChannelJobData = {
 })
 export class CalendarRelaunchFailedCalendarChannelJob {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   @Process(CalendarRelaunchFailedCalendarChannelJob.name)
   async handle(data: CalendarRelaunchFailedCalendarChannelJobData) {
     const { workspaceId, calendarChannelId } = data;
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-        { shouldBypassPermissionChecks: true },
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const calendarChannel = await calendarChannelRepository.findOne({
-      where: {
-        id: calendarChannelId,
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+            { shouldBypassPermissionChecks: true },
+          );
+
+        const calendarChannel = await calendarChannelRepository.findOne({
+          where: {
+            id: calendarChannelId,
+          },
+          relations: {
+            connectedAccount: {
+              accountOwner: true,
+            },
+          },
+        });
+
+        if (
+          !calendarChannel ||
+          calendarChannel.syncStage !== CalendarChannelSyncStage.FAILED ||
+          calendarChannel.syncStatus !==
+            CalendarChannelSyncStatus.FAILED_UNKNOWN
+        ) {
+          return;
+        }
+
+        await calendarChannelRepository.update(calendarChannelId, {
+          syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
+          syncStatus: CalendarChannelSyncStatus.ACTIVE,
+        });
       },
-      relations: {
-        connectedAccount: {
-          accountOwner: true,
-        },
-      },
-    });
-
-    if (
-      !calendarChannel ||
-      calendarChannel.syncStage !== CalendarChannelSyncStage.FAILED ||
-      calendarChannel.syncStatus !== CalendarChannelSyncStatus.FAILED_UNKNOWN
-    ) {
-      return;
-    }
-
-    await calendarChannelRepository.update(calendarChannelId, {
-      syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
-      syncStatus: CalendarChannelSyncStatus.ACTIVE,
-    });
+    );
   }
 }

packages/twenty-server/src/modules/calendar/calendar-event-import-manager/services/calendar-event-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 { CALENDAR_THROTTLE_MAX_ATTEMPTS } from 'src/modules/calendar/calendar-event-import-manager/constants/calendar-throttle-max-attempts';
 import {
   type CalendarEventImportDriverException,
@@ -28,7 +29,7 @@ export class CalendarEventImportErrorHandlerService {
     CalendarEventImportErrorHandlerService.name,
   );
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly calendarChannelSyncStatusService: CalendarChannelSyncStatusService,
     private readonly exceptionHandlerService: ExceptionHandlerService,
   ) {}
@@ -130,20 +131,27 @@ export class CalendarEventImportErrorHandlerService {
       throw calendarEventImportException;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await calendarChannelRepository.increment(
-      {
-        id: calendarChannel.id,
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.increment(
+          {
+            id: calendarChannel.id,
+          },
+          'throttleFailureCount',
+          1,
+          undefined,
+          ['throttleFailureCount', 'id'],
+        );
       },
-      'throttleFailureCount',
-      1,
-      undefined,
-      ['throttleFailureCount', 'id'],
     );
 
     switch (syncStep) {

packages/twenty-server/src/modules/calendar/calendar-event-import-manager/services/calendar-events-import.service.ts

@@ -7,7 +7,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 { CalendarEventCleanerService } from 'src/modules/calendar/calendar-event-cleaner/services/calendar-event-cleaner.service';
@@ -34,7 +35,7 @@ export class CalendarEventsImportService {
   constructor(
     @InjectCacheStorage(CacheStorageNamespace.ModuleCalendar)
     private readonly cacheStorage: CacheStorageService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     @InjectObjectMetadataRepository(BlocklistWorkspaceEntity)
     private readonly blocklistRepository: BlocklistRepository,
     private readonly calendarEventCleanerService: CalendarEventCleanerService,
@@ -55,115 +56,123 @@ export class CalendarEventsImportService {
       workspaceId,
     );
 
-    let calendarEvents: FetchedCalendarEvent[] = [];
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    try {
-      if (fetchedCalendarEvents) {
-        calendarEvents = fetchedCalendarEvents;
-      } else {
-        const eventIdsToFetch: string[] = await this.cacheStorage.setPop(
-          `calendar-events-to-import:${workspaceId}:${calendarChannel.id}`,
-          CALENDAR_EVENT_IMPORT_BATCH_SIZE,
-        );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        let calendarEvents: FetchedCalendarEvent[] = [];
+
+        try {
+          if (fetchedCalendarEvents) {
+            calendarEvents = fetchedCalendarEvents;
+          } else {
+            const eventIdsToFetch: string[] = await this.cacheStorage.setPop(
+              `calendar-events-to-import:${workspaceId}:${calendarChannel.id}`,
+              CALENDAR_EVENT_IMPORT_BATCH_SIZE,
+            );
+
+            if (!eventIdsToFetch || eventIdsToFetch.length === 0) {
+              await this.calendarChannelSyncStatusService.markAsCompletedAndMarkAsCalendarEventListFetchPending(
+                [calendarChannel.id],
+                workspaceId,
+              );
+
+              return;
+            }
+
+            switch (connectedAccount.provider) {
+              case 'microsoft':
+                calendarEvents =
+                  await this.microsoftCalendarImportEventService.getCalendarEvents(
+                    connectedAccount,
+                    eventIdsToFetch,
+                  );
+                break;
+              default:
+                break;
+            }
+          }
+
+          if (!calendarEvents || calendarEvents?.length === 0) {
+            await this.calendarChannelSyncStatusService.markAsCalendarEventListFetchPending(
+              [calendarChannel.id],
+              workspaceId,
+            );
+          }
+
+          const blocklist =
+            await this.blocklistRepository.getByWorkspaceMemberId(
+              connectedAccount.accountOwnerId,
+              workspaceId,
+            );
+
+          if (
+            !isDefined(connectedAccount.handleAliases) ||
+            !isDefined(calendarChannel.handle)
+          ) {
+            throw new CalendarEventImportDriverException(
+              'Calendar channel handle or Handle aliases are required',
+              CalendarEventImportDriverExceptionCode.CHANNEL_MISCONFIGURED,
+            );
+          }
+
+          const { filteredEvents, cancelledEvents } =
+            filterEventsAndReturnCancelledEvents(
+              [
+                calendarChannel.handle,
+                ...connectedAccount.handleAliases.split(','),
+              ],
+              calendarEvents,
+              blocklist.map((blocklist) => blocklist.handle ?? ''),
+            );
+
+          const cancelledEventExternalIds = cancelledEvents.map(
+            (event) => event.id,
+          );
+
+          const BATCH_SIZE = 1000;
+
+          for (let i = 0; i < filteredEvents.length; i = i + BATCH_SIZE) {
+            const eventsBatch = filteredEvents.slice(i, i + BATCH_SIZE);
+
+            await this.calendarSaveEventsService.saveCalendarEventsAndEnqueueContactCreationJob(
+              eventsBatch,
+              calendarChannel,
+              connectedAccount,
+              workspaceId,
+            );
+          }
+          const calendarChannelEventAssociationRepository =
+            await this.globalWorkspaceOrmManager.getRepository<CalendarChannelEventAssociationWorkspaceEntity>(
+              workspaceId,
+              'calendarChannelEventAssociation',
+            );
+
+          await calendarChannelEventAssociationRepository.delete({
+            eventExternalId: Any(cancelledEventExternalIds),
+            calendarChannel: {
+              id: calendarChannel.id,
+            },
+          });
+
+          await this.calendarEventCleanerService.cleanWorkspaceCalendarEvents(
+            workspaceId,
+          );
 
-        if (!eventIdsToFetch || eventIdsToFetch.length === 0) {
           await this.calendarChannelSyncStatusService.markAsCompletedAndMarkAsCalendarEventListFetchPending(
             [calendarChannel.id],
             workspaceId,
           );
-
-          return;
+        } catch (error) {
+          await this.calendarEventImportErrorHandlerService.handleDriverException(
+            error,
+            CalendarEventImportSyncStep.CALENDAR_EVENTS_IMPORT,
+            calendarChannel,
+            workspaceId,
+          );
         }
-
-        switch (connectedAccount.provider) {
-          case 'microsoft':
-            calendarEvents =
-              await this.microsoftCalendarImportEventService.getCalendarEvents(
-                connectedAccount,
-                eventIdsToFetch,
-              );
-            break;
-          default:
-            break;
-        }
-      }
-
-      if (!calendarEvents || calendarEvents?.length === 0) {
-        await this.calendarChannelSyncStatusService.markAsCalendarEventListFetchPending(
-          [calendarChannel.id],
-          workspaceId,
-        );
-      }
-
-      const blocklist = await this.blocklistRepository.getByWorkspaceMemberId(
-        connectedAccount.accountOwnerId,
-        workspaceId,
-      );
-
-      if (
-        !isDefined(connectedAccount.handleAliases) ||
-        !isDefined(calendarChannel.handle)
-      ) {
-        throw new CalendarEventImportDriverException(
-          'Calendar channel handle or Handle aliases are required',
-          CalendarEventImportDriverExceptionCode.CHANNEL_MISCONFIGURED,
-        );
-      }
-
-      const { filteredEvents, cancelledEvents } =
-        filterEventsAndReturnCancelledEvents(
-          [
-            calendarChannel.handle,
-            ...connectedAccount.handleAliases.split(','),
-          ],
-          calendarEvents,
-          blocklist.map((blocklist) => blocklist.handle ?? ''),
-        );
-
-      const cancelledEventExternalIds = cancelledEvents.map(
-        (event) => event.id,
-      );
-
-      const BATCH_SIZE = 1000;
-
-      for (let i = 0; i < filteredEvents.length; i = i + BATCH_SIZE) {
-        const eventsBatch = filteredEvents.slice(i, i + BATCH_SIZE);
-
-        await this.calendarSaveEventsService.saveCalendarEventsAndEnqueueContactCreationJob(
-          eventsBatch,
-          calendarChannel,
-          connectedAccount,
-          workspaceId,
-        );
-      }
-      const calendarChannelEventAssociationRepository =
-        await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelEventAssociationWorkspaceEntity>(
-          workspaceId,
-          'calendarChannelEventAssociation',
-        );
-
-      await calendarChannelEventAssociationRepository.delete({
-        eventExternalId: Any(cancelledEventExternalIds),
-        calendarChannel: {
-          id: calendarChannel.id,
-        },
-      });
-
-      await this.calendarEventCleanerService.cleanWorkspaceCalendarEvents(
-        workspaceId,
-      );
-
-      await this.calendarChannelSyncStatusService.markAsCompletedAndMarkAsCalendarEventListFetchPending(
-        [calendarChannel.id],
-        workspaceId,
-      );
-    } catch (error) {
-      await this.calendarEventImportErrorHandlerService.handleDriverException(
-        error,
-        CalendarEventImportSyncStep.CALENDAR_EVENTS_IMPORT,
-        calendarChannel,
-        workspaceId,
-      );
-    }
+      },
+    );
   }
 }

packages/twenty-server/src/modules/calendar/calendar-event-import-manager/services/calendar-fetch-events.service.ts

@@ -5,7 +5,8 @@ import { isDefined } from 'twenty-shared/utils';
 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 { 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 {
   CalendarEventImportDriverException,
   CalendarEventImportDriverExceptionCode,
@@ -27,7 +28,7 @@ export class CalendarFetchEventsService {
   constructor(
     @InjectCacheStorage(CacheStorageNamespace.ModuleCalendar)
     private readonly cacheStorage: CacheStorageService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly calendarChannelSyncStatusService: CalendarChannelSyncStatusService,
     private readonly getCalendarEventsService: CalendarGetCalendarEventsService,
     private readonly calendarEventImportErrorHandlerService: CalendarEventImportErrorHandlerService,
@@ -45,111 +46,115 @@ export class CalendarFetchEventsService {
       workspaceId,
     );
 
-    try {
-      const { accessToken, refreshToken } =
-        await this.calendarAccountAuthenticationService.validateAndRefreshConnectedAccountAuthentication(
-          {
-            connectedAccount,
+    const authContext = buildSystemAuthContext(workspaceId);
+
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        try {
+          const { accessToken, refreshToken } =
+            await this.calendarAccountAuthenticationService.validateAndRefreshConnectedAccountAuthentication(
+              {
+                connectedAccount,
+                workspaceId,
+                calendarChannelId: calendarChannel.id,
+              },
+            );
+
+          const connectedAccountWithFreshTokens = {
+            ...connectedAccount,
+            accessToken,
+            refreshToken,
+          };
+
+          if (!isDefined(calendarChannel.syncCursor)) {
+            throw new CalendarEventImportDriverException(
+              'Sync cursor is required',
+              CalendarEventImportDriverExceptionCode.SYNC_CURSOR_ERROR,
+            );
+          }
+
+          const getCalendarEventsResponse =
+            await this.getCalendarEventsService.getCalendarEvents(
+              connectedAccountWithFreshTokens,
+              calendarChannel.syncCursor,
+            );
+
+          const hasFullEvents = getCalendarEventsResponse.fullEvents;
+
+          const calendarEvents = hasFullEvents
+            ? getCalendarEventsResponse.calendarEvents
+            : null;
+          const calendarEventIds = getCalendarEventsResponse.calendarEventIds;
+          const nextSyncCursor = getCalendarEventsResponse.nextSyncCursor;
+
+          const calendarChannelRepository =
+            await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+              workspaceId,
+              'calendarChannel',
+            );
+
+          if (!calendarEvents || calendarEvents?.length === 0) {
+            await calendarChannelRepository.update(
+              {
+                id: calendarChannel.id,
+              },
+              {
+                syncCursor: nextSyncCursor,
+              },
+            );
+
+            await this.calendarChannelSyncStatusService.markAsCalendarEventListFetchPending(
+              [calendarChannel.id],
+              workspaceId,
+            );
+          }
+
+          await calendarChannelRepository.update(
+            {
+              id: calendarChannel.id,
+            },
+            {
+              syncCursor: nextSyncCursor,
+            },
+          );
+
+          if (hasFullEvents && calendarEvents) {
+            await this.calendarEventsImportService.processCalendarEventsImport(
+              calendarChannel,
+              connectedAccount,
+              workspaceId,
+              calendarEvents,
+            );
+          } else if (!hasFullEvents && calendarEventIds) {
+            await this.cacheStorage.setAdd(
+              `calendar-events-to-import:${workspaceId}:${calendarChannel.id}`,
+              calendarEventIds,
+            );
+
+            await this.calendarChannelSyncStatusService.markAsCalendarEventsImportPending(
+              [calendarChannel.id],
+              workspaceId,
+            );
+          } else {
+            throw new CalendarEventImportDriverException(
+              "Expected 'calendarEvents' or 'calendarEventIds' to be present",
+              CalendarEventImportDriverExceptionCode.UNKNOWN,
+            );
+          }
+        } catch (error) {
+          this.logger.log(
+            `Calendar event fetch error for workspace ${workspaceId} and calendar channel ${calendarChannel.id}`,
+          );
+          this.logger.error(error);
+          await this.calendarEventImportErrorHandlerService.handleDriverException(
+            error,
+            CalendarEventImportSyncStep.CALENDAR_EVENT_LIST_FETCH,
+            calendarChannel,
             workspaceId,
-            calendarChannelId: calendarChannel.id,
-          },
-        );
-
-      const connectedAccountWithFreshTokens = {
-        ...connectedAccount,
-        accessToken,
-        refreshToken,
-      };
-
-      if (!isDefined(calendarChannel.syncCursor)) {
-        throw new CalendarEventImportDriverException(
-          'Sync cursor is required',
-          CalendarEventImportDriverExceptionCode.SYNC_CURSOR_ERROR,
-        );
-      }
-
-      const getCalendarEventsResponse =
-        await this.getCalendarEventsService.getCalendarEvents(
-          connectedAccountWithFreshTokens,
-          calendarChannel.syncCursor,
-        );
-
-      const hasFullEvents = getCalendarEventsResponse.fullEvents;
-
-      const calendarEvents = hasFullEvents
-        ? getCalendarEventsResponse.calendarEvents
-        : null;
-      const calendarEventIds = getCalendarEventsResponse.calendarEventIds;
-      const nextSyncCursor = getCalendarEventsResponse.nextSyncCursor;
-
-      const calendarChannelRepository =
-        await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-          workspaceId,
-          'calendarChannel',
-        );
-
-      if (!calendarEvents || calendarEvents?.length === 0) {
-        await calendarChannelRepository.update(
-          {
-            id: calendarChannel.id,
-          },
-          {
-            syncCursor: nextSyncCursor,
-          },
-        );
-
-        await this.calendarChannelSyncStatusService.markAsCalendarEventListFetchPending(
-          [calendarChannel.id],
-          workspaceId,
-        );
-      }
-
-      await calendarChannelRepository.update(
-        {
-          id: calendarChannel.id,
-        },
-        {
-          syncCursor: nextSyncCursor,
-        },
-      );
-
-      if (hasFullEvents && calendarEvents) {
-        // Event Import already done
-        await this.calendarEventsImportService.processCalendarEventsImport(
-          calendarChannel,
-          connectedAccount,
-          workspaceId,
-          calendarEvents,
-        );
-      } else if (!hasFullEvents && calendarEventIds) {
-        // Event Import still needed
-
-        await this.cacheStorage.setAdd(
-          `calendar-events-to-import:${workspaceId}:${calendarChannel.id}`,
-          calendarEventIds,
-        );
-
-        await this.calendarChannelSyncStatusService.markAsCalendarEventsImportPending(
-          [calendarChannel.id],
-          workspaceId,
-        );
-      } else {
-        throw new CalendarEventImportDriverException(
-          "Expected 'calendarEvents' or 'calendarEventIds' to be present",
-          CalendarEventImportDriverExceptionCode.UNKNOWN,
-        );
-      }
-    } catch (error) {
-      this.logger.log(
-        `Calendar event fetch error for workspace ${workspaceId} and calendar channel ${calendarChannel.id}`,
-      );
-      this.logger.error(error);
-      await this.calendarEventImportErrorHandlerService.handleDriverException(
-        error,
-        CalendarEventImportSyncStep.CALENDAR_EVENT_LIST_FETCH,
-        calendarChannel,
-        workspaceId,
-      );
-    }
+          );
+        }
+      },
+    );
   }
 }

packages/twenty-server/src/modules/calendar/calendar-event-import-manager/services/calendar-save-events.service.ts

@@ -3,7 +3,8 @@ import { Injectable } from '@nestjs/common';
 import { Any } 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 { CalendarEventParticipantService } from 'src/modules/calendar/calendar-event-participant-manager/services/calendar-event-participant.service';
 import { type CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-channel-event-association.workspace-entity';
 import { type CalendarChannelWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
@@ -20,7 +21,7 @@ type FetchedCalendarEventWithDBEvent = {
 @Injectable()
 export class CalendarSaveEventsService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly calendarEventParticipantService: CalendarEventParticipantService,
   ) {}
 
@@ -30,227 +31,246 @@ export class CalendarSaveEventsService {
     connectedAccount: ConnectedAccountWorkspaceEntity,
     workspaceId: string,
   ): Promise<void> {
-    const calendarEventRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarEventWorkspaceEntity>(
-        workspaceId,
-        'calendarEvent',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const calendarChannelEventAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelEventAssociationWorkspaceEntity>(
-        workspaceId,
-        'calendarChannelEventAssociation',
-      );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarEventRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarEventWorkspaceEntity>(
+            workspaceId,
+            'calendarEvent',
+          );
 
-    const existingCalendarEvents = await calendarEventRepository.find({
-      where: {
-        iCalUid: Any(
-          fetchedCalendarEvents.map((event) => event.iCalUid as string),
-        ),
-      },
-    });
+        const calendarChannelEventAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelEventAssociationWorkspaceEntity>(
+            workspaceId,
+            'calendarChannelEventAssociation',
+          );
 
-    const fetchedCalendarEventsWithDBEvents: FetchedCalendarEventWithDBEvent[] =
-      fetchedCalendarEvents.map((event): FetchedCalendarEventWithDBEvent => {
-        const existingEventWithSameiCalUid = existingCalendarEvents.find(
-          (existingEvent) => existingEvent.iCalUid === event.iCalUid,
-        );
-
-        return {
-          fetchedCalendarEvent: event,
-          existingCalendarEvent: existingEventWithSameiCalUid ?? null,
-          newlyCreatedCalendarEvent: null,
-        };
-      });
-
-    const workspaceDataSource =
-      await this.twentyORMGlobalManager.getDataSourceForWorkspace({
-        workspaceId,
-      });
-
-    await workspaceDataSource.transaction(
-      async (transactionManager: WorkspaceEntityManager) => {
-        const savedCalendarEvents = await calendarEventRepository.save(
-          fetchedCalendarEventsWithDBEvents
-            .filter(
-              ({ existingCalendarEvent }) => existingCalendarEvent === null,
-            )
-            .map(
-              ({ fetchedCalendarEvent }) =>
-                ({
-                  iCalUid: fetchedCalendarEvent.iCalUid,
-                  title: fetchedCalendarEvent.title,
-                  description: fetchedCalendarEvent.description,
-                  startsAt: fetchedCalendarEvent.startsAt,
-                  endsAt: fetchedCalendarEvent.endsAt,
-                  location: fetchedCalendarEvent.location,
-                  isFullDay: fetchedCalendarEvent.isFullDay,
-                  isCanceled: fetchedCalendarEvent.isCanceled,
-                  conferenceSolution: fetchedCalendarEvent.conferenceSolution,
-                  conferenceLink: {
-                    primaryLinkLabel: fetchedCalendarEvent.conferenceLinkLabel,
-                    primaryLinkUrl: fetchedCalendarEvent.conferenceLinkUrl,
-                    secondaryLinks: [],
-                  },
-                  externalCreatedAt: fetchedCalendarEvent.externalCreatedAt,
-                  externalUpdatedAt: fetchedCalendarEvent.externalUpdatedAt,
-                }) satisfies Omit<
-                  CalendarEventWorkspaceEntity,
-                  | 'id'
-                  | 'calendarChannelEventAssociations'
-                  | 'calendarEventParticipants'
-                  | 'createdAt'
-                  | 'updatedAt'
-                  | 'deletedAt'
-                >,
+        const existingCalendarEvents = await calendarEventRepository.find({
+          where: {
+            iCalUid: Any(
+              fetchedCalendarEvents.map((event) => event.iCalUid as string),
             ),
-          {},
-          transactionManager,
-        );
+          },
+        });
 
-        const fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents: FetchedCalendarEventWithDBEvent[] =
-          fetchedCalendarEventsWithDBEvents.map(
-            ({ fetchedCalendarEvent, existingCalendarEvent }) => {
-              const savedCalendarEvent = savedCalendarEvents.find(
-                (savedCalendarEvent) =>
-                  savedCalendarEvent.iCalUid === fetchedCalendarEvent.iCalUid,
+        const fetchedCalendarEventsWithDBEvents: FetchedCalendarEventWithDBEvent[] =
+          fetchedCalendarEvents.map(
+            (event): FetchedCalendarEventWithDBEvent => {
+              const existingEventWithSameiCalUid = existingCalendarEvents.find(
+                (existingEvent) => existingEvent.iCalUid === event.iCalUid,
               );
 
               return {
-                fetchedCalendarEvent,
-                existingCalendarEvent: existingCalendarEvent,
-                newlyCreatedCalendarEvent: savedCalendarEvent ?? null,
+                fetchedCalendarEvent: event,
+                existingCalendarEvent: existingEventWithSameiCalUid ?? null,
+                newlyCreatedCalendarEvent: null,
               };
             },
           );
 
-        await calendarEventRepository.save(
-          fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents
-            .filter(
-              ({ existingCalendarEvent }) => existingCalendarEvent !== null,
-            )
-            .map(({ fetchedCalendarEvent, existingCalendarEvent }) => {
-              if (!existingCalendarEvent) {
-                throw new Error(
-                  `Existing calendar event with iCalUid ${fetchedCalendarEvent.iCalUid} not found - should never happen`,
-                );
-              }
-
-              return {
-                id: existingCalendarEvent.id,
-                iCalUid: fetchedCalendarEvent.iCalUid,
-                title: fetchedCalendarEvent.title,
-                description: fetchedCalendarEvent.description,
-                startsAt: fetchedCalendarEvent.startsAt,
-                endsAt: fetchedCalendarEvent.endsAt,
-                location: fetchedCalendarEvent.location,
-                isFullDay: fetchedCalendarEvent.isFullDay,
-                isCanceled: fetchedCalendarEvent.isCanceled,
-                conferenceSolution: fetchedCalendarEvent.conferenceSolution,
-                conferenceLink: {
-                  primaryLinkLabel: fetchedCalendarEvent.conferenceLinkLabel,
-                  primaryLinkUrl: fetchedCalendarEvent.conferenceLinkUrl,
-                  secondaryLinks: [],
-                },
-                externalCreatedAt: fetchedCalendarEvent.externalCreatedAt,
-                externalUpdatedAt: fetchedCalendarEvent.externalUpdatedAt,
-              } satisfies Omit<
-                CalendarEventWorkspaceEntity,
-                | 'calendarChannelEventAssociations'
-                | 'calendarEventParticipants'
-                | 'createdAt'
-                | 'updatedAt'
-                | 'deletedAt'
-              >;
-            }),
-          {},
-          transactionManager,
-        );
-
-        const calendarChannelEventAssociationsToSave: Pick<
-          CalendarChannelEventAssociationWorkspaceEntity,
-          | 'calendarEventId'
-          | 'eventExternalId'
-          | 'calendarChannelId'
-          | 'recurringEventExternalId'
-        >[] = fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents.map(
-          ({
-            fetchedCalendarEvent,
-            existingCalendarEvent,
-            newlyCreatedCalendarEvent,
-          }) => {
-            const calendarEventId =
-              existingCalendarEvent?.id ?? newlyCreatedCalendarEvent?.id;
-
-            if (!calendarEventId) {
-              throw new Error(
-                `Calendar event id not found for event with iCalUid ${fetchedCalendarEvent.iCalUid} - should never happen`,
-              );
-            }
-
-            return {
-              calendarEventId,
-              eventExternalId: fetchedCalendarEvent.id,
-              calendarChannelId: calendarChannel.id,
-              recurringEventExternalId:
-                fetchedCalendarEvent.recurringEventExternalId ?? '',
-            };
-          },
-        );
-
-        await calendarChannelEventAssociationRepository.save(
-          calendarChannelEventAssociationsToSave,
-          {},
-          transactionManager,
-        );
-
-        const participantsToCreate =
-          fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents
-            .filter(
-              ({ newlyCreatedCalendarEvent }) =>
-                newlyCreatedCalendarEvent !== null,
-            )
-            .flatMap(({ newlyCreatedCalendarEvent, fetchedCalendarEvent }) => {
-              if (!newlyCreatedCalendarEvent?.id) {
-                throw new Error(
-                  `Newly created calendar event with iCalUid ${fetchedCalendarEvent.iCalUid} not found - should never happen`,
-                );
-              }
-
-              return fetchedCalendarEvent.participants.map((participant) => ({
-                ...participant,
-                calendarEventId: newlyCreatedCalendarEvent.id,
-              }));
-            });
-
-        // todo: we should prevent duplicate rows on calendarEventAssociation by creating
-        // an index on calendarChannelId and calendarEventId
-        const participantsToUpdate =
-          fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents
-            .filter(
-              ({ existingCalendarEvent }) => existingCalendarEvent !== null,
-            )
-            .flatMap(({ fetchedCalendarEvent, existingCalendarEvent }) => {
-              if (!existingCalendarEvent?.id) {
-                throw new Error(
-                  `Existing calendar event with iCalUid ${fetchedCalendarEvent.iCalUid} not found - should never happen`,
-                );
-              }
-
-              return fetchedCalendarEvent.participants.map((participant) => ({
-                ...participant,
-                calendarEventId: existingCalendarEvent.id,
-              }));
-            });
-
-        await this.calendarEventParticipantService.upsertAndDeleteCalendarEventParticipants(
-          {
-            participantsToCreate,
-            participantsToUpdate,
-            transactionManager,
-            calendarChannel,
-            connectedAccount,
+        const workspaceDataSource =
+          await this.globalWorkspaceOrmManager.getDataSourceForWorkspace(
             workspaceId,
+          );
+
+        await workspaceDataSource.transaction(
+          async (transactionManager: WorkspaceEntityManager) => {
+            const savedCalendarEvents = await calendarEventRepository.save(
+              fetchedCalendarEventsWithDBEvents
+                .filter(
+                  ({ existingCalendarEvent }) => existingCalendarEvent === null,
+                )
+                .map(
+                  ({ fetchedCalendarEvent }) =>
+                    ({
+                      iCalUid: fetchedCalendarEvent.iCalUid,
+                      title: fetchedCalendarEvent.title,
+                      description: fetchedCalendarEvent.description,
+                      startsAt: fetchedCalendarEvent.startsAt,
+                      endsAt: fetchedCalendarEvent.endsAt,
+                      location: fetchedCalendarEvent.location,
+                      isFullDay: fetchedCalendarEvent.isFullDay,
+                      isCanceled: fetchedCalendarEvent.isCanceled,
+                      conferenceSolution:
+                        fetchedCalendarEvent.conferenceSolution,
+                      conferenceLink: {
+                        primaryLinkLabel:
+                          fetchedCalendarEvent.conferenceLinkLabel,
+                        primaryLinkUrl: fetchedCalendarEvent.conferenceLinkUrl,
+                        secondaryLinks: [],
+                      },
+                      externalCreatedAt: fetchedCalendarEvent.externalCreatedAt,
+                      externalUpdatedAt: fetchedCalendarEvent.externalUpdatedAt,
+                    }) satisfies Omit<
+                      CalendarEventWorkspaceEntity,
+                      | 'id'
+                      | 'calendarChannelEventAssociations'
+                      | 'calendarEventParticipants'
+                      | 'createdAt'
+                      | 'updatedAt'
+                      | 'deletedAt'
+                    >,
+                ),
+              {},
+              transactionManager,
+            );
+
+            const fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents: FetchedCalendarEventWithDBEvent[] =
+              fetchedCalendarEventsWithDBEvents.map(
+                ({ fetchedCalendarEvent, existingCalendarEvent }) => {
+                  const savedCalendarEvent = savedCalendarEvents.find(
+                    (savedCalendarEvent) =>
+                      savedCalendarEvent.iCalUid ===
+                      fetchedCalendarEvent.iCalUid,
+                  );
+
+                  return {
+                    fetchedCalendarEvent,
+                    existingCalendarEvent: existingCalendarEvent,
+                    newlyCreatedCalendarEvent: savedCalendarEvent ?? null,
+                  };
+                },
+              );
+
+            await calendarEventRepository.save(
+              fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents
+                .filter(
+                  ({ existingCalendarEvent }) => existingCalendarEvent !== null,
+                )
+                .map(({ fetchedCalendarEvent, existingCalendarEvent }) => {
+                  if (!existingCalendarEvent) {
+                    throw new Error(
+                      `Existing calendar event with iCalUid ${fetchedCalendarEvent.iCalUid} not found - should never happen`,
+                    );
+                  }
+
+                  return {
+                    id: existingCalendarEvent.id,
+                    iCalUid: fetchedCalendarEvent.iCalUid,
+                    title: fetchedCalendarEvent.title,
+                    description: fetchedCalendarEvent.description,
+                    startsAt: fetchedCalendarEvent.startsAt,
+                    endsAt: fetchedCalendarEvent.endsAt,
+                    location: fetchedCalendarEvent.location,
+                    isFullDay: fetchedCalendarEvent.isFullDay,
+                    isCanceled: fetchedCalendarEvent.isCanceled,
+                    conferenceSolution: fetchedCalendarEvent.conferenceSolution,
+                    conferenceLink: {
+                      primaryLinkLabel:
+                        fetchedCalendarEvent.conferenceLinkLabel,
+                      primaryLinkUrl: fetchedCalendarEvent.conferenceLinkUrl,
+                      secondaryLinks: [],
+                    },
+                    externalCreatedAt: fetchedCalendarEvent.externalCreatedAt,
+                    externalUpdatedAt: fetchedCalendarEvent.externalUpdatedAt,
+                  } satisfies Omit<
+                    CalendarEventWorkspaceEntity,
+                    | 'calendarChannelEventAssociations'
+                    | 'calendarEventParticipants'
+                    | 'createdAt'
+                    | 'updatedAt'
+                    | 'deletedAt'
+                  >;
+                }),
+              {},
+              transactionManager,
+            );
+
+            const calendarChannelEventAssociationsToSave: Pick<
+              CalendarChannelEventAssociationWorkspaceEntity,
+              | 'calendarEventId'
+              | 'eventExternalId'
+              | 'calendarChannelId'
+              | 'recurringEventExternalId'
+            >[] = fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents.map(
+              ({
+                fetchedCalendarEvent,
+                existingCalendarEvent,
+                newlyCreatedCalendarEvent,
+              }) => {
+                const calendarEventId =
+                  existingCalendarEvent?.id ?? newlyCreatedCalendarEvent?.id;
+
+                if (!calendarEventId) {
+                  throw new Error(
+                    `Calendar event id not found for event with iCalUid ${fetchedCalendarEvent.iCalUid} - should never happen`,
+                  );
+                }
+
+                return {
+                  calendarEventId,
+                  eventExternalId: fetchedCalendarEvent.id,
+                  calendarChannelId: calendarChannel.id,
+                  recurringEventExternalId:
+                    fetchedCalendarEvent.recurringEventExternalId ?? '',
+                };
+              },
+            );
+
+            await calendarChannelEventAssociationRepository.save(
+              calendarChannelEventAssociationsToSave,
+              {},
+              transactionManager,
+            );
+
+            const participantsToCreate =
+              fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents
+                .filter(
+                  ({ newlyCreatedCalendarEvent }) =>
+                    newlyCreatedCalendarEvent !== null,
+                )
+                .flatMap(
+                  ({ newlyCreatedCalendarEvent, fetchedCalendarEvent }) => {
+                    if (!newlyCreatedCalendarEvent?.id) {
+                      throw new Error(
+                        `Newly created calendar event with iCalUid ${fetchedCalendarEvent.iCalUid} not found - should never happen`,
+                      );
+                    }
+
+                    return fetchedCalendarEvent.participants.map(
+                      (participant) => ({
+                        ...participant,
+                        calendarEventId: newlyCreatedCalendarEvent.id,
+                      }),
+                    );
+                  },
+                );
+
+            // todo: we should prevent duplicate rows on calendarEventAssociation by creating
+            // an index on calendarChannelId and calendarEventId
+            const participantsToUpdate =
+              fetchedCalendarEventsWithDBEventsEnrichedWithSavedEvents
+                .filter(
+                  ({ existingCalendarEvent }) => existingCalendarEvent !== null,
+                )
+                .flatMap(({ fetchedCalendarEvent, existingCalendarEvent }) => {
+                  if (!existingCalendarEvent?.id) {
+                    throw new Error(
+                      `Existing calendar event with iCalUid ${fetchedCalendarEvent.iCalUid} not found - should never happen`,
+                    );
+                  }
+
+                  return fetchedCalendarEvent.participants.map(
+                    (participant) => ({
+                      ...participant,
+                      calendarEventId: existingCalendarEvent.id,
+                    }),
+                  );
+                });
+
+            await this.calendarEventParticipantService.upsertAndDeleteCalendarEventParticipants(
+              {
+                participantsToCreate,
+                participantsToUpdate,
+                transactionManager,
+                calendarChannel,
+                connectedAccount,
+                workspaceId,
+              },
+            );
           },
         );
       },

packages/twenty-server/src/modules/calendar/calendar-event-participant-manager/services/calendar-event-participant.service.ts

@@ -10,7 +10,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 CalendarChannelWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
 import { type CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-event-participant.workspace-entity';
 import { type FetchedCalendarEventParticipant } from 'src/modules/calendar/common/types/fetched-calendar-event';
@@ -34,7 +35,7 @@ type FetchedCalendarEventParticipantWithCalendarEventIdAndExistingId =
 @Injectable()
 export class CalendarEventParticipantService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     private readonly matchParticipantService: MatchParticipantService<CalendarEventParticipantWorkspaceEntity>,
     @InjectMessageQueue(MessageQueue.contactCreationQueue)
     private readonly messageQueueService: MessageQueueService,
@@ -55,125 +56,133 @@ export class CalendarEventParticipantService {
     connectedAccount: ConnectedAccountWorkspaceEntity;
     workspaceId: string;
   }): Promise<void> {
-    const chunkedParticipantsToUpdate = chunk(participantsToUpdate, 200);
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const calendarEventParticipantRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarEventParticipantWorkspaceEntity>(
-        workspaceId,
-        'calendarEventParticipant',
-      );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const chunkedParticipantsToUpdate = chunk(participantsToUpdate, 200);
 
-    for (const participantsToUpdateChunk of chunkedParticipantsToUpdate) {
-      const existingCalendarEventParticipants =
-        await calendarEventParticipantRepository.find({
-          where: {
-            calendarEventId: Any(
-              participantsToUpdateChunk
-                .map((participant) => participant.calendarEventId)
-                .filter(isDefined),
-            ),
-          },
-        });
+        const calendarEventParticipantRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarEventParticipantWorkspaceEntity>(
+            workspaceId,
+            'calendarEventParticipant',
+          );
 
-      const {
-        calendarEventParticipantsToUpdate,
-        newCalendarEventParticipants,
-      } = participantsToUpdateChunk.reduce<{
-        calendarEventParticipantsToUpdate: FetchedCalendarEventParticipantWithCalendarEventIdAndExistingId[];
-        newCalendarEventParticipants: FetchedCalendarEventParticipantWithCalendarEventId[];
-      }>(
-        (acc, calendarEventParticipant) => {
-          const existingCalendarEventParticipant =
-            existingCalendarEventParticipants.find(
-              (existingCalendarEventParticipant) =>
-                existingCalendarEventParticipant.handle ===
-                  calendarEventParticipant.handle &&
-                existingCalendarEventParticipant.calendarEventId ===
-                  calendarEventParticipant.calendarEventId,
+        for (const participantsToUpdateChunk of chunkedParticipantsToUpdate) {
+          const existingCalendarEventParticipants =
+            await calendarEventParticipantRepository.find({
+              where: {
+                calendarEventId: Any(
+                  participantsToUpdateChunk
+                    .map((participant) => participant.calendarEventId)
+                    .filter(isDefined),
+                ),
+              },
+            });
+
+          const {
+            calendarEventParticipantsToUpdate,
+            newCalendarEventParticipants,
+          } = participantsToUpdateChunk.reduce<{
+            calendarEventParticipantsToUpdate: FetchedCalendarEventParticipantWithCalendarEventIdAndExistingId[];
+            newCalendarEventParticipants: FetchedCalendarEventParticipantWithCalendarEventId[];
+          }>(
+            (acc, calendarEventParticipant) => {
+              const existingCalendarEventParticipant =
+                existingCalendarEventParticipants.find(
+                  (existingCalendarEventParticipant) =>
+                    existingCalendarEventParticipant.handle ===
+                      calendarEventParticipant.handle &&
+                    existingCalendarEventParticipant.calendarEventId ===
+                      calendarEventParticipant.calendarEventId,
+                );
+
+              if (existingCalendarEventParticipant) {
+                acc.calendarEventParticipantsToUpdate.push({
+                  ...calendarEventParticipant,
+                  id: existingCalendarEventParticipant.id,
+                });
+              } else {
+                acc.newCalendarEventParticipants.push(calendarEventParticipant);
+              }
+
+              return acc;
+            },
+            {
+              calendarEventParticipantsToUpdate: [],
+              newCalendarEventParticipants: [],
+            },
+          );
+
+          const calendarEventParticipantsToDelete = differenceWith(
+            existingCalendarEventParticipants,
+            participantsToUpdateChunk,
+            (existingCalendarEventParticipant, participantToUpdate) =>
+              existingCalendarEventParticipant.handle ===
+                participantToUpdate.handle &&
+              existingCalendarEventParticipant.calendarEventId ===
+                participantToUpdate.calendarEventId,
+          );
+
+          await calendarEventParticipantRepository.delete(
+            {
+              id: Any(
+                calendarEventParticipantsToDelete.map(
+                  (calendarEventParticipant) => calendarEventParticipant.id,
+                ),
+              ),
+            },
+            transactionManager,
+          );
+
+          await calendarEventParticipantRepository.updateMany(
+            calendarEventParticipantsToUpdate.map((participant) => ({
+              criteria: participant.id,
+              partialEntity: participant,
+            })),
+            transactionManager,
+          );
+          participantsToCreate.push(...newCalendarEventParticipants);
+        }
+
+        const chunkedParticipantsToCreate = chunk(participantsToCreate, 200);
+        const savedParticipants: CalendarEventParticipantWorkspaceEntity[] = [];
+
+        for (const participantsToCreateChunk of chunkedParticipantsToCreate) {
+          const savedParticipantsChunk =
+            await calendarEventParticipantRepository.insert(
+              participantsToCreateChunk,
+              transactionManager,
             );
 
-          if (existingCalendarEventParticipant) {
-            acc.calendarEventParticipantsToUpdate.push({
-              ...calendarEventParticipant,
-              id: existingCalendarEventParticipant.id,
-            });
-          } else {
-            acc.newCalendarEventParticipants.push(calendarEventParticipant);
-          }
+          savedParticipants.push(...savedParticipantsChunk.raw);
+        }
 
-          return acc;
-        },
-        {
-          calendarEventParticipantsToUpdate: [],
-          newCalendarEventParticipants: [],
-        },
-      );
+        if (calendarChannel.isContactAutoCreationEnabled) {
+          await this.messageQueueService.add<CreateCompanyAndContactJobData>(
+            CreateCompanyAndContactJob.name,
+            {
+              workspaceId,
+              connectedAccount,
+              contactsToCreate: savedParticipants.map((participant) => ({
+                handle: participant.handle ?? '',
+                displayName:
+                  participant.displayName ?? participant.handle ?? '',
+              })),
+              source: FieldActorSource.CALENDAR,
+            },
+          );
+        }
 
-      const calendarEventParticipantsToDelete = differenceWith(
-        existingCalendarEventParticipants,
-        participantsToUpdateChunk,
-        (existingCalendarEventParticipant, participantToUpdate) =>
-          existingCalendarEventParticipant.handle ===
-            participantToUpdate.handle &&
-          existingCalendarEventParticipant.calendarEventId ===
-            participantToUpdate.calendarEventId,
-      );
-
-      await calendarEventParticipantRepository.delete(
-        {
-          id: Any(
-            calendarEventParticipantsToDelete.map(
-              (calendarEventParticipant) => calendarEventParticipant.id,
-            ),
-          ),
-        },
-        transactionManager,
-      );
-
-      await calendarEventParticipantRepository.updateMany(
-        calendarEventParticipantsToUpdate.map((participant) => ({
-          criteria: participant.id,
-          partialEntity: participant,
-        })),
-        transactionManager,
-      );
-      participantsToCreate.push(...newCalendarEventParticipants);
-    }
-
-    const chunkedParticipantsToCreate = chunk(participantsToCreate, 200);
-    const savedParticipants: CalendarEventParticipantWorkspaceEntity[] = [];
-
-    for (const participantsToCreateChunk of chunkedParticipantsToCreate) {
-      const savedParticipantsChunk =
-        await calendarEventParticipantRepository.insert(
-          participantsToCreateChunk,
+        await this.matchParticipantService.matchParticipants({
+          participants: savedParticipants,
+          objectMetadataName: 'calendarEventParticipant',
           transactionManager,
-        );
-
-      savedParticipants.push(...savedParticipantsChunk.raw);
-    }
-
-    if (calendarChannel.isContactAutoCreationEnabled) {
-      await this.messageQueueService.add<CreateCompanyAndContactJobData>(
-        CreateCompanyAndContactJob.name,
-        {
+          matchWith: 'workspaceMemberAndPerson',
           workspaceId,
-          connectedAccount,
-          contactsToCreate: savedParticipants.map((participant) => ({
-            handle: participant.handle ?? '',
-            displayName: participant.displayName ?? participant.handle ?? '',
-          })),
-          source: FieldActorSource.CALENDAR,
-        },
-      );
-    }
-
-    await this.matchParticipantService.matchParticipants({
-      participants: savedParticipants,
-      objectMetadataName: 'calendarEventParticipant',
-      transactionManager,
-      matchWith: 'workspaceMemberAndPerson',
-      workspaceId,
-    });
+        });
+      },
+    );
   }
 }

packages/twenty-server/src/modules/calendar/common/query-hooks/calendar-event/services/apply-calendar-events-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 { CalendarChannelVisibility } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
 import { type CalendarEventWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-event.workspace-entity';
 
@@ -52,20 +52,21 @@ describe('ApplyCalendarEventsVisibilityRestrictionsService', () => {
     findOneByOrFail: jest.fn(),
   };
 
-  const mockTwentyORMGlobalManager = {
-    getRepositoryForWorkspace: jest
+  const mockGlobalWorkspaceOrmManager = {
+    getRepository: jest.fn().mockImplementation((workspaceId, name) => {
+      if (name === 'calendarChannelEventAssociation') {
+        return mockCalendarEventAssociationRepository;
+      }
+      if (name === 'connectedAccount') {
+        return mockConnectedAccountRepository;
+      }
+      if (name === 'workspaceMember') {
+        return mockWorkspaceMemberRepository;
+      }
+    }),
+    executeInWorkspaceContext: jest
       .fn()
-      .mockImplementation((workspaceId, name) => {
-        if (name === 'calendarChannelEventAssociation') {
-          return mockCalendarEventAssociationRepository;
-        }
-        if (name === 'connectedAccount') {
-          return mockConnectedAccountRepository;
-        }
-        if (name === 'workspaceMember') {
-          return mockWorkspaceMemberRepository;
-        }
-      }),
+      .mockImplementation((_authContext: any, fn: () => any) => fn()),
   };
 
   beforeEach(async () => {
@@ -73,8 +74,8 @@ describe('ApplyCalendarEventsVisibilityRestrictionsService', () => {
       providers: [
         ApplyCalendarEventsVisibilityRestrictionsService,
         {
-          provide: TwentyORMGlobalManager,
-          useValue: mockTwentyORMGlobalManager,
+          provide: GlobalWorkspaceOrmManager,
+          useValue: mockGlobalWorkspaceOrmManager,
         },
       ],
     }).compile();

packages/twenty-server/src/modules/calendar/common/query-hooks/calendar-event/services/apply-calendar-events-visibility-restrictions.service.ts

@@ -5,7 +5,8 @@ import { FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED } from 'twenty-shared/
 import { isDefined } from 'twenty-shared/utils';
 import { In } from 'typeorm';
 
-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 CalendarChannelEventAssociationWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-channel-event-association.workspace-entity';
 import { CalendarChannelVisibility } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
 import { type CalendarEventWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-event.workspace-entity';
@@ -15,7 +16,7 @@ import { WorkspaceMemberWorkspaceEntity } from 'src/modules/workspace-member/sta
 @Injectable()
 export class ApplyCalendarEventsVisibilityRestrictionsService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
   ) {}
 
   public async applyCalendarEventsVisibilityRestrictions(
@@ -23,90 +24,99 @@ export class ApplyCalendarEventsVisibilityRestrictionsService {
     workspaceId: string,
     userId?: string, // undefined when request is made with api key
   ) {
-    const calendarChannelEventAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelEventAssociationWorkspaceEntity>(
-        workspaceId,
-        'calendarChannelEventAssociation',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const calendarChannelCalendarEventsAssociations =
-      await calendarChannelEventAssociationRepository.find({
-        where: {
-          calendarEventId: In(calendarEvents.map((event) => event.id)),
-        },
-        relations: ['calendarChannel'],
-      });
+    return this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelEventAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelEventAssociationWorkspaceEntity>(
+            workspaceId,
+            'calendarChannelEventAssociation',
+          );
 
-    const connectedAccountRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<ConnectedAccountWorkspaceEntity>(
-        workspaceId,
-        'connectedAccount',
-      );
-
-    const workspaceMemberRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<WorkspaceMemberWorkspaceEntity>(
-        workspaceId,
-        'workspaceMember',
-      );
-
-    for (let i = calendarEvents.length - 1; i >= 0; i--) {
-      const calendarChannelCalendarEventAssociations =
-        calendarChannelCalendarEventsAssociations.filter(
-          (association) => association.calendarEventId === calendarEvents[i].id,
-        );
-
-      const calendarChannels = calendarChannelCalendarEventAssociations.map(
-        (association) => association.calendarChannel,
-      );
-
-      const calendarChannelsGroupByVisibility = groupBy(
-        calendarChannels,
-        (channel) => channel.visibility,
-      );
-
-      if (
-        calendarChannelsGroupByVisibility[
-          CalendarChannelVisibility.SHARE_EVERYTHING
-        ]
-      ) {
-        continue;
-      }
-
-      if (isDefined(userId)) {
-        const workspaceMember = await workspaceMemberRepository.findOneByOrFail(
-          {
-            userId: userId,
-          },
-        );
-
-        const connectedAccounts = await connectedAccountRepository.find({
-          select: ['id'],
-          where: {
-            calendarChannels: {
-              id: In(calendarChannels.map((channel) => channel.id)),
+        const calendarChannelCalendarEventsAssociations =
+          await calendarChannelEventAssociationRepository.find({
+            where: {
+              calendarEventId: In(calendarEvents.map((event) => event.id)),
             },
-            accountOwnerId: workspaceMember.id,
-          },
-        });
+            relations: ['calendarChannel'],
+          });
 
-        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 = calendarEvents.length - 1; i >= 0; i--) {
+          const calendarChannelCalendarEventAssociations =
+            calendarChannelCalendarEventsAssociations.filter(
+              (association) =>
+                association.calendarEventId === calendarEvents[i].id,
+            );
+
+          const calendarChannels = calendarChannelCalendarEventAssociations.map(
+            (association) => association.calendarChannel,
+          );
+
+          const calendarChannelsGroupByVisibility = groupBy(
+            calendarChannels,
+            (channel) => channel.visibility,
+          );
+
+          if (
+            calendarChannelsGroupByVisibility[
+              CalendarChannelVisibility.SHARE_EVERYTHING
+            ]
+          ) {
+            continue;
+          }
+
+          if (isDefined(userId)) {
+            const workspaceMember =
+              await workspaceMemberRepository.findOneByOrFail({
+                userId: userId,
+              });
+
+            const connectedAccounts = await connectedAccountRepository.find({
+              select: ['id'],
+              where: {
+                calendarChannels: {
+                  id: In(calendarChannels.map((channel) => channel.id)),
+                },
+                accountOwnerId: workspaceMember.id,
+              },
+            });
+
+            if (connectedAccounts.length > 0) {
+              continue;
+            }
+          }
+
+          if (
+            calendarChannelsGroupByVisibility[
+              CalendarChannelVisibility.METADATA
+            ]
+          ) {
+            calendarEvents[i].title =
+              FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
+            calendarEvents[i].description =
+              FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
+            continue;
+          }
+
+          calendarEvents.splice(i, 1);
         }
-      }
 
-      if (
-        calendarChannelsGroupByVisibility[CalendarChannelVisibility.METADATA]
-      ) {
-        calendarEvents[i].title =
-          FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
-        calendarEvents[i].description =
-          FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED;
-        continue;
-      }
-
-      calendarEvents.splice(i, 1);
-    }
-
-    return calendarEvents;
+        return calendarEvents;
+      },
+    );
   }
 }

packages/twenty-server/src/modules/calendar/common/services/calendar-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 {
   CalendarChannelSyncStage,
   CalendarChannelSyncStatus,
@@ -20,7 +21,7 @@ import { AccountsToReconnectKeys } from 'src/modules/connected-account/types/acc
 @Injectable()
 export class CalendarChannelSyncStatusService {
   constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
     @InjectCacheStorage(CacheStorageNamespace.ModuleCalendar)
     private readonly cacheStorage: CacheStorageService,
     private readonly accountsToReconnectService: AccountsToReconnectService,
@@ -36,16 +37,23 @@ export class CalendarChannelSyncStatusService {
       return;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
-      ...(!preserveSyncStageStartedAt ? { syncStageStartedAt: null } : {}),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
+          ...(!preserveSyncStageStartedAt ? { syncStageStartedAt: null } : {}),
+        });
+      },
+    );
   }
 
   public async markAsCalendarEventListFetchOngoing(
@@ -56,17 +64,24 @@ export class CalendarChannelSyncStatusService {
       return;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_ONGOING,
-      syncStatus: CalendarChannelSyncStatus.ONGOING,
-      syncStageStartedAt: new Date().toISOString(),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_ONGOING,
+          syncStatus: CalendarChannelSyncStatus.ONGOING,
+          syncStageStartedAt: new Date().toISOString(),
+        });
+      },
+    );
   }
 
   public async resetAndMarkAsCalendarEventListFetchPending(
@@ -83,17 +98,24 @@ export class CalendarChannelSyncStatusService {
       );
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncCursor: '',
-      syncStageStartedAt: null,
-      throttleFailureCount: 0,
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncCursor: '',
+          syncStageStartedAt: null,
+          throttleFailureCount: 0,
+        });
+      },
+    );
 
     await this.markAsCalendarEventListFetchPending(
       calendarChannelIds,
@@ -109,15 +131,22 @@ export class CalendarChannelSyncStatusService {
       return;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncStageStartedAt: null,
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncStageStartedAt: null,
+        });
+      },
+    );
   }
 
   public async markAsCalendarEventsImportPending(
@@ -129,16 +158,23 @@ export class CalendarChannelSyncStatusService {
       return;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncStage: CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_PENDING,
-      ...(!preserveSyncStageStartedAt ? { syncStageStartedAt: null } : {}),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncStage: CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_PENDING,
+          ...(!preserveSyncStageStartedAt ? { syncStageStartedAt: null } : {}),
+        });
+      },
+    );
   }
 
   public async markAsCalendarEventsImportOngoing(
@@ -149,16 +185,23 @@ export class CalendarChannelSyncStatusService {
       return;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncStage: CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_ONGOING,
-      syncStatus: CalendarChannelSyncStatus.ONGOING,
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncStage: CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_ONGOING,
+          syncStatus: CalendarChannelSyncStatus.ONGOING,
+        });
+      },
+    );
   }
 
   public async markAsCompletedAndMarkAsCalendarEventListFetchPending(
@@ -169,19 +212,26 @@ export class CalendarChannelSyncStatusService {
       return;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
-      syncStatus: CalendarChannelSyncStatus.ACTIVE,
-      throttleFailureCount: 0,
-      syncStageStartedAt: null,
-      syncedAt: new Date().toISOString(),
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_PENDING,
+          syncStatus: CalendarChannelSyncStatus.ACTIVE,
+          throttleFailureCount: 0,
+          syncStageStartedAt: null,
+          syncedAt: new Date().toISOString(),
+        });
+      },
+    );
 
     await this.markAsCalendarEventListFetchPending(
       calendarChannelIds,
@@ -202,22 +252,29 @@ export class CalendarChannelSyncStatusService {
       return;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
-
     for (const calendarChannelId of calendarChannelIds) {
       await this.cacheStorage.del(
         `calendar-events-to-import:${workspaceId}:${calendarChannelId}`,
       );
     }
 
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncStatus: CalendarChannelSyncStatus.FAILED_UNKNOWN,
-      syncStage: CalendarChannelSyncStage.FAILED,
-    });
+    const authContext = buildSystemAuthContext(workspaceId);
+
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
+
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncStatus: CalendarChannelSyncStatus.FAILED_UNKNOWN,
+          syncStage: CalendarChannelSyncStage.FAILED,
+        });
+      },
+    );
 
     await this.metricsService.batchIncrementCounter({
       key: MetricsKeys.CalendarEventSyncJobFailedUnknown,
@@ -233,49 +290,57 @@ export class CalendarChannelSyncStatusService {
       return;
     }
 
-    const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
-        workspaceId,
-        'calendarChannel',
-      );
-
     for (const calendarChannelId of calendarChannelIds) {
       await this.cacheStorage.del(
         `calendar-events-to-import:${workspaceId}:${calendarChannelId}`,
       );
     }
-    await calendarChannelRepository.update(calendarChannelIds, {
-      syncStatus: CalendarChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS,
-      syncStage: CalendarChannelSyncStage.FAILED,
-    });
 
-    const connectedAccountRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<ConnectedAccountWorkspaceEntity>(
-        workspaceId,
-        'connectedAccount',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);
 
-    const calendarChannels = await calendarChannelRepository.find({
-      select: ['id', 'connectedAccountId'],
-      where: { id: Any(calendarChannelIds) },
-    });
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const calendarChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
+            workspaceId,
+            'calendarChannel',
+          );
 
-    const connectedAccountIds = calendarChannels.map(
-      (calendarChannel) => calendarChannel.connectedAccountId,
-    );
+        await calendarChannelRepository.update(calendarChannelIds, {
+          syncStatus: CalendarChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS,
+          syncStage: CalendarChannelSyncStage.FAILED,
+        });
 
-    await connectedAccountRepository.update(
-      { id: Any(connectedAccountIds) },
-      {
-        authFailedAt: new Date(),
+        const connectedAccountRepository =
+          await this.globalWorkspaceOrmManager.getRepository<ConnectedAccountWorkspaceEntity>(
+            workspaceId,
+            'connectedAccount',
+          );
+
+        const calendarChannels = await calendarChannelRepository.find({
+          select: ['id', 'connectedAccountId'],
+          where: { id: Any(calendarChannelIds) },
+        });
+
+        const connectedAccountIds = calendarChannels.map(
+          (calendarChannel) => calendarChannel.connectedAccountId,
+        );
+
+        await connectedAccountRepository.update(
+          { id: Any(connectedAccountIds) },
+          {
+            authFailedAt: new Date(),
+          },
+        );
+
+        await this.addToAccountsToReconnect(
+          calendarChannels.map((calendarChannel) => calendarChannel.id),
+          workspaceId,
+        );
       },
     );
 
-    await this.addToAccountsToReconnect(
-      calendarChannels.map((calendarChannel) => calendarChannel.id),
-      workspaceId,
-    );
-
     await this.metricsService.batchIncrementCounter({
       key: MetricsKeys.CalendarEventSyncJobFailedInsufficientPermissions,
       eventIds: calendarChannelIds,
@@ -291,7 +356,7 @@ export class CalendarChannelSyncStatusService {
     }
 
     const calendarChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<CalendarChannelWorkspaceEntity>(
+      await this.globalWorkspaceOrmManager.getRepository<CalendarChannelWorkspaceEntity>(
         workspaceId,
         'calendarChannel',
       );