@wabot-dev/framework 0.1.0-beta.7 → 0.1.0-beta.71

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 };

package/dist/src/pre-made/module/register-user/RegisterUserModule.js

@@ -1,56 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../core/chat/repository/IChatRepository.js';
-import { User } from '../../../core/user/User.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 { RegisterUserWithEmailRequest } from './requests/RegisterUserWithEmailRequest.js';
-
-let RegisterUserModule = class RegisterUserModule {
-    userRepository;
-    context;
-    constructor(userRepository, context) {
-        this.userRepository = userRepository;
-        this.context = context;
-    }
-    async registerUserWithEmail(request) {
-        if (this.context.user) {
-            throw new Error('The User is already authenticated');
-        }
-        const user = new User({
-            shortName: request.shortName,
-            connections: [
-                {
-                    channelName: 'EmailChannel',
-                    id: request.email,
-                },
-            ],
-            keyValueData: {},
-        });
-        await this.userRepository.create(user);
-        return 'success';
-    }
-};
-__decorate([
-    mindsetFunction({
-        description: 'Register a new user using email',
-    }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [RegisterUserWithEmailRequest]),
-    __metadata("design:returntype", Promise)
-], RegisterUserModule.prototype, "registerUserWithEmail", null);
-RegisterUserModule = __decorate([
-    mindsetModule({
-        description: 'Provide functions to register an user',
-        language: 'english',
-    }),
-    __metadata("design:paramtypes", [UserRepository,
-        MessageContext])
-], RegisterUserModule);
-
-export { RegisterUserModule };

package/dist/src/pre-made/module/register-user/requests/RegisterUserWithEmailRequest.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 RegisterUserWithEmailRequest {
-    email = '';
-    shortName = '';
-}
-__decorate([
-    param({
-        description: 'Email of the User',
-    }),
-    __metadata("design:type", String)
-], RegisterUserWithEmailRequest.prototype, "email", void 0);
-__decorate([
-    param({
-        description: 'ShortName for the new User',
-    }),
-    __metadata("design:type", String)
-], RegisterUserWithEmailRequest.prototype, "shortName", void 0);
-
-export { RegisterUserWithEmailRequest };

package/dist/src/pre-made/repository/user/pg/PgUserRepository.js

@@ -1,33 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import '../../../../core/chat/repository/IChatRepository.js';
-import { User } from '../../../../core/user/User.js';
-import '../../../../core/user/IUserRepository.js';
-import { singleton } from '../../../../injection/index.js';
-import { PgCrudRepository } from '../../../../repository/pg/PgCrudRepository.js';
-import { Pool } from 'pg';
-
-let PgUserRepository = class PgUserRepository extends PgCrudRepository {
-    constructor(pool) {
-        super(pool, {
-            table: 'user',
-            schema: 'wabot',
-            constructor: User,
-        });
-    }
-    async findByConnection(query) {
-        const sql = `
-      SELECT ${this.columns}
-      FROM ${this.table}
-      WHERE data->'connections' @> $1::jsonb
-      LIMIT 1
-    `;
-        const items = await this.query(sql, [JSON.stringify([query])]);
-        return items.at(0) ?? null;
-    }
-};
-PgUserRepository = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [Pool])
-], PgUserRepository);
-
-export { PgUserRepository };

package/dist/src/pre-made/repository/user/ram/RamUserRepository.js

@@ -1,27 +0,0 @@
-import { __decorate } from 'tslib';
-import { v4 } from 'uuid';
-import { singleton } from '../../../../injection/index.js';
-
-let RamUserRepository = class RamUserRepository {
-    items = [];
-    async create(chat) {
-        if (chat.wasCreated()) {
-            throw new Error('User already created');
-        }
-        chat['data'].id = v4();
-        chat['data'].createdAt = new Date().getTime();
-        chat.validate();
-        this.items.push(chat);
-    }
-    async findByConnection(query) {
-        return this.items.find((item) => item.hasConnection(query)) ?? null;
-    }
-    async update(chat) {
-        // TODO
-    }
-};
-RamUserRepository = __decorate([
-    singleton()
-], RamUserRepository);
-
-export { RamUserRepository };

package/dist/src/pre-made/service/EmailService.js

@@ -1,13 +0,0 @@
-import { __decorate } from 'tslib';
-import { injectable } from '../../injection/index.js';
-
-let EmailService = class EmailService {
-    async sendEmail(request) {
-        throw new Error('Not implemented');
-    }
-};
-EmailService = __decorate([
-    injectable()
-], EmailService);
-
-export { EmailService };

