@wabot-dev/framework 0.1.0-beta.9 → 0.2.0-beta.1

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,74 +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) => {
-            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 '../validators/validateIsOptional.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 };