@wabot-dev/framework 0.2.0 → 0.2.1-beta.2

package/dist/src/addon/auth/api-key/@apiKeyGuard.js

@@ -6,6 +6,7 @@ import '../../../core/validation/metadata/ValidationMetadataStore.js';
 import '../../../feature/express/ExpressProvider.js';
 import 'express';
 import 'path';
+import '../../../feature/rest-controller/RestRequest.js';
 import { ApiKeyGuardMiddleware } from './ApiKeyGuardMiddleware.js';
 
 function apiKeyGuard() {

package/dist/src/addon/auth/api-key/PgApiKeyRepository.js

@@ -1,9 +1,9 @@
 import { __decorate, __metadata } from 'tslib';
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
 import { Pool } from 'pg';
-import { singleton } from 'tsyringe';
 import { ApiKey } from './ApiKey.js';
 import { CustomError } from '../../../core/error/CustomError.js';
+import { singleton } from '../../../core/injection/index.js';
 
 let PgApiKeyRepository = class PgApiKeyRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/addon/auth/jwt/@jwtGuard.js

@@ -6,6 +6,7 @@ import '../../../core/validation/metadata/ValidationMetadataStore.js';
 import '../../../feature/express/ExpressProvider.js';
 import 'express';
 import 'path';
+import '../../../feature/rest-controller/RestRequest.js';
 import { JwtGuardMiddleware } from './JwtGuardMiddleware.js';
 
 function jwtGuard() {

package/dist/src/addon/chat-controller/cmd/@cmd.js

@@ -5,7 +5,6 @@ import '../../../core/auth/Auth.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
-import 'reflect-metadata';
 import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
 import '../../../feature/mindset/MindsetOperator.js';
 import { CmdChannel } from './CmdChannel.js';

package/dist/src/addon/chat-controller/socket/@socket.js

@@ -5,7 +5,6 @@ import '../../../core/auth/Auth.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
-import 'reflect-metadata';
 import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
 import '../../../feature/mindset/MindsetOperator.js';
 import { SocketChannel } from './SocketChannel.js';

package/dist/src/addon/chat-controller/telegram/@telegram.js

@@ -5,7 +5,6 @@ import '../../../core/auth/Auth.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
-import 'reflect-metadata';
 import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
 import '../../../feature/mindset/MindsetOperator.js';
 import { TelegramChannel } from './TelegramChannel.js';

package/dist/src/addon/chat-controller/whatsapp/@whatsApp.js

@@ -6,7 +6,6 @@ import '../../../core/auth/Auth.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
-import 'reflect-metadata';
 import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
 import '../../../feature/mindset/MindsetOperator.js';
 import { WhatsAppChannel } from './WhatsAppChannel.js';

package/dist/src/addon/chat-controller/whatsapp/cloud-api/WhatsAppSenderByCloudApi.js

@@ -9,7 +9,6 @@ import '../../../../feature/chat-bot/ChatBot.js';
 import { ChatRepository } from '../../../../feature/chat-bot/ChatRepository.js';
 import 'uuid';
 import '../../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
-import 'reflect-metadata';
 import '../../../../feature/mindset/metadata/MindsetMetadataStore.js';
 import '../../../../feature/mindset/MindsetOperator.js';
 import { WhatsAppRepository } from '../WhatsAppRepository.js';

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppSenderByWabotProxy.js

@@ -9,7 +9,6 @@ import '../../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import '../../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
 import { ChatResolver } from '../../../../feature/chat-controller/ChatResolver.js';
 import '../../../../core/auth/Auth.js';
-import 'reflect-metadata';
 import '../../../../feature/mindset/metadata/MindsetMetadataStore.js';
 import '../../../../feature/mindset/MindsetOperator.js';
 import { WhatsAppRepository } from '../WhatsAppRepository.js';

package/dist/src/addon/mindset/html/HtmlModule.js

@@ -1,10 +1,9 @@
 import { __decorate, __metadata } from 'tslib';
-import { mindsetFunction } from '../../../feature/mindset/metadata/functions/@mindsetFunction.js';
-import 'reflect-metadata';
+import { description } from '../../../core/description/metadata/@description.js';
+import '../../../core/description/metadata/DescriptionMetadataStore.js';
 import '../../../core/injection/index.js';
 import '../../../feature/mindset/metadata/MindsetMetadataStore.js';
 import { mindsetModule } from '../../../feature/mindset/metadata/modules/@mindsetModule.js';
-import { param } from '../../../feature/mindset/metadata/params/@param.js';
 import '../../../feature/mindset/MindsetOperator.js';
 import { convert } from 'html-to-text';
 
@@ -33,9 +32,7 @@ class KeywordsReq {
     keywords = '';
 }
 __decorate([
-    param({
-        description: 'Keywords separated by space',
-    }),
+    description('Keywords separated by space'),
     __metadata("design:type", String)
 ], KeywordsReq.prototype, "keywords", void 0);
 function HtmlModule(options) {
@@ -52,17 +49,13 @@ function HtmlModule(options) {
         }
     };
     __decorate([
-        mindsetFunction({
-            description: `Search information using keywords in the document "${options.title}". Priorize this info.`,
-        }),
+        description(`Search information using keywords in the document "${options.title}". Priorize this info.`),
         __metadata("design:type", Function),
         __metadata("design:paramtypes", [KeywordsReq]),
         __metadata("design:returntype", Promise)
     ], HtmlModuleIntern.prototype, _a, null);
     HtmlModuleIntern = __decorate([
-        mindsetModule({
-            description: `Search information using keywords in the document ${options.title}`,
-        })
+        mindsetModule()
     ], HtmlModuleIntern);
     return HtmlModuleIntern;
 }

package/dist/src/core/description/metadata/@description.js

@@ -0,0 +1,21 @@
+import { container } from '../../injection/index.js';
+import { DescriptionMetadataStore } from './DescriptionMetadataStore.js';
+
+function description(description) {
+    return (target, propertyKey) => {
+        const propertyName = propertyKey.toString();
+        const propertyType = Reflect.getMetadata('design:type', target, propertyName);
+        const functionArgsTypes = Reflect.getMetadata('design:paramtypes', target, propertyName);
+        const store = container.resolve(DescriptionMetadataStore);
+        store.saveDescriptionMetadata({
+            constructor: target.constructor,
+            propertyName,
+            propertyType,
+            functionArgsTypes,
+            functionReturnType: undefined,
+            description
+        });
+    };
+}
+
+export { description };

package/dist/src/core/description/metadata/DescriptionMetadataStore.js

@@ -0,0 +1,21 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../injection/index.js';
+
+let DescriptionMetadataStore = class DescriptionMetadataStore {
+    descriptions = new Map();
+    saveDescriptionMetadata(metadata) {
+        let ctorDescriptions = this.descriptions.get(metadata.constructor);
+        if (!ctorDescriptions) {
+            this.descriptions.set(metadata.constructor, (ctorDescriptions = []));
+        }
+        ctorDescriptions.unshift(metadata);
+    }
+    getModelDescriptions(model) {
+        return this.descriptions.get(model) ?? [];
+    }
+};
+DescriptionMetadataStore = __decorate([
+    singleton()
+], DescriptionMetadataStore);
+
+export { DescriptionMetadataStore };

package/dist/src/core/validation/metadata/@isArray.js

@@ -11,6 +11,7 @@ function isArray(options) {
             propertyName,
             validator: validateArray,
             validatorOptions: options,
+            typeDescriptor: 'array'
         });
     };
 }

