@wabot-dev/framework 0.1.0-beta.1 → 0.1.0-beta.3

package/dist/src/ai/deepseek/DeepSeekChatBotAdapter.js

@@ -1,15 +1,13 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../injection/index.js';
 import { OpenAI } from 'openai';
-import 'reflect-metadata';
-import '../../mindset/metadata/MindsetMetadataStore.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 import 'uuid';
 import '../../chatbot/metadata/ChatBotMetadataStore.js';
 import '../../chatbot/ChatBot.js';
 import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 
 let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter {
     deepSeek;

package/dist/src/ai/openia/OpenaiChatBotAdapter.js

@@ -1,15 +1,13 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../injection/index.js';
 import { OpenAI } from 'openai';
-import 'reflect-metadata';
-import '../../mindset/metadata/MindsetMetadataStore.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 import 'uuid';
 import '../../chatbot/metadata/ChatBotMetadataStore.js';
 import '../../chatbot/ChatBot.js';
 import { ChatBotAdapter } from '../../chatbot/ChatBotAdapter.js';
+import 'reflect-metadata';
+import '../../mindset/metadata/MindsetMetadataStore.js';
+import { MindsetOperator } from '../../mindset/MindsetOperator.js';
 
 let OpenaiChatBotAdapter = class OpenaiChatBotAdapter extends ChatBotAdapter {
     openai = new OpenAI();

package/dist/src/channels/cmd/@cmd.js

@@ -1,11 +1,7 @@
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
 import { container } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { CmdChannel } from './CmdChannel.js';
 
 function cmd() {

package/dist/src/channels/cmd/CmdChannel.js

@@ -2,11 +2,7 @@ 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 '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import * as readline from 'readline';
 
 var CmdChannel_1;

package/dist/src/channels/express/ExpressProvider.js

@@ -0,0 +1,46 @@
+import { __decorate, __metadata } from 'tslib';
+import { HttpServerProvider } from '../http/HttpServerProvider.js';
+import express from 'express';
+import { singleton } from 'tsyringe';
+import bodyParser from 'body-parser';
+import { Logger } from '../../logger/Logger.js';
+
+let ExpressProvider = class ExpressProvider {
+    httpServerProvider;
+    expressApp = null;
+    logger = new Logger('wabot:express');
+    constructor(httpServerProvider) {
+        this.httpServerProvider = httpServerProvider;
+    }
+    getExpress() {
+        if (!this.expressApp) {
+            this.expressApp = this.createExpress();
+        }
+        return this.expressApp;
+    }
+    listen() {
+        this.httpServerProvider.listen();
+    }
+    createExpress() {
+        const expressApp = express();
+        expressApp.use(bodyParser.json());
+        expressApp.use((req, res, next) => {
+            const start = process.hrtime();
+            res.on('finish', () => {
+                const [seconds, nanoseconds] = process.hrtime(start);
+                const ms = (seconds * 1000 + nanoseconds / 1e6).toFixed(2);
+                this.logger.trace(`${req.method} ${req.originalUrl} ${res.statusCode} - ${ms}ms`);
+            });
+            next();
+        });
+        const httpServer = this.httpServerProvider.getHttpServer();
+        httpServer.on('request', expressApp);
+        return expressApp;
+    }
+};
+ExpressProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [HttpServerProvider])
+], ExpressProvider);
+
+export { ExpressProvider };

package/dist/src/channels/http/HttpServerProvider.js

@@ -0,0 +1,31 @@
+import { __decorate } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { Server } from 'http';
+import { singleton } from 'tsyringe';
+
+let HttpServerProvider = class HttpServerProvider {
+    server = null;
+    listening = false;
+    logger = new Logger('wabot:http');
+    getHttpServer() {
+        if (!this.server) {
+            this.server = new Server();
+        }
+        return this.server;
+    }
+    listen() {
+        if (!this.server || this.listening) {
+            return;
+        }
+        this.listening = true;
+        const PORT = process.env.PORT || 3000;
+        this.server.listen(PORT, () => {
+            this.logger.info(`server listenig on port ${PORT}`);
+        });
+    }
+};
+HttpServerProvider = __decorate([
+    singleton()
+], HttpServerProvider);
+
+export { HttpServerProvider };

package/dist/src/channels/{socket-io → socket}/@socket.js

