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.
2025-12-10 17:17:33 +01:00
parent 4f13022774
commit 9bd8f94b3a
203 changed files with 8887 additions and 7237 deletions
@@ -1,14 +1,15 @@
 import { Scope } from '@nestjs/common';

+import { MessageParticipantRole } from 'twenty-shared/types';
 import { isDefined } from 'twenty-shared/utils';
 import { And, Any, ILike, In, Not, Or } from 'typeorm';
-import { MessageParticipantRole } from 'twenty-shared/types';

 import { type ObjectRecordCreateEvent } from 'src/engine/core-modules/event-emitter/types/object-record-create.event';
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
 import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
 import { type MessageChannelMessageAssociationWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-channel-message-association.workspace-entity';
@@ -26,132 +27,141 @@ export type BlocklistItemDeleteMessagesJobData = WorkspaceEventBatch<
 export class BlocklistItemDeleteMessagesJob {
  constructor(
    private readonly threadCleanerService: MessagingMessageCleanerService,
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
  ) {}

  @Process(BlocklistItemDeleteMessagesJob.name)
  async handle(data: BlocklistItemDeleteMessagesJobData): Promise<void> {
    const workspaceId = data.workspaceId;

-    const blocklistItemIds = data.events.map(
-      (eventPayload) => eventPayload.recordId,
-    );
+    const authContext = buildSystemAuthContext(workspaceId);

-    const blocklistRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<BlocklistWorkspaceEntity>(
-        workspaceId,
-        'blocklist',
-      );
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const blocklistItemIds = data.events.map(
+          (eventPayload) => eventPayload.recordId,
+        );

-    const blocklist = await blocklistRepository.find({
-      where: {
-        id: Any(blocklistItemIds),
-      },
-    });
-
-    const handlesToDeleteByWorkspaceMemberIdMap = blocklist.reduce(
-      (acc, blocklistItem) => {
-        const { handle, workspaceMemberId } = blocklistItem;
-
-        if (!acc.has(workspaceMemberId)) {
-          acc.set(workspaceMemberId, []);
-        }
-
-        if (!isDefined(handle)) {
-          return acc;
-        }
-
-        acc.get(workspaceMemberId)?.push(handle);
-
-        return acc;
-      },
-      new Map<string, string[]>(),
-    );
-
-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
-
-    const messageChannelMessageAssociationRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelMessageAssociationWorkspaceEntity>(
-        workspaceId,
-        'messageChannelMessageAssociation',
-      );
-
-    for (const workspaceMemberId of handlesToDeleteByWorkspaceMemberIdMap.keys()) {
-      const handles =
-        handlesToDeleteByWorkspaceMemberIdMap.get(workspaceMemberId);
-
-      if (!handles) {
-        continue;
-      }
-
-      const rolesToDelete = [
-        MessageParticipantRole.FROM,
-        MessageParticipantRole.TO,
-      ] as const;
-
-      const messageChannels = await messageChannelRepository.find({
-        select: {
-          id: true,
-          handle: true,
-          connectedAccount: {
-            handleAliases: true,
-          },
-        },
-        where: {
-          connectedAccount: {
-            accountOwnerId: workspaceMemberId,
-          },
-        },
-        relations: ['connectedAccount'],
-      });
-
-      for (const messageChannel of messageChannels) {
-        const messageChannelHandles = [messageChannel.handle];
-
-        if (messageChannel.connectedAccount.handleAliases) {
-          messageChannelHandles.push(
-            ...messageChannel.connectedAccount.handleAliases.split(','),
+        const blocklistRepository =
+          await this.globalWorkspaceOrmManager.getRepository<BlocklistWorkspaceEntity>(
+            workspaceId,
+            'blocklist',
          );
-        }

-        const handleConditions = handles.map((handle) => {
-          const isHandleDomain = handle.startsWith('@');
-
-          return isHandleDomain
-            ? {
-                handle: And(
-                  Or(ILike(`%${handle}`), ILike(`%.${handle.slice(1)}`)),
-                  Not(In(messageChannelHandles)),
-                ),
-                role: In(rolesToDelete),
-              }
-            : { handle, role: In(rolesToDelete) };
+        const blocklist = await blocklistRepository.find({
+          where: {
+            id: Any(blocklistItemIds),
+          },
        });

-        const messageChannelMessageAssociationsToDelete =
-          await messageChannelMessageAssociationRepository.find({
-            where: {
-              messageChannelId: messageChannel.id,
-              message: {
-                messageParticipants: handleConditions,
+        const handlesToDeleteByWorkspaceMemberIdMap = blocklist.reduce(
+          (acc, blocklistItem) => {
+            const { handle, workspaceMemberId } = blocklistItem;
+
+            if (!acc.has(workspaceMemberId)) {
+              acc.set(workspaceMemberId, []);
+            }
+
+            if (!isDefined(handle)) {
+              return acc;
+            }
+
+            acc.get(workspaceMemberId)?.push(handle);
+
+            return acc;
+          },
+          new Map<string, string[]>(),
+        );
+
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );
+
+        const messageChannelMessageAssociationRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelMessageAssociationWorkspaceEntity>(
+            workspaceId,
+            'messageChannelMessageAssociation',
+          );
+
+        for (const workspaceMemberId of handlesToDeleteByWorkspaceMemberIdMap.keys()) {
+          const handles =
+            handlesToDeleteByWorkspaceMemberIdMap.get(workspaceMemberId);
+
+          if (!handles) {
+            continue;
+          }
+
+          const rolesToDelete = [
+            MessageParticipantRole.FROM,
+            MessageParticipantRole.TO,
+          ] as const;
+
+          const messageChannels = await messageChannelRepository.find({
+            select: {
+              id: true,
+              handle: true,
+              connectedAccount: {
+                handleAliases: true,
              },
            },
+            where: {
+              connectedAccount: {
+                accountOwnerId: workspaceMemberId,
+              },
+            },
+            relations: ['connectedAccount'],
          });

-        if (messageChannelMessageAssociationsToDelete.length === 0) {
-          continue;
+          for (const messageChannel of messageChannels) {
+            const messageChannelHandles = [messageChannel.handle];
+
+            if (messageChannel.connectedAccount.handleAliases) {
+              messageChannelHandles.push(
+                ...messageChannel.connectedAccount.handleAliases.split(','),
+              );
+            }
+
+            const handleConditions = handles.map((handle) => {
+              const isHandleDomain = handle.startsWith('@');
+
+              return isHandleDomain
+                ? {
+                    handle: And(
+                      Or(ILike(`%${handle}`), ILike(`%.${handle.slice(1)}`)),
+                      Not(In(messageChannelHandles)),
+                    ),
+                    role: In(rolesToDelete),
+                  }
+                : { handle, role: In(rolesToDelete) };
+            });
+
+            const messageChannelMessageAssociationsToDelete =
+              await messageChannelMessageAssociationRepository.find({
+                where: {
+                  messageChannelId: messageChannel.id,
+                  message: {
+                    messageParticipants: handleConditions,
+                  },
+                },
+              });
+
+            if (messageChannelMessageAssociationsToDelete.length === 0) {
+              continue;
+            }
+
+            await messageChannelMessageAssociationRepository.delete(
+              messageChannelMessageAssociationsToDelete.map(({ id }) => id),
+            );
+          }
        }

-        await messageChannelMessageAssociationRepository.delete(
-          messageChannelMessageAssociationsToDelete.map(({ id }) => id),
+        await this.threadCleanerService.cleanOrphanMessagesAndThreads(
+          workspaceId,
        );
-      }
-    }
-
-    await this.threadCleanerService.cleanOrphanMessagesAndThreads(workspaceId);
+      },
+    );
  }
 }
@@ -6,7 +6,8 @@ import { type ObjectRecordDeleteEvent } from 'src/engine/core-modules/event-emit
 import { Process } from 'src/engine/core-modules/message-queue/decorators/process.decorator';
 import { Processor } from 'src/engine/core-modules/message-queue/decorators/processor.decorator';
 import { MessageQueue } from 'src/engine/core-modules/message-queue/message-queue.constants';
-import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { GlobalWorkspaceOrmManager } from 'src/engine/twenty-orm/global-workspace-datasource/global-workspace-orm.manager';
+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';
 import { type WorkspaceEventBatch } from 'src/engine/workspace-event-emitter/types/workspace-event-batch.type';
 import { type BlocklistWorkspaceEntity } from 'src/modules/blocklist/standard-objects/blocklist.workspace-entity';
 import { MessageChannelSyncStatusService } from 'src/modules/messaging/common/services/message-channel-sync-status.service';
@@ -25,7 +26,7 @@ export type BlocklistReimportMessagesJobData = WorkspaceEventBatch<
 })
 export class BlocklistReimportMessagesJob {
  constructor(
-    private readonly twentyORMGlobalManager: TwentyORMGlobalManager,
+    private readonly globalWorkspaceOrmManager: GlobalWorkspaceOrmManager,
    private readonly messagingChannelSyncStatusService: MessageChannelSyncStatusService,
  ) {}

@@ -33,30 +34,39 @@ export class BlocklistReimportMessagesJob {
  async handle(data: BlocklistReimportMessagesJobData): Promise<void> {
    const workspaceId = data.workspaceId;

-    const messageChannelRepository =
-      await this.twentyORMGlobalManager.getRepositoryForWorkspace<MessageChannelWorkspaceEntity>(
-        workspaceId,
-        'messageChannel',
-      );
+    const authContext = buildSystemAuthContext(workspaceId);

-    for (const eventPayload of data.events) {
-      const workspaceMemberId =
-        eventPayload.properties.before.workspaceMemberId;
+    await this.globalWorkspaceOrmManager.executeInWorkspaceContext(
+      authContext,
+      async () => {
+        const messageChannelRepository =
+          await this.globalWorkspaceOrmManager.getRepository<MessageChannelWorkspaceEntity>(
+            workspaceId,
+            'messageChannel',
+          );

-      const messageChannels = await messageChannelRepository.find({
-        select: ['id'],
-        where: {
-          connectedAccount: {
-            accountOwnerId: workspaceMemberId,
-          },
-          syncStage: Not(MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING),
-        },
-      });
+        for (const eventPayload of data.events) {
+          const workspaceMemberId =
+            eventPayload.properties.before.workspaceMemberId;

-      await this.messagingChannelSyncStatusService.resetAndMarkAsMessagesListFetchPending(
-        messageChannels.map((messageChannel) => messageChannel.id),
-        workspaceId,
-      );
-    }
+          const messageChannels = await messageChannelRepository.find({
+            select: ['id'],
+            where: {
+              connectedAccount: {
+                accountOwnerId: workspaceMemberId,
+              },
+              syncStage: Not(
+                MessageChannelSyncStage.MESSAGE_LIST_FETCH_PENDING,
+              ),
+            },
+          });
+
+          await this.messagingChannelSyncStatusService.resetAndMarkAsMessagesListFetchPending(
+            messageChannels.map((messageChannel) => messageChannel.id),
+            workspaceId,
+          );
+        }
+      },
+    );
  }
 }