package/dist/src/pre-made/service/OtpService.js

@@ -1,14 +0,0 @@
-import { __decorate } from 'tslib';
-import { injectable } from '../../injection/index.js';
-import { randomInt } from 'crypto';
-
-let OtpService = class OtpService {
-    async generate() {
-        return randomInt(100000, 999999).toString();
-    }
-};
-OtpService = __decorate([
-    injectable()
-], OtpService);
-
-export { OtpService };

package/dist/src/rest-controller/runRestControllers.js

@@ -1,75 +0,0 @@
-import '../injection/index.js';
-import { RestControllerMetadataStore } from './metadata/RestControllerMetadataStore.js';
-import '../controller/channel/ChatResolver.js';
-import '../controller/channel/UserResolver.js';
-import '../controller/metadata/ControllerMetadataStore.js';
-import '../channels/cmd/CmdChannel.js';
-import { ExpressProvider } from '../channels/express/ExpressProvider.js';
-import '../channels/http/HttpServerProvider.js';
-import '../channels/socket/SocketChannel.js';
-import '../channels/socket/SocketChannelConfig.js';
-import '../channels/socket/SocketServerProvider.js';
-import '../channels/telegram/TelegramChannel.js';
-import '../channels/whatsapp/WhatsAppChannel.js';
-import '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
-import '../channels/whatsapp/WhatsAppReceiverByDevConnection.js';
-import '../channels/whatsapp/WhatsAppReceiverByWebHook.js';
-import '../channels/whatsapp/WhatsAppSenderByDevConnection.js';
-import '../channels/whatsapp/WhatsAppSenderByCloudApi.js';
-import '../channels/whatsapp/PgWhatsAppRepository.js';
-import '../channels/whatsapp/EnvWhatsAppRepository.js';
-import path from 'path';
-import { Logger } from '../logger/Logger.js';
-
-function buildRequest(req) {
-    return Object.assign({}, req.body, req.query, req.params);
-}
-function runRestControllers(controllers, container) {
-    const logger = new Logger('wabot:rest');
-    const metadataStore = container.resolve(RestControllerMetadataStore);
-    const expressProvider = container.resolve(ExpressProvider);
-    const expressApp = expressProvider.getExpress();
-    controllers.forEach((controller) => {
-        const endPoints = metadataStore.getControllerEndPointsInfo(controller);
-        endPoints.forEach((endPoint) => {
-            debugger;
-            const method = endPoint.method;
-            const route = path.join(endPoint.controller.path, endPoint.path ?? '');
-            logger.info(`config ${endPoint.method.toUpperCase()} ${route}`);
-            expressApp[method](route, async (req, res) => {
-                const requestContainer = container.createChildContainer();
-                const controllerInstance = requestContainer.resolve(endPoint.controllerConstructor);
-                const endPointArgs = [];
-                let defaultArgFound = false;
-                for (let paramIndex = 0; paramIndex < endPoint.paramsTypes.length; paramIndex++) {
-                    const paramType = endPoint.paramsTypes[paramIndex];
-                    if (defaultArgFound) {
-                        throw new Error(`Cant determine de parameter ${paramIndex} value`);
-                    }
-                    defaultArgFound = true;
-                    if (typeof paramType === 'function' && typeof paramType.__validate__ === 'function') {
-                        const { value, error } = paramType.__validate__(buildRequest(req));
-                        debugger;
-                        if (error) {
-                            res.status(400).json({ error });
-                            return;
-                        }
-                        endPointArgs.push(value);
-                    }
-                }
-                try {
-                    const response = await controllerInstance[endPoint.functionName].apply(controllerInstance, endPointArgs);
-                    res.status(200).json(response);
-                }
-                catch (err) {
-                    res.sendStatus(500);
-                }
-                requestContainer.dispose();
-            });
-        });
-    });
-    expressProvider.listen();
-}
-
-export { runRestControllers };

package/dist/src/server/prepareChatContainer.js

