@wabot-dev/framework 0.1.0-beta.45 → 0.1.0-beta.46

package/dist/src/addon/async/pg/PgJobRepository.js

@@ -1,7 +1,7 @@
 import { __decorate, __metadata } from 'tslib';
 import { Pool } from 'pg';
 import { singleton } from '../../../core/injection/index.js';
-import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
 import '../../../feature/async/CommandMetadataStore.js';
 import '../../../feature/async/Async.js';
 import { Job } from '../../../feature/async/Job.js';

package/dist/src/addon/auth/api-key/@apiKeyGuard.js

@@ -0,0 +1,17 @@
+import '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { middleware } from '../../../feature/rest-controller/metadata/@middleware.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import '../../../feature/express/ExpressProvider.js';
+import 'express';
+import 'path';
+import { ApiKeyGuardMiddleware } from './ApiKeyGuardMiddleware.js';
+
+function apiKeyGuard() {
+    return function (target, propertyKey) {
+        middleware(ApiKeyGuardMiddleware)(target, propertyKey);
+    };
+}
+
+export { apiKeyGuard };

package/dist/src/addon/auth/api-key/ApiKey.js

@@ -0,0 +1,46 @@
+import { Entity } from '../../../core/entity/Entity.js';
+import { CustomError } from '../../../core/error/CustomError.js';
+import { Password } from '../../../core/password/Password.js';
+
+class ApiKey extends Entity {
+    get authInfo() {
+        return this.data.authInfo;
+    }
+    generatePassword() {
+        if (this.data.passwordHash) {
+            throw new Error('This api key, already has a secret');
+        }
+        const password = Password.generate(64);
+        this.data.passwordHash = Password.hash({ password: password });
+        return password;
+    }
+    isValidPassword(password) {
+        if (!this.data.passwordHash)
+            return false;
+        return Password.isValid({ password: password, hash: this.data.passwordHash });
+    }
+    validatePassword(password) {
+        if (!this.isValidPassword(password)) {
+            throw new CustomError({ message: 'Invalid Api key', httpCode: 401 });
+        }
+    }
+    static inflate(secret) {
+        try {
+            const json = Buffer.from(secret, 'base64').toString('utf-8');
+            const data = JSON.parse(json);
+            if (!data.id || !data.pass) {
+                throw new Error('Invalid secret structure');
+            }
+            return data;
+        }
+        catch (err) {
+            throw new Error('Failed to inflate secret: ' + err.message);
+        }
+    }
+    static deflate(data) {
+        const json = JSON.stringify(data);
+        return Buffer.from(json, 'utf-8').toString('base64');
+    }
+}
+
+export { ApiKey };

package/dist/src/addon/auth/api-key/ApiKeyGuardMiddleware.js

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import { Auth } from '../../../core/auth/Auth.js';
+import { CustomError } from '../../../core/error/CustomError.js';
+import { ApiKeyRepository } from './ApiKeyRepository.js';
+import { ApiKey } from './ApiKey.js';
+
+let ApiKeyGuardMiddleware = class ApiKeyGuardMiddleware {
+    apiKeyRepository;
+    auth;
+    constructor(apiKeyRepository, auth) {
+        this.apiKeyRepository = apiKeyRepository;
+        this.auth = auth;
+    }
+    async handle(req, res, container) {
+        const authorization = req.header('Authorization');
+        if (!authorization) {
+            throw new CustomError({ httpCode: 401, message: 'Authorization header not available' });
+        }
+        const [keyPrefix, keySecret] = authorization.split(' ');
+        if (keyPrefix.toLowerCase() !== 'api-key' || !keySecret) {
+            throw new CustomError({ httpCode: 401, message: 'Authorization should be an Api-Key' });
+        }
+        try {
+            const keyData = ApiKey.inflate(keySecret);
+            const apiKey = await this.apiKeyRepository.findOrThrow(keyData.id);
+            apiKey.validatePassword(keyData.pass);
+            this.auth.assign(apiKey.authInfo);
+        }
+        catch (err) {
+            throw new CustomError({
+                httpCode: 401,
+                message: err instanceof Error ? `Invalid token: ${err.message}` : 'Invalid token',
+                cause: err instanceof Error ? err : undefined,
+            });
+        }
+    }
+};
+ApiKeyGuardMiddleware = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [ApiKeyRepository,
+        Auth])
+], ApiKeyGuardMiddleware);
+
+export { ApiKeyGuardMiddleware };

