Use twentyORM in Timeline messaging

packages/twenty-server/src/engine/core-modules/messaging/dtos/timeline-thread-participant.dto.ts

@@ -1,14 +1,14 @@
-import { ObjectType, Field } from '@nestjs/graphql';
+import { Field, ObjectType } from '@nestjs/graphql';
 
 import { UUIDScalarType } from 'src/engine/api/graphql/workspace-schema-builder/graphql-types/scalars';
 
 @ObjectType('TimelineThreadParticipant')
 export class TimelineThreadParticipant {
   @Field(() => UUIDScalarType, { nullable: true })
-  personId: string;
+  personId: string | null;
 
   @Field(() => UUIDScalarType, { nullable: true })
-  workspaceMemberId: string;
+  workspaceMemberId: string | null;
 
   @Field()
   firstName: string;

packages/twenty-server/src/engine/core-modules/messaging/services/get-messages-from-company-id.service.ts

@@ -0,0 +1,54 @@
+import { Injectable } from '@nestjs/common';
+
+import { TIMELINE_THREADS_DEFAULT_PAGE_SIZE } from 'src/engine/core-modules/messaging/constants/messaging.constants';
+import { TimelineThreadsWithTotal } from 'src/engine/core-modules/messaging/dtos/timeline-threads-with-total.dto';
+import { GetMessagesFromPersonIdsService } from 'src/engine/core-modules/messaging/services/get-messages-from-person-ids.service';
+import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
+import { PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
+
+@Injectable()
+export class GetMessagesFromCompanyIdService {
+  constructor(
+    private readonly twentyORMManager: TwentyORMManager,
+    private readonly getMessagesFromPersonIdsService: GetMessagesFromPersonIdsService,
+  ) {}
+
+  async getMessagesFromCompanyId(
+    workspaceMemberId: string,
+    companyId: string,
+    page = 1,
+    pageSize: number = TIMELINE_THREADS_DEFAULT_PAGE_SIZE,
+  ): Promise<TimelineThreadsWithTotal> {
+    const personRepository =
+      await this.twentyORMManager.getRepository<PersonWorkspaceEntity>(
+        'person',
+      );
+    const personIds = (
+      await personRepository.find({
+        where: {
+          companyId,
+        },
+        select: {
+          id: true,
+        },
+      })
+    ).map((person) => person.id);
+
+    if (!personIds) {
+      return {
+        totalNumberOfThreads: 0,
+        timelineThreads: [],
+      };
+    }
+
+    const messageThreads =
+      await this.getMessagesFromPersonIdsService.getMessagesFromPersonIds(
+        workspaceMemberId,
+        personIds,
+        page,
+        pageSize,
+      );
+
+    return messageThreads;
+  }
+}

packages/twenty-server/src/engine/core-modules/messaging/services/get-messages-from-person-ids.service.ts

@@ -0,0 +1,115 @@
+import { Injectable } from '@nestjs/common';
+
+import { Any } from 'typeorm';
+
+import { TIMELINE_THREADS_DEFAULT_PAGE_SIZE } from 'src/engine/core-modules/messaging/constants/messaging.constants';
+import { TimelineThreadsWithTotal } from 'src/engine/core-modules/messaging/dtos/timeline-threads-with-total.dto';
+import { TimelineMessagingService } from 'src/engine/core-modules/messaging/services/timeline-messaging.service';
+import { formatThreads } from 'src/engine/core-modules/messaging/utils/format-threads.util';
+import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
+import { MessageParticipantWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-participant.workspace-entity';
+import { MessageThreadWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-thread.workspace-entity';
+
+@Injectable()
+export class GetMessagesFromPersonIdsService {
+  constructor(
+    private readonly twentyORMManager: TwentyORMManager,
+    private readonly timelineMessagingService: TimelineMessagingService,
+  ) {}
+
+  async getMessagesFromPersonIds(
+    workspaceMemberId: string,
+    personIds: string[],
+    page = 1,
+    pageSize: number = TIMELINE_THREADS_DEFAULT_PAGE_SIZE,
+  ): Promise<TimelineThreadsWithTotal> {
+    const offset = (page - 1) * pageSize;
+
+    const messageThreadRepository =
+      await this.twentyORMManager.getRepository<MessageThreadWorkspaceEntity>(
+        'messageThread',
+      );
+
+    const messageThreads =
+      await this.timelineMessagingService.getMessageThreads(
+        personIds,
+        offset,
+        pageSize,
+      );
+
+    if (!messageThreads) {
+      return {
+        totalNumberOfThreads: 0,
+        timelineThreads: [],
+      };
+    }
+
+    const messageThreadIds = messageThreads.map(
+      (messageThread) => messageThread.id,
+    );
+
+    const totalNumberOfThreads = await messageThreadRepository.count({
+      where: {
+        messages: {
+          messageParticipants: {
+            personId: Any(personIds),
+          },
+        },
+      },
+    });
+
+    const messageParticipantRepository =
+      await this.twentyORMManager.getRepository<MessageParticipantWorkspaceEntity>(
+        'messageParticipant',
+      );
+
+    const threadParticipants = await messageParticipantRepository.find({
+      where: {
+        message: {
+          messageThreadId: Any(messageThreadIds),
+        },
+      },
+      order: {
+        message: {
+          receivedAt: 'DESC',
+        },
+      },
+      relations: ['person', 'workspaceMember', 'message'],
+    });
+
+    const threadParticipantsByThreadId: {
+      [key: string]: MessageParticipantWorkspaceEntity[];
+    } = threadParticipants.reduce(
+      (threadParticipantsAcc, threadParticipant) => {
+        if (!threadParticipant.message.messageThreadId)
+          return threadParticipantsAcc;
+
+        if (!threadParticipantsAcc[threadParticipant.message.messageThreadId])
+          threadParticipantsAcc[threadParticipant.message.messageThreadId] = [];
+
+        threadParticipantsAcc[threadParticipant.message.messageThreadId].push(
+          threadParticipant,
+        );
+
+        return threadParticipantsAcc;
+      },
+      {},
+    );
+
+    const threadVisibilityByThreadId =
+      await this.timelineMessagingService.getThreadVisibilityByThreadId(
+        messageThreadIds,
+        threadParticipantsByThreadId,
+        workspaceMemberId,
+      );
+
+    return {
+      totalNumberOfThreads,
+      timelineThreads: formatThreads(
+        messageThreads,
+        threadParticipantsByThreadId,
+        threadVisibilityByThreadId,
+      ),
+    };
+  }
+}

packages/twenty-server/src/engine/core-modules/messaging/services/timeline-messaging.service.ts

@@ -0,0 +1,172 @@
+import { Injectable } from '@nestjs/common';
+
+import { Any } from 'typeorm';
+
+import { TimelineThread } from 'src/engine/core-modules/messaging/dtos/timeline-thread.dto';
+import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
+import { MessageChannelVisibility } from 'src/modules/messaging/common/standard-objects/message-channel.workspace-entity';
+import { MessageParticipantWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-participant.workspace-entity';
+import { MessageThreadWorkspaceEntity } from 'src/modules/messaging/common/standard-objects/message-thread.workspace-entity';
+
+@Injectable()
+export class TimelineMessagingService {
+  constructor(private readonly twentyORMManager: TwentyORMManager) {}
+
+  public async getMessageThreads(
+    personIds: string[],
+    offset: number,
+    pageSize: number,
+  ): Promise<
+    Omit<
+      TimelineThread,
+      | 'firstParticipant'
+      | 'lastTwoParticipants'
+      | 'participantCount'
+      | 'read'
+      | 'visibility'
+    >[]
+  > {
+    const messageThreadRepository =
+      await this.twentyORMManager.getRepository<MessageThreadWorkspaceEntity>(
+        'messageThread',
+      );
+
+    const messageThreads = await messageThreadRepository.find({
+      select: {
+        id: true,
+        messages: {
+          receivedAt: true,
+          subject: true,
+          text: true,
+        },
+      },
+      where: {
+        messages: {
+          messageParticipants: {
+            personId: Any(personIds),
+          },
+        },
+      },
+      relations: ['messages', 'messages.messageParticipants'],
+      order: {
+        messages: {
+          receivedAt: 'DESC',
+        },
+      },
+      skip: offset,
+      take: pageSize,
+    });
+
+    return messageThreads.map((messageThread) => {
+      const lastMessage = messageThread.messages[0];
+      const firstMessage =
+        messageThread.messages[messageThread.messages.length - 1];
+
+      return {
+        id: messageThread.id,
+        subject: firstMessage.subject,
+        lastMessageBody: lastMessage.text,
+        lastMessageReceivedAt: lastMessage.receivedAt ?? new Date(),
+        numberOfMessagesInThread: messageThread.messages.length,
+      };
+    });
+  }
+
+  public async getThreadVisibilityByThreadId(
+    messageThreadIds: string[],
+    threadParticipantsByThreadId: {
+      [key: string]: MessageParticipantWorkspaceEntity[];
+    },
+    workspaceMemberId: string,
+  ): Promise<{
+    [key: string]: MessageChannelVisibility;
+  }> {
+    const messageThreadIdsForWhichWorkspaceMemberIsNotInParticipants =
+      messageThreadIds.reduce(
+        (
+          messageThreadIdsForWhichWorkspaceMemberIsInNotParticipantsAcc: string[],
+          messageThreadId,
+        ) => {
+          const threadMessagesWithWorkspaceMemberInParticipants =
+            threadParticipantsByThreadId[messageThreadId].filter(
+              (threadParticipant) =>
+                threadParticipant.workspaceMemberId === workspaceMemberId,
+            );
+
+          if (threadMessagesWithWorkspaceMemberInParticipants.length === 0)
+            messageThreadIdsForWhichWorkspaceMemberIsInNotParticipantsAcc.push(
+              messageThreadId,
+            );
+
+          return messageThreadIdsForWhichWorkspaceMemberIsInNotParticipantsAcc;
+        },
+        [],
+      );
+
+    const messageThreadRepository =
+      await this.twentyORMManager.getRepository<MessageThreadWorkspaceEntity>(
+        'messageThread',
+      );
+
+    const threadVisibility = await messageThreadRepository
+      .createQueryBuilder()
+      .select('messageThread.id', 'id')
+      .addSelect('messageChannel.visibility', 'visibility')
+      .leftJoin('messageThread.messages', 'message')
+      .leftJoin(
+        'message.messageChannelMessageAssociations',
+        'messageChannelMessageAssociation',
+      )
+      .leftJoin(
+        'messageChannelMessageAssociation.messageChannel',
+        'messageChannel',
+      )
+      .where('messageThread.id = ANY(:messageThreadIds)', {
+        messageThreadIds:
+          messageThreadIdsForWhichWorkspaceMemberIsNotInParticipants,
+      })
+      .getRawMany();
+
+    const visibilityValues = Object.values(MessageChannelVisibility);
+
+    const threadVisibilityByThreadIdForWhichWorkspaceMemberIsNotInParticipants:
+      | {
+          [key: string]: MessageChannelVisibility;
+        }
+      | undefined = threadVisibility?.reduce(
+      (threadVisibilityAcc, threadVisibility) => {
+        threadVisibilityAcc[threadVisibility.id] =
+          visibilityValues[
+            Math.max(
+              visibilityValues.indexOf(threadVisibility.visibility),
+              visibilityValues.indexOf(
+                threadVisibilityAcc[threadVisibility.id] ??
+                  MessageChannelVisibility.METADATA,
+              ),
+            )
+          ];
+
+        return threadVisibilityAcc;
+      },
+      {},
+    );
+
+    const threadVisibilityByThreadId: {
+      [key: string]: MessageChannelVisibility;
+    } = messageThreadIds.reduce((threadVisibilityAcc, messageThreadId) => {
+      // If the workspace member is not in the participants of the thread, use the visibility value from the query
+      threadVisibilityAcc[messageThreadId] =
+        messageThreadIdsForWhichWorkspaceMemberIsNotInParticipants.includes(
+          messageThreadId,
+        )
+          ? threadVisibilityByThreadIdForWhichWorkspaceMemberIsNotInParticipants?.[
+              messageThreadId
+            ] ?? MessageChannelVisibility.METADATA
+          : MessageChannelVisibility.SHARE_EVERYTHING;
+
+      return threadVisibilityAcc;
+    }, {});
+
+    return threadVisibilityByThreadId;
+  }
+}

packages/twenty-server/src/engine/core-modules/messaging/timeline-messaging.module.ts

@@ -1,12 +1,19 @@
 import { Module } from '@nestjs/common';
 
+import { GetMessagesFromCompanyIdService } from 'src/engine/core-modules/messaging/services/get-messages-from-company-id.service';
+import { GetMessagesFromPersonIdsService } from 'src/engine/core-modules/messaging/services/get-messages-from-person-ids.service';
+import { TimelineMessagingService } from 'src/engine/core-modules/messaging/services/timeline-messaging.service';
 import { TimelineMessagingResolver } from 'src/engine/core-modules/messaging/timeline-messaging.resolver';
-import { TimelineMessagingService } from 'src/engine/core-modules/messaging/timeline-messaging.service';
-import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
 import { UserModule } from 'src/engine/core-modules/user/user.module';
+import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
 @Module({
   imports: [WorkspaceDataSourceModule, UserModule],
   exports: [],
-  providers: [TimelineMessagingResolver, TimelineMessagingService],
+  providers: [
+    TimelineMessagingResolver,
+    TimelineMessagingService,
+    GetMessagesFromPersonIdsService,
+    GetMessagesFromCompanyIdService,
+  ],
 })
 export class TimelineMessagingModule {}