@wabot-dev/framework 0.1.0-beta.6 → 0.1.0-beta.61

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

@@ -1,59 +0,0 @@
-class WhatsAppReceiver {
-    logger;
-    listeners = new Map();
-    constructor(logger) {
-        this.logger = logger;
-    }
-    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,
-        };
-        const userConnection = {
-            id: contact.wa_id,
-            channelName,
-        };
-        await listener({
-            chatConnection,
-            userConnection,
-            senderName: contact.profile.name,
-            text: message.text.body,
-        });
-    }
-}
-
-export { WhatsAppReceiver };

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

@@ -1,32 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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/WhatsAppSenderByDevConnection.js

@@ -1,61 +0,0 @@
-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/ChatBot.js

@@ -1,51 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { ChatMemory } from '../core/chat/repository/IChatMemory.js';
-import '../core/chat/repository/IChatRepository.js';
-import { ChatItem } from '../core/chat/ChatItem.js';
-import '../core/user/IUserRepository.js';
-import { injectable } from '../injection/index.js';
-import { ChatBotAdapter } from './ChatBotAdapter.js';
-
-let ChatBot = class ChatBot {
-    memory;
-    adapter;
-    constructor(memory, adapter) {
-        this.memory = memory;
-        this.adapter = adapter;
-        this.memory = memory;
-    }
-    async sendMessage(message, callback) {
-        const newChatItem = new ChatItem({
-            type: 'CONNECTION_MESSAGE',
-            content: message,
-        });
-        await this.memory.create(newChatItem);
-        this.processLoop(callback);
-    }
-    async processLoop(callback) {
-        const prevChatItems = await this.memory.findLastItems(10);
-        if (prevChatItems.length === 0) {
-            return;
-        }
-        const lastChatItem = prevChatItems[prevChatItems.length - 1];
-        const lastItemType = lastChatItem.getType();
-        if (lastItemType === 'BOT_MESSAGE') {
-            return;
-        }
-        const newChatItem = await this.adapter.generateNextChatItem(prevChatItems);
-        await this.memory.create(newChatItem);
-        const newChatItemData = newChatItem.getData();
-        if (newChatItemData.type === 'BOT_MESSAGE') {
-            callback(newChatItemData.content);
-            return;
-        }
-        this.processLoop(callback);
-    }
-};
-ChatBot = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [ChatMemory,
-        ChatBotAdapter])
-], ChatBot);
-
-export { ChatBot };

package/dist/src/chatbot/ChatBotAdapter.js

@@ -1,72 +0,0 @@
-import '../core/chat/repository/IChatRepository.js';
-import { ChatItem } from '../core/chat/ChatItem.js';
-import '../core/user/IUserRepository.js';
-
-class ChatBotAdapter {
-    mindset;
-    constructor(mindset) {
-        this.mindset = mindset;
-    }
-    generateNextChatItem(chatItems) {
-        throw new Error('Not implemented');
-    }
-    async systemPrompt() {
-        let [identity, skills, limits] = await Promise.all([
-            this.mindset.identity(),
-            this.mindset.skills(),
-            this.mindset.limits(),
-        ]);
-        const language = identity.language.replaceAll('#', ' ');
-        const name = identity.name.replaceAll('#', ' ');
-        const age = identity.age ? identity.age.toString().replaceAll('#', ' ') : null;
-        const personality = identity.personality ? identity.personality.replaceAll('#', ' ') : null;
-        skills = skills.replaceAll('#', ' ');
-        limits = limits.replaceAll('#', ' ');
-        const systemPrompt = `
-         # System Instructions
-         you should act as a assistant.
-         your main language is ${language}.
-         your name is ${name}.
-         ${age ? 'you are ' + age + ' years old.' : ''}
-         
-          ${personality ? '## Personality (in your main language) \n' + personality : ''}
-  
-          ## Skills (in your main language)
-          ${skills}
-  
-          ## System limitations (in your main language)
-          ${limits}
-  
-          ## Chat memory
-          Next you will receive a chat history,
-          you should use this information to answer the user.
-      `;
-        return systemPrompt;
-    }
-    async buildBotMessageItem(text) {
-        const senderName = (await this.mindset.identity()).name;
-        const newBotMessage = new ChatItem({
-            type: 'BOT_MESSAGE',
-            content: {
-                senderName,
-                text,
-            },
-        });
-        return newBotMessage;
-    }
-    async buildFunctionCallItem(id, functionName, functionArguments) {
-        const functionResult = await this.mindset.callFunction(functionName, functionArguments);
-        const newFunctionCall = new ChatItem({
-            type: 'FUNCTION_CALL',
-            content: {
-                id,
-                name: functionName,
-                arguments: functionArguments,
-                result: functionResult,
-            },
-        });
-        return newFunctionCall;
-    }
-}
-
-export { ChatBotAdapter };

