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

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

@@ -21,7 +21,7 @@ let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter
         this.model = model || 'deepseek-chat';
         this.deepSeek = new OpenAI({
             apiKey: apiKey,
-            baseURL: baseURL
+            baseURL: baseURL,
         });
     }
     validateEnvVariables(envVariables) {
@@ -36,14 +36,15 @@ let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter
         const tools = (await this.mindset.allFunctionsDescriptors()).map((fn) => {
             const parameters = { ...fn.parameters, additionalProperties: false, type: 'object' };
             return {
-                type: 'function', function: { name: fn.name, description: fn.description, parameters, strict: true }
+                type: 'function',
+                function: { name: fn.name, description: fn.description, parameters, strict: true },
             };
         });
         const response = await this.deepSeek.chat.completions.create({
             model: this.model,
             messages: [{ role: 'system', content: systemPrompt }, ...this.mapChatItems(chatItems)],
             tools: tools,
-            tool_choice: 'auto'
+            tool_choice: 'auto',
         });
         let newChatItem;
         const { tool_calls: responseFunctionCall, content: responseText } = response.choices?.[0]?.message ?? {};
@@ -83,15 +84,15 @@ let DeepSeekChatBotAdapter = class DeepSeekChatBotAdapter extends ChatBotAdapter
                             type: 'function',
                             function: {
                                 name: itemData.content.name,
-                                arguments: JSON.stringify(itemData.content.arguments)
-                            }
-                        }
-                    ]
+                                arguments: JSON.stringify(itemData.content.arguments),
+                            },
+                        },
+                    ],
                 });
                 deepSeekInput.push({
                     role: 'tool',
                     tool_call_id: itemData.content.id,
-                    content: itemData.content.result
+                    content: itemData.content.result,
                 });
             }
         }

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

