@wabot-dev/framework 0.1.0-beta.5 → 0.1.0-beta.51

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

@@ -0,0 +1,65 @@
+import { __decorate, __metadata } from 'tslib';
+import { WhatsAppReceiver } from '../WhatsAppReceiver.js';
+import { injectable } from '../../../../core/injection/index.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import { WHATSAPP_MESSAGE_EVENT } from './WhatsAppProxyContracts.js';
+import { WhatsAppWabotProxyConnection } from './WhatsAppWabotProxyConnection.js';
+
+let WhatsAppReceiverByWabotProxy = class WhatsAppReceiverByWabotProxy extends WhatsAppReceiver {
+    connection;
+    loger = new Logger('wabot:whats-app-receiver-by-wabot-proxy');
+    constructor(connection) {
+        super();
+        this.connection = connection;
+    }
+    async connect() {
+        // Nothing
+    }
+    listenMessage(request) {
+        this.connection.getSocket().then(async (socket) => {
+            const req = {
+                event: 'listenMessage',
+                data: {
+                    to: [request.to],
+                },
+            };
+            const response = await socket.emitWithAck(req.event, req.data);
+            if (response && typeof response == 'object' && response['error']) {
+                this.loger.error(response.error);
+                return;
+            }
+            else if (!response ||
+                typeof response !== 'object' ||
+                !Array.isArray(response.from) ||
+                !Array.isArray(response.to)) {
+                this.loger.error('unknown response');
+                return;
+            }
+            this.loger.trace(`succes add whats-app proxy listener for messages from [${response.from.join(',')}] to [${response.to.join(',')}]`);
+            socket.on(WHATSAPP_MESSAGE_EVENT, (data, callback) => {
+                if (data.to !== request.to) {
+                    throw new Error(`expecting message to '${request.to}' but received to='${data.to}'`);
+                }
+                callback({ success: true });
+                this.loger.trace(`success receive message from '${data.from}' to '${data.to}'`);
+                request.listener({
+                    chatConnection: {
+                        channelName: 'WhatsAppChannel',
+                        id: data.from,
+                    },
+                    message: {
+                        text: data.content.text,
+                        senderName: data.senderName,
+                        senderId: data.from,
+                    },
+                });
+            });
+        });
+    }
+};
+WhatsAppReceiverByWabotProxy = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [WhatsAppWabotProxyConnection])
+], WhatsAppReceiverByWabotProxy);
+
+export { WhatsAppReceiverByWabotProxy };

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

@@ -0,0 +1,60 @@
+import { __decorate, __metadata } from 'tslib';
+import { WhatsAppSender } from '../WhatsAppSender.js';
+import { singleton } from '../../../../core/injection/index.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import '../../../../feature/chat-bot/ChatBot.js';
+import { ChatRepository } from '../../../../feature/chat-bot/ChatRepository.js';
+import 'uuid';
+import '../../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import { ChatResolver } from '../../../../feature/chat-controller/ChatResolver.js';
+import 'reflect-metadata';
+import '../../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../../feature/mindset/MindsetOperator.js';
+import { WhatsAppRepository } from '../WhatsAppRepository.js';
+import { WhatsAppWabotProxyConnection } from './WhatsAppWabotProxyConnection.js';
+
+let WhatsAppSenderByWabotProxy = class WhatsAppSenderByWabotProxy extends WhatsAppSender {
+    wabotDevConnection;
+    logger = new Logger('wabot:whatsapp-sender-by-wabot-proxy');
+    constructor(wabotDevConnection, chatRepository, chatResolver, whatsAppRepository) {
+        super(chatRepository, chatResolver, whatsAppRepository);
+        this.wabotDevConnection = wabotDevConnection;
+    }
+    async sendWhatsApp(request, options) {
+        try {
+            const socket = await this.wabotDevConnection.getSocket();
+            const req = {
+                event: 'sendMessage',
+                data: {
+                    from: request.from,
+                    to: request.to,
+                    content: {
+                        text: request.message.text ?? 'No Text',
+                    },
+                },
+            };
+            const ack = await socket.timeout(5000).emitWithAck(req.event, req.data);
+            if (!ack || !ack.success) {
+                throw new Error(`not success ack, when send whatsapp from '${request.from}' to '${request.to}'`);
+            }
+            this.logger.trace(`success send whatsapp from '${request.from}' to '${request.to}'`);
+            if (options?.writeChatMemory) {
+                await this.writePrivateChatMemory(request.message, request.to);
+            }
+        }
+        catch (err) {
+            this.logger.error(err);
+            throw new Error(undefined, { cause: err });
+        }
+    }
+};
+WhatsAppSenderByWabotProxy = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [WhatsAppWabotProxyConnection,
+        ChatRepository,
+        ChatResolver,
+        WhatsAppRepository])
+], WhatsAppSenderByWabotProxy);
+
+export { WhatsAppSenderByWabotProxy };

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

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from 'tslib';
+import { Env } from '../../../../core/env/Env.js';
+import { injectable } from '../../../../core/injection/index.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import { io } from 'socket.io-client';
+
+let WhatsAppWabotProxyConnection = class WhatsAppWabotProxyConnection {
+    baseUrl;
+    socket = null;
+    apiKey;
+    logger = new Logger('wabot:whats-app-wabot-proxy-connection');
+    constructor(env) {
+        this.apiKey = env.requireString('WABOT_API_KEY');
+        this.baseUrl = env.requireString('WABOT_PROXY_URL');
+        while (this.baseUrl.endsWith('/')) {
+            this.baseUrl = this.baseUrl.substring(0, this.baseUrl.length - 1);
+        }
+    }
+    async getSocket() {
+        if (this.socket) {
+            return this.socket;
+        }
+        return new Promise((resolve, reject) => {
+            const socket = io(`${this.baseUrl}/whats-app`, {
+                autoConnect: false,
+                auth: { token: this.apiKey },
+                reconnection: true,
+            });
+            socket.on('connect', async () => {
+                this.socket = socket;
+                resolve(socket);
+            });
+            socket.on('connect_error', (err) => {
+                reject(new Error(err && err.message ? err.message : 'connection error', { cause: err }));
+            });
+            socket.connect();
+        });
+    }
+};
+WhatsAppWabotProxyConnection = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Env])
+], WhatsAppWabotProxyConnection);
+
+export { WhatsAppWabotProxyConnection };

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