package/dist/src/controller/channel/UserResolver.js

@@ -1,21 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../core/chat/repository/IChatRepository.js';
-import { UserRepository } from '../../core/user/IUserRepository.js';
-import { singleton } from '../../injection/index.js';
-
-let UserResolver = class UserResolver {
-    userRepository;
-    constructor(userRepository) {
-        this.userRepository = userRepository;
-    }
-    async resolve(connection) {
-        let user = await this.userRepository.findByConnection(connection);
-        return user;
-    }
-};
-UserResolver = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [UserRepository])
-], UserResolver);
-
-export { UserResolver };

package/dist/src/core/IMessageContext.js

@@ -1,12 +0,0 @@
-class MessageContext {
-    message;
-    chat;
-    user;
-    constructor(message, chat, user) {
-        this.message = message;
-        this.chat = chat;
-        this.user = user;
-    }
-}
-
-export { MessageContext };

package/dist/src/core/chat/ChatItem.js

@@ -1,15 +0,0 @@
-import { Persistent } from '../Persistent.js';
-
-class ChatItem extends Persistent {
-    getType() {
-        return this.data.type;
-    }
-    getContent() {
-        return this.data.content;
-    }
-    getData() {
-        return this.data;
-    }
-}
-
-export { ChatItem };

package/dist/src/core/chat/repository/IChatMemory.js

@@ -1,10 +0,0 @@
-class ChatMemory {
-    findLastItems(count) {
-        throw new Error('Method not implemented.');
-    }
-    create(item) {
-        throw new Error('Method not implemented.');
-    }
-}
-
-export { ChatMemory };

package/dist/src/core/user/IUserRepository.js

@@ -1,19 +0,0 @@
-import { __decorate } from 'tslib';
-import { singleton } from '../../injection/index.js';
-
-let UserRepository = class UserRepository {
-    create(chat) {
-        throw new Error('Method not implemented.');
-    }
-    update(chat) {
-        throw new Error('Method not implemented.');
-    }
-    findByConnection(query) {
-        throw new Error('Method not implemented.');
-    }
-};
-UserRepository = __decorate([
-    singleton()
-], UserRepository);
-
-export { UserRepository };

package/dist/src/core/user/User.js

@@ -1,26 +0,0 @@
-import { Persistent } from '../Persistent.js';
-
-class User extends Persistent {
-    constructor(data) {
-        super(data);
-    }
-    hasConnection(connection) {
-        for (const con of this.data.connections) {
-            if (con.channelName === connection.channelName && con.id === connection.id) {
-                return true;
-            }
-        }
-        return false;
-    }
-    getValue(key) {
-        return this.data.keyValueData[key];
-    }
-    setValue(key, value) {
-        this.data.keyValueData[key] = value;
-    }
-    addConnection(connection) {
-        this.data.connections.push(connection);
-    }
-}
-
-export { User };

package/dist/src/env/WabotEnv.js

@@ -1,27 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { singleton } from 'tsyringe';
-
-let WabotEnv = class WabotEnv {
-    envType;
-    constructor() {
-        this.envType = process.env.WABOT_ENV ?? 'development';
-    }
-    isDevelopment() {
-        return this.envType === 'development';
-    }
-    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(),
-    __metadata("design:paramtypes", [])
-], WabotEnv);
-
-export { WabotEnv };

package/dist/src/injection/index.js

@@ -1,4 +0,0 @@
-await import('reflect-metadata');
-const { injectable, container, singleton, inject } = await import('tsyringe');
-
-export { container, inject, injectable, singleton };

package/dist/src/mindset/metadata/params/@isOptional.js

@@ -1,21 +0,0 @@
-import 'reflect-metadata';
-import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
-import { container } from '../../../injection/index.js';
-import { PARAM_DECORATION_IS_OPTIONAL } from './decoratorNames.js';
-
-function isOptional() {
-    return (target, propertyKey) => {
-        const paramName = propertyKey.toString();
-        const paramType = Reflect.getMetadata('design:type', target, paramName);
-        const store = container.resolve(MindsetMetadataStore);
-        store.saveParamDecoration({
-            decorationName: PARAM_DECORATION_IS_OPTIONAL,
-            paramType: paramType,
-            paramName: paramName,
-            constructor: target.constructor,
-            decorationConfig: {},
-        });
-    };
-}
-
-export { isOptional };

package/dist/src/pre-made/module/authentication/AuthenticationModule.js

