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'),
+};

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

@@ -0,0 +1,53 @@
+import { InstanceDto } from '@api/dto/instance.dto';
+import { SqsDto } from '@api/integrations/event/sqs/dto/sqs.dto';
+import { SqsService } from '@api/integrations/event/sqs/services/sqs.service';
+import { configService, Sqs } from '@config/env.config';
+import { BadRequestException } from '@exceptions';
+
+export class SqsController {
+  constructor(private readonly sqsService: SqsService) {}
+
+  public async createSqs(instance: InstanceDto, data: SqsDto) {
+    if (!configService.get<Sqs>('SQS').ENABLED) throw new BadRequestException('Sqs 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.sqsService.create(instance, data);
+  }
+
+  public async findSqs(instance: InstanceDto) {
+    return this.sqsService.find(instance);
+  }
+}

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

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

src/api/integrations/event/sqs/libs/sqs.server.ts

@@ -0,0 +1,101 @@
+import { SQS } from '@aws-sdk/client-sqs';
+import { configService, Sqs } from '@config/env.config';
+import { Logger } from '@config/logger.config';
+import { JsonValue } from '@prisma/client/runtime/library';
+
+const logger = new Logger('SQS');
+
+let sqs: SQS;
+
+export const initSQS = () => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  return new Promise<void>((resolve, reject) => {
+    const awsConfig = configService.get<Sqs>('SQS');
+    sqs = new SQS({
+      credentials: {
+        accessKeyId: awsConfig.ACCESS_KEY_ID,
+        secretAccessKey: awsConfig.SECRET_ACCESS_KEY,
+      },
+
+      region: awsConfig.REGION,
+    });
+
+    logger.info('SQS initialized');
+    resolve();
+  });
+};
+
+export const getSQS = (): SQS => {
+  return sqs;
+};
+
+export const initQueues = (instanceName: string, events: string[]) => {
+  if (!events || !events.length) return;
+
+  const queues = events.map((event) => {
+    return `${event.replace(/_/g, '_').toLowerCase()}`;
+  });
+
+  const sqs = getSQS();
+
+  queues.forEach((event) => {
+    const queueName = `${instanceName}_${event}.fifo`;
+
+    sqs.createQueue(
+      {
+        QueueName: queueName,
+        Attributes: {
+          FifoQueue: 'true',
+        },
+      },
+      (err, data) => {
+        if (err) {
+          logger.error(`Error creating queue ${queueName}: ${err.message}`);
+        } else {
+          logger.info(`Queue ${queueName} created: ${data.QueueUrl}`);
+        }
+      },
+    );
+  });
+};
+
+export const removeQueues = (instanceName: string, events: JsonValue) => {
+  const eventsArray = Array.isArray(events) ? events.map((event) => String(event)) : [];
+  if (!events || !eventsArray.length) return;
+
+  const sqs = getSQS();
+
+  const queues = eventsArray.map((event) => {
+    return `${event.replace(/_/g, '_').toLowerCase()}`;
+  });
+
+  queues.forEach((event) => {
+    const queueName = `${instanceName}_${event}.fifo`;
+
+    sqs.getQueueUrl(
+      {
+        QueueName: queueName,
+      },
+      (err, data) => {
+        if (err) {
+          logger.error(`Error getting queue URL for ${queueName}: ${err.message}`);
+        } else {
+          const queueUrl = data.QueueUrl;
+
+          sqs.deleteQueue(
+            {
+              QueueUrl: queueUrl,
+            },
+            (deleteErr) => {
+              if (deleteErr) {
+                logger.error(`Error deleting queue ${queueName}: ${deleteErr.message}`);
+              } else {
+                logger.info(`Queue ${queueName} deleted`);
+              }
+            },
+          );
+        }
+      },
+    );
+  });
+};

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

