@realvare/based 2.5.2 → 2.5.5

package/lib/Socket/socket.js

@@ -48,6 +48,47 @@ const makeSocket = (config) => {
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    let reconnectAttempts = 0;
+    const performanceConfig = (0, Utils_1.getPerformanceConfig)();
+    
+    const handleReconnect = async () => {
+        if (closed) return;
+        
+        reconnectAttempts++;
+        const delay = Math.min(
+            performanceConfig.performance.retryDelay * Math.pow(
+                performanceConfig.performance.retryBackoffMultiplier, 
+                reconnectAttempts - 1
+            ),
+            performanceConfig.performance.maxRetryDelay
+        );
+        
+        logger?.info({ 
+            reconnectAttempts, 
+            delay 
+        }, 'Attempting to reconnect...');
+        
+        await (0, Utils_1.delay)(delay);
+        
+        if (reconnectAttempts <= performanceConfig.performance.maxRetries) {
+            try {
+                ws.connect();
+            } catch (error) {
+                logger?.error({ error }, 'Reconnection attempt failed');
+                handleReconnect();
+            }
+        } else {
+            logger?.error('Max reconnection attempts reached');
+            ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: {
+                    error: new boom_1.Boom('Max reconnection attempts reached', { 
+                        statusCode: Types_1.DisconnectReason.connectionClosed 
+                    })
+                }
+            });
+        }
+    };
     const uqTagId = (0, Utils_1.generateMdTagPrefix)();
     const generateMessageTag = () => `${uqTagId}${epoch++}`;
     const sendPromise = (0, util_1.promisify)(ws.send);

package/lib/Utils/cache-manager.js

@@ -0,0 +1,73 @@
+"use strict";
+const NodeCache = require('node-cache');
+const { getPerformanceConfig } = require('./performance-config');
+
+class CacheManager {
+    constructor() {
+        const config = getPerformanceConfig();
+        this.caches = {};
+        this.memoryCheckInterval = null;
+        
+        // Inizializza le cache con TTL
+        Object.entries(config.cache).forEach(([name, options]) => {
+            this.caches[name] = new NodeCache({
+                stdTTL: options.ttl / 1000, // Converti da ms a secondi
+                checkperiod: options.cleanupInterval / 1000,
+                maxKeys: options.maxSize
+            });
+        });
+        
+        if (config.performance.enableMetrics) {
+            this.startMemoryMonitoring(config.performance.memoryThreshold);
+        }
+    }
+    
+    startMemoryMonitoring(threshold) {
+        this.memoryCheckInterval = setInterval(() => {
+            const used = process.memoryUsage().heapUsed;
+            const total = process.memoryUsage().heapTotal;
+            const ratio = used / total;
+            
+            if (ratio > threshold) {
+                this.evictLeastUsed();
+            }
+        }, 60000); // Controlla ogni minuto
+    }
+    
+    evictLeastUsed() {
+        Object.values(this.caches).forEach(cache => {
+            const stats = cache.getStats();
+            if (stats.keys > 100) { // Mantieni almeno 100 chiavi
+                const keys = cache.keys();
+                // Rimuovi il 20% delle chiavi meno usate
+                const toRemove = Math.floor(keys.length * 0.2);
+                keys.slice(0, toRemove).forEach(key => cache.del(key));
+            }
+        });
+    }
+    
+    get(cacheName, key) {
+        return this.caches[cacheName]?.get(key);
+    }
+    
+    set(cacheName, key, value, ttl = undefined) {
+        return this.caches[cacheName]?.set(key, value, ttl);
+    }
+    
+    del(cacheName, key) {
+        return this.caches[cacheName]?.del(key);
+    }
+    
+    getStats(cacheName) {
+        return this.caches[cacheName]?.getStats();
+    }
+    
+    shutdown() {
+        if (this.memoryCheckInterval) {
+            clearInterval(this.memoryCheckInterval);
+        }
+        Object.values(this.caches).forEach(cache => cache.close());
+    }
+}
+
+module.exports = new CacheManager();

package/lib/Utils/messages.js

@@ -248,10 +248,10 @@ const generateWAMessageContent = async (message, options) => {
     if ('text' in message) {
         const extContent = { text: message.text };
         let urlInfo = message.linkPreview;
-        if (typeof urlInfo === 'undefined') {
+        if (urlInfo === true) {
             urlInfo = await (0, exports.generateLinkPreviewIfRequired)(message.text, options.getUrlInfo, options.logger);
         }
-        if (urlInfo) {
+        if (urlInfo && typeof urlInfo === 'object') {
             extContent.matchedText = urlInfo['matched-text'];
             extContent.jpegThumbnail = urlInfo.jpegThumbnail;
             extContent.description = urlInfo.description;
@@ -291,6 +291,9 @@ const generateWAMessageContent = async (message, options) => {
     else if ('location' in message) {
         m.locationMessage = Types_1.WAProto.Message.LocationMessage.fromObject(message.location);
     }
+    else if ('liveLocation' in message) {
+        m.liveLocationMessage = Types_1.WAProto.Message.LiveLocationMessage.fromObject(message.liveLocation);
+    }
     else if ('react' in message) {
         if (!message.react.senderTimestampMs) {
             message.react.senderTimestampMs = Date.now();
@@ -459,23 +462,24 @@ const generateWAMessageContent = async (message, options) => {
         m.newsletterAdminInviteMessage.jpegThumbnail = message.inviteAdmin.thumbnail;
     }
     else if ('requestPayment' in message) {
-        const sticker = ((_c = message === null || message === void 0 ? void 0 : message.requestPayment) === null || _c === void 0 ? void 0 : _c.sticker) ?
-            await (0, exports.prepareWAMessageMedia)({ sticker: (_d = message === null || message === void 0 ? void 0 : message.requestPayment) === null || _d === void 0 ? void 0 : _d.sticker, ...options }, options)
+        const reqPayment = message.requestPayment;
+        const sticker = reqPayment.sticker ?
+            await (0, exports.prepareWAMessageMedia)({ sticker: reqPayment.sticker, ...options }, options)
             : null;
         let notes = {};
-        if ((_e = message === null || message === void 0 ? void 0 : message.requestPayment) === null || _e === void 0 ? void 0 : _e.sticker) {
+        if (reqPayment.sticker) {
             notes = {
                 stickerMessage: {
-                    ...sticker === null || sticker === void 0 ? void 0 : sticker.stickerMessage,
-                    contextInfo: (_f = message === null || message === void 0 ? void 0 : message.requestPayment) === null || _f === void 0 ? void 0 : _f.contextInfo
+                    ...sticker.stickerMessage,
+                    contextInfo: reqPayment.contextInfo
                 }
             };
         }
-        else if (message.requestPayment.note) {
+        else if (reqPayment.note) {
             notes = {
                 extendedTextMessage: {
-                    text: message.requestPayment.note,
-                    contextInfo: (_g = message === null || message === void 0 ? void 0 : message.requestPayment) === null || _g === void 0 ? void 0 : _g.contextInfo,
+                    text: reqPayment.note,
+                    contextInfo: reqPayment.contextInfo,
                 }
             };
         }
@@ -483,12 +487,14 @@ const generateWAMessageContent = async (message, options) => {
             throw new boom_1.Boom('Invalid media type', { statusCode: 400 });
         }
         m.requestPaymentMessage = Types_1.WAProto.Message.RequestPaymentMessage.fromObject({
-            expiryTimestamp: message.requestPayment.expiry,
-            amount1000: message.requestPayment.amount,
-            currencyCodeIso4217: message.requestPayment.currency,
-            requestFrom: message.requestPayment.from,
+            expiryTimestamp: reqPayment.expiryTimestamp || reqPayment.expiry,
+            amount1000: reqPayment.amount1000 || reqPayment.amount,
+            currencyCodeIso4217: reqPayment.currencyCodeIso4217 || reqPayment.currency,
+            requestFrom: reqPayment.requestFrom || reqPayment.from,
             noteMessage: { ...notes },
-            background: (_h = message.requestPayment.background) !== null && _h !== void 0 ? _h : null,
+            background: reqPayment.background,
+            // Aggiungi altri parametri se disponibili
+            ...reqPayment
         });
     }
     else if ('sharePhoneNumber' in message) {
@@ -499,6 +505,12 @@ const generateWAMessageContent = async (message, options) => {
     else if ('requestPhoneNumber' in message) {
         m.requestPhoneNumberMessage = {};
     }
+    else if ('call' in message) {
+        m.callMessage = Types_1.WAProto.Message.CallMessage.fromObject(message.call);
+    }
+    else if ('newsletterMessage' in message) {
+        m.newsletterMessage = Types_1.WAProto.Message.NewsletterMessage.fromObject(message.newsletterMessage);
+    }
     else if ('album' in message) {
         const imageMessages = message.album.filter(item => 'image' in item);
         const videoMessages = message.album.filter(item => 'video' in item);
@@ -541,29 +553,30 @@ const generateWAMessageContent = async (message, options) => {
         }
         m = { buttonsMessage };
     }
-    else if ('templateButtons' in message && !!message.templateButtons) {
-        const msg = {
-            hydratedButtons: message.hasOwnProperty("templateButtons") ? message.templateButtons : message.templateButtons
-        };
-        if ('text' in message) {
-            msg.hydratedContentText = message.text;
-        }
-        else {
-            if ('caption' in message) {
-                msg.hydratedContentText = message.caption;
-            }
-            Object.assign(msg, m);
-        }
-        if ('footer' in message && !!message.footer) {
-            msg.hydratedFooterText = message.footer;
-        }
-        m = {
-            templateMessage: {
-                fourRowTemplate: msg,
-                hydratedTemplate: msg
-            }
-        };
-    }
+                else if ('templateButtons' in message && !!message.templateButtons) {
+                    const templateMsg = {
+                        hydratedButtons: message.templateButtons
+                    };
+                    if ('text' in message) {
+                        templateMsg.hydratedContentText = message.text;
+                    }
+                    else if ('caption' in message) {
+                        templateMsg.hydratedContentText = message.caption;
+                    }
+                    if ('footer' in message && !!message.footer) {
+                        templateMsg.hydratedFooterText = message.footer;
+                    }
+                    // Add media to template if present
+                    if (m && Object.keys(m).length > 0) {
+                        Object.assign(templateMsg, m);
+                    }
+                    m = {
+                        templateMessage: {
+                            fourRowTemplate: templateMsg,
+                            hydratedTemplate: templateMsg
+                        }
+                    };
+                }
     if ('sections' in message && !!message.sections) {
         const listMessage = {
             sections: message.sections,
@@ -759,7 +772,10 @@ const generateWAMessageContent = async (message, options) => {
     if ('contextInfo' in message && !!message.contextInfo) {
         const [messageType] = Object.keys(m);
         m[messageType] = m[messageType] || {};
-        m[messageType].contextInfo = message.contextInfo;
+        m[messageType].contextInfo = {
+            ...m[messageType].contextInfo,
+            ...message.contextInfo
+        };
     }
     return Types_1.WAProto.Message.fromObject(m);
 };

package/lib/Utils/performance-config.d.ts

@@ -1,60 +1,60 @@
-/**
- * Configurazione performance per ottimizzazioni LID/JID
- */
-export interface CacheConfig {
-    ttl: number;
-    maxSize: number;
-    cleanupInterval: number;
-}
-
-export interface PerformanceSettings {
-    enableCache: boolean;
-    enableLogging: boolean;
-    enableMetrics: boolean;
-    batchSize: number;
-    maxRetries: number;
-    retryDelay: number;
-}
-
-export interface DebugSettings {
-    enableLidLogging: boolean;
-    enablePerformanceLogging: boolean;
-    enableErrorLogging: boolean;
-    logLevel: 'error' | 'warn' | 'info' | 'debug';
-}
-
-export interface PerformanceConfigInterface {
-    cache: {
-        lidCache: CacheConfig;
-        jidCache: CacheConfig;
-        lidToJidCache: CacheConfig;
-    };
-    performance: PerformanceSettings;
-    debug: DebugSettings;
-}
-
-export declare class PerformanceConfig implements PerformanceConfigInterface {
-    cache: {
-        lidCache: CacheConfig;
-        jidCache: CacheConfig;
-        lidToJidCache: CacheConfig;
-    };
-    performance: PerformanceSettings;
-    debug: DebugSettings;
-    
-    updateCacheConfig(cacheType: string, config: Partial<CacheConfig>): void;
-    updatePerformanceConfig(config: Partial<PerformanceSettings>): void;
-    updateDebugConfig(config: Partial<DebugSettings>): void;
-    shouldLog(level: string): boolean;
-}
-
-export declare class Logger {
-    static error(message: string, ...args: any[]): void;
-    static warn(message: string, ...args: any[]): void;
-    static info(message: string, ...args: any[]): void;
-    static debug(message: string, ...args: any[]): void;
-    static performance(message: string, ...args: any[]): void;
-}
-
-export declare const getPerformanceConfig: () => PerformanceConfig;
-export declare const setPerformanceConfig: (config: Partial<PerformanceConfigInterface> | PerformanceConfig) => void;
+/**
+ * Configurazione performance per ottimizzazioni LID/JID
+ */
+export interface CacheConfig {
+    ttl: number;
+    maxSize: number;
+    cleanupInterval: number;
+}
+
+export interface PerformanceSettings {
+    enableCache: boolean;
+    enableLogging: boolean;
+    enableMetrics: boolean;
+    batchSize: number;
+    maxRetries: number;
+    retryDelay: number;
+}
+
+export interface DebugSettings {
+    enableLidLogging: boolean;
+    enablePerformanceLogging: boolean;
+    enableErrorLogging: boolean;
+    logLevel: 'error' | 'warn' | 'info' | 'debug';
+}
+
+export interface PerformanceConfigInterface {
+    cache: {
+        lidCache: CacheConfig;
+        jidCache: CacheConfig;
+        lidToJidCache: CacheConfig;
+    };
+    performance: PerformanceSettings;
+    debug: DebugSettings;
+}
+
+export declare class PerformanceConfig implements PerformanceConfigInterface {
+    cache: {
+        lidCache: CacheConfig;
+        jidCache: CacheConfig;
+        lidToJidCache: CacheConfig;
+    };
+    performance: PerformanceSettings;
+    debug: DebugSettings;
+    
+    updateCacheConfig(cacheType: string, config: Partial<CacheConfig>): void;
+    updatePerformanceConfig(config: Partial<PerformanceSettings>): void;
+    updateDebugConfig(config: Partial<DebugSettings>): void;
+    shouldLog(level: string): boolean;
+}
+
+export declare class Logger {
+    static error(message: string, ...args: any[]): void;
+    static warn(message: string, ...args: any[]): void;
+    static info(message: string, ...args: any[]): void;
+    static debug(message: string, ...args: any[]): void;
+    static performance(message: string, ...args: any[]): void;
+}
+
+export declare const getPerformanceConfig: () => PerformanceConfig;
+export declare const setPerformanceConfig: (config: Partial<PerformanceConfigInterface> | PerformanceConfig) => void;