@@ -1,97 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../core/chat/repository/IChatRepository.js';
-import { UserRepository } from '../../../core/user/IUserRepository.js';
-import { MessageContext } from '../../../core/IMessageContext.js';
-import { mindsetFunction } from '../../../mindset/metadata/functions/@mindsetFunction.js';
-import 'reflect-metadata';
-import '../../../injection/index.js';
-import '../../../mindset/metadata/MindsetMetadataStore.js';
-import { mindsetModule } from '../../../mindset/metadata/modules/@mindsetModule.js';
-import '../../../mindset/MindsetOperator.js';
-import { EmailService } from '../../service/EmailService.js';
-import { OtpService } from '../../service/OtpService.js';
-import { SendOneTimePasswordRequest } from './requests/SendOneTimePasswordRequest.js';
-import { ValidateOneTimePasswordRequest } from './requests/ValidateOneTimePasswordRequest.js';
-
-let AuthenticationModule = class AuthenticationModule {
-    userRepository;
-    emailService;
-    otpService;
-    context;
-    constructor(userRepository, emailService, otpService, context) {
-        this.userRepository = userRepository;
-        this.emailService = emailService;
-        this.otpService = otpService;
-        this.context = context;
-    }
-    async sendOneTimePassword(request) {
-        const user = await this.userRepository.findByConnection({
-            channelName: 'EmailChannel',
-            id: request.toEmail,
-        });
-        if (!user)
-            return 'success';
-        const otp = await this.otpService.generate();
-        const html = await this.generateOtpEmailHtml(otp, user);
-        const subject = await this.generateOtpEmailSubject();
-        await this.emailService.sendEmail({
-            from: request.fromEmail,
-            to: request.toEmail,
-            subject,
-            html,
-        });
-        user.setValue('OTP', otp);
-        await this.userRepository.update(user);
-        return 'success';
-    }
-    async validateOneTimePassword(request) {
-        const user = await this.userRepository.findByConnection({
-            channelName: 'EmailChannel',
-            id: request.userEmail,
-        });
-        if (!user) {
-            throw new Error('Invalid OTP');
-        }
-        const otp = user.getValue('OTP');
-        if (otp !== request.otp) {
-            throw new Error('Invalid OTP');
-        }
-        user.addConnection(this.context.message.userConnection);
-        await this.userRepository.update(user);
-        return 'success';
-    }
-    async generateOtpEmailHtml(otp, user) {
-        return `<p>Your OTP Code is ${otp}</p>`;
-    }
-    async generateOtpEmailSubject() {
-        return 'OTP Code';
-    }
-};
-__decorate([
-    mindsetFunction({
-        description: 'Send an One Time Password to the user when want authenticate',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [SendOneTimePasswordRequest]),
-    __metadata("design:returntype", Promise)
-], AuthenticationModule.prototype, "sendOneTimePassword", null);
-__decorate([
-    mindsetFunction({
-        description: 'Send an One Time Password to the user when want authenticate',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [ValidateOneTimePasswordRequest]),
-    __metadata("design:returntype", Promise)
-], AuthenticationModule.prototype, "validateOneTimePassword", null);
-AuthenticationModule = __decorate([
-    mindsetModule({
-        description: 'Provide authentication methods',
-        language: 'english',
-    }),
-    __metadata("design:paramtypes", [UserRepository,
-        EmailService,
-        OtpService,
-        MessageContext])
-], AuthenticationModule);
-
-export { AuthenticationModule };

package/dist/src/pre-made/module/authentication/requests/SendOneTimePasswordRequest.js

@@ -1,25 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import 'reflect-metadata';
-import '../../../../injection/index.js';
-import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import { param } from '../../../../mindset/metadata/params/@param.js';
-import '../../../../mindset/MindsetOperator.js';
-
-class SendOneTimePasswordRequest {
-    fromEmail = '';
-    toEmail = '';
-}
-__decorate([
-    param({
-        description: 'Sender Email address',
-    }),
-    __metadata("design:type", String)
-], SendOneTimePasswordRequest.prototype, "fromEmail", void 0);
-__decorate([
-    param({
-        description: 'Recipient Email Address, to send one time password',
-    }),
-    __metadata("design:type", String)
-], SendOneTimePasswordRequest.prototype, "toEmail", void 0);
-
-export { SendOneTimePasswordRequest };

package/dist/src/pre-made/module/authentication/requests/ValidateOneTimePasswordRequest.js

@@ -1,25 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import 'reflect-metadata';
-import '../../../../injection/index.js';
-import '../../../../mindset/metadata/MindsetMetadataStore.js';
-import { param } from '../../../../mindset/metadata/params/@param.js';
-import '../../../../mindset/MindsetOperator.js';
-
-class ValidateOneTimePasswordRequest {
-    userEmail = '';
-    otp = '';
-}
-__decorate([
-    param({
-        description: 'User Email',
-    }),
-    __metadata("design:type", String)
-], ValidateOneTimePasswordRequest.prototype, "userEmail", void 0);
-__decorate([
-    param({
-        description: 'Otp provided by the User',
-    }),
-    __metadata("design:type", String)
-], ValidateOneTimePasswordRequest.prototype, "otp", void 0);
-
-export { ValidateOneTimePasswordRequest };