@@ -1,43 +0,0 @@
-import '../injection/index.js';
-import 'reflect-metadata';
-import '../mindset/metadata/MindsetMetadataStore.js';
-import { Mindset } from '../mindset/IMindset.js';
-import '../mindset/MindsetOperator.js';
-import { ChatMemory } from '../core/chat/repository/IChatMemory.js';
-import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
-import { MessageContext } from '../core/IMessageContext.js';
-import 'uuid';
-import { ChatBotMetadataStore } from '../chatbot/metadata/ChatBotMetadataStore.js';
-import { ChatBot } from '../chatbot/ChatBot.js';
-import { Container } from '../injection/Container.js';
-
-async function prepareChatContainer(container, context, mindsetCtor) {
-    const chatContainer = container.createChildContainer();
-    chatContainer.register(Container, { useValue: chatContainer });
-    chatContainer.register(MessageContext, {
-        useValue: new MessageContext(context.message, context.chat, context.user),
-    });
-    const chatRepository = container.resolve(ChatRepository);
-    const chatMemory = await chatRepository.findMemory(context.chat.getId());
-    if (!chatMemory) {
-        throw new Error('Not found Chat Memory for Chat with Id=' + context.chat.getId());
-    }
-    chatContainer.register(ChatMemory, { useValue: chatMemory });
-    const chatBotMetadataStore = container.resolve(ChatBotMetadataStore);
-    const chatBots = chatBotMetadataStore.getChatBotsMetadata();
-    for (const chatBotMetadata of chatBots) {
-        chatContainer.beforeResolution(chatBotMetadata.constructor, (a, b) => {
-            const subContainer = chatContainer.createChildContainer();
-            subContainer.register(Mindset, { useClass: chatBotMetadata.mindsetConstructor });
-            const chatBot = subContainer.resolve(ChatBot);
-            chatContainer.register(chatBotMetadata.injectionToken, { useValue: chatBot });
-        });
-    }
-    if (mindsetCtor) {
-        chatContainer.register(Mindset, { useClass: mindsetCtor });
-    }
-    return chatContainer;
-}
-
-export { prepareChatContainer };

package/dist/src/server/runChannel.js

@@ -1,27 +0,0 @@
-import { container } from '../injection/index.js';
-import 'uuid';
-import '../chatbot/metadata/ChatBotMetadataStore.js';
-import { ChatBot } from '../chatbot/ChatBot.js';
-import { ChatBotAdapter } from '../chatbot/ChatBotAdapter.js';
-import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
-import { prepareChatContainer } from './prepareChatContainer.js';
-
-function runChannel(props) {
-    container.registerSingleton(ChatRepository, props.chatRepository);
-    container.register(ChatBotAdapter, { useClass: props.chatBotAdapter });
-    if (props.channelConfig) {
-        container.register(props.channelConfig.constructor, { useValue: props.channelConfig });
-    }
-    const channel = container.resolve(props.channel);
-    channel.listen(async (context) => {
-        const channelContainer = await prepareChatContainer(container, context, props.mindset);
-        const chatBot = channelContainer.resolve(ChatBot);
-        chatBot.sendMessage(context.message, (replyMessage) => {
-            context.reply(replyMessage);
-        });
-    });
-    channel.connect();
-}
-
-export { runChannel };

package/dist/src/server/runServer.js

@@ -1,40 +0,0 @@
-import '../controller/channel/ChatResolver.js';
-import '../controller/channel/UserResolver.js';
-import { container } from '../injection/index.js';
-import { ControllerMetadataStore } from '../controller/metadata/ControllerMetadataStore.js';
-import { prepareChatContainer } from './prepareChatContainer.js';
-
-function runServer(config) {
-    for (const provider of config.providers ?? []) {
-        if (provider.singleton) {
-            container.registerSingleton(provider.replace, provider.with);
-        }
-        else {
-            container.register(provider.replace, provider.with);
-        }
-    }
-    const metadataStore = container.resolve(ControllerMetadataStore);
-    for (const controllerCtor of config.controllers) {
-        const chatControllerMetadata = metadataStore.getChatControllerMetadata(controllerCtor);
-        if (!chatControllerMetadata) {
-            continue;
-        }
-        for (const channelMetadata of chatControllerMetadata.channels) {
-            const channelContainer = container.createChildContainer();
-            if (channelMetadata.channelConfig) {
-                channelContainer.register(channelMetadata.channelConfig.constructor, {
-                    useValue: channelMetadata.channelConfig,
-                });
-            }
-            const channel = channelContainer.resolve(channelMetadata.channelConstructor);
-            channel.listen(async (messageContext) => {
-                const chatContainer = await prepareChatContainer(channelContainer, messageContext);
-                const chatController = chatContainer.resolve(channelMetadata.controllerConstructor);
-                chatController[channelMetadata.functionName](messageContext);
-            });
-            channel.connect();
-        }
-    }
-}
-
-export { runServer };