@@ -0,0 +1,70 @@
+import { __decorate, __metadata } from 'tslib';
+import { mindsetFunction } from '../../../feature/mindset/metadata/functions/@mindsetFunction.js';
+import 'reflect-metadata';
+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';
+
+function toPascalCaseFunctionName(title) {
+    const cleaned = title.replace(/[^a-zA-Z0-9]+/g, ' ');
+    const words = cleaned
+        .trim()
+        .split(/\s+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
+    return words.join('');
+}
+async function fetchRawHtml(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+        const html = await response.text();
+        return html;
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch HTML from ${url}: ${error.message}`);
+    }
+}
+class KeywordsReq {
+    keywords = '';
+}
+__decorate([
+    param({
+        description: 'Keywords separated by space',
+    }),
+    __metadata("design:type", String)
+], KeywordsReq.prototype, "keywords", void 0);
+function HtmlModule(options) {
+    var _a;
+    const standaricedTitle = toPascalCaseFunctionName(options.title);
+    let documentText = null;
+    let HtmlModuleIntern = class HtmlModuleIntern {
+        async [_a = `searchInTheDocument${standaricedTitle}`](req) {
+            if (!documentText) {
+                const rawHtml = await fetchRawHtml(options.url);
+                documentText = convert(rawHtml);
+            }
+            return documentText;
+        }
+    };
+    __decorate([
+        mindsetFunction({
+            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}`,
+        })
+    ], HtmlModuleIntern);
+    return HtmlModuleIntern;
+}
+
+export { HtmlModule };

package/dist/src/core/auth/Auth.js

@@ -0,0 +1,24 @@
+import { __decorate } from 'tslib';
+import { CustomError } from '../error/CustomError.js';
+import { scoped, Lifecycle } from '../injection/index.js';
+
+let Auth = class Auth {
+    authInfo = null;
+    require() {
+        if (!this.authInfo) {
+            throw new CustomError({ message: 'Unauthorized', httpCode: 401 });
+        }
+        return this.authInfo;
+    }
+    assign(authInfo) {
+        if (this.authInfo) {
+            throw new CustomError({ message: 'Authorization info already assigned', httpCode: 401 });
+        }
+        this.authInfo = authInfo;
+    }
+};
+Auth = __decorate([
+    scoped(Lifecycle.ContainerScoped)
+], Auth);
+
+export { Auth };

package/dist/src/core/{Persistent.js → entity/Entity.js}

@@ -1,22 +1,32 @@
-class Persistent {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-    getId() {
+import { Storable } from '../storable/Storable.js';
+
+class Entity extends Storable {
+    get id() {
         if (!this.data.id) {
             throw new Error('id is required');
         }
         return this.data.id;
     }
-    getCreatedAt() {
+    /**
+     * @deprecated use id
+     */
+    getId() {
+        return this.id;
+    }
+    get createdAt() {
         if (!this.data.createdAt) {
             throw new Error('createdAt is required');
         }
         return new Date(this.data.createdAt);
     }
+    /**
+     * @deprecated use createdAt
+     */
+    getCreatedAt() {
+        return this.createdAt;
+    }
     update(newData) {
-        this.data = newData;
+        this.data = { ...this.data, ...newData, updatedAt: new Date().getTime() };
     }
     wasCreated() {
         return !!this.data.createdAt || !!this.data.id;
@@ -33,5 +43,10 @@ class Persistent {
         this.data.discardedAt = new Date().getTime();
     }
 }
+/**
+ * @deprecated Should use Entity
+ */
+class Persistent extends Entity {
+}
 
-export { Persistent };
+export { Entity, Persistent };

package/dist/src/core/env/Env.js

@@ -0,0 +1,39 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../injection/index.js';
+
+let Env = class Env {
+    envType;
+    constructor() {
+        this.envType = process.env.WABOT_ENV ?? 'development';
+    }
+    isDevelopment() {
+        return this.envType === 'development';
+    }
+    isProduction() {
+        return this.envType === 'production';
+    }
+    isTesting() {
+        return this.envType === 'testing';
+    }
+    requireString(varName, options) {
+        const value = process.env[varName] ?? options?.default;
+        if (!value)
+            throw new Error(`Env Variable ${varName} is required`);
+        return value;
+    }
+    requireNumber(varName, options) {
+        const strValue = this.requireString(varName, {
+            default: options?.default != null ? String(options.default) : undefined,
+        });
+        const value = Number(strValue);
+        if (isNaN(value))
+            throw new Error(`Env Variable ${varName} should have number format`);
+        return value;
+    }
+};
+Env = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], Env);
+
+export { Env };

package/dist/src/core/error/CustomError.js

@@ -0,0 +1,15 @@
+class CustomError extends Error {
+    humanMessage;
+    code;
+    httpCode;
+    info;
+    constructor(data) {
+        super(data.message, { cause: data.cause });
+        this.humanMessage = data.humanMessage;
+        this.code = data.code;
+        this.httpCode = data.httpCode;
+        this.info = data.info;
+    }
+}
+
+export { CustomError };

package/dist/src/core/injection/index.js

@@ -0,0 +1,4 @@
+await import('reflect-metadata');
+const { injectable, container, singleton, inject, scoped, Lifecycle } = await import('tsyringe');
+
+export { Lifecycle, container, inject, injectable, scoped, singleton };

package/dist/src/core/mapper/Mapper.js

@@ -0,0 +1,42 @@
+import { Storable } from '../storable/Storable.js';
+import { CustomError } from '../error/CustomError.js';
+import '../injection/index.js';
+import '../validation/metadata/ValidationMetadataStore.js';
+import { validate } from '../validation/validate.js';
+
+function deepCopyWithStorable(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return obj.getTime();
+    }
+    if (obj instanceof Storable) {
+        return deepCopyWithStorable(obj['data']);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepCopyWithStorable(item));
+    }
+    const copy = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            copy[key] = deepCopyWithStorable(obj[key]);
+        }
+    }
+    return copy;
+}
+class Mapper {
+    map(data, ctor) {
+        const validationResult = validate(deepCopyWithStorable(data), ctor);
+        if (validationResult.error) {
+            throw new CustomError({
+                httpCode: 500,
+                message: `Cant map value to ${ctor.name}`,
+                info: validationResult.error,
+            });
+        }
+        return validationResult.value;
+    }
+}
+
+export { Mapper };

package/dist/src/core/password/Password.js

@@ -0,0 +1,30 @@
+import { randomBytes, scryptSync, timingSafeEqual } from 'node:crypto';
+import { Random } from '../random/Random.js';
+
+class Password {
+    static hash(options) {
+        const { password: secret, saltLength = 16, keyLength = 64 } = options;
+        const salt = randomBytes(saltLength).toString('hex');
+        const derivedKey = scryptSync(secret, salt, keyLength);
+        return `${salt}:${derivedKey.toString('hex')}`;
+    }
+    static isValid(req) {
+        const [salt, storedKeyHex] = req.hash.split(':');
+        if (!salt || !storedKeyHex)
+            return false;
+        try {
+            const keyLength = Buffer.from(storedKeyHex, 'hex').length;
+            const derivedKey = scryptSync(req.password, salt, keyLength);
+            const storedKey = Buffer.from(storedKeyHex, 'hex');
+            return timingSafeEqual(derivedKey, storedKey);
+        }
+        catch {
+            return false;
+        }
+    }
+    static generate(length) {
+        return Random.alphaNumeric(length);
+    }
+}
+
+export { Password };

package/dist/src/core/random/Random.js