package/dist/src/core/validation/metadata/@isModel.js

@@ -11,6 +11,7 @@ function isModel(model) {
             propertyName,
             validator: validateModel,
             validatorOptions: store.getModelValidatorsInfo(model),
+            typeDescriptor: 'object'
         });
     };
 }

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

@@ -58,6 +58,7 @@ let ValidationMetadataStore = class ValidationMetadataStore {
         constructors.unshift(modelConstructor);
         const modelValidators = {
             modelConstructor: modelConstructor,
+            modelHierarchy: constructors,
             properties: Object.assign({}, ...constructors.map((x) => this.getConstructorPropertiesValidatorsInfo(x))),
         };
         return modelValidators;

package/dist/src/core/validation/validators/is-boolean/@isBoolean.js

@@ -10,6 +10,7 @@ function isBoolean() {
             modelConstructor: target.constructor,
             propertyName,
             validator: validateIsBoolean,
+            validatorOptions: 'boolean',
         });
     };
 }

package/dist/src/core/validation/validators/is-date/@isDate.js

@@ -10,6 +10,7 @@ function isDate() {
             modelConstructor: target.constructor,
             propertyName,
             validator: validateIsDate,
+            typeDescriptor: 'date'
         });
     };
 }

package/dist/src/core/validation/validators/is-number/@isNumber.js

@@ -10,6 +10,7 @@ function isNumber() {
             modelConstructor: target.constructor,
             propertyName,
             validator: validateIsNumber,
+            typeDescriptor: 'number'
         });
     };
 }

package/dist/src/core/validation/validators/is-record/@isRecord.js

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

package/dist/src/core/validation/validators/is-record/validateIsRecord.js

@@ -0,0 +1,35 @@
+function validateIsRecord(value, options) {
+    if (value == null) {
+        return {
+            error: { description: `null is not allowed` },
+        };
+    }
+    if (typeof value !== 'object') {
+        return {
+            error: { description: `value should be an object` },
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            error: { description: `array is not allowed` },
+        };
+    }
+    for (const key in value) {
+        if (typeof key !== options.keyType) {
+            return {
+                error: { description: `record keys should be ${options.keyType}` },
+            };
+        }
+        const keyValue = value[key];
+        if (typeof keyValue !== options.valueType) {
+            return {
+                error: { description: `record values should be ${options.valueType}` },
+            };
+        }
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsRecord };

package/dist/src/core/validation/validators/is-string/@isString.js

@@ -10,6 +10,7 @@ function isString() {
             modelConstructor: target.constructor,
             propertyName,
             validator: validateIsString,
+            typeDescriptor: 'string'
         });
     };
 }

package/dist/src/feature/chat-bot/ChatBot.js

@@ -1,5 +1,4 @@
 import { __decorate, __metadata } from 'tslib';
-import 'reflect-metadata';
 import { injectable } from '../../core/injection/index.js';
 import '../mindset/metadata/MindsetMetadataStore.js';
 import { MindsetOperator } from '../mindset/MindsetOperator.js';

package/dist/src/feature/chat-controller/runChatControllers.js

@@ -6,7 +6,6 @@ import { ChatMemory } from '../chat-bot/ChatMemory.js';
 import { ChatRepository } from '../chat-bot/ChatRepository.js';
 import 'uuid';
 import { ChatBotMetadataStore } from '../chat-bot/metadata/ChatBotMetadataStore.js';
