refactor: integrations folder structure

src/api/integrations/event/rabbitmq/controllers/rabbitmq.controller.ts

@@ -0,0 +1,53 @@
+import { InstanceDto } from '@api/dto/instance.dto';
+import { RabbitmqDto } from '@api/integrations/event/rabbitmq/dto/rabbitmq.dto';
+import { RabbitmqService } from '@api/integrations/event/rabbitmq/services/rabbitmq.service';
+import { configService, Rabbitmq } from '@config/env.config';
+import { BadRequestException } from '@exceptions';
+
+export class RabbitmqController {
+  constructor(private readonly rabbitmqService: RabbitmqService) {}
+
+  public async createRabbitmq(instance: InstanceDto, data: RabbitmqDto) {
+    if (!configService.get<Rabbitmq>('RABBITMQ').ENABLED) throw new BadRequestException('Rabbitmq is disabled');
+
+    if (!data.enabled) {
+      data.events = [];
+    }
+
+    if (data.events.length === 0) {
+      data.events = [
+        'APPLICATION_STARTUP',
+        'QRCODE_UPDATED',
+        'MESSAGES_SET',
+        'MESSAGES_UPSERT',
+        'MESSAGES_EDITED',
+        'MESSAGES_UPDATE',
+        'MESSAGES_DELETE',
+        'SEND_MESSAGE',
+        'CONTACTS_SET',
+        'CONTACTS_UPSERT',
+        'CONTACTS_UPDATE',
+        'PRESENCE_UPDATE',
+        'CHATS_SET',
+        'CHATS_UPSERT',
+        'CHATS_UPDATE',
+        'CHATS_DELETE',
+        'GROUPS_UPSERT',
+        'GROUP_UPDATE',
+        'GROUP_PARTICIPANTS_UPDATE',
+        'CONNECTION_UPDATE',
+        'LABELS_EDIT',
+        'LABELS_ASSOCIATION',
+        'CALL',
+        'TYPEBOT_START',
+        'TYPEBOT_CHANGE_STATUS',
+      ];
+    }
+
+    return this.rabbitmqService.create(instance, data);
+  }
+
+  public async findRabbitmq(instance: InstanceDto) {
+    return this.rabbitmqService.find(instance);
+  }
+}

src/api/integrations/event/rabbitmq/dto/rabbitmq.dto.ts

@@ -0,0 +1,4 @@
+export class RabbitmqDto {
+  enabled: boolean;
+  events?: string[];
+}

src/api/integrations/event/rabbitmq/libs/amqp.server.ts

@@ -0,0 +1,137 @@
+import { configService, Rabbitmq } from '@config/env.config';
+import { Logger } from '@config/logger.config';
+import { JsonValue } from '@prisma/client/runtime/library';
+import * as amqp from 'amqplib/callback_api';
+
+const logger = new Logger('AMQP');
+
+let amqpChannel: amqp.Channel | null = null;
+
+export const initAMQP = () => {
+  return new Promise<void>((resolve, reject) => {
+    const uri = configService.get<Rabbitmq>('RABBITMQ').URI;
+    amqp.connect(uri, (error, connection) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      connection.createChannel((channelError, channel) => {
+        if (channelError) {
+          reject(channelError);
+          return;
+        }
+
+        const exchangeName = configService.get<Rabbitmq>('RABBITMQ').EXCHANGE_NAME || 'evolution_exchange';
+
+        channel.assertExchange(exchangeName, 'topic', {
+          durable: true,
+          autoDelete: false,
+        });
+
+        amqpChannel = channel;
+
+        logger.info('AMQP initialized');
+        resolve();
+      });
+    });
+  });
+};
+
+export const getAMQP = (): amqp.Channel | null => {
+  return amqpChannel;
+};
+
+export const initGlobalQueues = () => {
+  logger.info('Initializing global queues');
+  const events = configService.get<Rabbitmq>('RABBITMQ').EVENTS;
+
+  if (!events) {
+    logger.warn('No events to initialize on AMQP');
+    return;
+  }
+
+  const eventKeys = Object.keys(events);
+
+  eventKeys.forEach((event) => {
+    if (events[event] === false) return;
+
+    const queueName = `${event.replace(/_/g, '.').toLowerCase()}`;
+    const amqp = getAMQP();
+    const exchangeName = configService.get<Rabbitmq>('RABBITMQ').EXCHANGE_NAME || 'evolution_exchange';
+
+    amqp.assertExchange(exchangeName, 'topic', {
+      durable: true,
+      autoDelete: false,
+    });
+
+    amqp.assertQueue(queueName, {
+      durable: true,
+      autoDelete: false,
+      arguments: {
+        'x-queue-type': 'quorum',
+      },
+    });
+
+    amqp.bindQueue(queueName, exchangeName, event);
+  });
+};
+
+export const initQueues = (instanceName: string, events: string[]) => {
+  if (!events || !events.length) return;
+
+  const queues = events.map((event) => {
+    return `${event.replace(/_/g, '.').toLowerCase()}`;
+  });
+
+  queues.forEach((event) => {
+    const amqp = getAMQP();
+    const exchangeName = instanceName ?? 'evolution_exchange';
+
+    amqp.assertExchange(exchangeName, 'topic', {
+      durable: true,
+      autoDelete: false,
+    });
+
+    const queueName = `${instanceName}.${event}`;
+
+    amqp.assertQueue(queueName, {
+      durable: true,
+      autoDelete: false,
+      arguments: {
+        'x-queue-type': 'quorum',
+      },
+    });
+
+    amqp.bindQueue(queueName, exchangeName, event);
+  });
+};
+
+export const removeQueues = (instanceName: string, events: JsonValue) => {
+  const eventsArray = Array.isArray(events) ? events.map((event) => String(event)) : [];
+
+  if (!events || !eventsArray.length) return;
+
+  const channel = getAMQP();
+
+  const queues = eventsArray.map((event) => {
+    return `${event.replace(/_/g, '.').toLowerCase()}`;
+  });
+
+  const exchangeName = instanceName ?? 'evolution_exchange';
+
+  queues.forEach((event) => {
+    const amqp = getAMQP();
+
+    amqp.assertExchange(exchangeName, 'topic', {
+      durable: true,
+      autoDelete: false,
+    });
+
+    const queueName = `${instanceName}.${event}`;
+
+    amqp.deleteQueue(queueName);
+  });
+
+  channel.deleteExchange(exchangeName);
+};