@@ -0,0 +1,36 @@
+import { RouterBroker } from '@api/abstract/abstract.router';
+import { InstanceDto } from '@api/dto/instance.dto';
+import { SqsDto } from '@api/integrations/event/sqs/dto/sqs.dto';
+import { HttpStatus } from '@api/routes/index.router';
+import { sqsController } from '@api/server.module';
+import { instanceSchema, sqsSchema } from '@validate/validate.schema';
+import { RequestHandler, Router } from 'express';
+
+export class SqsRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('set'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SqsDto>({
+          request: req,
+          schema: sqsSchema,
+          ClassRef: SqsDto,
+          execute: (instance, data) => sqsController.createSqs(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) => sqsController.findSqs(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router: Router = Router();
+}

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

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

src/api/integrations/event/sqs/validate/sqs.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 sqsSchema: 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'),
+};

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

@@ -0,0 +1,215 @@
+import { WebsocketDto } from '@api/integrations/event/websocket/dto/websocket.dto';
+import { PrismaRepository } from '@api/repository/repository.service';
+import { WAMonitoringService } from '@api/services/monitor.service';
+import { wa } from '@api/types/wa.types';
+import { configService, Cors, HttpServer, Log, Websocket } from '@config/env.config';
+import { Logger } from '@config/logger.config';
+import { NotFoundException } from '@exceptions';
+import { Server } from 'http';
+import { Server as SocketIO } from 'socket.io';
+
+export class WebsocketController {
+  private io: SocketIO;
+  private prismaRepository: PrismaRepository;
+  private waMonitor: WAMonitoringService;
+  private corsConfig: Array<any>;
+  private readonly logger = new Logger('SocketStartupService');
+  public readonly 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',
+    'REMOVE_INSTANCE',
+    'LOGOUT_INSTANCE',
+  ];
+
+  constructor(prismaRepository: PrismaRepository, waMonitor: WAMonitoringService) {
+    this.prisma = prismaRepository;
+    this.monitor = waMonitor;
+    this.cors = configService.get<Cors>('CORS').ORIGIN;
+  }
+
+  public init(httpServer: Server): void {
+    if (!configService.get<Websocket>('WEBSOCKET')?.ENABLED) {
+      return;
+    }
+
+    this.socket = new SocketIO(httpServer, {
+      cors: {
+        origin: this.cors,
+      },
+    });
+
+    this.socket.on('connection', (socket) => {
+      this.logger.info('User connected');
+
+      socket.on('disconnect', () => {
+        this.logger.info('User disconnected');
+      });
+    });
+
+    this.logger.info('Socket.io initialized');
+  }
+
+  private set prisma(prisma: PrismaRepository) {
+    this.prismaRepository = prisma;
+  }
+
+  private get prisma() {
+    return this.prismaRepository;
+  }
+
+  private set monitor(waMonitor: WAMonitoringService) {
+    this.waMonitor = waMonitor;
+  }
+
+  private get monitor() {
+    return this.waMonitor;
+  }
+
+  private set cors(cors: Array<any>) {
+    this.corsConfig = cors;
+  }
+
+  private get cors(): string | Array<any> {
+    return this.corsConfig?.includes('*') ? '*' : this.corsConfig;
+  }
+
+  private set socket(socket: SocketIO) {
+    this.io = socket;
+  }
+
+  public get socket(): SocketIO {
+    return this.io;
+  }
+
+  public async set(instanceName: string, data: WebsocketDto): Promise<wa.LocalWebsocket> {
+    if (!data.enabled) {
+      data.events = [];
+    } else {
+      if (0 === data.events.length) {
+        data.events = this.events;
+      }
+    }
+
+    try {
+      await this.get(instanceName);
+
+      return this.prisma.websocket.update({
+        where: {
+          instanceId: this.monitor.waInstances[instanceName].instanceId,
+        },
+        data,
+      });
+    } catch (err) {
+      return this.prisma.websocket.create({
+        data: {
+          enabled: data.enabled,
+          events: data.events,
+          instanceId: this.monitor.waInstances[instanceName].instanceId,
+        },
+      });
+    }
+  }
+
+  public async get(instanceName: string): Promise<wa.LocalWebsocket> {
+    if (undefined === this.monitor.waInstances[instanceName]) {
+      throw new NotFoundException('Instance not found');
+    }
+
+    const data = await this.prisma.websocket.findUnique({
+      where: {
+        instanceId: this.monitor.waInstances[instanceName].instanceId,
+      },
+    });
+
+    if (!data) {
+      throw new NotFoundException('Websocket not found');
+    }
+
+    return data;
+  }
+
+  public async emit({
+    instanceName,
+    origin,
+    event,
+    data,
+  }: {
+    instanceName: string;
+    origin: string;
+    event: string;
+    data: Object;
+  }): Promise<void> {
+    if (!configService.get<Websocket>('WEBSOCKET')?.ENABLED) {
+      return;
+    }
+
+    const configEv = event.replace(/[.-]/gm, '_').toUpperCase();
+    const logEnabled = configService.get<Log>('LOG').LEVEL.includes('WEBSOCKET');
+    const serverUrl = configService.get<HttpServer>('SERVER').URL;
+    const date = new Date(Date.now() - new Date().getTimezoneOffset() * 60000).toISOString();
+    const message = {
+      event,
+      instanceName,
+      data,
+      serverUrl,
+      date,
+    };
+
+    if (configService.get<Websocket>('WEBSOCKET')?.GLOBAL_EVENTS) {
+      this.socket.emit(event, message);
+
+      if (logEnabled) {
+        this.logger.log({
+          local: `${origin}.sendData-WebsocketGlobal`,
+          ...message,
+        });
+      }
+    }
+
+    try {
+      const instanceSocket = await this.get(instanceName);
+
+      if (!instanceSocket.enabled) {
+        return;
+      }
+
+      if (Array.isArray(instanceSocket.events) && instanceSocket.events.includes(configEv)) {
+        this.socket.of(`/${instanceName}`).emit(event, message);
+
+        if (logEnabled) {
+          this.logger.log({
+            local: `${origin}.sendData-Websocket`,
+            ...message,
+          });
+        }
+      }
+    } catch (err) {
+      if (logEnabled) {
+        this.logger.log(err);
+      }
+    }
+  }
+}

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

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

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

@@ -0,0 +1,36 @@
+import { RouterBroker } from '@api/abstract/abstract.router';
+import { InstanceDto } from '@api/dto/instance.dto';
+import { WebsocketDto } from '@api/integrations/event/websocket/dto/websocket.dto';
+import { HttpStatus } from '@api/routes/index.router';
+import { websocketController } from '@api/server.module';
+import { instanceSchema, websocketSchema } from '@validate/validate.schema';
+import { RequestHandler, Router } from 'express';
+
+export class WebsocketRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('set'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<WebsocketDto>({
+          request: req,
+          schema: websocketSchema,
+          ClassRef: WebsocketDto,
+          execute: (instance, data) => websocketController.set(instance.instanceName, 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) => websocketController.get(instance.instanceName),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router: Router = Router();
+}

src/api/integrations/event/websocket/validate/websocket.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 websocketSchema: 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'),
+};