Refactor backend folder structure (#4505)

* Refactor backend folder structure

Co-authored-by: Charles Bochet <charles@twenty.com>

* fix tests

* fix

* move yoga hooks

---------

Co-authored-by: Charles Bochet <charles@twenty.com>

packages/twenty-server/src/modules/messaging/jobs/create-companies-and-contacts-after-sync.job.ts

@@ -0,0 +1,67 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { CreateCompanyAndContactService } from 'src/modules/connected-account/auto-companies-and-contacts-creation/create-company-and-contact/create-company-and-contact.service';
+import { MessageChannelService } from 'src/modules/messaging/repositories/message-channel/message-channel.service';
+import { MessageParticipantService } from 'src/modules/messaging/repositories/message-participant/message-participant.service';
+
+export type CreateCompaniesAndContactsAfterSyncJobData = {
+  workspaceId: string;
+  messageChannelId: string;
+};
+
+@Injectable()
+export class CreateCompaniesAndContactsAfterSyncJob
+  implements MessageQueueJob<CreateCompaniesAndContactsAfterSyncJobData>
+{
+  private readonly logger = new Logger(
+    CreateCompaniesAndContactsAfterSyncJob.name,
+  );
+  constructor(
+    private readonly createCompaniesAndContactsService: CreateCompanyAndContactService,
+    private readonly messageChannelService: MessageChannelService,
+    private readonly messageParticipantService: MessageParticipantService,
+  ) {}
+
+  async handle(
+    data: CreateCompaniesAndContactsAfterSyncJobData,
+  ): Promise<void> {
+    this.logger.log(
+      `create contacts and companies after sync for workspace ${data.workspaceId} and messageChannel ${data.messageChannelId}`,
+    );
+    const { workspaceId, messageChannelId } = data;
+
+    const messageChannel = await this.messageChannelService.getByIds(
+      [messageChannelId],
+      workspaceId,
+    );
+
+    const { handle, isContactAutoCreationEnabled } = messageChannel[0];
+
+    if (!isContactAutoCreationEnabled) {
+      return;
+    }
+
+    const messageParticipantsWithoutPersonIdAndWorkspaceMemberId =
+      await this.messageParticipantService.getByMessageChannelIdWithoutPersonIdAndWorkspaceMemberIdAndMessageOutgoing(
+        messageChannelId,
+        workspaceId,
+      );
+
+    await this.createCompaniesAndContactsService.createCompaniesAndContacts(
+      handle,
+      messageParticipantsWithoutPersonIdAndWorkspaceMemberId,
+      workspaceId,
+    );
+
+    await this.messageParticipantService.updateMessageParticipantsAfterPeopleCreation(
+      messageParticipantsWithoutPersonIdAndWorkspaceMemberId,
+      workspaceId,
+    );
+
+    this.logger.log(
+      `create contacts and companies after sync for workspace ${data.workspaceId} and messageChannel ${data.messageChannelId} done`,
+    );
+  }
+}

packages/twenty-server/src/modules/messaging/jobs/delete-connected-account-associated-calendar-data.job.ts

@@ -0,0 +1,40 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { CalendarEventCleanerService } from 'src/modules/calendar/services/calendar-event-cleaner/calendar-event-cleaner.service';
+
+export type DeleteConnectedAccountAssociatedCalendarDataJobData = {
+  workspaceId: string;
+  connectedAccountId: string;
+};
+
+@Injectable()
+export class DeleteConnectedAccountAssociatedCalendarDataJob
+  implements
+    MessageQueueJob<DeleteConnectedAccountAssociatedCalendarDataJobData>
+{
+  private readonly logger = new Logger(
+    DeleteConnectedAccountAssociatedCalendarDataJob.name,
+  );
+
+  constructor(
+    private readonly calendarEventCleanerService: CalendarEventCleanerService,
+  ) {}
+
+  async handle(
+    data: DeleteConnectedAccountAssociatedCalendarDataJobData,
+  ): Promise<void> {
+    this.logger.log(
+      `Deleting connected account ${data.connectedAccountId} associated calendar data in workspace ${data.workspaceId}`,
+    );
+
+    await this.calendarEventCleanerService.cleanWorkspaceCalendarEvents(
+      data.workspaceId,
+    );
+
+    this.logger.log(
+      `Deleted connected account ${data.connectedAccountId} associated calendar data in workspace ${data.workspaceId}`,
+    );
+  }
+}

packages/twenty-server/src/modules/messaging/jobs/delete-connected-account-associated-messaging-data.job.ts

@@ -0,0 +1,36 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { ThreadCleanerService } from 'src/modules/messaging/services/thread-cleaner/thread-cleaner.service';
+
+export type DeleteConnectedAccountAssociatedMessagingDataJobData = {
+  workspaceId: string;
+  connectedAccountId: string;
+};
+
+@Injectable()
+export class DeleteConnectedAccountAssociatedMessagingDataJob
+  implements
+    MessageQueueJob<DeleteConnectedAccountAssociatedMessagingDataJobData>
+{
+  private readonly logger = new Logger(
+    DeleteConnectedAccountAssociatedMessagingDataJob.name,
+  );
+
+  constructor(private readonly threadCleanerService: ThreadCleanerService) {}
+
+  async handle(
+    data: DeleteConnectedAccountAssociatedMessagingDataJobData,
+  ): Promise<void> {
+    this.logger.log(
+      `Deleting connected account ${data.connectedAccountId} associated messaging data in workspace ${data.workspaceId}`,
+    );
+
+    await this.threadCleanerService.cleanWorkspaceThreads(data.workspaceId);
+
+    this.logger.log(
+      `Deleted connected account ${data.connectedAccountId} associated messaging data in workspace ${data.workspaceId}`,
+    );
+  }
+}

packages/twenty-server/src/modules/messaging/jobs/gmail-full-sync.job.ts

@@ -0,0 +1,50 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { GoogleAPIsRefreshAccessTokenService } from 'src/modules/connected-account/services/google-apis-refresh-access-token.service';
+import { GmailFullSyncService } from 'src/modules/messaging/services/gmail-full-sync.service';
+
+export type GmailFullSyncJobData = {
+  workspaceId: string;
+  connectedAccountId: string;
+  nextPageToken?: string;
+};
+
+@Injectable()
+export class GmailFullSyncJob implements MessageQueueJob<GmailFullSyncJobData> {
+  private readonly logger = new Logger(GmailFullSyncJob.name);
+
+  constructor(
+    private readonly googleAPIsRefreshAccessTokenService: GoogleAPIsRefreshAccessTokenService,
+    private readonly gmailFullSyncService: GmailFullSyncService,
+  ) {}
+
+  async handle(data: GmailFullSyncJobData): Promise<void> {
+    this.logger.log(
+      `gmail full-sync for workspace ${data.workspaceId} and account ${
+        data.connectedAccountId
+      } ${data.nextPageToken ? `and ${data.nextPageToken} pageToken` : ''}`,
+    );
+
+    try {
+      await this.googleAPIsRefreshAccessTokenService.refreshAndSaveAccessToken(
+        data.workspaceId,
+        data.connectedAccountId,
+      );
+    } catch (e) {
+      this.logger.error(
+        `Error refreshing access token for connected account ${data.connectedAccountId} in workspace ${data.workspaceId}`,
+        e,
+      );
+
+      return;
+    }
+
+    await this.gmailFullSyncService.fetchConnectedAccountThreads(
+      data.workspaceId,
+      data.connectedAccountId,
+      data.nextPageToken,
+    );
+  }
+}

packages/twenty-server/src/modules/messaging/jobs/gmail-partial-sync.job.ts

@@ -0,0 +1,48 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { GoogleAPIsRefreshAccessTokenService } from 'src/modules/connected-account/services/google-apis-refresh-access-token.service';
+import { GmailPartialSyncService } from 'src/modules/messaging/services/gmail-partial-sync.service';
+
+export type GmailPartialSyncJobData = {
+  workspaceId: string;
+  connectedAccountId: string;
+};
+
+@Injectable()
+export class GmailPartialSyncJob
+  implements MessageQueueJob<GmailPartialSyncJobData>
+{
+  private readonly logger = new Logger(GmailPartialSyncJob.name);
+
+  constructor(
+    private readonly googleAPIsRefreshAccessTokenService: GoogleAPIsRefreshAccessTokenService,
+    private readonly gmailPartialSyncService: GmailPartialSyncService,
+  ) {}
+
+  async handle(data: GmailPartialSyncJobData): Promise<void> {
+    this.logger.log(
+      `gmail partial-sync for workspace ${data.workspaceId} and account ${data.connectedAccountId}`,
+    );
+
+    try {
+      await this.googleAPIsRefreshAccessTokenService.refreshAndSaveAccessToken(
+        data.workspaceId,
+        data.connectedAccountId,
+      );
+    } catch (e) {
+      this.logger.error(
+        `Error refreshing access token for connected account ${data.connectedAccountId} in workspace ${data.workspaceId}`,
+        e,
+      );
+
+      return;
+    }
+
+    await this.gmailPartialSyncService.fetchConnectedAccountThreads(
+      data.workspaceId,
+      data.connectedAccountId,
+    );
+  }
+}

packages/twenty-server/src/modules/messaging/jobs/match-message-participant.job.ts

@@ -0,0 +1,47 @@
+import { Injectable } from '@nestjs/common';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { MessageParticipantService } from 'src/modules/messaging/repositories/message-participant/message-participant.service';
+
+export type MatchMessageParticipantsJobData = {
+  workspaceId: string;
+  email: string;
+  personId?: string;
+  workspaceMemberId?: string;
+};
+
+@Injectable()
+export class MatchMessageParticipantJob
+  implements MessageQueueJob<MatchMessageParticipantsJobData>
+{
+  constructor(
+    private readonly messageParticipantService: MessageParticipantService,
+  ) {}
+
+  async handle(data: MatchMessageParticipantsJobData): Promise<void> {
+    const { workspaceId, personId, workspaceMemberId, email } = data;
+
+    const messageParticipantsToUpdate =
+      await this.messageParticipantService.getByHandles([email], workspaceId);
+
+    const messageParticipantIdsToUpdate = messageParticipantsToUpdate.map(
+      (participant) => participant.id,
+    );
+
+    if (personId) {
+      await this.messageParticipantService.updateParticipantsPersonId(
+        messageParticipantIdsToUpdate,
+        personId,
+        workspaceId,
+      );
+    }
+    if (workspaceMemberId) {
+      await this.messageParticipantService.updateParticipantsWorkspaceMemberId(
+        messageParticipantIdsToUpdate,
+        workspaceMemberId,
+        workspaceId,
+      );
+    }
+  }
+}