@@ -1,11 +1,7 @@
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
 import { container } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { SocketChannel } from './SocketChannel.js';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
 

package/dist/src/channels/{socket-io → socket}/SocketChannel.js

@@ -1,26 +1,25 @@
-import { __decorate, __param, __metadata } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
-import { injectable, inject } from '../../injection/index.js';
+import { injectable } from '../../injection/index.js';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import { UserResolver } from '../../controller/channel/UserResolver.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import { SocketIoApp } from '../../controller/socket.io/SocketIO.js';
+import { SocketServerProvider } from './SocketServerProvider.js';
 
 var SocketChannel_1;
 let SocketChannel = SocketChannel_1 = class SocketChannel {
     config;
-    server;
+    socketServerProvider;
     chatResolver;
     userResolver;
     callBack = null;
-    constructor(config, server, chatResolver, userResolver) {
+    server;
+    constructor(config, socketServerProvider, chatResolver, userResolver) {
         this.config = config;
-        this.server = server;
+        this.socketServerProvider = socketServerProvider;
         this.chatResolver = chatResolver;
         this.userResolver = userResolver;
+        this.server = this.socketServerProvider.getSocketServer();
     }
     listen(callback) {
         this.callBack = callback;
@@ -66,12 +65,14 @@ let SocketChannel = SocketChannel_1 = class SocketChannel {
                 });
             });
         });
+        this.socketServerProvider.listen();
     }
 };
 SocketChannel = SocketChannel_1 = __decorate([
     injectable(),
-    __param(1, inject(SocketIoApp)),
-    __metadata("design:paramtypes", [SocketChannelConfig, Function, ChatResolver,
+    __metadata("design:paramtypes", [SocketChannelConfig,
+        SocketServerProvider,
+        ChatResolver,
         UserResolver])
 ], SocketChannel);
 

package/dist/src/channels/socket/SocketServerProvider.js

@@ -0,0 +1,50 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { HttpServerProvider } from '../http/HttpServerProvider.js';
+import { Server } from 'socket.io';
+import { singleton } from 'tsyringe';
+
+let SocketServerProvider = class SocketServerProvider {
+    httpServerProvider;
+    socketServer = null;
+    logger = new Logger('wabot:socket');
+    constructor(httpServerProvider) {
+        this.httpServerProvider = httpServerProvider;
+    }
+    getSocketServer() {
+        if (!this.socketServer) {
+            this.socketServer = this.createSocketServer();
+        }
+        return this.socketServer;
+    }
+    listen() {
+        this.httpServerProvider.listen();
+    }
+    createSocketServer() {
+        const httpServer = this.httpServerProvider.getHttpServer();
+        const socketServer = new Server(httpServer, {
+            cors: {
+                origin: '*',
+            },
+        });
+        socketServer.on('connection', (socket) => {
+            this.logger.trace(`socket:${socket.id} connection`);
+            socket.onAny((event) => {
+                this.logger.trace(`socket:${socket.id} emmits ${event}`);
+            });
+            socket.on('disconnect', (reason) => {
+                this.logger.trace(`socket:${socket.id} disconnect with reason: ${reason}`);
+            });
+        });
+        httpServer.on('listening', () => {
+            this.logger.info(`socket server listening`);
+        });
+        return socketServer;
+    }
+};
+SocketServerProvider = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [HttpServerProvider])
+], SocketServerProvider);
+
+export { SocketServerProvider };

package/dist/src/channels/telegram/@telegram.js

@@ -1,11 +1,7 @@
 import { container } from '../../injection/index.js';
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { TelegramChannel } from './TelegramChannel.js';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/channels/telegram/TelegramChannel.js

@@ -2,11 +2,7 @@ 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 '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/channels/wabot/WabotDevConnection.js