package/dist/src/addon/auth/api-key/ApiKeyRepository.js

@@ -0,0 +1,13 @@
+class ApiKeyRepository {
+    find(id) {
+        throw new Error('Method not implemented.');
+    }
+    findOrThrow(id) {
+        throw new Error('Method not implemented.');
+    }
+    create(item) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+export { ApiKeyRepository };

package/dist/src/addon/auth/api-key/PgApiKeyRepository.js

@@ -0,0 +1,14 @@
+import { ApiKey } from './ApiKey.js';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+
+class PgApiKeyRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            schema: 'wabot',
+            table: 'apy_key',
+            constructor: ApiKey,
+        });
+    }
+}
+
+export { PgApiKeyRepository };

package/dist/src/addon/auth/jwt/@jwtConnectionGuard.js

@@ -0,0 +1,16 @@
+import { connectionMiddleware } from '../../../feature/socket-controller/metadata/@connectionMiddleware.js';
+import '../../../core/injection/index.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import 'path';
+import 'debug';
+import '../../../feature/socket/SocketServerProvider.js';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { JwtConnectionGuardMiddleware } from './JwtConnectionGuardMiddleware.js';
+
+function jwtConnectionGuard() {
+    return function (target, propertyKey) {
+        connectionMiddleware(JwtConnectionGuardMiddleware)(target, propertyKey);
+    };
+}
+
+export { jwtConnectionGuard };

package/dist/src/addon/auth/jwt/JwtConnectionGuardMiddleware.js

@@ -0,0 +1,57 @@
+import { __decorate, __metadata } from 'tslib';
+import jwt from 'jsonwebtoken';
+import { injectable } from '../../../core/injection/index.js';
+import { Auth } from '../../../core/auth/Auth.js';
+import { CustomError } from '../../../core/error/CustomError.js';
+import { JwtConfig } from './JwtConfig.js';
+
+let JwtConnectionGuardMiddleware = class JwtConnectionGuardMiddleware {
+    config;
+    auth;
+    constructor(config, auth) {
+        this.config = config;
+        this.auth = auth;
+    }
+    async handle(socket, container) {
+        if (!socket.handshake.auth.token) {
+            let authorization = socket.handshake.headers['Authorization'] ?? socket.handshake.headers['authorization'];
+            if (Array.isArray(authorization)) {
+                authorization = authorization[0];
+            }
+            if (authorization) {
+                const [bearer, token] = authorization.split(' ');
+                if (bearer.toLowerCase() !== 'bearer' || !token) {
+                    throw new CustomError({
+                        httpCode: 401,
+                        message: 'Authorization should be a bearer token',
+                    });
+                }
+                socket.handshake.auth.token = token;
+            }
+        }
+        let token = socket.handshake.auth.token;
+        if (!token) {
+            throw new CustomError({ httpCode: 401, message: 'Token not available' });
+        }
+        try {
+            const jwtPayload = jwt.verify(token, this.config.secretOrPublicKey, {
+                algorithms: [this.config.algorithm],
+            });
+            this.auth.assign(jwtPayload);
+        }
+        catch (err) {
+            throw new CustomError({
+                httpCode: 401,
+                message: err instanceof Error ? `Invalid token: ${err.message}` : 'Invalid token',
+                cause: err instanceof Error ? err : undefined,
+            });
+        }
+    }
+};
+JwtConnectionGuardMiddleware = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [JwtConfig,
+        Auth])
+], JwtConnectionGuardMiddleware);
+
+export { JwtConnectionGuardMiddleware };

package/dist/src/addon/auth/jwt/JwtRefreshTokenRepository.js

