init project evolution api

src/whatsapp/routers/chat.router.ts

@@ -0,0 +1,198 @@
+import { RequestHandler, Router } from 'express';
+import {
+  archiveChatSchema,
+  contactValidateSchema,
+  deleteMessageSchema,
+  messageUpSchema,
+  messageValidateSchema,
+  profileNameSchema,
+  profilePictureSchema,
+  profileStatusSchema,
+  readMessageSchema,
+  whatsappNumberSchema,
+} from '../../validate/validate.schema';
+import {
+  ArchiveChatDto,
+  DeleteMessage,
+  NumberDto,
+  ProfileNameDto,
+  ProfilePictureDto,
+  ProfileStatusDto,
+  ReadMessageDto,
+  WhatsAppNumberDto,
+} from '../dto/chat.dto';
+import { ContactQuery } from '../repository/contact.repository';
+import { MessageQuery } from '../repository/message.repository';
+import { chatController } from '../whatsapp.module';
+import { RouterBroker } from '../abstract/abstract.router';
+import { HttpStatus } from './index.router';
+import { MessageUpQuery } from '../repository/messageUp.repository';
+import { proto } from '@evolution/base';
+import { InstanceDto } from '../dto/instance.dto';
+
+export class ChatRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('whatsappNumbers'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<WhatsAppNumberDto>({
+          request: req,
+          schema: whatsappNumberSchema,
+          ClassRef: WhatsAppNumberDto,
+          execute: (instance, data) => chatController.whatsappNumber(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .put(this.routerPath('markMessageAsRead'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<ReadMessageDto>({
+          request: req,
+          schema: readMessageSchema,
+          ClassRef: ReadMessageDto,
+          execute: (instance, data) => chatController.readMessage(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .put(this.routerPath('archiveChat'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<ArchiveChatDto>({
+          request: req,
+          schema: archiveChatSchema,
+          ClassRef: ArchiveChatDto,
+          execute: (instance, data) => chatController.archiveChat(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .delete(
+        this.routerPath('deleteMessageForEveryone'),
+        ...guards,
+        async (req, res) => {
+          const response = await this.dataValidate<DeleteMessage>({
+            request: req,
+            schema: deleteMessageSchema,
+            ClassRef: DeleteMessage,
+            execute: (instance, data) => chatController.deleteMessage(instance, data),
+          });
+
+          return res.status(HttpStatus.CREATED).json(response);
+        },
+      )
+      .post(this.routerPath('fetchProfilePictureUrl'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<NumberDto>({
+          request: req,
+          schema: profilePictureSchema,
+          ClassRef: NumberDto,
+          execute: (instance, data) => chatController.fetchProfilePicture(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('findContacts'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<ContactQuery>({
+          request: req,
+          schema: contactValidateSchema,
+          ClassRef: ContactQuery,
+          execute: (instance, data) => chatController.fetchContacts(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('getBase64FromMediaMessage'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<proto.IWebMessageInfo>({
+          request: req,
+          schema: null,
+          ClassRef: Object,
+          execute: (instance, data) =>
+            chatController.getBase64FromMediaMessage(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('findMessages'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<MessageQuery>({
+          request: req,
+          schema: messageValidateSchema,
+          ClassRef: MessageQuery,
+          execute: (instance, data) => chatController.fetchMessages(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('findStatusMessage'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<MessageUpQuery>({
+          request: req,
+          schema: messageUpSchema,
+          ClassRef: MessageUpQuery,
+          execute: (instance, data) => chatController.fetchStatusMessage(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('findChats'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: null,
+          ClassRef: InstanceDto,
+          execute: (instance) => chatController.fetchChats(instance),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      // Profile routes
+      .post(this.routerPath('getBusinessProfile'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<ProfilePictureDto>({
+          request: req,
+          schema: profilePictureSchema,
+          ClassRef: ProfilePictureDto,
+          execute: (instance, data) => chatController.getBusinessProfile(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('updateProfileName'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<ProfileNameDto>({
+          request: req,
+          schema: profileNameSchema,
+          ClassRef: ProfileNameDto,
+          execute: (instance, data) => chatController.updateProfileName(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .post(this.routerPath('updateProfileStatus'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<ProfileStatusDto>({
+          request: req,
+          schema: profileStatusSchema,
+          ClassRef: ProfileStatusDto,
+          execute: (instance, data) => chatController.updateProfileStatus(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .put(this.routerPath('updateProfilePicture'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<ProfilePictureDto>({
+          request: req,
+          schema: profilePictureSchema,
+          ClassRef: ProfilePictureDto,
+          execute: (instance, data) =>
+            chatController.updateProfilePicture(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .delete(this.routerPath('removeProfilePicture'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<ProfilePictureDto>({
+          request: req,
+          schema: profilePictureSchema,
+          ClassRef: ProfilePictureDto,
+          execute: (instance, data) =>
+            chatController.removeProfilePicture(instance, data),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}

src/whatsapp/routers/group.router.ts

@@ -0,0 +1,141 @@
+import { RequestHandler, Router } from 'express';
+import {
+  createGroupSchema,
+  groupJidSchema,
+  updateParticipantsSchema,
+  updateSettingsSchema,
+  toggleEphemeralSchema,
+  updateGroupPicture,
+  groupInviteSchema,
+} from '../../validate/validate.schema';
+import { RouterBroker } from '../abstract/abstract.router';
+import {
+  CreateGroupDto,
+  GroupInvite,
+  GroupJid,
+  GroupPictureDto,
+  GroupUpdateParticipantDto,
+  GroupUpdateSettingDto,
+  GroupToggleEphemeralDto,
+} from '../dto/group.dto';
+import { groupController } from '../whatsapp.module';
+import { HttpStatus } from './index.router';
+
+export class GroupRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('create'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<CreateGroupDto>({
+          request: req,
+          schema: createGroupSchema,
+          ClassRef: CreateGroupDto,
+          execute: (instance, data) => groupController.createGroup(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .put(this.routerPath('updateGroupPicture'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupPictureDto>({
+          request: req,
+          schema: updateGroupPicture,
+          ClassRef: GroupPictureDto,
+          execute: (instance, data) => groupController.updateGroupPicture(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .get(this.routerPath('findGroupInfos'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupJid>({
+          request: req,
+          schema: groupJidSchema,
+          ClassRef: GroupJid,
+          execute: (instance, data) => groupController.findGroupInfo(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('participants'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupJid>({
+          request: req,
+          schema: groupJidSchema,
+          ClassRef: GroupJid,
+          execute: (instance, data) => groupController.findParticipants(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('inviteCode'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupJid>({
+          request: req,
+          schema: groupJidSchema,
+          ClassRef: GroupJid,
+          execute: (instance, data) => groupController.inviteCode(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('inviteInfo'), ...guards, async (req, res) => {
+        const response = await this.inviteCodeValidate<GroupInvite>({
+          request: req,
+          schema: groupInviteSchema,
+          ClassRef: GroupInvite,
+          execute: (instance, data) => groupController.inviteInfo(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      })
+      .put(this.routerPath('revokeInviteCode'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupJid>({
+          request: req,
+          schema: groupJidSchema,
+          ClassRef: GroupJid,
+          execute: (instance, data) => groupController.revokeInviteCode(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .put(this.routerPath('updateParticipant'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupUpdateParticipantDto>({
+          request: req,
+          schema: updateParticipantsSchema,
+          ClassRef: GroupUpdateParticipantDto,
+          execute: (instance, data) => groupController.updateGParticipate(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .put(this.routerPath('updateSetting'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupUpdateSettingDto>({
+          request: req,
+          schema: updateSettingsSchema,
+          ClassRef: GroupUpdateSettingDto,
+          execute: (instance, data) => groupController.updateGSetting(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .put(this.routerPath('toggleEphemeral'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupToggleEphemeralDto>({
+          request: req,
+          schema: toggleEphemeralSchema,
+          ClassRef: GroupToggleEphemeralDto,
+          execute: (instance, data) => groupController.toggleEphemeral(instance, data),
+        });
+
+        res.status(HttpStatus.CREATED).json(response);
+      })
+      .delete(this.routerPath('leaveGroup'), ...guards, async (req, res) => {
+        const response = await this.groupValidate<GroupJid>({
+          request: req,
+          schema: {},
+          ClassRef: GroupJid,
+          execute: (instance, data) => groupController.leaveGroup(instance, data),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}

src/whatsapp/routers/index.router.ts

@@ -0,0 +1,37 @@
+import { Router } from 'express';
+import { Auth, configService } from '../../config/env.config';
+import { instanceExistsGuard, instanceLoggedGuard } from '../guards/instance.guard';
+import { authGuard } from '../guards/auth.guard';
+import { ChatRouter } from './chat.router';
+import { GroupRouter } from './group.router';
+import { InstanceRouter } from './instance.router';
+import { MessageRouter } from './sendMessage.router';
+import { ViewsRouter } from './view.router';
+import { WebhookRouter } from './webhook.router';
+
+enum HttpStatus {
+  OK = 200,
+  CREATED = 201,
+  NOT_FOUND = 404,
+  FORBIDDEN = 403,
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  INTERNAL_SERVER_ERROR = 500,
+}
+
+const router = Router();
+const authType = configService.get<Auth>('AUTHENTICATION').TYPE;
+const guards = [instanceExistsGuard, instanceLoggedGuard, authGuard[authType]];
+
+router
+  .use(
+    '/instance',
+    new InstanceRouter(configService, ...guards).router,
+    new ViewsRouter(instanceExistsGuard).router,
+  )
+  .use('/message', new MessageRouter(...guards).router)
+  .use('/chat', new ChatRouter(...guards).router)
+  .use('/group', new GroupRouter(...guards).router)
+  .use('/webhook', new WebhookRouter(...guards).router);
+
+export { router, HttpStatus };

src/whatsapp/routers/instance.router.ts

@@ -0,0 +1,113 @@
+import { RequestHandler, Router } from 'express';
+import { instanceNameSchema, oldTokenSchema } from '../../validate/validate.schema';
+import { InstanceDto } from '../dto/instance.dto';
+import { instanceController } from '../whatsapp.module';
+import { RouterBroker } from '../abstract/abstract.router';
+import { HttpStatus } from './index.router';
+import { OldToken } from '../services/auth.service';
+import { Auth, ConfigService, Database } from '../../config/env.config';
+import { dbserver } from '../../db/db.connect';
+import { BadRequestException, InternalServerErrorException } from '../../exceptions';
+
+export class InstanceRouter extends RouterBroker {
+  constructor(readonly configService: ConfigService, ...guards: RequestHandler[]) {
+    super();
+    const auth = configService.get<Auth>('AUTHENTICATION');
+    this.router
+      .post('/create', ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => instanceController.createInstance(instance),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .get(this.routerPath('connect'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => instanceController.connectToWhatsapp(instance),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('connectionState'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => instanceController.connectionState(instance),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .get(this.routerPath('fetchInstances', false), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: null,
+          ClassRef: InstanceDto,
+          execute: (instance) => instanceController.fetchInstances(instance),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .delete(this.routerPath('logout'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => instanceController.logout(instance),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      })
+      .delete(this.routerPath('delete'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<InstanceDto>({
+          request: req,
+          schema: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => instanceController.deleteInstance(instance),
+        });
+
+        return res.status(HttpStatus.OK).json(response);
+      });
+
+    if (auth.TYPE === 'jwt') {
+      this.router.put('/refreshToken', async (req, res) => {
+        const response = await this.dataValidate<OldToken>({
+          request: req,
+          schema: oldTokenSchema,
+          ClassRef: OldToken,
+          execute: (_, data) => instanceController.refreshToken(_, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      });
+    }
+
+    this.router.delete('/deleteDatabase', async (req, res) => {
+      const db = this.configService.get<Database>('DATABASE');
+      if (db.ENABLED) {
+        try {
+          await dbserver.dropDatabase();
+          return res
+            .status(HttpStatus.CREATED)
+            .json({ error: false, message: 'Database deleted' });
+        } catch (error) {
+          return res
+            .status(HttpStatus.INTERNAL_SERVER_ERROR)
+            .json({ error: true, message: error.message });
+        }
+      }
+
+      return res
+        .status(HttpStatus.INTERNAL_SERVER_ERROR)
+        .json({ error: true, message: 'Database is not enabled' });
+    });
+  }
+
+  public readonly router = Router();
+}

src/whatsapp/routers/sendMessage.router.ts

@@ -0,0 +1,139 @@
+import { RequestHandler, Router } from 'express';
+import {
+  audioMessageSchema,
+  buttonMessageSchema,
+  contactMessageSchema,
+  linkPreviewSchema,
+  listMessageSchema,
+  locationMessageSchema,
+  mediaMessageSchema,
+  pollMessageSchema,
+  reactionMessageSchema,
+  textMessageSchema,
+} from '../../validate/validate.schema';
+import {
+  SendAudioDto,
+  SendButtonDto,
+  SendContactDto,
+  SendLinkPreviewDto,
+  SendListDto,
+  SendLocationDto,
+  SendMediaDto,
+  SendPollDto,
+  SendReactionDto,
+  SendTextDto,
+} from '../dto/sendMessage.dto';
+import { sendMessageController } from '../whatsapp.module';
+import { RouterBroker } from '../abstract/abstract.router';
+import { HttpStatus } from './index.router';
+
+export class MessageRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('sendText'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendTextDto>({
+          request: req,
+          schema: textMessageSchema,
+          ClassRef: SendTextDto,
+          execute: (instance, data) => sendMessageController.sendText(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendMedia'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendMediaDto>({
+          request: req,
+          schema: mediaMessageSchema,
+          ClassRef: SendMediaDto,
+          execute: (instance, data) => sendMessageController.sendMedia(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendWhatsAppAudio'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendAudioDto>({
+          request: req,
+          schema: audioMessageSchema,
+          ClassRef: SendMediaDto,
+          execute: (instance, data) =>
+            sendMessageController.sendWhatsAppAudio(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendButtons'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendButtonDto>({
+          request: req,
+          schema: buttonMessageSchema,
+          ClassRef: SendButtonDto,
+          execute: (instance, data) => sendMessageController.sendButtons(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendLocation'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendLocationDto>({
+          request: req,
+          schema: locationMessageSchema,
+          ClassRef: SendLocationDto,
+          execute: (instance, data) => sendMessageController.sendLocation(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendList'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendListDto>({
+          request: req,
+          schema: listMessageSchema,
+          ClassRef: SendListDto,
+          execute: (instance, data) => sendMessageController.sendList(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendContact'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendContactDto>({
+          request: req,
+          schema: contactMessageSchema,
+          ClassRef: SendContactDto,
+          execute: (instance, data) => sendMessageController.sendContact(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendReaction'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendReactionDto>({
+          request: req,
+          schema: reactionMessageSchema,
+          ClassRef: SendReactionDto,
+          execute: (instance, data) => sendMessageController.sendReaction(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendPoll'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendPollDto>({
+          request: req,
+          schema: pollMessageSchema,
+          ClassRef: SendPollDto,
+          execute: (instance, data) => sendMessageController.sendPoll(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      })
+      .post(this.routerPath('sendLinkPreview'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<SendLinkPreviewDto>({
+          request: req,
+          schema: linkPreviewSchema,
+          ClassRef: SendLinkPreviewDto,
+          execute: (instance, data) =>
+            sendMessageController.sendLinkPreview(instance, data),
+        });
+
+        return res.status(HttpStatus.CREATED).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}

src/whatsapp/routers/view.router.ts

@@ -0,0 +1,15 @@
+import { RequestHandler, Router } from 'express';
+import { RouterBroker } from '../abstract/abstract.router';
+import { viewsController } from '../whatsapp.module';
+
+export class ViewsRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+
+    this.router.get(this.routerPath('qrcode'), ...guards, (req, res) => {
+      return viewsController.qrcode(req, res);
+    });
+  }
+
+  public readonly router = Router();
+}

src/whatsapp/routers/webhook.router.ts

@@ -0,0 +1,36 @@
+import { RequestHandler, Router } from 'express';
+import { instanceNameSchema, webhookSchema } from '../../validate/validate.schema';
+import { RouterBroker } from '../abstract/abstract.router';
+import { InstanceDto } from '../dto/instance.dto';
+import { WebhookDto } from '../dto/webhook.dto';
+import { webhookController } from '../whatsapp.module';
+import { HttpStatus } from './index.router';
+
+export class WebhookRouter extends RouterBroker {
+  constructor(...guards: RequestHandler[]) {
+    super();
+    this.router
+      .post(this.routerPath('set'), ...guards, async (req, res) => {
+        const response = await this.dataValidate<WebhookDto>({
+          request: req,
+          schema: webhookSchema,
+          ClassRef: WebhookDto,
+          execute: (instance, data) => webhookController.createWebhook(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: instanceNameSchema,
+          ClassRef: InstanceDto,
+          execute: (instance) => webhookController.findWebhook(instance),
+        });
+
+        res.status(HttpStatus.OK).json(response);
+      });
+  }
+
+  public readonly router = Router();
+}