@@ -0,0 +1,57 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../injection/index.js';
+import { Logger } from '../../logger/Logger.js';
+import { io } from 'socket.io-client';
+import { devEmitEvent } from './WabotDevSocketContracts.js';
+
+var WabotDevConnection_1;
+let WabotDevConnection = WabotDevConnection_1 = class WabotDevConnection {
+    devProxy;
+    devProxySocket = null;
+    devToken;
+    logger = new Logger('wabot:dev-connection');
+    static isTokenAvailable() {
+        return !!process.env.WABOT_DEV_TOKEN;
+    }
+    constructor() {
+        if (!WabotDevConnection_1.isTokenAvailable()) {
+            throw new Error('WABOT_DEV_TOKEN is not set in environment variables');
+        }
+        this.devToken = process.env.WABOT_DEV_TOKEN;
+        this.devProxy = process.env.WABOT_DEV_PROXY ?? 'https://proxy.wabot.dev';
+    }
+    async getSocket() {
+        if (this.devProxySocket) {
+            return this.devProxySocket;
+        }
+        return new Promise((resolve, reject) => {
+            const devProxySocket = io(this.devProxy, { autoConnect: false });
+            devProxySocket.on('connect', async () => {
+                try {
+                    const req = {
+                        token: this.devToken,
+                    };
+                    this.logger.debug('dev connection request');
+                    const ack = await devProxySocket.emitWithAck(devEmitEvent.DEV_CONNECTION, req);
+                    if (ack != 'OK') {
+                        return reject(new Error('Dev connection failed'));
+                    }
+                    this.logger.debug('success dev connection');
+                    this.devProxySocket = devProxySocket;
+                    resolve(devProxySocket);
+                }
+                catch (err) {
+                    this.logger.error(err);
+                    reject(err);
+                }
+            });
+            devProxySocket.connect();
+        });
+    }
+};
+WabotDevConnection = WabotDevConnection_1 = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], WabotDevConnection);
+
+export { WabotDevConnection };

package/dist/src/channels/{whatsapp/WhatsAppDevSocketContracts.js → wabot/WabotDevSocketContracts.js}

