@wabot-dev/framework 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/src/channels/whatsapp/WhatsAppReceiverByWebHook.js

@@ -0,0 +1,63 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { WhatsAppReceiver } from './WhatsAppReceiver.js';
+import { singleton } from 'tsyringe';
+import { ExpressProvider } from '../express/ExpressProvider.js';
+import { WhatsAppRepository } from './WhatsAppRepository.js';
+import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
+import { container } from '../../injection/index.js';
+
+let WhatsAppReceiverByWebHook = class WhatsAppReceiverByWebHook extends WhatsAppReceiver {
+    expressProvider;
+    whatsAppRepository;
+    expressApp;
+    webhookPath = '/whatsapp/web-hook/:slug';
+    constructor(expressProvider, whatsAppRepository) {
+        super(new Logger('wabot:whatsapp-receiver-by-webhook'));
+        this.expressProvider = expressProvider;
+        this.whatsAppRepository = whatsAppRepository;
+        this.expressApp = this.expressProvider.getExpress();
+    }
+    async connect() {
+        this.expressApp.get(this.webhookPath, 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, (req, res) => {
+            const payload = req.body;
+            this.handlePayload(payload);
+            res.sendStatus(200);
+        });
+        this.expressProvider.listen();
+    }
+};
+WhatsAppReceiverByWebHook = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [ExpressProvider,
+        WhatsAppRepository])
+], WhatsAppReceiverByWebHook);
+if (!WabotDevConnection.isTokenAvailable()) {
+    container.register(WhatsAppReceiver, {
+        useClass: WhatsAppReceiverByWebHook,
+    });
+}
+
+export { WhatsAppReceiverByWebHook };

package/dist/src/channels/whatsapp/WhatsAppRepository.js

@@ -0,0 +1,10 @@
+class WhatsAppRepository {
+    findBySlug(slug) {
+        throw new Error('Method not implemented.');
+    }
+    findByBusinessNumber(number) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+export { WhatsAppRepository };

package/dist/src/channels/whatsapp/WhatsAppSender.js

@@ -1,23 +1,82 @@
-import { __decorate, __metadata } from 'tslib';
-import { singleton } from 'tsyringe';
+import '../../core/chat/repository/IChatRepository.js';
+import { ChatItem } from '../../core/chat/ChatItem.js';
+import '../../core/user/IUserRepository.js';
 
-let WhatsAppSender = class WhatsAppSender {
-    wabotEnv;
-    whatsAppConection;
-    constructor(wabotEnv, devConnection, prodConnection) {
-        this.wabotEnv = wabotEnv;
-        this.whatsAppConection = this.wabotEnv.isProduction() ? prodConnection : devConnection;
+class WhatsAppSender {
+    logger;
+    chatRepository;
+    chatResolver;
+    whatsAppRepository;
+    constructor(logger, chatRepository, chatResolver, whatsAppRepository) {
+        this.logger = logger;
+        this.chatRepository = chatRepository;
+        this.chatResolver = chatResolver;
+        this.whatsAppRepository = whatsAppRepository;
     }
-    async send(businessNumber, to, message) {
-        this.whatsAppConection.sendWhatsApp(businessNumber, to, message);
+    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}`);
+        }
     }
-    async sendTemplate(businessNumber, to, templateMessage) {
-        this.whatsAppConection.sendWhatsAppTemplate(businessNumber, to, templateMessage);
+    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}`);
+        }
     }
-};
-WhatsAppSender = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [Function, Function, Function])
-], WhatsAppSender);
+    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 });
+        }
+    }
+    async resolveTemplateToChatMessage(request) {
+        const template = await this.handleGetWhatsAppTemplate({
+            from: request.from,
+            templateName: request.templateMessage.templateName,
+            languageCode: request.templateMessage.languageCode,
+        });
+        if (!template) {
+            throw new Error(`WhatsAppTemplate with name ${request.templateMessage.templateName} and language ${request.templateMessage.languageCode} not found`);
+        }
+        return {
+            text: template.components
+                .filter((x) => x.text != null)
+                .map((x) => x.text)
+                .join('\n'),
+            senderName: request.senderName,
+        };
+    }
+    async writePrivateChatMemory(message, to) {
+        const chatConnection = {
+            id: to,
+            chatType: 'PRIVATE',
+            channelName: 'WhatsAppChannel',
+        };
+        const chat = await this.chatResolver.resolve(chatConnection);
+        const chatMemory = await this.chatRepository.findMemory(chat.getId());
+        const chatItem = new ChatItem({
+            type: 'BOT_MESSAGE',
+            content: message,
+        });
+        await chatMemory.create(chatItem);
+    }
+}
 
 export { WhatsAppSender };

