@wabot-dev/framework 0.5.7 → 0.5.9

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

@@ -1,6 +1,7 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
 import { Logger } from '../../../core/logger/Logger.js';
+import { cmdChannelName } from './cmdChannelName.js';
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -10,13 +11,15 @@ import { Auth } from '../../../core/auth/Auth.js';
 var CmdChannel_1;
 const chatIdPath = '.cmd-channel/id.json';
 const authInfoPath = '.cmd-channel/auth-info.json';
-let CmdChannel = CmdChannel_1 = class CmdChannel {
+let CmdChannel = class CmdChannel {
+    static { CmdChannel_1 = this; }
     auth;
     chatId = undefined;
     rl = readline.createInterface({
         input: process.stdin,
         output: process.stdout,
     });
+    static channelName = cmdChannelName;
     callBack = null;
     constructor(auth) {
         this.auth = auth;
@@ -50,7 +53,7 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
             const chatConnection = {
                 id: this.chatId,
                 chatType: 'PRIVATE',
-                channelName: CmdChannel_1.name,
+                channelName: CmdChannel_1.channelName,
             };
             if (!this.callBack)
                 return;
@@ -61,6 +64,7 @@ let CmdChannel = CmdChannel_1 = class CmdChannel {
                 }
             }
             await this.callBack({
+                channel: cmdChannelName,
                 chatConnection,
                 message: {
                     text: trimmedInput,

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

@@ -0,0 +1,3 @@
+const cmdChannelName = 'CmdChannel';
+
+export { cmdChannelName };

package/dist/src/addon/chat-controller/socket/SocketChannel.js

@@ -1,5 +1,6 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
+import { socketChannelName } from './socketChannelName.js';
 import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
 import { socketController } from '../../../feature/socket-controller/metadata/@socketController.js';
 import { onSocketEvent } from '../../../feature/socket-controller/metadata/@onSocketEvent.js';
@@ -33,8 +34,10 @@ __decorate([
     isNotEmpty(),
     __metadata("design:type", String)
 ], SocketChannelReceivedMessage.prototype, "text", void 0);
-let SocketChannel = SocketChannel_1 = class SocketChannel {
+let SocketChannel = class SocketChannel {
+    static { SocketChannel_1 = this; }
     config;
+    static channelName = socketChannelName;
     callBack = null;
     controller = null;
     constructor(config) {
@@ -58,9 +61,10 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
                 const chatConnection = {
                     id: message.chatId,
                     chatType: 'PRIVATE',
-                    channelName: SocketChannel_1.name,
+                    channelName: SocketChannel_1.channelName,
                 };
                 await channel.callBack({
+                    channel: socketChannelName,
                     chatConnection,
                     message: {
                         text: message.text,

package/dist/src/addon/chat-controller/socket/socketChannelName.js

@@ -0,0 +1,3 @@
+const socketChannelName = 'SocketChannel';
+
+export { socketChannelName };

package/dist/src/addon/chat-controller/telegram/TelegramChannel.js

@@ -2,10 +2,13 @@ import { __decorate, __metadata } from 'tslib';
 import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 import { injectable } from '../../../core/injection/index.js';
+import { telegramChannelName } from './telegramChannelName.js';
 
 var TelegramChannel_1;
-let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
+let TelegramChannel = class TelegramChannel {
+    static { TelegramChannel_1 = this; }
     config;
+    static channelName = telegramChannelName;
     bot;
     constructor(config) {
         this.config = config;
@@ -19,9 +22,10 @@ let TelegramChannel = TelegramChannel_1 = class TelegramChannel {
             const chatConnection = {
                 id: ctx.message.chat.id.toString(),
                 chatType: ctx.message.chat.type === 'private' ? 'PRIVATE' : 'GROUP',
-                channelName: TelegramChannel_1.name,
+                channelName: TelegramChannel_1.channelName,
             };
             await callback({
+                channel: telegramChannelName,
                 chatConnection,
                 message: {
                     senderName: ctx.from.first_name,

package/dist/src/addon/chat-controller/telegram/telegramChannelName.js

@@ -0,0 +1,3 @@
+const telegramChannelName = 'TelegramChannel';
+
+export { telegramChannelName };

package/dist/src/addon/chat-controller/wasender/@whatsAppByWasender.js

@@ -0,0 +1,20 @@
+import { container } from '../../../core/injection/index.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../feature/chat-controller/runChatControllers.js';
+import { WhatsAppByWasenderChannel } from './WhatsAppByWasenderChannel.js';
+
+function whatsAppByWasender(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: WhatsAppByWasenderChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new WhatsAppByWasenderChannelConfig(config ?? {}),
+        });
+    };
+}
+
+export { whatsAppByWasender };

package/dist/src/addon/chat-controller/wasender/WasenderWebhookController.js

@@ -0,0 +1,82 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../../core/logger/Logger.js';
+import '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { onPost } from '../../../feature/rest-controller/metadata/@onPost.js';
+import { extractNumberFromWasenderMessageKey } from './extractNumberFromWasenderKey.js';
+import { IncomingMessage } from 'http';
+
+class WasenderWebhookController {
+    wasender;
+    listener;
+    logger = new Logger('wabot:wasender-webhook');
+    constructor(wasender, listener) {
+        this.wasender = wasender;
+        this.listener = listener;
+    }
+    async handleWebhook(req) {
+        const rawBody = await this.getRawBody(req);
+        const event = await this.parseEvent(req, rawBody);
+        this.logger.trace(`received event ${event.event}`);
+        switch (event.event) {
+            case 'messages.received':
+                const messages = Array.isArray(event.data.messages)
+                    ? event.data.messages
+                    : [event.data.messages];
+                await this.handleMessages(messages);
+                break;
+            default:
+                this.logger.warn(`unhandled event type ${event.event}`);
+        }
+    }
+    async handleMessages(messages) {
+        for (const message of messages) {
+            const rawNumber = extractNumberFromWasenderMessageKey(message.key);
+            const from = rawNumber.startsWith('+') ? rawNumber : `+${rawNumber}`;
+            this.logger.trace(`new message from '${from}'`);
+            if (message.message.conversation) {
+                await this.listener({
+                    text: message.message.conversation,
+                    senderName: message.pushName,
+                    senderId: from,
+                    metadata: {
+                        whatsAppNumber: from,
+                    },
+                }, from);
+            }
+        }
+    }
+    async parseEvent(req, rawBody) {
+        const adapter = {
+            getHeader: (name) => {
+                const value = req.headers[name.toLowerCase()];
+                return Array.isArray(value) ? value[0] : value;
+            },
+            getRawBody: () => rawBody,
+        };
+        const event = await this.wasender.handleWebhookEvent(adapter);
+        return event;
+    }
+    getRawBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', (chunk) => {
+                data += chunk;
+            });
+            req.on('end', () => {
+                resolve(data);
+            });
+            req.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+}
+__decorate([
+    onPost({ disableJsonParser: true, disableUrlEncodedParser: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [IncomingMessage]),
+    __metadata("design:returntype", Promise)
+], WasenderWebhookController.prototype, "handleWebhook", null);
+
+export { WasenderWebhookController };

package/dist/src/addon/chat-controller/wasender/WhatsAppByWasenderChannel.js

@@ -0,0 +1,67 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import { Env } from '../../../core/env/Env.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { WhatsAppReceiverByWasender } from './WhatsAppReceiverByWasender.js';
+import { WhatsAppSenderByWasender } from './WhatsAppSenderByWasender.js';
+import { whatsAppByWasenderChannelName } from './whatsAppByWasenderChannelName.js';
+
+var WhatsAppByWasenderChannel_1;
+let WhatsAppByWasenderChannel = class WhatsAppByWasenderChannel {
+    static { WhatsAppByWasenderChannel_1 = this; }
+    logger = new Logger('wabot:whatsapp-by-wasender-channel');
+    sender;
+    receiver;
+    phoneNumber;
+    static channelName = whatsAppByWasenderChannelName;
+    constructor(config, env) {
+        const apiKey = config.apiKey ?? env.requireString('WASENDER_API_KEY');
+        const webhookSecret = config.webhookSecret ?? env.requireString('WASENDER_WEBHOOK_SECRET');
+        this.phoneNumber = config.phoneNumber ?? env.requireString('WASENDER_PHONE_NUMBER');
+        this.sender = new WhatsAppSenderByWasender(apiKey, config.retryOptions);
+        this.receiver = new WhatsAppReceiverByWasender({
+            apiKey,
+            webhookSecret,
+            webhookPath: config.webhookPath,
+            retryOptions: config.retryOptions,
+        });
+    }
+    listen(callback) {
+        this.receiver.listenMessage(async (message, from) => {
+            try {
+                await callback({
+                    channel: whatsAppByWasenderChannelName,
+                    chatConnection: {
+                        chatType: 'PRIVATE',
+                        channelName: WhatsAppByWasenderChannel_1.channelName,
+                        id: from,
+                    },
+                    message,
+                    reply: async (replyMessage) => {
+                        await this.sender.send({
+                            from: this.phoneNumber,
+                            to: from,
+                            message: replyMessage,
+                        });
+                    },
+                });
+            }
+            catch (err) {
+                this.logger.error('Failed to handle WhatsApp message', err);
+            }
+        });
+    }
+    connect() {
+        this.receiver.connect();
+    }
+    disconnect() {
+        this.receiver.disconnect();
+    }
+};
+WhatsAppByWasenderChannel = WhatsAppByWasenderChannel_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [WhatsAppByWasenderChannelConfig, Env])
+], WhatsAppByWasenderChannel);
+
+export { WhatsAppByWasenderChannel };

package/dist/src/addon/chat-controller/wasender/WhatsAppByWasenderChannelConfig.js

@@ -0,0 +1,16 @@
+class WhatsAppByWasenderChannelConfig {
+    apiKey;
+    webhookSecret;
+    phoneNumber;
+    webhookPath;
+    retryOptions;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.webhookSecret = config.webhookSecret;
+        this.phoneNumber = config.phoneNumber;
+        this.webhookPath = config.webhookPath ?? '/wasender/hook';
+        this.retryOptions = config.retryOptions ?? { enabled: true, maxRetries: 3 };
+    }
+}
+
+export { WhatsAppByWasenderChannelConfig };

package/dist/src/addon/chat-controller/wasender/WhatsAppReceiverByWasender.js

@@ -0,0 +1,39 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { restController } from '../../../feature/rest-controller/metadata/@restController.js';
+import { runRestControllers } from '../../../feature/rest-controller/runRestControllers.js';
+import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+import { WasenderWebhookController } from './WasenderWebhookController.js';
+
+class WhatsAppReceiverByWasender {
+    config;
+    wasender;
+    listener = null;
+    constructor(config) {
+        this.config = config;
+        this.wasender = createWasender(config.apiKey, undefined, undefined, undefined, config.retryOptions, config.webhookSecret);
+    }
+    listenMessage(listener) {
+        this.listener = listener;
+    }
+    connect() {
+        const wasender = this.wasender;
+        const listener = this.listener;
+        let UniqueController = class UniqueController extends WasenderWebhookController {
+            constructor() {
+                super(wasender, listener);
+            }
+        };
+        UniqueController = __decorate([
+            restController(this.config.webhookPath),
+            __metadata("design:paramtypes", [])
+        ], UniqueController);
+        runRestControllers([UniqueController]);
+    }
+    disconnect() {
+        // Nothing to disconnect
+    }
+}
+
+export { WhatsAppReceiverByWasender };

package/dist/src/addon/chat-controller/wasender/WhatsAppSenderByWasender.js

@@ -0,0 +1,33 @@
+import { Logger } from '../../../core/logger/Logger.js';
+import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+
+class WhatsAppSenderByWasender {
+    wasender;
+    logger = new Logger('wabot:whatsapp-sender-by-wasender');
+    constructor(apiKey, retryOptions) {
+        this.wasender = createWasender(apiKey, undefined, undefined, undefined, retryOptions, undefined);
+    }
+    async send(request) {
+        try {
+            const textPayload = {
+                messageType: 'text',
+                to: `+${request.to.replace(/\D+/g, '')}`,
+                text: request.message.text ?? 'No Text',
+            };
+            const result = await this.wasender.send(textPayload);
+            this.logger.trace(`message sent from '${request.from}' to '${request.to}'`);
+            this.logger.trace(`rate limit remaining: ${result.rateLimit?.remaining}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to send message from '${request.from}' to '${request.to}'`, error);
+            if (error instanceof Error) {
+                throw new Error(error.message, { cause: error });
+            }
+            else {
+                throw new Error('error sending message');
+            }
+        }
+    }
+}
+
+export { WhatsAppSenderByWasender };

package/dist/src/addon/chat-controller/wasender/extractNumberFromWasenderKey.js

@@ -0,0 +1,5 @@
+function extractNumberFromWasenderMessageKey(key) {
+    return key.cleanedSenderPn ?? key.senderPn?.split('@')?.at(0) ?? key.remoteJid.split('@').at(0);
+}
+
+export { extractNumberFromWasenderMessageKey };

package/dist/src/addon/chat-controller/wasender/whatsAppByWasenderChannelName.js

@@ -0,0 +1,3 @@
+const whatsAppByWasenderChannelName = 'WhatsAppByWasenderChannel';
+
+export { whatsAppByWasenderChannelName };

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

@@ -4,11 +4,13 @@ import { Logger } from '../../../core/logger/Logger.js';
 import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
 import { WhatsAppReceiver } from './WhatsAppReceiver.js';
 import { WhatsAppSender } from './WhatsAppSender.js';
+import { whatsAppChannelName } from './whatsAppChannelName.js';
 
 let WhatsAppChannel = class WhatsAppChannel {
     config;
     sender;
     receiver;
+    static channelName = whatsAppChannelName;
     logger = new Logger('wabot:whatsapp-channel');
     constructor(config, sender, receiver) {
         this.config = config;
@@ -21,6 +23,7 @@ let WhatsAppChannel = class WhatsAppChannel {
             listener: async (message) => {
                 try {
                     await callback({
+                        channel: whatsAppChannelName,
                         chatConnection: message.chatConnection,
                         message: message.message,
                         reply: async (replyMessage) => {

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

@@ -1,4 +1,5 @@
 import { Logger } from '../../../../core/logger/Logger.js';
+import { whatsAppChannelName } from '../whatsAppChannelName.js';
 import { json } from 'express';
 import { WhatsAppReceiver } from '../WhatsAppReceiver.js';
 
@@ -78,11 +79,10 @@ class WhatsAppReceiverByCloudApi extends WhatsAppReceiver {
             this.logger.warn(`Message type '${message.type}' is not supported yet`);
             return;
         }
-        const channelName = 'WhatsAppChannel';
         const chatConnection = {
             id: contact.wa_id,
             chatType: 'PRIVATE',
-            channelName,
+            channelName: whatsAppChannelName,
         };
         await listener({
             chatConnection,

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppReceiverByWabotProxy.js

@@ -1,5 +1,6 @@
 import { __decorate, __metadata } from 'tslib';
 import { WhatsAppReceiver } from '../WhatsAppReceiver.js';
+import { whatsAppChannelName } from '../whatsAppChannelName.js';
 import { injectable } from '../../../../core/injection/index.js';
 import { Logger } from '../../../../core/logger/Logger.js';
 import { WHATSAPP_MESSAGE_EVENT } from './WhatsAppProxyContracts.js';
@@ -45,7 +46,7 @@ let WhatsAppReceiverByWabotProxy = class WhatsAppReceiverByWabotProxy extends Wh
                 request.listener({
                     chatConnection: {
                         chatType: 'PRIVATE',
-                        channelName: 'WhatsAppChannel',
+                        channelName: whatsAppChannelName,
                         id: data.from,
                     },
                     message: {

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

@@ -0,0 +1,3 @@
+const whatsAppChannelName = 'WhatsAppChannel';
+
+export { whatsAppChannelName };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/@whatsAppByWasender.js

@@ -0,0 +1,20 @@
+import { container } from '../../../core/injection/index.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../feature/chat-controller/runChatControllers.js';
+import { WhatsAppByWasenderChannel } from './WhatsAppByWasenderChannel.js';
+
+function whatsAppByWasender(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: WhatsAppByWasenderChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new WhatsAppByWasenderChannelConfig(config),
+        });
+    };
+}
+
+export { whatsAppByWasender };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/WhatsAppByWasenderChannel.js

@@ -0,0 +1,52 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { WhatsAppReceiverByWasender } from './WhatsAppReceiverByWasender.js';
+import { WhatsAppSenderByWasender } from './WhatsAppSenderByWasender.js';
+
+let WhatsAppByWasenderChannel = class WhatsAppByWasenderChannel {
+    config;
+    sender;
+    receiver;
+    logger = new Logger('wabot:whatsapp-by-wasender-channel');
+    constructor(config, sender, receiver) {
+        this.config = config;
+        this.sender = sender;
+        this.receiver = receiver;
+    }
+    listen(callback) {
+        this.receiver.listenMessage(async (message) => {
+            try {
+                await callback({
+                    chatConnection: message.chatConnection,
+                    message: message.message,
+                    reply: async (replyMessage) => {
+                        await this.sender.send({
+                            from: this.config.phoneNumber,
+                            to: message.chatConnection.id,
+                            message: replyMessage,
+                        });
+                    },
+                });
+            }
+            catch (err) {
+                this.logger.error('Failed to handle WhatsApp message', err);
+            }
+        });
+    }
+    connect() {
+        this.receiver.connect();
+    }
+    disconnect() {
+        this.receiver.disconnect();
+    }
+};
+WhatsAppByWasenderChannel = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [WhatsAppByWasenderChannelConfig,
+        WhatsAppSenderByWasender,
+        WhatsAppReceiverByWasender])
+], WhatsAppByWasenderChannel);
+
+export { WhatsAppByWasenderChannel };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/WhatsAppByWasenderChannelConfig.js

@@ -0,0 +1,16 @@
+class WhatsAppByWasenderChannelConfig {
+    apiKey;
+    webhookSecret;
+    phoneNumber;
+    webhookPath;
+    retryOptions;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.webhookSecret = config.webhookSecret;
+        this.phoneNumber = config.phoneNumber;
+        this.webhookPath = config.webhookPath ?? '/wasender/hook';
+        this.retryOptions = config.retryOptions ?? { enabled: true, maxRetries: 3 };
+    }
+}
+
+export { WhatsAppByWasenderChannelConfig };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/WhatsAppReceiverByWasender.js

@@ -0,0 +1,106 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../../core/logger/Logger.js';
+import { injectable } from '../../../core/injection/index.js';
+import { ExpressProvider } from '../../../feature/express/ExpressProvider.js';
+import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { extractNumberFromWasenderMessageKey } from './extractNumberFromWasenderKey.js';
+
+let WhatsAppReceiverByWasender = class WhatsAppReceiverByWasender {
+    expressProvider;
+    config;
+    wasender;
+    listener = null;
+    logger = new Logger('wabot:whatsapp-receiver-by-wasender');
+    constructor(expressProvider, config) {
+        this.expressProvider = expressProvider;
+        this.config = config;
+        this.wasender = createWasender(config.apiKey, undefined, undefined, undefined, config.retryOptions, config.webhookSecret);
+    }
+    listenMessage(listener) {
+        this.listener = listener;
+    }
+    connect() {
+        const expressApp = this.expressProvider.getExpress();
+        expressApp.post(this.config.webhookPath, async (req, res) => {
+            try {
+                const rawBody = await this.getRawBody(req);
+                const event = await this.parseEvent(req, rawBody);
+                this.logger.trace(`received event ${event.event}`);
+                switch (event.event) {
+                    case 'messages.received':
+                        const messages = Array.isArray(event.data.messages)
+                            ? event.data.messages
+                            : [event.data.messages];
+                        await this.handleMessages(messages);
+                        break;
+                    default:
+                        this.logger.warn(`unhandled event type ${event.event}`);
+                }
+                res.sendStatus(200);
+            }
+            catch (err) {
+                this.logger.error('Failed to handle Wasender webhook', err);
+                res.sendStatus(500);
+            }
+        });
+        this.expressProvider.listen();
+    }
+    disconnect() {
+        // Nothing to disconnect
+    }
+    async handleMessages(messages) {
+        if (!this.listener) {
+            this.logger.warn('No listener registered, ignoring messages');
+            return;
+        }
+        for (const message of messages) {
+            const from = extractNumberFromWasenderMessageKey(message.key);
+            this.logger.trace(`new message from '${from}' to '${this.config.phoneNumber}'`);
+            if (message.message.conversation) {
+                const chatConnection = {
+                    chatType: 'PRIVATE',
+                    channelName: 'WhatsAppByWasenderChannel',
+                    id: from,
+                };
+                await this.listener({
+                    chatConnection,
+                    message: {
+                        text: message.message.conversation,
+                        senderName: message.pushName,
+                        senderId: from,
+                    },
+                });
+            }
+        }
+    }
+    async parseEvent(req, rawBody) {
+        const adapter = {
+            getHeader: (name) => req.header(name),
+            getRawBody: () => rawBody,
+        };
+        const event = await this.wasender.handleWebhookEvent(adapter);
+        return event;
+    }
+    getRawBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', (chunk) => {
+                data += chunk;
+            });
+            req.on('end', () => {
+                resolve(data);
+            });
+            req.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+};
+WhatsAppReceiverByWasender = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [ExpressProvider,
+        WhatsAppByWasenderChannelConfig])
+], WhatsAppReceiverByWasender);
+
+export { WhatsAppReceiverByWasender };