@@ -1,10 +1,10 @@
-const devWhatsAppListentEvent = {
+const devListentEvent = {
     DEV_WATSAPP_WEBHOOK: 'dev-whatsapp-webhook',
 };
-const devWhatsappEmitEvent = {
+const devEmitEvent = {
     DEV_CONNECTION: 'dev-connection',
     DEV_SEND_WHATSAPP: 'dev-send-whatsapp',
     DEV_SEND_WHATSAPP_TEMPLATE: 'dev-send-whatsapp-template',
 };
 
-export { devWhatsAppListentEvent, devWhatsappEmitEvent };
+export { devEmitEvent, devListentEvent };

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

@@ -2,11 +2,7 @@ import { container } from '../../injection/index.js';
 import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
 import '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
 import { WhatsAppChannel } from './WhatsAppChannel.js';
 
 function whatsapp(config) {

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

@@ -0,0 +1,29 @@
+import '../../core/chat/repository/IChatRepository.js';
+import { Persistent } from '../../core/Persistent.js';
+import '../../core/user/IUserRepository.js';
+
+class WhatsApp extends Persistent {
+    getVerifyToken() {
+        return this.data.verifyToken;
+    }
+    getBusinessAccount() {
+        return this.data.businessAccount;
+    }
+    getAppSecret() {
+        return this.data.appSecret;
+    }
+    getBusinessNumbers() {
+        return this.data.businessNumbers;
+    }
+    getAccessToken() {
+        return this.data.accessToken;
+    }
+    hasBusinessNumber(number) {
+        return this.data.businessNumbers.some((x) => x.number === number);
+    }
+    getBussinessNumber(number) {
+        return this.data.businessNumbers.find((x) => x.number === number) ?? null;
+    }
+}
+
+export { WhatsApp };

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

@@ -2,52 +2,54 @@ 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 '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
-import { WabotEnv } from '../../env/WabotEnv.js';
 import { Logger } from '../../logger/Logger.js';
 import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
-import { WhatsAppDevConnection } from './WhatsAppDevConnection.js';
-import { WhatsAppProdConnection } from './WhatsAppProdConnection.js';
+import { WhatsAppReceiver } from './WhatsAppReceiver.js';
+import { WhatsAppSender } from './WhatsAppSender.js';
 
 let WhatsAppChannel = class WhatsAppChannel {
     config;
     chatResolver;
     userResolver;
-    wabotEnv;
+    sender;
+    receiver;
     logger = new Logger('wabot:whatsapp-channel');
-    whatsAppConection;
-    constructor(config, chatResolver, userResolver, wabotEnv, devConnection, prodConnection) {
+    constructor(config, chatResolver, userResolver, sender, receiver) {
         this.config = config;
         this.chatResolver = chatResolver;
         this.userResolver = userResolver;
-        this.wabotEnv = wabotEnv;
-        this.whatsAppConection = this.wabotEnv.isProduction() ? prodConnection : devConnection;
+        this.sender = sender;
+        this.receiver = receiver;
     }
     listen(callback) {
-        this.whatsAppConection.listenMessage(this.config.number, async (message) => {
-            try {
-                const chat = await this.chatResolver.resolve(message.chatConnection);
-                const user = await this.userResolver.resolve(message.userConnection);
-                callback({
-                    chat,
-                    user,
-                    message,
-                    reply: (replyMessage) => {
-                        this.whatsAppConection.sendWhatsApp(this.config.number, message.userConnection.id, replyMessage);
-                    },
-                });
-            }
-            catch (err) {
-                this.logger.error(err);
-            }
+        this.receiver.listenMessage({
+            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,
+                        reply: (replyMessage) => {
+                            this.sender.sendWhatsApp({
+                                from: this.config.number,
+                                to: message.userConnection.id,
+                                message: replyMessage,
+                            });
+                        },
+                    });
+                }
+                catch (err) {
+                    this.logger.error(err);
+                }
+            },
         });
     }
     connect() {
-        this.whatsAppConection.connect();
+        this.receiver.connect();
     }
 };
 WhatsAppChannel = __decorate([
@@ -55,9 +57,8 @@ WhatsAppChannel = __decorate([
     __metadata("design:paramtypes", [WhatsappChannelConfig,
         ChatResolver,
         UserResolver,
-        WabotEnv,
-        WhatsAppDevConnection,
-        WhatsAppProdConnection])
+        WhatsAppSender,
+        WhatsAppReceiver])
 ], WhatsAppChannel);
 
 export { WhatsAppChannel };

package/dist/src/channels/whatsapp/{WhatsAppConnection.js → WhatsAppReceiver.js}

@@ -1,13 +1,11 @@
-import 'debug';
-
-class WhatsAppConnection {
+class WhatsAppReceiver {
     logger;
     listeners = new Map();
     constructor(logger) {
         this.logger = logger;
     }
-    listenMessage(businessNumber, listener) {
-        this.listeners.set(businessNumber, listener);
+    listenMessage(request) {
+        this.listeners.set(request.to, request.listener);
     }
     async handlePayload(payload) {
         try {
@@ -58,4 +56,4 @@ class WhatsAppConnection {
     }
 }
 
-export { WhatsAppConnection };
+export { WhatsAppReceiver };

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

@@ -0,0 +1,32 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { WhatsAppReceiver } from './WhatsAppReceiver.js';
+import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
+import { devListentEvent } from '../wabot/WabotDevSocketContracts.js';
+import { singleton } from 'tsyringe';
+import { container } from '../../injection/index.js';
+
+let WhatsAppReceiverByDevConnection = class WhatsAppReceiverByDevConnection extends WhatsAppReceiver {
+    wabotDevConnection;
+    constructor(wabotDevConnection) {
+        super(new Logger('wabot:whatsapp-receiver-by-dev-connection'));
+        this.wabotDevConnection = wabotDevConnection;
+    }
+    async connect() {
+        const socket = await this.wabotDevConnection.getSocket();
+        socket.on(devListentEvent.DEV_WATSAPP_WEBHOOK, (payload) => {
+            this.handlePayload(payload);
+        });
+    }
+};
+WhatsAppReceiverByDevConnection = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [WabotDevConnection])
+], WhatsAppReceiverByDevConnection);
+if (WabotDevConnection.isTokenAvailable()) {
+    container.register(WhatsAppReceiver, {
+        useClass: WhatsAppReceiverByDevConnection,
+    });
+}
+
+export { WhatsAppReceiverByDevConnection };

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,41 @@
+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';
+
+let WhatsAppRepository = class WhatsAppRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            table: 'whatsapp',
+            constructor: WhatsApp,
+            schema: 'wabot',
+        });
+    }
+    async findBySlug(slug) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data @> $1
+      LIMIT 1
+    `;
+        const items = await this.query(sql, [JSON.stringify({ slug })]);
+        return items.at(0) ?? null;
+    }
+    async findByBusinessNumber(number) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data->'businessNumbers' @> $1
+      LIMIT 1
+    `;
+        const items = await this.query(sql, [JSON.stringify([{ number }])]);
+        return items.at(0) ?? null;
+    }
+};
+WhatsAppRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], WhatsAppRepository);
+
+export { WhatsAppRepository };