package/dist/src/channels/whatsapp/WhatsAppSenderByCloudApi.js

@@ -0,0 +1,124 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { WhatsAppSender } from './WhatsAppSender.js';
+import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
+import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
+import { singleton, container } from '../../injection/index.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import { WhatsAppRepository } from './WhatsAppRepository.js';
+import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
+
+let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSender {
+    constructor(chatRepository, chatResolver, whatsAppRepository) {
+        super(new Logger('wabot:whatsapp-sender-by-cloud-api'), chatRepository, chatResolver, whatsAppRepository);
+    }
+    async handleSendRequest(request) {
+        const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
+        if (!whatsApp) {
+            throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
+        }
+        const businessNumber = whatsApp.getBussinessNumber(request.from);
+        const url = `https://graph.facebook.com/v23.0/${businessNumber.id}/messages`;
+        const payload = {
+            messaging_product: 'whatsapp',
+            recipient_type: 'individual',
+            to: request.to,
+            type: 'text',
+            text: {
+                preview_url: false,
+                body: request.message.text,
+            },
+        };
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${whatsApp.getAccessToken()}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(JSON.stringify(data));
+        }
+    }
+    async handleSendTemplateRequest(request) {
+        const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
+        if (!whatsApp) {
+            throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
+        }
+        const businessNumber = whatsApp.getBussinessNumber(request.from);
+        const payload = {
+            messaging_product: 'whatsapp',
+            recipient_type: 'individual',
+            to: request.to,
+            type: 'template',
+            template: {
+                name: request.templateMessage.templateName,
+                language: {
+                    code: request.templateMessage.languageCode,
+                },
+                components: [
+                    {
+                        type: 'body',
+                        parameters: request.templateMessage.parameters,
+                    },
+                ],
+            },
+        };
+        const response = await fetch(`https://graph.facebook.com/v23.0/${businessNumber.id}/messages`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${whatsApp.getAccessToken()}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(JSON.stringify(data));
+        }
+    }
+    async handleGetWhatsAppTemplate(request) {
+        const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
+        if (!whatsApp) {
+            throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
+        }
+        const businessAccount = whatsApp.getBusinessAccount();
+        try {
+            // Make API call to WhatsApp Cloud API to get templates
+            const response = await fetch(`https://graph.facebook.com/v23.0/${businessAccount.id}/message_templates?name=${request.templateName}&language=${request.languageCode}&limit=1`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${whatsApp.getAccessToken()}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            const data = (await response.json());
+            if (!response.ok) {
+                throw new Error(JSON.stringify(data));
+            }
+            const template = data.data[0] ?? null;
+            return template;
+        }
+        catch (error) {
+            console.error('Failed to get WhatsApp template:', error);
+            throw error;
+        }
+    }
+};
+WhatsAppSenderByCloudApi = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [ChatRepository,
+        ChatResolver,
+        WhatsAppRepository])
+], WhatsAppSenderByCloudApi);
+if (!WabotDevConnection.isTokenAvailable()) {
+    container.register(WhatsAppSender, {
+        useClass: WhatsAppSenderByCloudApi,
+    });
+}
+
+export { WhatsAppSenderByCloudApi };

package/dist/src/channels/whatsapp/WhatsAppSenderByDevConnection.js