@@ -0,0 +1,47 @@
+import { randomBytes } from 'node:crypto';
+
+const DIGITS = '0123456789';
+const ALPHA_NUMERIC_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+const ALPHA_NUMERIC_LOWER_CASE_CHARSET = 'abcdefghijklmnopqrstuvwxyz0123456789';
+class Random {
+    static slug(name, options) {
+        const base = name
+            .toLowerCase()
+            .trim()
+            .replace(/[\s\_]+/g, '-') // spaces/underscores to hyphens
+            .replace(/[^a-z0-9\-]/g, '') // remove non-alphanumeric except hyphens
+            .replace(/\-+/g, '-') // collapse multiple hyphens
+            .replace(/^\-+|\-+$/g, ''); // trim hyphens from ends
+        const random = this.alphaNumericLowerCase(options.randomLength);
+        return `${base}-${random}`;
+    }
+    static alphaNumeric(length) {
+        const bytes = randomBytes(length);
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const index = bytes[i] % ALPHA_NUMERIC_CHARSET.length;
+            result += ALPHA_NUMERIC_CHARSET[index];
+        }
+        return result;
+    }
+    static alphaNumericLowerCase(length) {
+        const bytes = randomBytes(length);
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const index = bytes[i] % ALPHA_NUMERIC_LOWER_CASE_CHARSET.length;
+            result += ALPHA_NUMERIC_LOWER_CASE_CHARSET[index];
+        }
+        return result;
+    }
+    static numberCode(length) {
+        const bytes = randomBytes(length);
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const index = bytes[i] % 10; // 0–9
+            result += DIGITS[index];
+        }
+        return result;
+    }
+}
+
+export { Random };

package/dist/src/core/storable/Storable.js

@@ -0,0 +1,8 @@
+class Storable {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+}
+
+export { Storable };

package/dist/src/core/validation/core/validateArray.js

@@ -0,0 +1,51 @@
+function validateArray(value, options) {
+    if (!Array.isArray(value)) {
+        return {
+            error: { description: 'Should be an array', items: [] },
+        };
+    }
+    if (options?.minLength != null && value.length < options.minLength) {
+        return {
+            error: { description: 'exceeds the established min length limit', items: [] },
+        };
+    }
+    if (options?.maxLength != null && value.length > options.maxLength) {
+        return {
+            error: { description: 'exceeds the established max length limit', items: [] },
+        };
+    }
+    const { itemsValidator } = options ?? {};
+    const valueOut = [];
+    const errorItems = [];
+    for (const item of value) {
+        let itemOut = item;
+        const itemErrors = [];
+        for (const itemValidator of itemsValidator ?? []) {
+            const { error, value } = itemValidator.validator(itemOut, itemValidator.options);
+            if (error) {
+                itemErrors.push(error);
+            }
+            else {
+                itemOut = value;
+            }
+        }
+        if (itemErrors.length == 0) {
+            valueOut.push(itemOut);
+            errorItems.push(null);
+        }
+        else {
+            valueOut.push(null);
+            errorItems.push(itemErrors);
+        }
+    }
+    if (errorItems.some((x) => x != null)) {
+        return {
+            error: { description: 'Error on some items', items: errorItems },
+        };
+    }
+    return {
+        value: valueOut,
+    };
+}
+
+export { validateArray };

package/dist/src/core/validation/core/validateIsOptional.js

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

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

@@ -0,0 +1,36 @@
+function validateModel(value, info) {
+    if (typeof value !== 'object' || value === null) {
+        return { error: { description: 'Invalid object', properties: {} } };
+    }
+    let propertiesErrors = {};
+    let resultValue = new info.modelConstructor();
+    for (const propertyName in info.properties) {
+        const propertyInfo = info.properties[propertyName];
+        const propertyValidators = propertyInfo.validators ?? [];
+        resultValue[propertyName] = propertyInfo.isOptional
+            ? (value[propertyName] ?? resultValue[propertyName])
+            : value[propertyName];
+        if (resultValue[propertyName] == null && propertyInfo.isOptional) {
+            resultValue[propertyName] = undefined;
+            continue;
+        }
+        for (let propertyValidatorInfo of propertyValidators) {
+            const propertyValidatorResult = propertyValidatorInfo.validator(resultValue[propertyName], propertyValidatorInfo.validatorOptions);
+            resultValue[propertyName] = propertyValidatorResult.value;
+            if (propertyValidatorResult.error) {
+                let propertyErrors = propertiesErrors[propertyName];
+                if (!propertyErrors) {
+                    propertyErrors = [];
+                    propertiesErrors[propertyName] = propertyErrors;
+                }
+                propertyErrors.push(propertyValidatorResult.error.description);
+            }
+        }
+    }
+    if (Object.keys(propertiesErrors).length > 0) {
+        return { error: { description: 'Invalid properties', properties: propertiesErrors } };
+    }
+    return { value: resultValue };
+}
+
+export { validateModel };

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

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

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

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

package/dist/src/core/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 '../core/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 };