package/dist/src/validation/metadata/@validable.js

@@ -1,14 +0,0 @@
-import { container } from 'tsyringe';
-import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { validateModel } from '../validators/validateModel.js';
-
-function validable() {
-    return function (target) {
-        target.__validate__ = function (value) {
-            const info = container.resolve(ValidationMetadataStore).getModelValidatorsInfo(target);
-            return validateModel(value, info);
-        };
-    };
-}
-
-export { validable };

package/dist/src/validation/metadata/ValidationMetadataStore.js

@@ -1,55 +0,0 @@
-import { __decorate } from 'tslib';
-import { singleton } from '../../injection/index.js';
-import { _IS_OPTIONAL_DUMMY_VALIDATOR_ } from './@isOptional.js';
-
-let ValidationMetadataStore = class ValidationMetadataStore {
-    validators = new Map();
-    saveValidatorMetadata(validatorMetadata) {
-        let modelValidators = this.validators.get(validatorMetadata.modelConstructor);
-        if (!modelValidators) {
-            this.validators.set(validatorMetadata.modelConstructor, (modelValidators = new Map()));
-        }
-        let propertyValidators = modelValidators.get(validatorMetadata.propertyName);
-        if (!propertyValidators) {
-            propertyValidators = [];
-            modelValidators.set(validatorMetadata.propertyName, propertyValidators);
-        }
-        propertyValidators.unshift(validatorMetadata);
-    }
-    getModelValidatorsInfo(modelConstructor) {
-        const modelValidators = {
-            modelConstructor: modelConstructor,
-            properties: {},
-        };
-        [...(this.validators.get(modelConstructor)?.values() ?? [])].forEach((propertyValidatorsMetadata) => {
-            const propertyName = propertyValidatorsMetadata.at(0)?.propertyName;
-            if (!propertyName) {
-                return;
-            }
-            let propertyInfo = modelValidators.properties[propertyName];
-            if (!propertyInfo) {
-                propertyInfo = {};
-                modelValidators.properties[propertyName] = propertyInfo;
-            }
-            let validators = propertyInfo.validators;
-            if (!validators) {
-                validators = [];
-                propertyInfo.validators = validators;
-            }
-            propertyValidatorsMetadata.forEach((propertyValidatorMetadata) => {
-                if (propertyValidatorMetadata.validator === _IS_OPTIONAL_DUMMY_VALIDATOR_) {
-                    propertyInfo.isOptional = true;
-                }
-                else {
-                    validators.push(propertyValidatorMetadata);
-                }
-            });
-        });
-        return modelValidators;
-    }
-};
-ValidationMetadataStore = __decorate([
-    singleton()
-], ValidationMetadataStore);
-
-export { ValidationMetadataStore };

package/dist/src/validation/validators/validateModel.js

@@ -1,47 +0,0 @@
-function validateModel(value, info) {
-    const result = {};
-    if (typeof value !== 'object') {
-        result.error = {
-            model: [
-                {
-                    description: `the value should be an object`,
-                },
-            ],
-            properties: [],
-        };
-        return result;
-    }
-    const validatedValue = new info.modelConstructor();
-    for (const propertyName in info.properties) {
-        const propertyInfo = info.properties[propertyName];
-        const propertyValidators = propertyInfo.validators ?? [];
-        validatedValue[propertyName] = value[propertyName] ?? validatedValue[propertyName];
-        if (validatedValue[propertyName] == null && propertyInfo.isOptional) {
-            validatedValue[propertyName] = null;
-            continue;
-        }
-        for (let propertyValidatorInfo of propertyValidators) {
-            const propertyValidatorResult = propertyValidatorInfo.validator(validatedValue[propertyName], propertyValidatorInfo.validatorOptions);
-            validatedValue[propertyName] = propertyValidatorResult.value;
-            if (propertyValidatorResult.error) {
-                let resultError = result.error;
-                if (!resultError) {
-                    resultError = { model: [], properties: [] };
-                    result.error = resultError;
-                }
-                let propertyErrors = resultError.properties.find((x) => x.name === propertyName);
-                if (!propertyErrors) {
-                    propertyErrors = { name: propertyName, errors: [] };
-                    resultError.properties.push(propertyErrors);
-                }
-                propertyErrors.errors.push(propertyValidatorResult.error);
-            }
-        }
-    }
-    if (!result.error) {
-        result.value = validatedValue;
-    }
-    return result;
-}
-
-export { validateModel };