@wabot-dev/framework 0.1.0-beta.9 → 0.2.0-beta.1

package/dist/src/{channels/whatsapp → addon/chat-controller/whatsapp/cloud-api}/WhatsAppSenderByCloudApi.js

@@ -1,20 +1,25 @@
 import { __decorate, __metadata } from 'tslib';
-import { Logger } from '../../logger/Logger.js';
-import { WhatsAppSender } from './WhatsAppSender.js';
-import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import { ChatResolver } from '../../controller/channel/ChatResolver.js';
-import '../../controller/channel/UserResolver.js';
-import { singleton, container } from '../../injection/index.js';
-import '../../controller/metadata/ControllerMetadataStore.js';
-import { WhatsAppRepository } from './WhatsAppRepository.js';
-import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import { WhatsAppSender } from '../WhatsAppSender.js';
+import { singleton } from '../../../../core/injection/index.js';
+import '../../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import { ChatResolver } from '../../../../feature/chat-controller/ChatResolver.js';
+import '../../../../core/auth/Auth.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 'reflect-metadata';
+import '../../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../../feature/mindset/MindsetOperator.js';
+import { WhatsAppRepository } from '../WhatsAppRepository.js';
 
 let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSender {
+    logger = new Logger('wabot:whatsapp-sender-by-cloud-api');
     constructor(chatRepository, chatResolver, whatsAppRepository) {
-        super(new Logger('wabot:whatsapp-sender-by-cloud-api'), chatRepository, chatResolver, whatsAppRepository);
+        super(chatRepository, chatResolver, whatsAppRepository);
     }
-    async handleSendRequest(request) {
+    async sendWhatsApp(request, options) {
         const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
         if (!whatsApp) {
             throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
@@ -43,8 +48,11 @@ let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSe
         if (!response.ok) {
             throw new Error(JSON.stringify(data));
         }
+        if (options?.writeChatMemory) {
+            await this.writePrivateChatMemory(request.message, request.to);
+        }
     }
-    async handleSendTemplateRequest(request) {
+    async sendWhatsAppTemplate(request, options) {
         const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
         if (!whatsApp) {
             throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
@@ -80,8 +88,12 @@ let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSe
         if (!response.ok) {
             throw new Error(JSON.stringify(data));
         }
+        if (options?.writeChatMemory) {
+            const message = await this.mapTemplateToChatMessage(request);
+            await this.writePrivateChatMemory(message, request.to);
+        }
     }
-    async handleGetWhatsAppTemplate(request) {
+    async getWhatsAppTemplate(request) {
         const whatsApp = await this.whatsAppRepository.findByBusinessNumber(request.from);
         if (!whatsApp) {
             throw new Error(`not found WhatsApp with bussiness number '${request.from}'`);
@@ -104,7 +116,7 @@ let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSe
             return template;
         }
         catch (error) {
-            console.error('Failed to get WhatsApp template:', error);
+            this.logger.error(error);
             throw error;
         }
     }
@@ -115,10 +127,5 @@ WhatsAppSenderByCloudApi = __decorate([
         ChatResolver,
         WhatsAppRepository])
 ], WhatsAppSenderByCloudApi);
-if (!WabotDevConnection.isTokenAvailable()) {
-    container.register(WhatsAppSender, {
-        useClass: WhatsAppSenderByCloudApi,
-    });
-}
 
 export { WhatsAppSenderByCloudApi };

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

@@ -0,0 +1,5 @@
+const WHATSAPP_PROXY_SEND_MESSAGE_EVENT = 'sendMessage';
+const WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT = 'listenMessage';
+const WHATSAPP_MESSAGE_EVENT = 'message';
+
+export { WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT };

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,61 @@
+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 '../../../../core/auth/Auth.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/{pre-made/module → addon/mindset}/html/HtmlModule.js

@@ -1,12 +1,12 @@
 import { __decorate, __metadata } from 'tslib';
-import { mindsetFunction } from '../../../mindset/metadata/functions/@mindsetFunction.js';
+import { mindsetFunction } from '../../../feature/mindset/metadata/functions/@mindsetFunction.js';
 import 'reflect-metadata';
-import '../../../injection/index.js';
-import '../../../mindset/metadata/MindsetMetadataStore.js';
-import { mindsetModule } from '../../../mindset/metadata/modules/@mindsetModule.js';
-import { param } from '../../../mindset/metadata/params/@param.js';
-import '../../../mindset/MindsetOperator.js';
-import { convert } from '../../../node_modules/html-to-text/lib/html-to-text.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';
 
 function toPascalCaseFunctionName(title) {
     const cleaned = title.replace(/[^a-zA-Z0-9]+/g, ' ');

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

@@ -0,0 +1,33 @@
+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;
+    }
+    override(authInfo) {
+        this.authInfo = authInfo;
+    }
+    clear() {
+        this.authInfo = null;
+    }
+    isAssigned() {
+        return this.authInfo !== null;
+    }
+};
+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;
@@ -29,9 +39,11 @@ class Persistent {
             throw new Error('createdAt is required');
         }
     }
-    discard() {
-        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,65 @@
+import { randomBytes } from 'node:crypto';
+
+const DIGITS = '0123456789';
+const ALPHA_NUMERIC_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+const ALPHA_NUMERIC_LOWER_CASE_CHARSET = 'abcdefghijklmnopqrstuvwxyz0123456789';
+class Random {
+    static integer(options) {
+        const { min, max } = options;
+        if (min > max) {
+            throw new RangeError('min must be less than or equal to max');
+        }
+        const range = max - min + 1;
+        if (range <= 0) {
+            throw new RangeError('Range must be a positive number');
+        }
+        const byteSize = 6; // gives us up to 2^48
+        const maxGeneratedValue = Math.pow(2, byteSize * 8) - 1;
+        const maxAcceptable = maxGeneratedValue - (maxGeneratedValue % range);
+        let randomNumber;
+        do {
+            randomNumber = parseInt(randomBytes(byteSize).toString('hex'), 16);
+        } while (randomNumber >= maxAcceptable);
+        return min + (randomNumber % range);
+    }
+    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 };