@@ -0,0 +1,61 @@
+import { __decorate, __metadata } from 'tslib';
+import { WhatsAppSender } from './WhatsAppSender.js';
+import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
+import { devEmitEvent } from '../wabot/WabotDevSocketContracts.js';
+import { Logger } from '../../logger/Logger.js';
+import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
+import { singleton, container } from '../../injection/index.js';
+import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import { WhatsAppRepository } from './WhatsAppRepository.js';
+
+let WhatsAppSenderByDevConnection = class WhatsAppSenderByDevConnection extends WhatsAppSender {
+    wabotDevConnection;
+    constructor(wabotDevConnection, chatRepository, chatResolver, whatsAppRepository) {
+        super(new Logger('wabot:whatsapp-sender-by-dev-connection'), chatRepository, chatResolver, whatsAppRepository);
+        this.wabotDevConnection = wabotDevConnection;
+    }
+    async handleSendRequest(request) {
+        const socket = await this.wabotDevConnection.getSocket();
+        const req = {
+            from: request.from,
+            to: request.to,
+            message: request.message,
+        };
+        const ack = await socket.emitWithAck(devEmitEvent.DEV_SEND_WHATSAPP, req);
+        if (ack != 'OK') {
+            throw new Error(`Error sending WhatsApp template: ${ack}`);
+        }
+    }
+    async handleSendTemplateRequest(request) {
+        const socket = await this.wabotDevConnection.getSocket();
+        const req = {
+            from: request.from,
+            to: request.to,
+            message: request.templateMessage,
+        };
+        const ack = await socket.emitWithAck(devEmitEvent.DEV_SEND_WHATSAPP_TEMPLATE, req);
+        if (ack != 'OK') {
+            throw new Error(`Error sending WhatsApp template: ${ack}`);
+        }
+    }
+    async handleGetWhatsAppTemplate(request) {
+        throw new Error("Not implemented");
+    }
+};
+WhatsAppSenderByDevConnection = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [WabotDevConnection,
+        ChatRepository,
+        ChatResolver,
+        WhatsAppRepository])
+], WhatsAppSenderByDevConnection);
+if (WabotDevConnection.isTokenAvailable()) {
+    container.register(WhatsAppSender, {
+        useClass: WhatsAppSenderByDevConnection,
+    });
+}
+
+export { WhatsAppSenderByDevConnection };

package/dist/src/chatbot/ChatBotAdapter.js

@@ -1,10 +1,6 @@
-import { ChatItem } from '../core/chat/ChatItem.js';
 import '../core/chat/repository/IChatRepository.js';
+import { ChatItem } from '../core/chat/ChatItem.js';
 import '../core/user/IUserRepository.js';
-import 'reflect-metadata';
-import '../injection/index.js';
-import '../mindset/metadata/MindsetMetadataStore.js';
-import '../mindset/MindsetOperator.js';
 
 class ChatBotAdapter {
     mindset;

package/dist/src/chatbot/metadata/@chatBot.js

@@ -1,9 +1,4 @@
-import 'reflect-metadata';
 import { container, inject } from '../../injection/index.js';
-import '../../mindset/metadata/MindsetMetadataStore.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import '../../mindset/MindsetOperator.js';
 import { v4 } from 'uuid';
 import { ChatBotMetadataStore } from './ChatBotMetadataStore.js';
 

package/dist/src/chatbot/metadata/ChatBotMetadataStore.js

@@ -1,10 +1,5 @@
 import { __decorate } from 'tslib';
 import { singleton } from '../../injection/index.js';
-import 'reflect-metadata';
-import '../../mindset/metadata/MindsetMetadataStore.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import '../../mindset/MindsetOperator.js';
 
 let ChatBotMetadataStore = class ChatBotMetadataStore {
     chatBots = [];

package/dist/src/controller/metadata/ControllerMetadataStore.js

@@ -1,7 +1,5 @@
 import { __decorate } from 'tslib';
 import { singleton } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 
 let ControllerMetadataStore = class ControllerMetadataStore {
     channels = new Map();

package/dist/src/controller/metadata/controller/@chatController.js

@@ -1,6 +1,4 @@
 import { container, injectable } from '../../../injection/index.js';
-import '../../../core/chat/repository/IChatRepository.js';
-import '../../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../ControllerMetadataStore.js';
 
 function chatController(config) {

package/dist/src/core/IMessageContext.js

@@ -1,5 +1,3 @@
-import './user/IUserRepository.js';
-
 class MessageContext {
     message;
     chat;

package/dist/src/env/WabotEnv.js

@@ -12,6 +12,12 @@ let WabotEnv = class WabotEnv {
     isProduction() {
         return this.envType === 'production';
     }
+    requireString(varName) {
+        const value = process.env[varName];
+        if (!value)
+            throw new Error(`Env Variable ${varName} is required`);
+        return value;
+    }
 };
 WabotEnv = __decorate([
     singleton(),