-import 'reflect-metadata';
 import '../mindset/metadata/MindsetMetadataStore.js';
 import { Mindset } from '../mindset/IMindset.js';
 import '../mindset/MindsetOperator.js';

package/dist/src/feature/mindset/MindsetOperator.js

@@ -2,6 +2,9 @@ import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../core/injection/index.js';
 import { Mindset } from './IMindset.js';
 import { MindsetMetadataStore } from './metadata/MindsetMetadataStore.js';
+import { validateModel } from '../../core/validation/core/validateModel.js';
+import '../../core/validation/metadata/ValidationMetadataStore.js';
+import { CustomError } from '../../core/error/CustomError.js';
 import { Container } from '../../core/injection/Container.js';
 
 let MindsetOperator = class MindsetOperator {
@@ -11,7 +14,7 @@ let MindsetOperator = class MindsetOperator {
     constructor(mindset, container, metadataStore) {
         this.mindset = mindset;
         this.container = container;
-        this.metadata = metadataStore.getMindsetMetadata(this.mindset.constructor);
+        this.metadata = metadataStore.getMindsetInfo(this.mindset.constructor);
     }
     identity() {
         return this.mindset.identity();
@@ -68,41 +71,36 @@ let MindsetOperator = class MindsetOperator {
     }
     tools() {
         return this.metadata.modules
-            .map((module) => module.functions.map((fn) => this.tool(fn, module)))
+            .map((module) => module.functions.map((fn) => {
+            return {
+                language: module.config?.language ?? 'english',
+                name: fn.name,
+                description: fn.description,
+                parameters: fn.argsDescriptions.map((x) => ({
+                    type: this.paramType(x.typeDescriptor),
+                    name: x.propertyName,
+                    description: this.paramDescription(x.description, x.typeDescriptor),
+                })),
+            };
+        }))
             .flat();
     }
-    tool(fn, module) {
-        const description = fn.config.description.replaceAll('#', ' ');
-        return {
-            language: module.config.language ?? 'english',
-            name: fn.name,
-            description,
-            parameters: fn.params.map((param) => this.toolParameter(param)),
-        };
-    }
-    toolParameter(param) {
+    paramDescription(rawDescription, rawType) {
         let description = `
       ### description (in your main language)
-      ${param.config.description.replaceAll('#', ' ')}
-      `;
-        const type = (() => {
-            if (param.type === Number)
-                return 'number';
-            if (param.type === String)
-                return 'string';
-            if (param.type === Date) {
-                description = `${description}
+      ${rawDescription.replaceAll('#', ' ')}
+    `;
+        if (rawType === 'date') {
+            description = `${description}
           ### format: ISO 8681 - YYYY-MM-DDTHH:mm:ssZ
-        `;
-                return 'string';
-            }
-            throw new Error(`Unsupported type`);
-        })();
-        return {
-            type,
-            name: param.name,
-            description,
-        };
+      `;
+        }
+        return description;
+    }
+    paramType(rawType) {
+        if (rawType === 'date')
+            return 'string';
+        return rawType;
     }
     async callFunction(name, params) {
         const fnMetadata = this.metadata.modules
@@ -112,9 +110,17 @@ let MindsetOperator = class MindsetOperator {
         if (!fnMetadata) {
             throw new Error(`Function ${name} not found`);
         }
-        const paramsObj = JSON.parse(params);
-        const module = this.container.resolve(fnMetadata.moduleConstructor);
         try {
+            let paramsObj = JSON.parse(params);
+            const modelValidationInfo = fnMetadata.argsValidatorsInfo;
+            if (modelValidationInfo) {
+                const validation = validateModel(paramsObj, modelValidationInfo);
+                if (validation.error) {
+                    throw new CustomError({ message: 'IA Params Are invalid', info: validation.error });
+                }
+                paramsObj = validation.value;
+            }
+            const module = this.container.resolve(fnMetadata.moduleConstructor);
             const response = await module[name](paramsObj);
             if (!response) {
                 return 'success';

package/dist/src/feature/mindset/metadata/MindsetMetadataStore.js

@@ -1,134 +1,81 @@
-import { __decorate } from 'tslib';
+import { __decorate, __metadata } from 'tslib';
 import { singleton } from '../../../core/injection/index.js';
-import { MINDSET_FUNCTION_DECORATION_FUNCTION } from './functions/decoratorNames.js';
-import { MINDSET_DECORATION_MINDSET } from './mindsets/decoratorNames.js';
-import { MINDSET_MODULE_DECORATION_MODULE } from './modules/decoratorNames.js';
+import { DescriptionMetadataStore } from '../../../core/description/metadata/DescriptionMetadataStore.js';
+import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
 
 let MindsetMetadataStore = class MindsetMetadataStore {
-    paramsDecorations = new Map();
-    functionsDecorations = new Map();
-    modulesDecorations = new Map();
-    mindsetsDecorations = new Map();
-    saveParamDecoration(paramDecoration) {
-        let paramsMap = this.paramsDecorations.get(paramDecoration.constructor);
-        if (!paramsMap) {
-            paramsMap = new Map();
-            this.paramsDecorations.set(paramDecoration.constructor, paramsMap);
-        }
-        let decorations = paramsMap.get(paramDecoration.paramName);
-        if (!decorations) {
-            decorations = [];
-            paramsMap.set(paramDecoration.paramName, decorations);
-        }
-        decorations.push(paramDecoration);
+    descriptionMetadataStore;
+    validationMetadataStore;
+    modules = new Map();
+    mindsets = new Map();
+    constructor(descriptionMetadataStore, validationMetadataStore) {
+        this.descriptionMetadataStore = descriptionMetadataStore;
+        this.validationMetadataStore = validationMetadataStore;
     }
-    saveFunctionDecoration(functionDecoration) {
-        let functionsMap = this.functionsDecorations.get(functionDecoration.constructor);
-        if (!functionsMap) {
-            functionsMap = new Map();
-            this.functionsDecorations.set(functionDecoration.constructor, functionsMap);
-        }
-        let decorations = functionsMap.get(functionDecoration.functionName);
-        if (!decorations) {
-            decorations = [];
-            functionsMap.set(functionDecoration.functionName, decorations);
-        }
-        decorations.push(functionDecoration);
+    saveModuleMetadata(metadata) {
+        this.modules.set(metadata.constructor, metadata);
     }
-    saveModuleDecoration(moduleDecoration) {
-        let modulesDecorations = this.modulesDecorations.get(moduleDecoration.constructor);
-        if (!modulesDecorations) {
-            modulesDecorations = [];
-            this.modulesDecorations.set(moduleDecoration.constructor, modulesDecorations);
-        }
-        modulesDecorations.push(moduleDecoration);
-    }
-    saveMindsetDecoration(mindsetDecoration) {
-        let mindsetsDecorations = this.mindsetsDecorations.get(mindsetDecoration.constructor);
-        if (!mindsetsDecorations) {
-            mindsetsDecorations = [];
-            this.mindsetsDecorations.set(mindsetDecoration.constructor, mindsetsDecorations);
-        }
-        mindsetsDecorations.push(mindsetDecoration);
+    saveMindsetMetadata(metadata) {
+        this.mindsets.set(metadata.constructor, metadata);
     }
-    getRequestParamsMetadata(requestConstructor) {
-        const paramsMap = this.paramsDecorations.get(requestConstructor);
-        if (!paramsMap) {
-            return [];
-        }
-        const paramsMetadata = [];
-        paramsMap.forEach((decorations, paramName) => {
-            const paramMainDecoration = decorations.find((decoration) => decoration.decorationConfig);
-            if (!paramMainDecoration) {
-                return;
-            }
-            paramsMetadata.push({
-                config: paramMainDecoration.decorationConfig,
-                name: paramName,
-                type: paramMainDecoration.paramType,
-            });
-            // TODO: add support for validation decorators
-        });
-        return paramsMetadata;
-    }
-    getFunctionsMetadata(moduleConstructor) {
-        const functionsMap = this.functionsDecorations.get(moduleConstructor);
-        if (!functionsMap) {
-            return [];
-        }
-        const functionsMetadata = [];
-        functionsMap.forEach((decorations) => {
-            const mainDecoration = decorations.find((decoration) => decoration.decorationName === MINDSET_FUNCTION_DECORATION_FUNCTION);
-            if (!mainDecoration) {
-                return;
-            }
-            functionsMetadata.push({
-                moduleConstructor: mainDecoration.constructor,
-                config: mainDecoration.decorationConfig,
-                name: mainDecoration.functionName,
-                requestConstructor: mainDecoration.paramsTypes[0],
-                params: mainDecoration.paramsTypes[0]
-                    ? this.getRequestParamsMetadata(mainDecoration.paramsTypes[0])
-                    : [],
-            });
-        });
-        return functionsMetadata;
-    }
-    getModuleMetadata(moduleConstructor) {
-        const decorations = this.modulesDecorations.get(moduleConstructor);
-        if (!decorations) {
-            throw new Error(`Module ${moduleConstructor.name} not found`);
-        }
-        const mainDecoration = decorations.find((decoration) => decoration.decorationName === MINDSET_MODULE_DECORATION_MODULE);
-        if (!mainDecoration) {
-            throw new Error(`Module ${moduleConstructor.name} not found`);
+    getModuleInfo(moduleCtor) {
+        const module = this.modules.get(moduleCtor);
+        if (!module) {
+            throw new Error(`not found mindsetModule info for ${moduleCtor.name}`);
         }
+        const descriptions = this.descriptionMetadataStore.getModelDescriptions(moduleCtor);
+        const functions = descriptions.filter((x) => x.propertyType === Function);
         return {
-            constructor: moduleConstructor,
-            config: mainDecoration.decorationConfig,
-            functions: this.getFunctionsMetadata(moduleConstructor),
+            config: module.config,
+            functions: functions.map((x) => {
+                if (x.functionArgsTypes && x.functionArgsTypes.length > 1) {
+                    throw new Error(`invalid mindset function ${x.propertyName}, should have none or one object parámeter`);
+                }
+                const functionArgsModel = x.functionArgsTypes && x.functionArgsTypes.length === 1 ? x.functionArgsTypes[0] : null;
+                const argsDescriptions = (functionArgsModel &&
+                    this.descriptionMetadataStore.getModelDescriptions(functionArgsModel)) ??
+                    [];
+                const functionArgsModelValidatorsInfo = functionArgsModel &&
+                    this.validationMetadataStore.getModelValidatorsInfo(functionArgsModel);
+                const argsValidators = functionArgsModelValidatorsInfo?.properties ?? {};
+                const argsDescriptionsWithTypes = argsDescriptions.map((argDescription) => {
+                    const argValidator = argsValidators[argDescription.propertyName];
+                    const typeValidator = argValidator?.validators?.find((x) => x.typeDescriptor);
+                    const typeDescriptor = typeValidator?.typeDescriptor;
+                    if (!typeDescriptor) {
+                        throw new Error(`the property '${argDescription.constructor.name}.${argDescription.propertyName}' should have a type validator`);
+                    }
+                    return { ...argDescription, typeDescriptor };
+                });
+                if (argsDescriptions.length !== Object.keys(argsValidators).length) {
+                    throw new Error(`the model '${moduleCtor.name}' have properties without descriptions`);
+                }
+                return {
+                    moduleConstructor: moduleCtor,
+                    function: x,
+                    name: x.propertyName,
+                    description: x.description,
+                    argsDescriptions: argsDescriptionsWithTypes,
+                    argsValidatorsInfo: functionArgsModelValidatorsInfo,
+                };
+            }),
         };
     }
-    getMindsetMetadata(ctor) {
-        const decorations = this.mindsetsDecorations.get(ctor);
-        if (!decorations) {
-            throw new Error(`Mindset ${ctor.name} not found`);
-        }
-        const mainDecoration = decorations.find((decoration) => decoration.decorationName === MINDSET_DECORATION_MINDSET);
-        if (!mainDecoration) {
-            throw new Error(`Mindset ${ctor.name} not found`);
+    getMindsetInfo(mindsetCtor) {
+        const mindset = this.mindsets.get(mindsetCtor);
+        if (!mindset) {
+            throw new Error(`not found mindset info for ${mindsetCtor.name}`);
         }
         return {
-            constructor: ctor,
-            config: mainDecoration.decorationConfig,
-            modules: mainDecoration.decorationConfig.modules
-                ? mainDecoration.decorationConfig.modules.map((module) => this.getModuleMetadata(module))
-                : [],
+            config: mindset.config,
+            modules: mindset.config?.modules?.map((x) => this.getModuleInfo(x)) ?? [],
         };
     }
 };
 MindsetMetadataStore = __decorate([
-    singleton()
+    singleton(),
+    __metadata("design:paramtypes", [DescriptionMetadataStore,
+        ValidationMetadataStore])
 ], MindsetMetadataStore);
 
 export { MindsetMetadataStore };

package/dist/src/feature/mindset/metadata/mindsets/@mindset.js

@@ -1,15 +1,12 @@
-import 'reflect-metadata';
 import { container, injectable } from '../../../../core/injection/index.js';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
-import { MINDSET_DECORATION_MINDSET } from './decoratorNames.js';
 
 function mindset(config) {
     return function (target) {
         const store = container.resolve(MindsetMetadataStore);
-        store.saveMindsetDecoration({
-            decorationName: MINDSET_DECORATION_MINDSET,
+        store.saveMindsetMetadata({
             constructor: target,
-            decorationConfig: config ?? {},
+            config,
         });
         injectable()(target);
     };

package/dist/src/feature/mindset/metadata/modules/@mindsetModule.js

@@ -1,14 +1,12 @@
 import { container, injectable } from '../../../../core/injection/index.js';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
-import { MINDSET_MODULE_DECORATION_MODULE } from './decoratorNames.js';
 
 function mindsetModule(config) {
     return function (target) {
         const store = container.resolve(MindsetMetadataStore);
-        store.saveModuleDecoration({
-            decorationName: MINDSET_MODULE_DECORATION_MODULE,
+        store.saveModuleMetadata({
             constructor: target,
-            decorationConfig: config,
+            config: config,
         });
         injectable()(target);
     };

package/dist/src/feature/rest-controller/RestRequest.js

@@ -0,0 +1,14 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../core/injection/index.js';
+import '../../core/validation/metadata/ValidationMetadataStore.js';
+import { isRecord } from '../../core/validation/validators/is-record/@isRecord.js';
+
+class RestRequest {
+    headers;
+}
+__decorate([
+    isRecord('string', 'string'),
+    __metadata("design:type", Object)
+], RestRequest.prototype, "headers", void 0);
+
+export { RestRequest };

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

@@ -1,13 +1,14 @@
 import { CustomError } from '../../core/error/CustomError.js';
 import { container } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
-import '../../core/validation/metadata/ValidationMetadataStore.js';
-import { validateAndTransform } from '../../core/validation/validateAndTransform.js';
+import { validateModel } from '../../core/validation/core/validateModel.js';
+import { ValidationMetadataStore } from '../../core/validation/metadata/ValidationMetadataStore.js';
 import { ExpressProvider } from '../express/ExpressProvider.js';
 import { json, urlencoded } from 'express';
 import path__default from 'path';
 import { EXPRESS_REQ, EXPRESS_RES } from './injection-tokens.js';
 import { RestControllerMetadataStore } from './metadata/RestControllerMetadataStore.js';
+import { RestRequest } from './RestRequest.js';
 
 function buildRequest(req) {
     return Object.assign({}, req.body, req.query, req.params);
@@ -16,6 +17,7 @@ function runRestControllers(controllers) {
     const logger = new Logger('wabot:rest');
     const metadataStore = container.resolve(RestControllerMetadataStore);
     const expressProvider = container.resolve(ExpressProvider);
+    const validationMetadataStore = container.resolve(ValidationMetadataStore);
     const expressApp = expressProvider.getExpress();
     controllers.forEach((controller) => {
         const endPoints = metadataStore.getControllerEndPointsInfo(controller);
@@ -43,20 +45,23 @@ function runRestControllers(controllers) {
                     }
                     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`);
+                    if (endPoint.paramsTypes.length > 1) {
+                        throw new Error(`rest controller endpoints should have zero or one parameter only`);
+                    }
+                    if (endPoint.paramsTypes.length === 1) {
+                        const paramType = endPoint.paramsTypes[0];
+                        if (typeof paramType !== 'function') {
+                            throw new Error(`invalid rest controller endpoint parameter type`);
                         }
-                        defaultArgFound = true;
-                        if (typeof paramType === 'function') {
-                            const { value, error } = validateAndTransform(buildRequest(req), paramType);
-                            if (error) {
-                                throw new CustomError({ httpCode: 400, message: error.description, info: error });
-                            }
-                            endPointArgs.push(value);
+                        const paramInfo = validationMetadataStore.getModelValidatorsInfo(paramType);
+                        const validableReq = paramInfo.modelHierarchy.includes(RestRequest)
+                            ? req
+                            : buildRequest(req);
+                        const { value, error } = validateModel(validableReq, paramInfo);
+                        if (error) {
+                            throw new CustomError({ httpCode: 400, message: error.description, info: error });
                         }
+                        endPointArgs.push(value);
                     }
                     const response = await controllerInstance[endPoint.functionName].apply(controllerInstance, endPointArgs);
                     res.status(200).json(response ?? null);

package/dist/src/index.d.ts

@@ -172,9 +172,11 @@ interface IPropertyValidatorInfo {
     propertyName: string;
     validator: IValidator;
     validatorOptions?: any;
+    typeDescriptor?: string;
 }
 type IModelValidatorsInfo<V> = {
     modelConstructor: IConstructor<V>;
+    modelHierarchy: IConstructor<any>[];
     properties: {
         [prop: string]: {
             isOptional?: boolean;
@@ -202,6 +204,7 @@ interface IValidatorMetadata {
     propertyName: string;
     validator: IValidator;
     validatorOptions?: any;
+    typeDescriptor?: string;
 }
 
 declare class ValidationMetadataStore {
@@ -265,6 +268,14 @@ interface IValidateMinOptions {
 }
 declare function validateMin(value: any, options: IValidateMinOptions): IValidationResult<any>;
 
+declare function isRecord(keyType: 'number' | 'string', valueType: 'number' | 'string' | 'boolean'): (target: object, propertyKey: string | symbol) => void;
+
+interface IValidateIsRecordOptions {
+    keyType: 'string' | 'number';
+    valueType: 'string' | 'number' | 'boolean';
+}
+declare function validateIsRecord(value: any, options: IValidateIsRecordOptions): IValidationResult<any>;
+
 declare class Mapper {
     map<T>(data: IValidateInputShape<T>, ctor: IConstructor<T>): T;
 }
@@ -422,22 +433,6 @@ declare class Chat extends Entity<IChatData> {
     validate(): void;
 }
 
-interface IMindsetFunctionConfig {
-    description: string;
-}
-
-declare function mindsetFunction(config: IMindsetFunctionConfig): (target: object, propertyKey: string | symbol) => void;
-
-declare const MINDSET_FUNCTION_DECORATION_FUNCTION = "mindsetFunction";
-
-interface IMindsetFunctionDecoration {
-    decorationName: string;
-    functionName: string;
-    constructor: Function;
-    paramsTypes: Function[];
-    decorationConfig: any;
-}
-
 interface IMindsetIdentity {
     name: string;
     language: string;
@@ -470,84 +465,86 @@ interface IMindsetConfig {
 
 declare function mindset(config?: IMindsetConfig): (target: IConstructor<IMindset>) => void;
 
-declare const MINDSET_DECORATION_MINDSET = "mindset";
-
-interface IMindsetDecoration {
-    decorationName: string;
-    constructor: Function;
-    decorationConfig: IMindsetConfig;
+interface IMindsetMetadata {
+    constructor: IConstructor<IMindset>;
+    config?: IMindsetConfig;
 }
 
 interface IMindsetModuleConfig {
-    description: string;
     language?: string;
 }
 
-declare function mindsetModule<A>(config: IMindsetModuleConfig): (target: IConstructor<A>) => void;
-
-declare const MINDSET_MODULE_DECORATION_MODULE = "mindsetModule";
+declare function mindsetModule<A>(config?: IMindsetModuleConfig): (target: IConstructor<A>) => void;
 
-interface IMindsetModuleDecoration {
-    decorationName: string;
+interface IMindsetModuleMetadata {
     constructor: Function;
-    decorationConfig: any;
+    config?: IMindsetModuleConfig;
 }
 
-interface IParamConfig {
-    name?: string;
-    optional?: boolean;
+interface IDescriptionMetadata {
+    constructor: IConstructor<any>;
+    propertyName: string;
+    propertyType?: Function;
+    functionArgsTypes?: Function[];
+    functionReturnType?: Function;
     description: string;
 }
 
-declare function param(config: IParamConfig): PropertyDecorator;
-
-interface IParamDecoration {
-    decorationName: string;
-    paramType: any;
-    paramName: string;
-    constructor: Function;
-    decorationConfig: any;
-}
-
-declare const PARAM_DECORATION_IS_OPTIONAL = "isOptional";
-declare const PARAM_DECORATION_PARAM = "param";
-
-interface IMindsetFunctionParamMetadata {
-    config: IParamConfig;
-    name: string;
-    type: Function;
-}
-interface IMindsetFunctionMetadata {
-    moduleConstructor: Function;
-    requestConstructor?: Function;
-    name: string;
-    config: IMindsetFunctionConfig;
-    params: IMindsetFunctionParamMetadata[];
-}
-interface IMindsetModuleMetadata {
-    constructor: Function;
-    config: IMindsetModuleConfig;
-    functions: IMindsetFunctionMetadata[];
-}
-interface IMindsetMetadata {
-    constructor: IConstructor<IMindset>;
-    config: IMindsetConfig;
-    modules: IMindsetModuleMetadata[];
+declare class DescriptionMetadataStore {
+    private descriptions;
+    saveDescriptionMetadata(metadata: IDescriptionMetadata): void;
+    getModelDescriptions(model: IConstructor<any>): IDescriptionMetadata[];
 }
 
 declare class MindsetMetadataStore {
-    private readonly paramsDecorations;
-    private readonly functionsDecorations;
-    private readonly modulesDecorations;
-    private readonly mindsetsDecorations;
-    saveParamDecoration(paramDecoration: IParamDecoration): void;
-    saveFunctionDecoration(functionDecoration: IMindsetFunctionDecoration): void;
-    saveModuleDecoration(moduleDecoration: IMindsetModuleDecoration): void;
-    saveMindsetDecoration(mindsetDecoration: IMindsetDecoration): void;
-    getRequestParamsMetadata(requestConstructor: Function): IMindsetFunctionParamMetadata[];
-    getFunctionsMetadata(moduleConstructor: Function): IMindsetFunctionMetadata[];
-    getModuleMetadata(moduleConstructor: Function): IMindsetModuleMetadata;
-    getMindsetMetadata(ctor: Function): IMindsetMetadata;
+    private descriptionMetadataStore;
+    private validationMetadataStore;
+    private readonly modules;
+    private readonly mindsets;
+    constructor(descriptionMetadataStore: DescriptionMetadataStore, validationMetadataStore: ValidationMetadataStore);
+    saveModuleMetadata(metadata: IMindsetModuleMetadata): void;
+    saveMindsetMetadata(metadata: IMindsetMetadata): void;
+    getModuleInfo(moduleCtor: IConstructor<any>): {
+        config: IMindsetModuleConfig | undefined;
+        functions: {
+            moduleConstructor: IConstructor<any>;
+            function: IDescriptionMetadata;
+            name: string;
+            description: string;
+            argsDescriptions: {
+                typeDescriptor: string;
+                constructor: IConstructor<any>;
+                propertyName: string;
+                propertyType?: Function;
+                functionArgsTypes?: Function[];
+                functionReturnType?: Function;
+                description: string;
+            }[];
+            argsValidatorsInfo: IModelValidatorsInfo<unknown> | null;
+        }[];
+    };
+    getMindsetInfo(mindsetCtor: IConstructor<IMindset>): {
+        config: IMindsetConfig | undefined;
+        modules: {
+            config: IMindsetModuleConfig | undefined;
+            functions: {
+                moduleConstructor: IConstructor<any>;
+                function: IDescriptionMetadata;
+                name: string;
+                description: string;
+                argsDescriptions: {
+                    typeDescriptor: string;
+                    constructor: IConstructor<any>;
+                    propertyName: string;
+                    propertyType?: Function;
+                    functionArgsTypes?: Function[];
+                    functionReturnType?: Function;
+                    description: string;
+                }[];
+                argsValidatorsInfo: IModelValidatorsInfo<unknown> | null;
+            }[];
+        }[];
+    };
 }
 
 interface IMindsetToolParameter {
@@ -555,6 +552,7 @@ interface IMindsetToolParameter {
     name: string;
     description: string;
 }
+
 interface IMindsetTool {
     language: string;
     name: string;
@@ -574,8 +572,8 @@ declare class MindsetOperator implements IMindset {
     llms(): Promise<IMindsetLlm[]>;
     systemPrompt(): Promise<string>;
     tools(): IMindsetTool[];
-    protected tool(fn: IMindsetFunctionMetadata, module: IMindsetModuleMetadata): IMindsetTool;
-    protected toolParameter(param: IMindsetFunctionParamMetadata): IMindsetToolParameter;
+    protected paramDescription(rawDescription: string, rawType: string): string;
+    protected paramType(rawType: string): string;
     callFunction(name: string, params: string): Promise<string>;
     functionResponseToString(response: any): Promise<string>;
     functionErrorToString(error: any): Promise<string>;
@@ -915,6 +913,10 @@ declare function runRestControllers(controllers: IConstructor<any>[]): void;
 declare const EXPRESS_REQ = "EXPRESS_REQ";
 declare const EXPRESS_RES = "EXPRESS_RES";
 
+declare class RestRequest {
+    headers?: Record<string, string>;
+}
+
 declare class SocketServerProvider {
     private httpServerProvider;
     private socketServer;
@@ -1625,4 +1627,4 @@ declare function HtmlModule(options: IHtmlModuleOptions): {
     new (): {};
 };
 
-export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, param, readJsonFromFile, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsApp, writeJsonToFile };
+export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, readJsonFromFile, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, writeJsonToFile };

package/dist/src/index.js

@@ -34,6 +34,8 @@ export { max } from './core/validation/validators/max/@max.js';
 export { validateMax } from './core/validation/validators/max/validateMax.js';
 export { min } from './core/validation/validators/min/@min.js';
 export { validateMin } from './core/validation/validators/min/validateMin.js';
+export { isRecord } from './core/validation/validators/is-record/@isRecord.js';
+export { validateIsRecord } from './core/validation/validators/is-record/validateIsRecord.js';
 export { command } from './feature/async/@command.js';
 export { commandHandler } from './feature/async/@commandHandler.js';
 export { Async } from './feature/async/Async.js';
@@ -59,14 +61,8 @@ export { ChatResolver } from './feature/chat-controller/ChatResolver.js';
 export { runChatControllers } from './feature/chat-controller/runChatControllers.js';
 export { ExpressProvider } from './feature/express/ExpressProvider.js';
 export { HttpServerProvider } from './feature/http/HttpServerProvider.js';
-export { mindsetFunction } from './feature/mindset/metadata/functions/@mindsetFunction.js';
-export { MINDSET_FUNCTION_DECORATION_FUNCTION } from './feature/mindset/metadata/functions/decoratorNames.js';
 export { mindset } from './feature/mindset/metadata/mindsets/@mindset.js';
-export { MINDSET_DECORATION_MINDSET } from './feature/mindset/metadata/mindsets/decoratorNames.js';
 export { mindsetModule } from './feature/mindset/metadata/modules/@mindsetModule.js';
-export { MINDSET_MODULE_DECORATION_MODULE } from './feature/mindset/metadata/modules/decoratorNames.js';
-export { param } from './feature/mindset/metadata/params/@param.js';
-export { PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM } from './feature/mindset/metadata/params/decoratorNames.js';
 export { MindsetMetadataStore } from './feature/mindset/metadata/MindsetMetadataStore.js';
 export { Mindset } from './feature/mindset/IMindset.js';
 export { MindsetOperator } from './feature/mindset/MindsetOperator.js';
@@ -83,6 +79,7 @@ export { restController } from './feature/rest-controller/metadata/@restControll
 export { RestControllerMetadataStore } from './feature/rest-controller/metadata/RestControllerMetadataStore.js';
 export { runRestControllers } from './feature/rest-controller/runRestControllers.js';
 export { EXPRESS_REQ, EXPRESS_RES } from './feature/rest-controller/injection-tokens.js';
+export { RestRequest } from './feature/rest-controller/RestRequest.js';
 export { SocketServerProvider } from './feature/socket/SocketServerProvider.js';
 export { handshakeMiddlewares } from './feature/socket-controller/metadata/@handshakeMiddlewares.js';
 export { socketController } from './feature/socket-controller/metadata/@socketController.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.2.0",
+  "version": "0.2.1-beta.2",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -26,7 +26,6 @@
     "@rollup/plugin-typescript": "12.1.2",
     "@yucacodes/ts": "^0.0.4",
     "prettier": "^3.5.3",
-    "resend": "^4.4.1",
     "rollup": "4.39.0",
     "tsup": "^8.4.0",
     "typescript": "5.8.3"

package/dist/src/feature/mindset/metadata/functions/@mindsetFunction.js

@@ -1,21 +0,0 @@
-import 'reflect-metadata';
-import { container } from '../../../../core/injection/index.js';
-import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
-import { MINDSET_FUNCTION_DECORATION_FUNCTION } from './decoratorNames.js';
-
-function mindsetFunction(config) {
-    return function (target, propertyKey) {
-        const functionName = propertyKey.toString();
-        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
-        const store = container.resolve(MindsetMetadataStore);
-        store.saveFunctionDecoration({
-            decorationName: MINDSET_FUNCTION_DECORATION_FUNCTION,
-            paramsTypes: paramsTypes,
-            functionName,
-            constructor: target.constructor,
-            decorationConfig: config,
-        });
-    };
-}
-
-export { mindsetFunction };

package/dist/src/feature/mindset/metadata/functions/decoratorNames.js

@@ -1,3 +0,0 @@
-const MINDSET_FUNCTION_DECORATION_FUNCTION = 'mindsetFunction';
-
-export { MINDSET_FUNCTION_DECORATION_FUNCTION };

package/dist/src/feature/mindset/metadata/mindsets/decoratorNames.js

@@ -1,3 +0,0 @@
-const MINDSET_DECORATION_MINDSET = 'mindset';
-
-export { MINDSET_DECORATION_MINDSET };

package/dist/src/feature/mindset/metadata/modules/decoratorNames.js

@@ -1,3 +0,0 @@
-const MINDSET_MODULE_DECORATION_MODULE = 'mindsetModule';
-
-export { MINDSET_MODULE_DECORATION_MODULE };

package/dist/src/feature/mindset/metadata/params/@param.js

@@ -1,21 +0,0 @@
-import 'reflect-metadata';
-import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
-import { container } from '../../../../core/injection/index.js';
-import { PARAM_DECORATION_PARAM } from './decoratorNames.js';
-
-function param(config) {
-    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_PARAM,
-            paramType: paramType,
-            paramName: paramName,
-            constructor: target.constructor,
-            decorationConfig: config,
-        });
-    };
-}
-
-export { param };

package/dist/src/feature/mindset/metadata/params/decoratorNames.js

@@ -1,4 +0,0 @@
-const PARAM_DECORATION_IS_OPTIONAL = 'isOptional';
-const PARAM_DECORATION_PARAM = 'param';
-
-export { PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM };