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

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

@@ -0,0 +1,32 @@
+import '../../core/chat/repository/IChatRepository.js';
+import { Entity } from '../../core/Entity.js';
+import '../../core/user/IUserRepository.js';
+
+class WhatsApp extends Entity {
+    getVerifyToken() {
+        return this.data.verifyToken;
+    }
+    getSlug() {
+        return this.data.slug;
+    }
+    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,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,110 @@
-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;
-    }
-    async send(businessNumber, to, message) {
-        this.whatsAppConection.sendWhatsApp(businessNumber, to, message);
-    }
-    async sendTemplate(businessNumber, to, templateMessage) {
-        this.whatsAppConection.sendWhatsAppTemplate(businessNumber, to, templateMessage);
-    }
-};
-WhatsAppSender = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [Function, Function, Function])
-], WhatsAppSender);
+class WhatsAppSender {
+    logger;
+    chatRepository;
+    chatResolver;
+    whatsAppRepository;
+    constructor(logger, chatRepository, chatResolver, whatsAppRepository) {
+        this.logger = logger;
+        this.chatRepository = chatRepository;
+        this.chatResolver = chatResolver;
+        this.whatsAppRepository = whatsAppRepository;
+    }
+    handleSendRequest(request) {
+        throw new Error('Not implemented');
+    }
+    handleSendTemplateRequest(request) {
+        throw new Error('Not implemented');
+    }
+    handleGetWhatsAppTemplate(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({
+            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`);
+        }
+        const components = template.components
+            .filter((x) => x.text != null)
+            .map((x) => x.text)
+            .join('\n');
+        return {
+            text: this.replaceTemplateParameters(components, request.templateMessage.parameters),
+            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.id);
+        const chatItem = new ChatItem({
+            type: 'BOT_MESSAGE',
+            content: message,
+        });
+        await chatMemory.create(chatItem);
+    }
+    replaceTemplateParameters(template, data) {
+        let result = template;
+        data.forEach((param) => {
+            if (param.type === 'text' && param.parameter_name) {
+                const tag = `{{${param.parameter_name}}}`;
+                result = result.split(tag).join(param.text);
+            }
+        });
+        data.forEach((param, index) => {
+            if (param.type === 'text') {
+                const tag = `{{${index + 1}}}`;
+                result = result.split(tag).join(param.text);
+            }
+        });
+        return result;
+    }
+}
 
 export { WhatsAppSender };

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

@@ -0,0 +1,118 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../logger/Logger.js';
+import { WhatsAppSender } from './WhatsAppSender.js';
+import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
+import { singleton } from '../../injection/index.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
+import { WhatsAppRepository } from './WhatsAppRepository.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);
+
+export { WhatsAppSenderByCloudApi };

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

@@ -0,0 +1,56 @@
+import { __decorate, __metadata } from 'tslib';
+import { WhatsAppSender } from './WhatsAppSender.js';
+import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
+import { singleton } from '../../injection/index.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
+import { Logger } from '../../logger/Logger.js';
+import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
+import { devEmitEvent } from '../wabot/WabotDevSocketContracts.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);
+
+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/{Persistent.js → Entity.js}

@@ -1,22 +1,32 @@
-class Persistent {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-    getId() {
+import { Storable } from './Storable.js';
+
+class Entity extends Storable {
+    get id() {
         if (!this.data.id) {
             throw new Error('id is required');
         }
         return this.data.id;
     }
-    getCreatedAt() {
+    /**
+     * @deprecated use id
+     */
+    getId() {
+        return this.id;
+    }
+    get createdAt() {
         if (!this.data.createdAt) {
             throw new Error('createdAt is required');
         }
         return new Date(this.data.createdAt);
     }
+    /**
+     * @deprecated use createdAt
+     */
+    getCreatedAt() {
+        return this.createdAt;
+    }
     update(newData) {
-        this.data = newData;
+        this.data = { ...this.data, ...newData, updatedAt: new Date().getTime() };
     }
     wasCreated() {
         return !!this.data.createdAt || !!this.data.id;
@@ -33,5 +43,10 @@ class Persistent {
         this.data.discardedAt = new Date().getTime();
     }
 }
+/**
+ * @deprecated Should use Entity
+ */
+class Persistent extends Entity {
+}
 
-export { Persistent };
+export { Entity, Persistent };