src/api/integrations/event/rabbitmq/routes/rabbitmq.router.ts

@@ -0,0 +1,36 @@
+import { RouterBroker } from '@api/abstract/abstract.router';
+import { InstanceDto } from '@api/dto/instance.dto';
+import { RabbitmqDto } from '@api/integrations/event/rabbitmq/dto/rabbitmq.dto';
+import { HttpStatus } from '@api/routes/index.router';
+import { rabbitmqController } from '@api/server.module';
+import { instanceSchema, rabbitmqSchema } from '@validate/validate.schema';
+import { RequestHandler, Router } from 'express';
+
+export class RabbitmqRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('set'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<RabbitmqDto>({
+          request: req,
+          schema: rabbitmqSchema,
+          ClassRef: RabbitmqDto,
+          execute: (instance, data) => rabbitmqController.createRabbitmq(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .get(this.routerPath('find'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => rabbitmqController.findRabbitmq(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router: Router = Router();
+}

src/api/integrations/event/rabbitmq/services/rabbitmq.service.ts

@@ -0,0 +1,33 @@
+import { InstanceDto } from '@api/dto/instance.dto';
+import { RabbitmqDto } from '@api/integrations/event/rabbitmq/dto/rabbitmq.dto';
+import { initQueues } from '@api/integrations/event/rabbitmq/libs/amqp.server';
+import { WAMonitoringService } from '@api/services/monitor.service';
+import { Logger } from '@config/logger.config';
+import { Rabbitmq } from '@prisma/client';
+
+export class RabbitmqService {
+  constructor(private readonly waMonitor: WAMonitoringService) {}
+
+  private readonly logger = new Logger('RabbitmqService');
+
+  public create(instance: InstanceDto, data: RabbitmqDto) {
+    this.waMonitor.waInstances[instance.instanceName].setRabbitmq(data);
+
+    initQueues(instance.instanceName, data.events);
+    return { rabbitmq: { ...instance, rabbitmq: data } };
+  }
+
+  public async find(instance: InstanceDto): Promise<Rabbitmq> {
+    try {
+      const result = await this.waMonitor.waInstances[instance.instanceName].findRabbitmq();
+
+      if (Object.keys(result).length === 0) {
+        throw new Error('Rabbitmq not found');
+      }
+
+      return result;
+    } catch (error) {
+      return null;
+    }
+  }
+}

src/api/integrations/event/rabbitmq/validate/rabbitmq.schema.ts

@@ -0,0 +1,65 @@
+import { JSONSchema7 } from 'json-schema';
+import { v4 } from 'uuid';
+
+const isNotEmpty = (...propertyNames: string[]): JSONSchema7 => {
+  const properties = {};
+  propertyNames.forEach(
+    (property) =>
+      (properties[property] = {
+        minLength: 1,
+        description: `The "${property}" cannot be empty`,
+      }),
+  );
+  return {
+    if: {
+      propertyNames: {
+        enum: [...propertyNames],
+      },
+    },
+    then: { properties },
+  };
+};
+
+export const rabbitmqSchema: JSONSchema7 = {
+  $id: v4(),
+  type: 'object',
+  properties: {
+    enabled: { type: 'boolean', enum: [true, false] },
+    events: {
+      type: 'array',
+      minItems: 0,
+      items: {
+        type: 'string',
+        enum: [
+          'APPLICATION_STARTUP',
+          'QRCODE_UPDATED',
+          'MESSAGES_SET',
+          'MESSAGES_UPSERT',
+          'MESSAGES_EDITED',
+          'MESSAGES_UPDATE',
+          'MESSAGES_DELETE',
+          'SEND_MESSAGE',
+          'CONTACTS_SET',
+          'CONTACTS_UPSERT',
+          'CONTACTS_UPDATE',
+          'PRESENCE_UPDATE',
+          'CHATS_SET',
+          'CHATS_UPSERT',
+          'CHATS_UPDATE',
+          'CHATS_DELETE',
+          'GROUPS_UPSERT',
+          'GROUP_UPDATE',
+          'GROUP_PARTICIPANTS_UPDATE',
+          'CONNECTION_UPDATE',
+          'LABELS_EDIT',
+          'LABELS_ASSOCIATION',
+          'CALL',
+          'TYPEBOT_START',
+          'TYPEBOT_CHANGE_STATUS',
+        ],
+      },
+    },
+  },
+  required: ['enabled'],
+  ...isNotEmpty('enabled'),
+};