@@ -55,7 +55,10 @@ class WhatsAppSender {
         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');
+        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,
@@ -77,7 +80,7 @@ class WhatsAppSender {
     }
     replaceTemplateParameters(template, data) {
         let result = template;
-        data.forEach(param => {
+        data.forEach((param) => {
             if (param.type === 'text' && param.parameter_name) {
                 const tag = `{{${param.parameter_name}}}`;
                 result = result.split(tag).join(param.text);

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

@@ -42,7 +42,7 @@ let WhatsAppSenderByDevConnection = class WhatsAppSenderByDevConnection extends
         }
     }
     async handleGetWhatsAppTemplate(request) {
-        throw new Error("Not implemented");
+        throw new Error('Not implemented');
     }
 };
 WhatsAppSenderByDevConnection = __decorate([

package/dist/src/index.d.ts

@@ -226,8 +226,6 @@ interface IMindsetModuleDecoration {
     decorationConfig: any;
 }
 
-declare function isOptional(): PropertyDecorator;
-
 interface IParamConfig {
     name?: string;
     optional?: boolean;
@@ -972,4 +970,143 @@ declare class RamChatRepository implements IChatRepository {
     private getMemory;
 }
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, EnvWhatsAppRepository, ExpressProvider, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type IEmailService, type IGetWhatsAppTemplateRequest, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IReceivedMessage, type IReceivedMessageItem, type IReversibleMapper, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IWabotEnvType, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, socket, telegram, whatsapp };
+interface IGetConfig {
+    path?: string;
+}
+
+declare function get(config?: IGetConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IRestControllerConfig {
+    path: string;
+}
+
+declare function restController(config: IRestControllerConfig): (target: IConstructor<any>) => void;
+
+interface IEndPointMetadata {
+    method: 'get' | 'post';
+    path?: string;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
+}
+
+interface IRestControllerMetadata {
+    controllerConstructor: IConstructor<any>;
+    path: string;
+}
+
+declare class RestControllerMetadataStore {
+    private endPoints;
+    private restControllers;
+    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
+    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
+    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
+        controller: IRestControllerMetadata;
+        method: "get" | "post";
+        path?: string;
+        controllerConstructor: IConstructor<any>;
+        functionName: string;
+        paramsTypes: any[];
+    }[];
+}
+
+declare function runRestControllers(controllers: IConstructor<any>[], container: DependencyContainer$1): void;
+
+declare function isBoolean(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isDate(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isNotEmpty(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isNumber(): (target: object, propertyKey: string | symbol) => void;
+
+declare const _IS_OPTIONAL_DUMMY_VALIDATOR_: (value: any) => {
+    value: any;
+    errors: never[];
+};
+declare function isOptional(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isPresent(): (target: object, propertyKey: string | symbol) => void;
+
+declare function isString(): (target: object, propertyKey: string | symbol) => void;
+
+declare function max(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+declare function min(limit: any): (target: object, propertyKey: string | symbol) => void;
+
+declare function validable<A>(): (target: IConstructor<A>) => void;
+
+interface IValidationError {
+    description: string;
+}
+interface IModelValidationError {
+    model: IValidationError[];
+    properties: {
+        name: string;
+        errors: IValidationError[];
+    }[];
+}
+interface IValidationResult<V> {
+    value?: V;
+    error?: IValidationError;
+}
+interface IModelValidationResult<V> {
+    value?: V;
+    error?: IModelValidationError;
+}
+type IValidator = (value: any, options: any) => IValidationResult<any>;
+interface IPropertyValidatorInfo {
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
+}
+type IModelValidatorsInfo<V> = {
+    modelConstructor: IConstructor<V>;
+    properties: {
+        [prop: string]: {
+            isOptional?: boolean;
+            validators?: IPropertyValidatorInfo[];
+        } | undefined;
+    };
+};
+
+interface IValidatorMetadata {
+    modelConstructor: IConstructor<any>;
+    propertyName: string;
+    validator: IValidator;
+    validatorOptions?: any;
+}
+
+declare class ValidationMetadataStore {
+    private validators;
+    saveValidatorMetadata(validatorMetadata: IValidatorMetadata): void;
+    getModelValidatorsInfo<V>(modelConstructor: IConstructor<V>): IModelValidatorsInfo<V>;
+}
+
+declare function validateIsBoolean(value: any): IValidationResult<boolean>;
+
+declare function validateIsDate(value: any): IValidationResult<Date>;
+
+declare function validateIsNotEmpty(value: any): IValidationResult<any>;
+
+declare function validateIsNumber(value: any): IValidationResult<number>;
+
+declare function validateIsString(value: any): IValidationResult<string>;
+
+interface IValidateMaxOptions {
+    limit: any;
+}
+declare function validateMax(value: any, options: IValidateMaxOptions): IValidationResult<any>;
+
+interface IValidateMinOptions {
+    limit: any;
+}
+declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
+
+declare function validateIsPresent(value: any): IValidationResult<any>;
+
+declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IModelValidationResult<V>;
+
+declare function validateModel2<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
+
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, EnvWhatsAppRepository, ExpressProvider, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type IEmailService, type IEndPointMetadata, type IGetConfig, type IGetWhatsAppTemplateRequest, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type IReversibleMapper, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWabotEnvType, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, _IS_OPTIONAL_DUMMY_VALIDATOR_, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isNotEmpty, isNumber, isOptional, isPresent, isString, max, min, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, restController, runChannel, runRestControllers, runServer, singleton, socket, telegram, validable, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, validateModel2, whatsapp };

package/dist/src/index.js

@@ -47,7 +47,6 @@ export { mindset } from './mindset/metadata/mindsets/@mindset.js';
 export { MINDSET_DECORATION_MINDSET } from './mindset/metadata/mindsets/decoratorNames.js';
 export { mindsetModule } from './mindset/metadata/modules/@mindsetModule.js';
 export { MINDSET_MODULE_DECORATION_MODULE } from './mindset/metadata/modules/decoratorNames.js';
-export { isOptional } from './mindset/metadata/params/@isOptional.js';
 export { param } from './mindset/metadata/params/@param.js';
 export { PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM } from './mindset/metadata/params/decoratorNames.js';
 export { MindsetMetadataStore } from './mindset/metadata/MindsetMetadataStore.js';
@@ -73,4 +72,29 @@ export { PgCrudRepository } from './repository/pg/PgCrudRepository.js';
 export { PgRepositoryBase } from './repository/pg/PgRepositoryBase.js';
 export { Logger } from './logger/Logger.js';
 export { WabotEnv } from './env/WabotEnv.js';
+export { get } from './rest-controller/metadata/@get.js';
+export { restController } from './rest-controller/metadata/@restController.js';
+export { RestControllerMetadataStore } from './rest-controller/metadata/RestControllerMetadataStore.js';
+export { runRestControllers } from './rest-controller/runRestControllers.js';
+export { isBoolean } from './validation/metadata/@isBoolean.js';
+export { isDate } from './validation/metadata/@isDate.js';
+export { isNotEmpty } from './validation/metadata/@isNotEmpty.js';
+export { isNumber } from './validation/metadata/@isNumber.js';
+export { _IS_OPTIONAL_DUMMY_VALIDATOR_, isOptional } from './validation/metadata/@isOptional.js';
+export { isPresent } from './validation/metadata/@isPresent.js';
+export { isString } from './validation/metadata/@isString.js';
+export { max } from './validation/metadata/@max.js';
+export { min } from './validation/metadata/@min.js';
+export { validable } from './validation/metadata/@validable.js';
+export { ValidationMetadataStore } from './validation/metadata/ValidationMetadataStore.js';
+export { validateIsBoolean } from './validation/validators/validateIsBoolean.js';
+export { validateIsDate } from './validation/validators/validateIsDate.js';
+export { validateIsNotEmpty } from './validation/validators/validateIsNotEmpty.js';
+export { validateIsNumber } from './validation/validators/validateIsNumber.js';
+export { validateIsString } from './validation/validators/validateIsString.js';
+export { validateMax } from './validation/validators/validateMax.js';
+export { validateMin } from './validation/validators/validateMin.js';
+export { validateIsPresent } from './validation/validators/validateIsPresent.js';
+export { validateModel } from './validation/validators/validateModel.js';
+export { validateModel2 } from './validation/validateModel2.js';
 export { Container } from './injection/Container.js';

package/dist/src/mindset/MindsetOperator.js

@@ -60,7 +60,7 @@ let MindsetOperator = class MindsetOperator {
                     ...prev,
                     [param.name]: this.toolParam(param),
                 }), {}),
-                required: fn.params.filter((param) => !param.config.optional).map((param) => param.name)
+                required: fn.params.filter((param) => !param.config.optional).map((param) => param.name),
             },
         };
     }

package/dist/src/rest-controller/metadata/@get.js

@@ -0,0 +1,19 @@
+import { container } from '../../injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function get(config) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
+        const store = container.resolve(RestControllerMetadataStore);
+        store.saveEndPointMetadata({
+            controllerConstructor: target.constructor,
+            functionName,
+            method: 'get',
+            path: config?.path,
+            paramsTypes,
+        });
+    };
+}
+
+export { get };

package/dist/src/rest-controller/metadata/@restController.js

@@ -0,0 +1,15 @@
+import { container, injectable } from '../../injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function restController(config) {
+    return function (target) {
+        const metaDataStore = container.resolve(RestControllerMetadataStore);
+        metaDataStore.saveControllerMetadata({
+            controllerConstructor: target,
+            path: config.path,
+        });
+        injectable()(target);
+    };
+}
+
+export { restController };

package/dist/src/rest-controller/metadata/RestControllerMetadataStore.js

@@ -0,0 +1,37 @@
+import { __decorate } from 'tslib';
+import { singleton } from 'tsyringe';
+
+let RestControllerMetadataStore = class RestControllerMetadataStore {
+    endPoints = new Map();
+    restControllers = new Map();
+    saveControllerMetadata(controllerMetadata) {
+        this.restControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
+    }
+    saveEndPointMetadata(endPointMetadata) {
+        let controllerEndPoints = this.endPoints.get(endPointMetadata.controllerConstructor);
+        if (!controllerEndPoints) {
+            this.endPoints.set(endPointMetadata.controllerConstructor, (controllerEndPoints = new Map()));
+        }
+        controllerEndPoints.set(endPointMetadata.functionName, endPointMetadata);
+    }
+    getControllerEndPointsInfo(controllerConstructor) {
+        const controller = this.restControllers.get(controllerConstructor);
+        if (!controller) {
+            throw new Error(`${controllerConstructor.name} should be decorated with @restController`);
+        }
+        const endPoints = this.endPoints.get(controllerConstructor);
+        if (!endPoints?.size) {
+            // TODO: Warning
+            return [];
+        }
+        return [...endPoints.values()].map((endPoint) => ({
+            ...endPoint,
+            controller: this.restControllers.get(endPoint.controllerConstructor),
+        }));
+    }
+};
+RestControllerMetadataStore = __decorate([
+    singleton()
+], RestControllerMetadataStore);
+
+export { RestControllerMetadataStore };

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

@@ -0,0 +1,75 @@
+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/validation/metadata/@isBoolean.js

@@ -0,0 +1,17 @@
+import { container } from '../../injection/index.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+import { validateIsBoolean } from '../validators/validateIsBoolean.js';
+
+function isBoolean() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsBoolean,
+        });
+    };
+}
+
+export { isBoolean };

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