@@ -0,0 +1,25 @@
+class JwtRefreshTokenRepository {
+    find(id) {
+        throw new Error('Method not implemented.');
+    }
+    findOrThrow(id) {
+        throw new Error('Method not implemented.');
+    }
+    findByIds(ids) {
+        throw new Error('Method not implemented.');
+    }
+    findAll(id) {
+        throw new Error('Method not implemented.');
+    }
+    create(item) {
+        throw new Error('Method not implemented.');
+    }
+    update(item) {
+        throw new Error('Method not implemented.');
+    }
+    discard(item) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+export { JwtRefreshTokenRepository };

package/dist/src/addon/{rest-controller → auth}/jwt/JwtTokenDto.js

@@ -1,9 +1,9 @@
 import { __decorate, __metadata } from 'tslib';
 import '../../../core/injection/index.js';
 import '../../../core/validation/metadata/ValidationMetadataStore.js';
-import { isDate } from '../../validation/is-date/@isDate.js';
-import { isNotEmpty } from '../../validation/is-not-empty/@isNotEmpty.js';
-import { isString } from '../../validation/is-string/@isString.js';
+import { isDate } from '../../../core/validation/validators/is-date/@isDate.js';
+import { isNotEmpty } from '../../../core/validation/validators/is-not-empty/@isNotEmpty.js';
+import { isString } from '../../../core/validation/validators/is-string/@isString.js';
 
 class JwtTokenDto {
     token;

package/dist/src/addon/{rest-controller/jwt/JwtRefreshTokenRepository.js → auth/jwt/PgJwtRefreshTokenRepository.js}

@@ -1,10 +1,10 @@
 import { __decorate, __metadata } from 'tslib';
 import { singleton } from '../../../core/injection/index.js';
-import { JwtRefreshToken } from './JwtRefreshToken.js';
 import { Pool } from 'pg';
-import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
 
-let JwtRefreshTokenRepository = class JwtRefreshTokenRepository extends PgCrudRepository {
+let PgJwtRefreshTokenRepository = class PgJwtRefreshTokenRepository extends PgCrudRepository {
     constructor(pool) {
         super(pool, {
             schema: 'wabot',
@@ -13,9 +13,9 @@ let JwtRefreshTokenRepository = class JwtRefreshTokenRepository extends PgCrudRe
         });
     }
 };
-JwtRefreshTokenRepository = __decorate([
+PgJwtRefreshTokenRepository = __decorate([
     singleton(),
     __metadata("design:paramtypes", [Pool])
-], JwtRefreshTokenRepository);
+], PgJwtRefreshTokenRepository);
 
-export { JwtRefreshTokenRepository };
+export { PgJwtRefreshTokenRepository };

package/dist/src/addon/chat-bot/pg/PgChatMemory.js

@@ -1,4 +1,4 @@
-import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import { ChatItem } from '../../../feature/chat-bot/ChatItem.js';
 import '../../../core/injection/index.js';

package/dist/src/addon/chat-bot/pg/PgChatRepository.js

@@ -2,7 +2,7 @@ import { __decorate, __metadata } from 'tslib';
 import { Pool } from 'pg';
 import { PgChatMemory } from './PgChatMemory.js';
 import { singleton } from '../../../core/injection/index.js';
-import { PgCrudRepository } from '../../repository/pg/PgCrudRepository.js';
+import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
 import { Chat } from '../../../feature/chat-bot/Chat.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import 'uuid';

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

@@ -10,16 +10,16 @@ import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
 import '../../../feature/mindset/MindsetOperator.js';
 import { WhatsAppChannel } from './WhatsAppChannel.js';
 
-function whatsapp(config) {
+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(config.number),
+            channelConfig: new WhatsappChannelConfig(typeof config === 'string' ? config : config.number),
         });
     };
 }
 
-export { whatsapp };
+export { whatsApp };

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

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

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

@@ -1,55 +1,9 @@
 class WhatsAppReceiver {
-    logger;
-    listeners = new Map();
-    constructor(logger) {
-        this.logger = logger;
+    connect() {
+        throw new Error('Not Implemented');
     }
     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,
-            },
-        });
+        throw new Error('Not Implemented');
     }
 }
 

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

@@ -5,62 +5,25 @@ 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;
     }
