Fix cron module structure (#4933)

This PR introduces a new folder structure for business modules.
Cron commands and jobs are now stored within the same module/folder at
the root of the business module
e.g: /modules/messaging/crons/commands instead of
/modules/messaging/commands/crons
Patterns are now inside their own cron-command files since they don't
need to be exported
Ideally cronJobs and cronCommands should have their logic within the
same class but it's a bit harder than expected due to how commanderjs
and our worker need both some class heritage check, hence the first
approach is to move them in the same folder

Also Messaging fullsync/partialsync V2 has been dropped since this is
the only used version => Breaking change for ongoing jobs and crons.
Jobs can be dropped but we will need to re-run our crons (only
cron:messaging:gmail-fetch-messages-from-cache)

packages/twenty-server/src/modules/messaging/crons/jobs/gmail-fetch-messages-from-cache.cron.job.ts

@@ -0,0 +1,65 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository, In } from 'typeorm';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { DataSourceEntity } from 'src/engine/metadata-modules/data-source/data-source.entity';
+import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
+import { MessageChannelRepository } from 'src/modules/messaging/repositories/message-channel.repository';
+import { MessageChannelObjectMetadata } from 'src/modules/messaging/standard-objects/message-channel.object-metadata';
+import { GmailFetchMessageContentFromCacheService } from 'src/modules/messaging/services/gmail-fetch-message-content-from-cache/gmail-fetch-message-content-from-cache.service';
+
+@Injectable()
+export class GmailFetchMessagesFromCacheCronJob
+  implements MessageQueueJob<undefined>
+{
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    private readonly workspaceRepository: Repository<Workspace>,
+    @InjectRepository(DataSourceEntity, 'metadata')
+    private readonly dataSourceRepository: Repository<DataSourceEntity>,
+    @InjectObjectMetadataRepository(MessageChannelObjectMetadata)
+    private readonly messageChannelRepository: MessageChannelRepository,
+    private readonly gmailFetchMessageContentFromCacheService: GmailFetchMessageContentFromCacheService,
+  ) {}
+
+  async handle(): Promise<void> {
+    const workspaceIds = (
+      await this.workspaceRepository.find({
+        where: {
+          subscriptionStatus: 'active',
+        },
+        select: ['id'],
+      })
+    ).map((workspace) => workspace.id);
+
+    const dataSources = await this.dataSourceRepository.find({
+      where: {
+        workspaceId: In(workspaceIds),
+      },
+    });
+
+    const workspaceIdsWithDataSources = new Set(
+      dataSources.map((dataSource) => dataSource.workspaceId),
+    );
+
+    for (const workspaceId of workspaceIdsWithDataSources) {
+      await this.fetchWorkspaceMessages(workspaceId);
+    }
+  }
+
+  private async fetchWorkspaceMessages(workspaceId: string): Promise<void> {
+    const messageChannels =
+      await this.messageChannelRepository.getAll(workspaceId);
+
+    for (const messageChannel of messageChannels) {
+      await this.gmailFetchMessageContentFromCacheService.fetchMessageContentFromCache(
+        workspaceId,
+        messageChannel.connectedAccountId,
+      );
+    }
+  }
+}

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

@@ -0,0 +1,83 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import { Repository, In } from 'typeorm';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { MessageQueue } from 'src/engine/integrations/message-queue/message-queue.constants';
+import { MessageQueueService } from 'src/engine/integrations/message-queue/services/message-queue.service';
+import { ConnectedAccountRepository } from 'src/modules/connected-account/repositories/connected-account.repository';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { DataSourceEntity } from 'src/engine/metadata-modules/data-source/data-source.entity';
+import { InjectObjectMetadataRepository } from 'src/engine/object-metadata-repository/object-metadata-repository.decorator';
+import { ConnectedAccountObjectMetadata } from 'src/modules/connected-account/standard-objects/connected-account.object-metadata';
+import {
+  GmailPartialSyncJob as GmailPartialSyncJob,
+  GmailPartialSyncJobData as GmailPartialSyncJobData,
+} from 'src/modules/messaging/jobs/gmail-partial-sync.job';
+
+@Injectable()
+export class GmailPartialSyncCronJob implements MessageQueueJob<undefined> {
+  private readonly logger = new Logger(GmailPartialSyncCronJob.name);
+
+  constructor(
+    @InjectRepository(Workspace, 'core')
+    private readonly workspaceRepository: Repository<Workspace>,
+    @InjectRepository(DataSourceEntity, 'metadata')
+    private readonly dataSourceRepository: Repository<DataSourceEntity>,
+    @Inject(MessageQueue.messagingQueue)
+    private readonly messageQueueService: MessageQueueService,
+    @InjectObjectMetadataRepository(ConnectedAccountObjectMetadata)
+    private readonly connectedAccountRepository: ConnectedAccountRepository,
+  ) {}
+
+  async handle(): Promise<void> {
+    const workspaceIds = (
+      await this.workspaceRepository.find({
+        where: {
+          subscriptionStatus: 'active',
+        },
+        select: ['id'],
+      })
+    ).map((workspace) => workspace.id);
+
+    const dataSources = await this.dataSourceRepository.find({
+      where: {
+        workspaceId: In(workspaceIds),
+      },
+    });
+
+    const workspaceIdsWithDataSources = new Set(
+      dataSources.map((dataSource) => dataSource.workspaceId),
+    );
+
+    for (const workspaceId of workspaceIdsWithDataSources) {
+      await this.enqueuePartialSyncs(workspaceId);
+    }
+  }
+
+  private async enqueuePartialSyncs(workspaceId: string): Promise<void> {
+    try {
+      const connectedAccounts =
+        await this.connectedAccountRepository.getAll(workspaceId);
+
+      for (const connectedAccount of connectedAccounts) {
+        await this.messageQueueService.add<GmailPartialSyncJobData>(
+          GmailPartialSyncJob.name,
+          {
+            workspaceId,
+            connectedAccountId: connectedAccount.id,
+          },
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `Error while fetching workspace messages for workspace ${workspaceId}`,
+      );
+      this.logger.error(error);
+
+      return;
+    }
+  }
+}