@wabot-dev/framework 0.0.17 → 0.0.50

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

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

package/dist/src/server/prepareChatContainer.js

@@ -1,12 +1,12 @@
-import { ChatMemory } from '../core/chat/repository/IChatMemory.js';
-import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
-import { MessageContext } from '../core/IMessageContext.js';
 import '../injection/index.js';
 import 'reflect-metadata';
 import '../mindset/metadata/MindsetMetadataStore.js';
 import { Mindset } from '../mindset/IMindset.js';
 import '../mindset/MindsetOperator.js';
+import { ChatMemory } from '../core/chat/repository/IChatMemory.js';
+import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
+import '../core/user/IUserRepository.js';
+import { MessageContext } from '../core/IMessageContext.js';
 import 'uuid';
 import { ChatBotMetadataStore } from '../chatbot/metadata/ChatBotMetadataStore.js';
 import { ChatBot } from '../chatbot/ChatBot.js';

package/dist/src/server/runChannel.js

@@ -1,18 +1,10 @@
-import 'reflect-metadata';
 import { container } from '../injection/index.js';
-import '../mindset/metadata/MindsetMetadataStore.js';
-import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
-import '../mindset/MindsetOperator.js';
 import 'uuid';
 import '../chatbot/metadata/ChatBotMetadataStore.js';
 import { ChatBot } from '../chatbot/ChatBot.js';
 import { ChatBotAdapter } from '../chatbot/ChatBotAdapter.js';
-import '../controller/channel/ChatResolver.js';
-import '../controller/channel/UserResolver.js';
-import '../controller/metadata/ControllerMetadataStore.js';
-import 'express';
-import 'socket.io';
+import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
+import '../core/user/IUserRepository.js';
 import { prepareChatContainer } from './prepareChatContainer.js';
 
 function runChannel(props) {

package/dist/src/server/runServer.js

@@ -1,49 +1,10 @@
 import '../controller/channel/ChatResolver.js';
 import '../controller/channel/UserResolver.js';
 import { container } from '../injection/index.js';
-import '../core/chat/repository/IChatRepository.js';
-import '../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../controller/metadata/ControllerMetadataStore.js';
-import { ExpressApp } from '../controller/express/Express.js';
-import { SocketIoApp } from '../controller/socket.io/SocketIO.js';
 import { prepareChatContainer } from './prepareChatContainer.js';
-import express from 'express';
-import { Server } from 'socket.io';
-import http from 'http';
-import bodyParser from 'body-parser';
-import { Logger } from '../logger/Logger.js';
 
 function runServer(config) {
-    const httpLogger = new Logger('wabot:http');
-    const socketLogger = new Logger('wabot:socket');
-    const expressApp = express();
-    const httpServer = http.createServer(expressApp);
-    const io = new Server(httpServer, {
-        cors: {
-            origin: '*',
-        },
-    });
-    expressApp.use(bodyParser.json());
-    expressApp.use((req, res, next) => {
-        const start = process.hrtime();
-        res.on('finish', () => {
-            const [seconds, nanoseconds] = process.hrtime(start);
-            const ms = (seconds * 1000 + nanoseconds / 1e6).toFixed(2);
-            httpLogger.trace(`${req.method} ${req.originalUrl} ${res.statusCode} - ${ms}ms`);
-        });
-        next();
-    });
-    io.on('connection', (socket) => {
-        socketLogger.trace(`socket:${socket.id} connection`);
-        socket.onAny((event) => {
-            socketLogger.trace(`socket:${socket.id} emmits ${event}`);
-        });
-        socket.on('disconnect', (reason) => {
-            socketLogger.trace(`socket:${socket.id} disconnect with reason: ${reason}`);
-        });
-    });
-    container.register(ExpressApp, { useValue: expressApp });
-    container.register(SocketIoApp, { useValue: io });
     for (const provider of config.providers ?? []) {
         if (provider.singleton) {
             container.registerSingleton(provider.replace, provider.with);
@@ -74,10 +35,6 @@ function runServer(config) {
             channel.connect();
         }
     }
-    const PORT = process.env.PORT || 3000;
-    httpServer.listen(PORT, () => {
-        httpLogger.info(`server listenig on port ${PORT}`);
-    });
 }
 
 export { runServer };

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

package/dist/src/validation/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/validateIsOptional.js

@@ -0,0 +1,5 @@
+const _IS_OPTIONAL_DUMMY_VALIDATOR_ = (value) => {
+    return { value, errors: [] };
+};
+
+export { _IS_OPTIONAL_DUMMY_VALIDATOR_ };

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.0.17",
+  "version": "0.0.50",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -16,7 +16,7 @@
     "fmt": "prettier --write .",
     "fmt:check": "prettier --check .",
     "types:check": "tsc --noEmit",
-    "elia:dev": "yts --import ./dotenv.config.mjs  ./test/elia/runElia.ts"
+    "elia:dev": "yts --import ./env.mjs  ./test/elia/runElia.ts"
   },
   "devDependencies": {
     "@rollup/plugin-alias": "5.1.1",
@@ -24,6 +24,7 @@
     "@rollup/plugin-json": "6.1.0",
     "@rollup/plugin-node-resolve": "16.0.1",
     "@rollup/plugin-typescript": "12.1.2",
+    "@types/html-to-text": "^9.0.4",
     "@types/node": "22.14.1",
     "@types/react": "^19.1.2",
     "@yucacodes/ts": "^0.0.4",
@@ -39,20 +40,17 @@
     "@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",
     "grammy": "^1.36.0",
+    "html-to-text": "^9.0.5",
     "openai": "^4.93.0",
     "pg": "^8.15.6",
     "reflect-metadata": "^0.2.2",
     "short-uuid": "^5.2.0",
     "socket.io": "^4.8.1",
     "socket.io-client": "^4.8.1",
-    "sqlite": "^5.1.1",
-    "sqlite3": "^5.1.7",
     "tslib": "^2.8.1",
     "tsyringe": "^4.9.1",
     "uuid": "^11.1.0"