@@ -0,0 +1,17 @@
+import { container } from '../../injection/index.js';
+import { validateIsDate } from '../validators/validateIsDate.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+
+function isDate() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsDate,
+        });
+    };
+}
+
+export { isDate };

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

@@ -0,0 +1,17 @@
+import { container } from '../../injection/index.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+import { validateIsNotEmpty } from '../validators/validateIsNotEmpty.js';
+
+function isNotEmpty() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsNotEmpty,
+        });
+    };
+}
+
+export { isNotEmpty };

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

@@ -0,0 +1,17 @@
+import { container } from '../../injection/index.js';
+import { validateIsNumber } from '../validators/validateIsNumber.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+
+function isNumber() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsNumber,
+        });
+    };
+}
+
+export { isNumber };

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

@@ -0,0 +1,19 @@
+import { container } from '../../injection/index.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+
+const _IS_OPTIONAL_DUMMY_VALIDATOR_ = (value) => {
+    return { value, errors: [] };
+};
+function isOptional() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: _IS_OPTIONAL_DUMMY_VALIDATOR_,
+        });
+    };
+}
+
+export { _IS_OPTIONAL_DUMMY_VALIDATOR_, isOptional };

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

@@ -0,0 +1,17 @@
+import { container } from '../../injection/index.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+import { validateIsPresent } from '../validators/validateIsPresent.js';
+
+function isPresent() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsPresent,
+        });
+    };
+}
+
+export { isPresent };

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

@@ -0,0 +1,17 @@
+import { container } from '../../injection/index.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+import { validateIsString } from '../validators/validateIsString.js';
+
+function isString() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsString,
+        });
+    };
+}
+
+export { isString };

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

@@ -0,0 +1,18 @@
+import { container } from '../../injection/index.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+import { validateMax } from '../validators/validateMax.js';
+
+function max(limit) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateMax,
+            validatorOptions: { limit },
+        });
+    };
+}
+
+export { max };

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

@@ -0,0 +1,18 @@
+import { container } from '../../injection/index.js';
+import { ValidationMetadataStore } from './ValidationMetadataStore.js';
+import { validateMin } from '../validators/validateMin.js';
+
+function min(limit) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateMin,
+            validatorOptions: { limit },
+        });
+    };
+}
+
+export { min };

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

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

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

@@ -0,0 +1,11 @@
+import { container } from '../injection/index.js';
+import { ValidationMetadataStore } from './metadata/ValidationMetadataStore.js';
+import { validateModel } from './validators/validateModel.js';
+
+function validateModel2(value, modelConstructor) {
+    const metadataStore = container.resolve(ValidationMetadataStore);
+    const info = metadataStore.getModelValidatorsInfo(modelConstructor);
+    return validateModel(value, info);
+}
+
+export { validateModel2 };

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

@@ -0,0 +1,12 @@
+function validateIsBoolean(value) {
+    if (typeof value !== 'boolean') {
+        return {
+            error: { description: `boolean value is required` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsBoolean };

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

@@ -0,0 +1,16 @@
+function validateIsDate(value) {
+    const _value = new Date(value);
+    const time = _value.getTime();
+    if ((typeof value !== 'number' && typeof value !== 'string' && !(value instanceof Date)) ||
+        isNaN(time) ||
+        time < 0) {
+        return {
+            error: { description: `Date value is not valid` },
+        };
+    }
+    return {
+        value: _value,
+    };
+}
+
+export { validateIsDate };

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

@@ -0,0 +1,12 @@
+function validateIsNotEmpty(value) {
+    if (value === '' || (Array.isArray(value) && value.length === 0)) {
+        return {
+            error: { description: `empty value not allowed` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsNotEmpty };

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

@@ -0,0 +1,12 @@
+function validateIsNumber(value) {
+    if (typeof value !== 'number') {
+        return {
+            error: { description: `number value is required` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsNumber };

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

@@ -0,0 +1,12 @@
+function validateIsPresent(value) {
+    if (value == null) {
+        return {
+            error: { description: `not present` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsPresent };

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

@@ -0,0 +1,12 @@
+function validateIsString(value) {
+    if (typeof value !== 'string') {
+        return {
+            error: { description: `string value is required` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsString };

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

@@ -0,0 +1,17 @@
+function validateMax(value, options) {
+    if (value == null) {
+        return {
+            error: { description: `null or undefined value can't be validated with max` },
+        };
+    }
+    if (Number(value) > Number(options.limit)) {
+        return {
+            error: { description: `exceeds the established max limit` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateMax };

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

@@ -0,0 +1,17 @@
+function validateMin(value, options) {
+    if (value == null) {
+        return {
+            error: { description: `null or undefined value can't be validated with min` },
+        };
+    }
+    if (Number(value) < Number(options.limit)) {
+        return {
+            error: { description: `exceeds the established min limit` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateMin };

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

@@ -0,0 +1,47 @@
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.1.0-beta.6",
+  "version": "0.1.0-beta.7",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -39,8 +39,6 @@
     "@types/pg": "^8.11.14",
     "@yucacodes/ts": "^0.0.4",
     "body-parser": "^2.2.0",
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.1",
     "debug": "^4.4.0",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",

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