@realvare/baileys 1.0.0

package/lib/Utils/cache-manager.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheManager = exports.default = void 0;
+const NodeCache = require('node-cache');
+const { getPerformanceConfig } = require('./performance-config');
+
+class CacheManager {
+    constructor() {
+        const config = getPerformanceConfig();
+        this.caches = {};
+        this.memoryCheckInterval = null;
+        this.msgStore = null;
+
+        // Inizializza le cache con TTL
+        Object.entries(config.cache).forEach(([name, options]) => {
+            this.caches[name] = new NodeCache({
+                stdTTL: options.ttl / 1000,
+                checkperiod: Math.min(options.cleanupInterval / 1000, 60),
+                maxKeys: options.maxSize,
+                useClones: false
+            });
+        });
+
+        if (config.performance.enableMetrics) {
+            this.startMemoryMonitoring(config.performance.memoryThreshold);
+        }
+    }
+    setMessageStore(msgStore) {
+        this.msgStore = msgStore;
+    }
+    
+    startMemoryMonitoring(threshold) {
+        this.memoryCheckInterval = setInterval(() => {
+            const memoryUsage = process.memoryUsage();
+            const used = memoryUsage.heapUsed;
+            const total = memoryUsage.heapTotal;
+            const rss = memoryUsage.rss;
+            const ratio = used / total;
+            
+            // Se heapUsed supera la soglia o RSS supera 1GB, forza una pulizia
+            if (ratio > threshold || rss > 1024 * 1024 * 1024) {
+                console.log(`[CacheManager] Memory pressure detected (RSS: ${(rss / 1024 / 1024).toFixed(2)}MB). Evicting...`);
+                this.evictLeastUsed();
+                if (global && global.gc) {
+                    global.gc();
+                }
+            }
+        }, 30000); // Controlla ogni 30 secondi
+    }
+    
+    evictLeastUsed() {
+        Object.values(this.caches).forEach(cache => {
+            const stats = cache.getStats();
+            if (stats.keys > 20) {
+                const keys = cache.keys();
+                // Rimuovi il 50% delle chiavi meno usate
+                const toRemove = Math.floor(keys.length * 0.5);
+                keys.slice(0, toRemove).forEach(key => cache.del(key));
+            }
+        });
+        
+        // Pulisci lo store se presente
+        if (this.msgStore) {
+            try {
+                // Riduci drasticamente i messaggi salvati se siamo in pressione
+                for (const jid in this.msgStore.messages) {
+                    const list = this.msgStore.messages[jid];
+                    if (list && list.array && list.array.length > 10) {
+                        list.array.splice(0, list.array.length - 10);
+                    }
+                }
+            } catch (e) {
+                console.error('[CacheManager] Error during store cleanup:', e);
+            }
+        }
+    }
+    
+    get(cacheName, key) {
+        return this.caches[cacheName]?.get(key);
+    }
+    
+    set(cacheName, key, value, ttl = undefined) {
+        const ttlSeconds = typeof ttl === 'number' ? ttl / 1000 : ttl;
+        return this.caches[cacheName]?.set(key, value, ttlSeconds);
+    }
+    
+    async setAsync(cacheName, key, fetchData, ttl = undefined) {
+        try {
+            const value = await fetchData();
+            return this.set(cacheName, key, value, ttl);
+        } catch (error) {
+            // If fetchData fails, don't cache the error
+            throw error;
+        }
+    }
+    
+    del(cacheName, key) {
+        return this.caches[cacheName]?.del(key);
+    }
+    
+    getStats(cacheName) {
+        if (!this.caches || !this.caches[cacheName]) {
+            return undefined;
+        }
+        try {
+            return this.caches[cacheName].getStats();
+        } catch (error) {
+            return undefined;
+        }
+    }
+    
+    // Enhanced cleanup for bad ACK entries
+    on(event, callback) {
+        if (event === 'bad_ack') {
+            // Setup cleanup listener for bad ACKs
+            this.badAckCallback = callback;
+        }
+    }
+
+    // Method to trigger bad ACK cleanup
+    cleanupBadAck(key) {
+        if (this.badAckCallback) {
+            this.badAckCallback(key);
+        }
+    }
+
+    shutdown() {
+        if (this.memoryCheckInterval) {
+            clearInterval(this.memoryCheckInterval);
+        }
+        Object.values(this.caches).forEach(cache => cache.close());
+    }
+}
+
+const cacheManager = new CacheManager();
+exports.default = cacheManager;
+exports.CacheManager = cacheManager;

package/lib/Utils/chat-utils.d.ts

@@ -0,0 +1,70 @@
+import { AxiosRequestConfig } from 'axios';
+import { proto } from '../../WAProto';
+import { BaileysEventEmitter, ChatModification, ChatMutation, Contact, InitialAppStateSyncOptions, LTHashState, WAPatchCreate, WAPatchName } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { ILogger } from './logger';
+type FetchAppStateSyncKey = (keyId: string) => Promise<proto.Message.IAppStateSyncKeyData | null | undefined>;
+export type ChatMutationMap = {
+    [index: string]: ChatMutation;
+};
+export declare const newLTHashState: () => LTHashState;
+export declare const encodeSyncdPatch: ({ type, index, syncAction, apiVersion, operation }: WAPatchCreate, myAppStateKeyId: string, state: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey) => Promise<{
+    patch: proto.ISyncdPatch;
+    state: LTHashState;
+}>;
+export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation | proto.ISyncdRecord)[], initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
+    hash: Buffer<any>;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+}>;
+export declare const decodeSyncdPatch: (msg: proto.ISyncdPatch, name: WAPatchName, initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
+    hash: Buffer<any>;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+}>;
+export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosRequestConfig<any>) => Promise<{
+    critical_unblock_low: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+    regular_high: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+    regular_low: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+    critical_block: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+    regular: {
+        patches: proto.ISyncdPatch[];
+        hasMorePatches: boolean;
+        snapshot?: proto.ISyncdSnapshot;
+    };
+}>;
+export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<any>) => Promise<Buffer<ArrayBuffer>>;
+export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<any>) => Promise<proto.SyncdMutations>;
+export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean) => Promise<{
+    state: LTHashState;
+    mutationMap: ChatMutationMap;
+}>;
+export declare const decodePatches: (name: WAPatchName, syncds: proto.ISyncdPatch[], initial: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, options: AxiosRequestConfig<any>, minimumVersionNumber?: number, logger?: ILogger, validateMacs?: boolean) => Promise<{
+    state: LTHashState;
+    mutationMap: ChatMutationMap;
+}>;
+export declare const chatModificationToAppPatch: (mod: ChatModification, jid: string) => WAPatchCreate;
+export declare const processSyncAction: (syncAction: ChatMutation, ev: BaileysEventEmitter, me: Contact, initialSyncOpts?: InitialAppStateSyncOptions, logger?: ILogger) => void;
+export {};