@wabot-dev/framework 0.1.0-beta.1 → 0.1.0-beta.11

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/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/validate.js

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

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.1.0-beta.1",
+  "version": "0.1.0-beta.11",
   "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"

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

@@ -1,69 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { singleton } from '../../injection/index.js';
-import { Logger } from '../../logger/Logger.js';
-import { io } from 'socket.io-client';
-import { WhatsAppConnection } from './WhatsAppConnection.js';
-import { devWhatsappEmitEvent, devWhatsAppListentEvent } from './WhatsAppDevSocketContracts.js';
-
-let WhatsAppDevConnection = class WhatsAppDevConnection extends WhatsAppConnection {
-    devProxy;
-    devProxySocket;
-    devToken;
-    connected = false;
-    constructor() {
-        super(new Logger('wabot:whatsapp-dev-connection'));
-        this.devProxy = process.env.WABOT_DEV_PROXY ?? 'https://proxy.wabot.dev';
-        this.devToken = process.env.WABOT_DEV_TOKEN;
-        this.devProxySocket = io(this.devProxy, { autoConnect: false });
-    }
-    async sendWhatsApp(businessNumber, to, chatMessage) {
-        const req = {
-            from: businessNumber,
-            to,
-            message: chatMessage,
-        };
-        await this.devProxySocket.emitWithAck(devWhatsappEmitEvent.DEV_SEND_WHATSAPP, req);
-    }
-    async sendWhatsAppTemplate(businessNumber, to, templateMessage) {
-        const req = {
-            from: businessNumber,
-            to,
-            message: templateMessage,
-        };
-        await this.devProxySocket.emitWithAck(devWhatsappEmitEvent.DEV_SEND_WHATSAPP_TEMPLATE, req);
-    }
-    connect() {
-        if (this.connected) {
-            return;
-        }
-        this.connected = true;
-        this.devProxySocket.connect();
-        this.devProxySocket.on('connect', async () => {
-            if (!this.devToken) {
-                return;
-            }
-            try {
-                const req = {
-                    token: this.devToken,
-                };
-                const ack = await this.devProxySocket.emitWithAck(devWhatsappEmitEvent.DEV_CONNECTION, req);
-                if (ack != 'OK') {
-                    return this.logger.debug('dev connection fails');
-                }
-                this.devProxySocket.on(devWhatsAppListentEvent.DEV_WATSAPP_WEBHOOK, async (payload) => {
-                    await this.handlePayload(payload);
-                });
-                return this.logger.debug('success dev connection');
-            }
-            catch (err) {
-                this.logger.error(err);
-            }
-        });
-    }
-};
-WhatsAppDevConnection = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [])
-], WhatsAppDevConnection);
-
-export { WhatsAppDevConnection };

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

@@ -1,39 +0,0 @@
-import { __decorate, __param, __metadata } from 'tslib';
-import '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import { inject } from '../../injection/index.js';
-import '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import '../../controller/metadata/ControllerMetadataStore.js';
-import { ExpressApp } from '../../controller/express/Express.js';
-import 'socket.io';
-import { singleton } from 'tsyringe';
-
-let WhatsAppProdConnection = class WhatsAppProdConnection {
-    express;
-    constructor(express) {
-        this.express = express;
-        this.express.get('/try-express', (req, res) => {
-            res.status(200).json({ success: true });
-        });
-    }
-    listenMessage(businessNumber, listener) {
-        throw new Error('Method not implemented.');
-    }
-    sendWhatsApp(businessNumber, to, replyMessage) {
-        throw new Error('Method not implemented.');
-    }
-    sendWhatsAppTemplate(businessNumber, to, templateMessage) {
-        throw new Error('Method not implemented.');
-    }
-    connect() {
-        throw new Error('Method not implemented.');
-    }
-};
-WhatsAppProdConnection = __decorate([
-    singleton(),
-    __param(0, inject(ExpressApp)),
-    __metadata("design:paramtypes", [Function])
-], WhatsAppProdConnection);
-
-export { WhatsAppProdConnection };

package/dist/src/controller/express/Express.js

@@ -1,5 +0,0 @@
-import 'express';
-
-const ExpressApp = Symbol.for('ExpressApp');
-
-export { ExpressApp };

package/dist/src/controller/socket.io/SocketIO.js

@@ -1,5 +0,0 @@
-import 'socket.io';
-
-const SocketIoApp = Symbol.for('SocketIoApp');
-
-export { SocketIoApp };

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

package/dist/src/pre-made/repository/chat/sqlite/SqliteChatMemory.js

@@ -1,23 +0,0 @@
-import path from 'path';
-import { ChatItem } from '../../../../core/chat/ChatItem.js';
-import '../../../../core/chat/repository/IChatRepository.js';
-import '../../../../core/user/IUserRepository.js';
-import 'pg';
-import 'short-uuid';
-import { SqliteCrudRepository } from '../../../../repository/sqlite/SqliteCrudRepository.js';
-import { sqliteMapperFor } from '../../../../repository/sqlite/SqlitePersistentMapper.js';
-
-class SqliteChatMemory extends SqliteCrudRepository {
-    constructor(chatId) {
-        super('chat_item', SqliteChatMemory.getDbPath(chatId), sqliteMapperFor(ChatItem));
-    }
-    async findLastItems(count) {
-        const allItems = await this.findAll();
-        return allItems.slice(allItems.length - count, allItems.length);
-    }
-    static getDbPath(chatId) {
-        return path.join(process.cwd(), '.sqlite', 'chat-memory', chatId + '.db');
-    }
-}
-
-export { SqliteChatMemory };

package/dist/src/pre-made/repository/chat/sqlite/SqliteChatRepository.js

@@ -1,30 +0,0 @@
-import '../../../../core/chat/repository/IChatRepository.js';
-import { Chat } from '../../../../core/chat/Chat.js';
-import '../../../../core/user/IUserRepository.js';
-import path from 'path';
-import { SqliteChatMemory } from './SqliteChatMemory.js';
-import 'pg';
-import 'short-uuid';
-import { SqliteCrudRepository } from '../../../../repository/sqlite/SqliteCrudRepository.js';
-import { sqliteMapperFor } from '../../../../repository/sqlite/SqlitePersistentMapper.js';
-
-class SqliteChatRepository extends SqliteCrudRepository {
-    constructor() {
-        super('chat', SqliteChatRepository.getDbPath(), sqliteMapperFor(Chat));
-    }
-    async findByConnection(query) {
-        const allChats = await this.findAll();
-        return allChats.find((chat) => chat.hasConnection(query)) ?? null;
-    }
-    async findMemory(chatId) {
-        const chat = await this.find(chatId);
-        if (!chat)
-            return null;
-        return new SqliteChatMemory(chatId);
-    }
-    static getDbPath() {
-        return path.join(process.cwd(), '.sqlite', 'chat.db');
-    }
-}
-
-export { SqliteChatRepository };