-    handleSendRequest(request) {
+    async sendWhatsApp(request, options) {
         throw new Error('Not implemented');
     }
-    handleSendTemplateRequest(request) {
+    async sendWhatsAppTemplate(request, options) {
         throw new Error('Not implemented');
     }
-    handleGetWhatsAppTemplate(request) {
+    getWhatsAppTemplate(request) {
         throw new Error('Not implemented');
     }
-    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(`Error sending WhatsApp message: ${error}`, { cause: error });
-        }
-    }
-    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(`Error sending WhatsApp message: ${error}`, { cause: error });
-        }
-    }
-    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({
+    async mapTemplateToChatMessage(request) {
+        const template = await this.getWhatsAppTemplate({
             from: request.from,
             templateName: request.templateMessage.templateName,
             languageCode: request.templateMessage.languageCode,
@@ -87,7 +50,7 @@ class WhatsAppSender {
         const chatMemory = await this.chatRepository.findMemory(chat.id);
         const chatItem = new ChatItem({
             type: 'botMessage',
-            botMessage: message
+            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 };

package/dist/src/addon/chat-controller/whatsapp/{WhatsAppSenderByCloudApi.js → cloud-api/WhatsAppSenderByCloudApi.js}

@@ -1,23 +1,24 @@
 import { __decorate, __metadata } from 'tslib';
-import { Logger } from '../../../core/logger/Logger.js';
-import { WhatsAppSender } from './WhatsAppSender.js';
-import { singleton } from '../../../core/injection/index.js';
-import '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
-import { ChatResolver } from '../../../feature/chat-controller/ChatResolver.js';
-import '../../../feature/chat-bot/ChatBot.js';
-import { ChatRepository } from '../../../feature/chat-bot/ChatRepository.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import { WhatsAppSender } from '../WhatsAppSender.js';
+import { singleton } from '../../../../core/injection/index.js';
+import '../../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import { ChatResolver } from '../../../../feature/chat-controller/ChatResolver.js';
+import '../../../../feature/chat-bot/ChatBot.js';
+import { ChatRepository } from '../../../../feature/chat-bot/ChatRepository.js';
 import 'uuid';
-import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import 'reflect-metadata';
-import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
-import '../../../feature/mindset/MindsetOperator.js';
-import { WhatsAppRepository } from './WhatsAppRepository.js';
+import '../../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../../feature/mindset/MindsetOperator.js';
+import { WhatsAppRepository } from '../WhatsAppRepository.js';
 
 let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSender {
+    logger = new Logger('wabot:whatsapp-sender-by-cloud-api');
     constructor(chatRepository, chatResolver, whatsAppRepository) {
-        super(new Logger('wabot:whatsapp-sender-by-cloud-api'), chatRepository, chatResolver, whatsAppRepository);
+        super(chatRepository, chatResolver, whatsAppRepository);
     }
-    async handleSendRequest(request) {
+    async sendWhatsApp(request, options) {
         const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
         if (!whatsApp) {
             throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
@@ -46,8 +47,11 @@ let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSe
         if (!response.ok) {
             throw new Error(JSON.stringify(data));
         }
+        if (options?.writeChatMemory) {
+            await this.writePrivateChatMemory(request.message, request.to);
+        }
     }
-    async handleSendTemplateRequest(request) {
+    async sendWhatsAppTemplate(request, options) {
         const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
         if (!whatsApp) {
             throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
@@ -83,8 +87,12 @@ let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSe
         if (!response.ok) {
             throw new Error(JSON.stringify(data));
         }
+        if (options?.writeChatMemory) {
+            const message = await this.mapTemplateToChatMessage(request);
+            await this.writePrivateChatMemory(message, request.to);
+        }
     }
-    async handleGetWhatsAppTemplate(request) {
+    async getWhatsAppTemplate(request) {
         const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
         if (!whatsApp) {
             throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
@@ -107,7 +115,7 @@ let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSe
             return template;
         }
         catch (error) {
-            console.error('Failed to get WhatsApp template:', error);
+            this.logger.error(error);
             throw error;
         }
     }

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

@@ -0,0 +1,5 @@
+const WHATSAPP_PROXY_SEND_MESSAGE_EVENT = 'sendMessage';
+const WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT = 'listenMessage';
+const WHATSAPP_MESSAGE_EVENT = 'message';
+
+export { WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT };