@wabot-dev/framework 0.1.0-beta.9 → 0.2.0-beta.1

package/dist/src/addon/chat-bot/wabot/WabotChatAdapter.js

@@ -0,0 +1,41 @@
+import { __decorate, __metadata } from 'tslib';
+import { Env } from '../../../core/env/Env.js';
+import { CustomError } from '../../../core/error/CustomError.js';
+import { singleton } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+
+let WabotChatAdapter = class WabotChatAdapter {
+    apiKey;
+    baseUrl;
+    logger = new Logger('wabot:wabot-chat-adapter');
+    constructor(env) {
+        this.apiKey = env.requireString('WABOT_API_KEY');
+        this.baseUrl = env.requireString('WABOT_LLM_URL');
+        while (this.baseUrl.endsWith('/')) {
+            this.baseUrl = this.baseUrl.substring(0, this.baseUrl.length - 1);
+        }
+    }
+    async nextItem(req) {
+        const response = await fetch(this.baseUrl + '/chat-bot/next-item', {
+            method: 'post',
+            headers: {
+                Authorization: `Api-Key ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(req),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new CustomError({
+                message: (data?.error && JSON.stringify(data.error)) ?? 'error calling wabot llm api',
+            });
+        }
+        return data;
+    }
+};
+WabotChatAdapter = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Env])
+], WabotChatAdapter);
+
+export { WabotChatAdapter };

package/dist/src/addon/chat-controller/cmd/@cmd.js

@@ -0,0 +1,24 @@
+import { container } from '../../../core/injection/index.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../core/auth/Auth.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../feature/mindset/MindsetOperator.js';
+import { CmdChannel } from './CmdChannel.js';
+
+function cmd() {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: CmdChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+        });
+    };
+}
+
+export { cmd };

package/dist/src/addon/chat-controller/cmd/CmdChannel.js

@@ -0,0 +1,91 @@
+import { __decorate } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Random } from '../../../core/random/Random.js';
+
+var CmdChannel_1;
+const chatIdPath = '.cmd-channel/id.json';
+const authInfoPath = '.cmd-channel/auth-info.json';
+let CmdChannel = CmdChannel_1 = class CmdChannel {
+    authInfo = undefined;
+    chatId = undefined;
+    rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    callBack = null;
+    listen(callback) {
+        this.callBack = callback;
+    }
+    connect() {
+        this.rl.on('line', async (input) => {
+            const trimmedInput = input.trim();
+            if (!trimmedInput) {
+                this.rl.prompt();
+                return;
+            }
+            if (trimmedInput.toLowerCase() === 'exit') {
+                this.rl.close();
+                return;
+            }
+            if (this.chatId === undefined) {
+                this.chatId = readJsonFromFile(chatIdPath) ?? undefined;
+                if (!this.chatId) {
+                    this.chatId = Random.alphaNumericLowerCase(10);
+                    writeJsonToFile(chatIdPath, this.chatId);
+                }
+            }
+            const chatConnection = {
+                id: this.chatId,
+                chatType: 'PRIVATE',
+                channelName: CmdChannel_1.name,
+            };
+            if (!this.callBack)
+                return;
+            if (this.authInfo === undefined) {
+                this.authInfo = readJsonFromFile(authInfoPath);
+            }
+            this.callBack({
+                chatConnection,
+                message: {
+                    text: trimmedInput,
+                },
+                reply: (message) => {
+                    console.log(`\n[${message.senderName}]: ${message.text}\n`);
+                    this.rl.prompt();
+                },
+                authInfo: this.authInfo || undefined,
+                setAuthInfo: (authInfo) => {
+                    this.authInfo = authInfo || null;
+                    writeJsonToFile(authInfoPath, this.authInfo);
+                },
+            });
+        });
+    }
+};
+CmdChannel = CmdChannel_1 = __decorate([
+    injectable()
+], CmdChannel);
+function writeJsonToFile(filename, data) {
+    const filePath = path.resolve(process.cwd(), filename);
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+function readJsonFromFile(filename) {
+    const filePath = path.resolve(process.cwd(), filename);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const jsonData = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(jsonData);
+    }
+    catch (err) {
+        return null;
+    }
+}
+
+export { CmdChannel, readJsonFromFile, writeJsonToFile };

package/dist/src/{channels → addon/chat-controller}/socket/@socket.js

@@ -1,7 +1,13 @@
-import '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import { container } from '../../injection/index.js';
-import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import { container } from '../../../core/injection/index.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../core/auth/Auth.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../feature/mindset/MindsetOperator.js';
 import { SocketChannel } from './SocketChannel.js';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
 

package/dist/src/{channels → addon/chat-controller}/socket/SocketChannel.js

@@ -1,24 +1,17 @@
 import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import { SocketServerProvider } from '../../../feature/socket/SocketServerProvider.js';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
-import { injectable } from '../../injection/index.js';
-import { ChatResolver } from '../../controller/channel/ChatResolver.js';
-import { UserResolver } from '../../controller/channel/UserResolver.js';
-import '../../controller/metadata/ControllerMetadataStore.js';
-import { SocketServerProvider } from './SocketServerProvider.js';
 
 var SocketChannel_1;
 let SocketChannel = SocketChannel_1 = class SocketChannel {
     config;
     socketServerProvider;
-    chatResolver;
-    userResolver;
     callBack = null;
     server;
-    constructor(config, socketServerProvider, chatResolver, userResolver) {
+    constructor(config, socketServerProvider) {
         this.config = config;
         this.socketServerProvider = socketServerProvider;
-        this.chatResolver = chatResolver;
-        this.userResolver = userResolver;
         this.server = this.socketServerProvider.getSocketServer();
     }
     listen(callback) {
@@ -42,26 +35,21 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
                     chatType: 'PRIVATE',
                     channelName: SocketChannel_1.name,
                 };
-                const chat = await this.chatResolver.resolve(chatConnection);
-                const userConnection = {
-                    id: message.userId,
-                    channelName: SocketChannel_1.name,
-                };
-                const user = await this.userResolver.resolve(userConnection);
                 if (!this.callBack)
                     return;
                 this.callBack({
-                    chat,
-                    user,
+                    chatConnection,
                     message: {
-                        chatConnection,
-                        userConnection,
                         text: trimmedInput,
                         senderName: message.senderName,
                     },
                     reply: (message) => {
                         socket.emit(this.config.channel, message);
                     },
+                    authInfo: socket.data.authInfo,
+                    setAuthInfo: (authInfo) => {
+                        socket.data.authInfo = authInfo;
+                    },
                 });
             });
         });
@@ -71,9 +59,7 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
 SocketChannel = SocketChannel_1 = __decorate([
     injectable(),
     __metadata("design:paramtypes", [SocketChannelConfig,
-        SocketServerProvider,
-        ChatResolver,
-        UserResolver])
+        SocketServerProvider])
 ], SocketChannel);
 
 export { SocketChannel };

package/dist/src/{channels → addon/chat-controller}/socket/SocketChannelConfig.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from 'tslib';
-import { injectable } from '../../injection/index.js';
+import { injectable } from '../../../core/injection/index.js';
 
 let SocketChannelConfig = class SocketChannelConfig {
     channel;

package/dist/src/{channels → addon/chat-controller}/telegram/@telegram.js

@@ -1,7 +1,13 @@
-import { container } from '../../injection/index.js';
-import '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import { container } from '../../../core/injection/index.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../core/auth/Auth.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../feature/mindset/MindsetOperator.js';
 import { TelegramChannel } from './TelegramChannel.js';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/{channels → addon/chat-controller}/telegram/TelegramChannel.js

@@ -1,21 +1,14 @@
 import { __decorate, __metadata } from 'tslib';
-import { ChatResolver } from '../../controller/channel/ChatResolver.js';
-import { UserResolver } from '../../controller/channel/UserResolver.js';
-import { injectable } from '../../injection/index.js';
-import '../../controller/metadata/ControllerMetadataStore.js';
 import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
+import { injectable } from '../../../core/injection/index.js';
 
 var TelegramChannel_1;
 let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
     config;
-    chatResolver;
-    userResolver;
     bot;
-    constructor(config, chatResolver, userResolver) {
+    constructor(config) {
         this.config = config;
-        this.chatResolver = chatResolver;
-        this.userResolver = userResolver;
         this.bot = new Bot(this.config.botToken);
     }
     listen(callback) {
@@ -28,18 +21,9 @@ let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
                 chatType: ctx.message.chat.type === 'private' ? 'PRIVATE' : 'GROUP',
                 channelName: TelegramChannel_1.name,
             };
-            const chat = await this.chatResolver.resolve(chatConnection);
-            const userConnection = {
-                id: ctx.from.id.toString(),
-                channelName: TelegramChannel_1.name,
-            };
-            const user = await this.userResolver.resolve(userConnection);
             callback({
-                chat,
-                user,
+                chatConnection,
                 message: {
-                    chatConnection,
-                    userConnection,
                     senderName: ctx.from.first_name,
                     text: ctx.message.text,
                 },
@@ -55,9 +39,7 @@ let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
 };
 TelegramChannel = TelegramChannel_1 = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [TelegramChannelConfig,
-        ChatResolver,
-        UserResolver])
+    __metadata("design:paramtypes", [TelegramChannelConfig])
 ], TelegramChannel);
 
 export { TelegramChannel };

package/dist/src/addon/chat-controller/whatsapp/@whatsApp.js

@@ -0,0 +1,26 @@
+import { container } from '../../../core/injection/index.js';
+import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../core/auth/Auth.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import 'reflect-metadata';
+import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../feature/mindset/MindsetOperator.js';
+import { WhatsAppChannel } from './WhatsAppChannel.js';
+
+function whatsApp(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: WhatsAppChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new WhatsappChannelConfig(typeof config === 'string' ? config : config.number),
+        });
+    };
+}
+
+export { whatsApp };

package/dist/src/{channels → addon/chat-controller}/whatsapp/EnvWhatsAppRepository.js

@@ -1,7 +1,7 @@
 import { __decorate, __metadata } from 'tslib';
-import { singleton } from '../../injection/index.js';
+import { singleton } from '../../../core/injection/index.js';
 import { WhatsApp } from './WhatsApp.js';
-import { WabotEnv } from '../../env/WabotEnv.js';
+import { Env } from '../../../core/env/Env.js';
 
 let EnvWhatsAppRepository = class EnvWhatsAppRepository {
     env;
@@ -43,7 +43,7 @@ let EnvWhatsAppRepository = class EnvWhatsAppRepository {
 };
 EnvWhatsAppRepository = __decorate([
     singleton(),
-    __metadata("design:paramtypes", [WabotEnv])
+    __metadata("design:paramtypes", [Env])
 ], EnvWhatsAppRepository);
 
 export { EnvWhatsAppRepository };

package/dist/src/{channels → addon/chat-controller}/whatsapp/PgWhatsAppRepository.js

@@ -1,8 +1,8 @@
 import { __decorate, __metadata } from 'tslib';
 import { Pool } from 'pg';
 import { WhatsApp } from './WhatsApp.js';
-import { singleton } from '../../injection/index.js';
-import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+import { singleton } from '../../../core/injection/index.js';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
 
 let PgWhatsAppRepository = class PgWhatsAppRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/{channels → addon/chat-controller}/whatsapp/WhatsApp.js

@@ -1,8 +1,6 @@
-import '../../core/chat/repository/IChatRepository.js';
-import { Persistent } from '../../core/Persistent.js';
-import '../../core/user/IUserRepository.js';
+import { Entity } from '../../../core/entity/Entity.js';
 
-class WhatsApp extends Persistent {
+class WhatsApp extends Entity {
     getVerifyToken() {
         return this.data.verifyToken;
     }

package/dist/src/{channels → addon/chat-controller}/whatsapp/WhatsAppChannel.js

@@ -1,24 +1,17 @@
 import { __decorate, __metadata } from 'tslib';
-import { ChatResolver } from '../../controller/channel/ChatResolver.js';
-import { UserResolver } from '../../controller/channel/UserResolver.js';
-import { injectable } from '../../injection/index.js';
-import '../../controller/metadata/ControllerMetadataStore.js';
-import { Logger } from '../../logger/Logger.js';
+import { injectable } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
 import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
 import { WhatsAppReceiver } from './WhatsAppReceiver.js';
 import { WhatsAppSender } from './WhatsAppSender.js';
 
 let WhatsAppChannel = class WhatsAppChannel {
     config;
-    chatResolver;
-    userResolver;
     sender;
     receiver;
     logger = new Logger('wabot:whatsapp-channel');
-    constructor(config, chatResolver, userResolver, sender, receiver) {
+    constructor(config, sender, receiver) {
         this.config = config;
-        this.chatResolver = chatResolver;
-        this.userResolver = userResolver;
         this.sender = sender;
         this.receiver = receiver;
     }
@@ -27,16 +20,13 @@ let WhatsAppChannel = class WhatsAppChannel {
             to: this.config.number,
             listener: async (message) => {
                 try {
-                    const chat = await this.chatResolver.resolve(message.chatConnection);
-                    const user = await this.userResolver.resolve(message.userConnection);
                     callback({
-                        chat,
-                        user,
-                        message,
+                        chatConnection: message.chatConnection,
+                        message: message.message,
                         reply: (replyMessage) => {
                             this.sender.sendWhatsApp({
                                 from: this.config.number,
-                                to: message.userConnection.id,
+                                to: message.chatConnection.id,
                                 message: replyMessage,
                             });
                         },
@@ -55,8 +45,6 @@ let WhatsAppChannel = class WhatsAppChannel {
 WhatsAppChannel = __decorate([
     injectable(),
     __metadata("design:paramtypes", [WhatsappChannelConfig,
-        ChatResolver,
-        UserResolver,
         WhatsAppSender,
         WhatsAppReceiver])
 ], WhatsAppChannel);

package/dist/src/addon/chat-controller/whatsapp/WhatsAppReceiver.js

@@ -0,0 +1,10 @@
+class WhatsAppReceiver {
+    connect() {
+        throw new Error('Not Implemented');
+    }
+    listenMessage(request) {
+        throw new Error('Not Implemented');
+    }
+}
+
+export { WhatsAppReceiver };

package/dist/src/{channels → addon/chat-controller}/whatsapp/WhatsAppSender.js

@@ -1,53 +1,29 @@
-import '../../core/chat/repository/IChatRepository.js';
-import { ChatItem } from '../../core/chat/ChatItem.js';
-import '../../core/user/IUserRepository.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import { ChatItem } from '../../../feature/chat-bot/ChatItem.js';
+import '../../../core/injection/index.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 
 class WhatsAppSender {
-    logger;
     chatRepository;
     chatResolver;
     whatsAppRepository;
-    constructor(logger, chatRepository, chatResolver, whatsAppRepository) {
-        this.logger = logger;
+    constructor(chatRepository, chatResolver, whatsAppRepository) {
         this.chatRepository = chatRepository;
         this.chatResolver = chatResolver;
         this.whatsAppRepository = whatsAppRepository;
     }
     async sendWhatsApp(request, options) {
-        try {
-            await this.handleSendRequest(request);
-            if (options?.writeChatMemory) {
-                await this.writePrivateChatMemory(request.message, request.to);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error sending WhatsApp message: ${error}`);
-        }
+        throw new Error('Not implemented');
     }
     async sendWhatsAppTemplate(request, options) {
-        try {
-            await this.handleSendTemplateRequest(request);
-            if (options?.writeChatMemory) {
-                const message = await this.resolveTemplateToChatMessage(request);
-                await this.writePrivateChatMemory(message, request.to);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error sending WhatsApp message: ${error}`);
-        }
+        throw new Error('Not implemented');
     }
-    async getWhatsAppTemplate(request) {
-        try {
-            const template = await this.handleGetWhatsAppTemplate(request);
-            return template;
-        }
-        catch (error) {
-            this.logger.error(error);
-            throw new Error('Error getting WhatsApp template:', { cause: error });
-        }
+    getWhatsAppTemplate(request) {
+        throw new Error('Not implemented');
     }
-    async resolveTemplateToChatMessage(request) {
-        const template = await this.handleGetWhatsAppTemplate({
+    async mapTemplateToChatMessage(request) {
+        const template = await this.getWhatsAppTemplate({
             from: request.from,
             templateName: request.templateMessage.templateName,
             languageCode: request.templateMessage.languageCode,
@@ -71,10 +47,10 @@ class WhatsAppSender {
             channelName: 'WhatsAppChannel',
         };
         const chat = await this.chatResolver.resolve(chatConnection);
-        const chatMemory = await this.chatRepository.findMemory(chat.getId());
+        const chatMemory = await this.chatRepository.findMemory(chat.id);
         const chatItem = new ChatItem({
-            type: 'BOT_MESSAGE',
-            content: message,
+            type: 'botMessage',
+            botMessage: message,
         });
         await chatMemory.create(chatItem);
     }

package/dist/src/addon/chat-controller/whatsapp/cloud-api/WhatsAppReceiverByCloudApi.js

@@ -0,0 +1,97 @@
+import { Logger } from '../../../../core/logger/Logger.js';
+import { json } from 'express';
+import { WhatsAppReceiver } from '../WhatsAppReceiver.js';
+
+class WhatsAppReceiverByCloudApi extends WhatsAppReceiver {
+    expressProvider;
+    whatsAppRepository;
+    listeners = new Map();
+    expressApp;
+    logger = new Logger('wabot:whatsapp-receiver-by-webhook');
+    webhookPath = '/whatsapp/web-hook/:slug';
+    constructor(expressProvider, whatsAppRepository) {
+        super();
+        this.expressProvider = expressProvider;
+        this.whatsAppRepository = whatsAppRepository;
+        this.expressApp = this.expressProvider.getExpress();
+    }
+    async connect() {
+        this.expressApp.get(this.webhookPath, json(), async (req, res) => {
+            try {
+                let mode = req.query['hub.mode'];
+                let token = req.query['hub.verify_token'];
+                let challenge = req.query['hub.challenge'];
+                if (!mode || !token || !challenge) {
+                    res.sendStatus(400);
+                    return;
+                }
+                const whatsApp = await this.whatsAppRepository.findBySlug(req.params.slug);
+                if (!whatsApp || mode !== 'subscribe' || token !== whatsApp.getVerifyToken()) {
+                    res.sendStatus(403);
+                    return;
+                }
+                res.status(200).send(challenge);
+            }
+            catch (e) {
+                this.logger.error(e);
+                res.sendStatus(500);
+                return;
+            }
+        });
+        this.expressApp.post(this.webhookPath, json(), (req, res) => {
+            const payload = req.body;
+            this.handlePayload(payload);
+            res.sendStatus(200);
+        });
+        this.expressProvider.listen();
+    }
+    listenMessage(request) {
+        this.listeners.set(request.to, request.listener);
+    }
+    async handlePayload(payload) {
+        try {
+            for (const entry of payload.entry) {
+                for (const change of entry.changes) {
+                    if (change.field !== 'messages' || !change.value.messages || !change.value.contacts) {
+                        continue;
+                    }
+                    for (const message of change.value.messages) {
+                        const contact = change.value.contacts.find((x) => x.wa_id === message.from);
+                        if (!contact) {
+                            continue;
+                        }
+                        await this.emmitMessage(change.value.metadata, message, contact);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logger.error(err);
+        }
+    }
+    async emmitMessage(metadata, message, contact) {
+        const listener = this.listeners.get(metadata.display_phone_number);
+        if (!listener) {
+            return;
+        }
+        if (message.type !== 'text') {
+            this.logger.error(`message type ${message.type} is not supported yet`);
+            return;
+        }
+        const channelName = 'WhatsAppChannel';
+        const chatConnection = {
+            id: contact.wa_id,
+            chatType: 'PRIVATE',
+            channelName,
+        };
+        await listener({
+            chatConnection,
+            message: {
+                senderName: contact.profile.name,
+                text: message.text.body,
+            },
+        });
+    }
+}
+
+export { WhatsAppReceiverByCloudApi };