@violetix/baileys 0.5.6 → 0.6.0

package/lib/Utils/auth-utils.js

@@ -61,7 +61,6 @@ export function makeCacheableSignalKeyStore(store, logger, _cache) {
         },
         async set(data) {
             return cacheMutex.runExclusive(async () => {
-                await store.set(data);
                 let keys = 0;
                 for (const type in data) {
                     for (const id in data[type]) {
@@ -70,13 +69,12 @@ export function makeCacheableSignalKeyStore(store, logger, _cache) {
                     }
                 }
                 logger?.trace({ keys }, 'updated cache');
+                await store.set(data);
             });
         },
         async clear() {
-            await cacheMutex.runExclusive(async () => {
-                await store.clear?.();
-                await cache.flushAll();
-            });
+            await cache.flushAll();
+            await store.clear?.();
         }
     };
 }
@@ -93,12 +91,35 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
     const txMutexRefCounts = new Map();
     // Pre-key manager for specialized operations
     const preKeyManager = new PreKeyManager(state, logger);
-    const storeToken = Symbol('SignalKeyStore');
+    // Debounced writer: collects writes within a window and flushes as one SQLite tx
+    const debounceWindow = 5000;
+    let debounceTimer = null;
+    let debouncedData = {};
+    // One writer at a time. A debounced flush and a transaction commit both call state.set, and
+    // interleaving them lets an older debounced value land on top of a newer committed one.
     const writeMutex = new Mutex();
-    function getContext() {
-        const ctx = txStorage.getStore()?.get(storeToken);
-        return ctx?.active ? ctx : undefined;
-    }
+    const flushDebounced = async () => {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+        const data = debouncedData;
+        debouncedData = {};
+        if (Object.keys(data).length === 0) return;
+        // All types in one call: that is the single SQLite transaction this debounce exists for.
+        await writeMutex.runExclusive(() => state.set(data));
+    };
+    const scheduleFlush = () => {
+        // Max age, not a sliding window: re-arming the timer on every write meant a socket that
+        // never went quiet for a full window never flushed at all, leaving ratchet state in memory
+        // only until the process happened to die.
+        if (debounceTimer) return;
+        debounceTimer = setTimeout(() => {
+            // The timer has nowhere to report to, and an unhandled rejection here takes down the
+            // whole process - every other session in it included.
+            flushDebounced().catch(err => logger.error({ err }, 'failed to flush signal keys'));
+        }, debounceWindow);
+    };
     /**
      * Get or create a transaction mutex
      */
@@ -135,7 +156,7 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
      * Check if currently in a transaction
      */
     function isInTransaction() {
-        return !!getContext();
+        return !!txStorage.getStore();
     }
     /**
      * Commit transaction with retries
@@ -146,15 +167,17 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
             return;
         }
         logger.trace('committing transaction');
-        const attempts = Math.max(1, maxCommitRetries);
-        for (let attempt = 0; attempt < attempts; attempt++) {
+        // Whatever is still debounced was written BEFORE these mutations, so it has to land first
+        // or it overwrites them.
+        await flushDebounced();
+        for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
             try {
                 await writeMutex.runExclusive(() => state.set(mutations));
                 logger.trace({ mutationCount: Object.keys(mutations).length }, 'committed transaction');
                 return;
             }
             catch (error) {
-                const retriesLeft = attempts - attempt - 1;
+                const retriesLeft = maxCommitRetries - attempt - 1;
                 logger.warn(`failed to commit mutations, retries left=${retriesLeft}`);
                 if (retriesLeft === 0) {
                     throw error;
@@ -165,7 +188,7 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
     }
     return {
         get: async (type, ids) => {
-            const ctx = getContext();
+            const ctx = txStorage.getStore();
             if (!ctx) {
                 // No transaction - direct read without exclusive lock for concurrency
                 return state.get(type, ids);
@@ -176,7 +199,7 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
             if (missing.length > 0) {
                 ctx.dbQueries++;
                 logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction');
-                const fetched = await state.get(type, missing);
+                const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing));
                 // Update cache
                 ctx.cache[type] = ctx.cache[type] || {};
                 Object.assign(ctx.cache[type], fetched);
@@ -192,14 +215,18 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
             return result;
         },
         set: async (data) => {
-            const ctx = getContext();
+            const ctx = txStorage.getStore();
             if (!ctx) {
-                return writeMutex.runExclusive(async () => {
-                    if (data['pre-key']) {
-                        await preKeyManager.validateDeletions(data, 'pre-key');
+                // No transaction - debounce writes to batch into fewer SQLite transactions
+                for (const type_ in data) {
+                    const type = type_;
+                    if (type === 'pre-key') {
+                        await preKeyManager.validateDeletions(data, type);
                     }
-                    await state.set(data);
-                });
+                    debouncedData[type] = { ...debouncedData[type], ...data[type] };
+                }
+                scheduleFlush();
+                return;
             }
             // In transaction - update cache and mutations
             logger.trace({ types: Object.keys(data) }, 'caching in transaction');
@@ -221,7 +248,7 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
         },
         isInTransaction,
         transaction: async (work, key) => {
-            const existing = getContext();
+            const existing = txStorage.getStore();
             // Nested transaction - reuse existing context
             if (existing) {
                 logger.trace('reusing existing transaction context');
@@ -233,19 +260,13 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
             try {
                 return await mutex.runExclusive(async () => {
                     const ctx = {
-                        active: true,
                         cache: {},
                         mutations: {},
                         dbQueries: 0
                     };
-                    const contexts = new Map(txStorage.getStore());
-                    contexts.set(storeToken, ctx);
                     logger.trace('entering transaction');
                     try {
-                        const result = await txStorage.run(contexts, work);
-                        // Detached async work can outlive this callback. It must not write into
-                        // a context whose mutations have already been handed to the commit.
-                        ctx.active = false;
+                        const result = await txStorage.run(ctx, work);
                         // Commit mutations
                         await commitWithRetry(ctx.mutations);
                         logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed');
@@ -255,18 +276,13 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
                         logger.error({ error }, 'transaction failed, rolling back');
                         throw error;
                     }
-                    finally {
-                        ctx.active = false;
-                    }
                 });
             }
             finally {
                 releaseTxMutexRef(key);
             }
         },
-        flush: () => writeMutex.runExclusive(async () => {
-            await state.flush?.();
-        })
+        flush: flushDebounced
     };
 };
 /**
@@ -303,4 +319,4 @@ export const initAuthCreds = () => {
         additionalData: undefined
     };
 };
-//# sourceMappingURL=auth-utils.js.map
+//# sourceMappingURL=auth-utils.js.map

package/lib/Utils/business.js

@@ -1,6 +1,5 @@
 import { Boom } from '@hapi/boom';
 import { createHash } from 'crypto';
-import { once } from 'events';
 import { createWriteStream, promises as fs } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
@@ -200,31 +199,18 @@ export const uploadingNecessaryImages = async (images, waUploadToServer, timeout
         const hasher = createHash('sha256');
         const filePath = join(tmpdir(), 'img' + generateMessageIDV2());
         const encFileWriteStream = createWriteStream(filePath);
-        try {
-            for await (const block of stream) {
-                hasher.update(block);
-                // Respect backpressure instead of queueing the whole image in memory.
-                if (!encFileWriteStream.write(block)) {
-                    await once(encFileWriteStream, 'drain');
-                }
-            }
-            // The upload reads the path, so the writes have to be on disk first. Without this the
-            // upload could read a partial file while the hash covers the whole image, and the
-            // server rejects the mismatch.
-            await new Promise((resolve, reject) => encFileWriteStream.end(err => (err ? reject(err) : resolve())));
-            const sha = hasher.digest('base64');
-            const { directPath } = await waUploadToServer(filePath, {
-                mediaType: 'product-catalog-image',
-                fileEncSha256B64: sha,
-                timeoutMs
-            });
-            return { url: getUrlFromDirectPath(directPath) };
-        }
-        finally {
-            // Also runs when the upload throws, which used to leak the temp file.
-            encFileWriteStream.destroy();
-            await fs.unlink(filePath).catch(() => { });
+        for await (const block of stream) {
+            hasher.update(block);
+            encFileWriteStream.write(block);
         }
+        const sha = hasher.digest('base64');
+        const { directPath } = await waUploadToServer(filePath, {
+            mediaType: 'product-catalog-image',
+            fileEncSha256B64: sha,
+            timeoutMs
+        });
+        await fs.unlink(filePath).catch(err => console.log('Error deleting temp file ', err));
+        return { url: getUrlFromDirectPath(directPath) };
     }));
     return results;
 };

package/lib/Utils/chat-utils.js

@@ -344,6 +344,7 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
             syncd.mutations?.push(...ref.mutations);
         }
         const patchVersion = toNumber(version.version);
+        newState.version = patchVersion;
         const shouldMutate = typeof minimumVersionNumber === 'undefined' || patchVersion > minimumVersionNumber;
         let decodeResult;
         try {
@@ -357,12 +358,9 @@ export const decodePatches = async (name, syncds, initial, getAppStateSyncKey, o
         catch (err) {
             if (isMissingKeyError(err))
                 throw err;
-            // stop here: advancing the version past an undecoded patch loses its mutations for good;
-            // the next sync resumes from the last good version
-            logger?.warn({ name, version: patchVersion, error: err.message }, 'failed to decode patch, stopping');
-            break;
+            logger?.warn({ name, version: patchVersion, error: err.message }, 'failed to decode patch, skipping');
+            continue;
         }
-        newState.version = patchVersion;
         newState.hash = decodeResult.hash;
         newState.indexValueMap = decodeResult.indexValueMap;
         if (validateMacs) {
@@ -732,7 +730,7 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
     }
     else if (action?.pushNameSetting) {
         const name = action?.pushNameSetting?.name;
-        if (name && me?.id && me?.name !== name) {
+        if (name && me?.name !== name) {
             ev.emit('creds.update', { me: { ...me, name } });
         }
     }

package/lib/Utils/decode-wa-message.js

@@ -192,7 +192,7 @@ export function decodeMessageNode(stanza, meId, meLid) {
         if (!participant) {
             throw new Boom('No participant in group message');
         }
-        const isParticipantMe = isMe(participant) || isMeLid(participant);
+        const isParticipantMe = isMe(participant);
         if (isJidStatusBroadcast(from)) {
             msgType = isParticipantMe ? 'direct_peer_status' : 'other_status';
         }
@@ -226,7 +226,7 @@ export function decodeMessageNode(stanza, meId, meLid) {
         remoteJid: chatId,
         remoteJidAlt: !isJidGroup(chatId) ? addressingContext.senderAlt : undefined,
         remoteJidUsername: !isJidGroup(chatId)
-            ? stanza.attrs.peer_recipient_username || stanza.attrs.recipient_username || stanza.attrs.username
+            ? stanza.attrs.peer_recipient_username || stanza.attrs.recipient_username
             : undefined,
         fromMe,
         id: msgId,

package/lib/Utils/event-buffer.js

@@ -26,7 +26,7 @@ const BUFFERABLE_EVENT_SET = new Set(BUFFERABLE_EVENT);
 export const makeEventBuffer = (logger) => {
     const ev = new EventEmitter();
     const historyCache = new Set();
-    let trackedListeners = [];
+    const trackedListeners = [];
     let data = makeBufferData();
     let isBuffering = false;
     let bufferTimeout = null;
@@ -108,7 +108,9 @@ export const makeEventBuffer = (logger) => {
     }
     return {
         process(handler) {
-            const listener = listenerGuard.wrap(handler);
+            const listener = async (map) => {
+                await handler(map);
+            };
             ev.on('event', listener);
             return () => {
                 ev.off('event', listener);
@@ -179,20 +181,8 @@ export const makeEventBuffer = (logger) => {
         on: (...args) => { trackedOn(...args); return ev; },
         // unwrap, or removal would look for the caller's function while the registration holds the
         // guarded wrapper - every off() would silently leave the listener attached.
-        off: (event, handler) => {
-            const guarded = listenerGuard.unwrap(handler);
-            const result = ev.off(event, guarded);
-            const index = trackedListeners.findLastIndex(([name, listener]) => name === event && listener === guarded);
-            if (index !== -1) {
-                trackedListeners.splice(index, 1);
-            }
-            return result;
-        },
-        removeAllListeners: (...args) => {
-            const result = ev.removeAllListeners(...args);
-            trackedListeners = args.length ? trackedListeners.filter(([event]) => event !== args[0]) : [];
-            return result;
-        },
+        off: (event, handler) => ev.off(event, listenerGuard.unwrap(handler)),
+        removeAllListeners: (...args) => ev.removeAllListeners(...args),
         removeTrackedListeners() {
             for (const [event, handler] of trackedListeners) {
                 ev.off(event, handler);
@@ -400,8 +390,7 @@ eventData, logger) {
                     data.contactUpserts[contact.id] = upsert;
                 }
                 if (data.contactUpdates[contact.id]) {
-                    // merge into the stored upsert itself; the old code merged into a temp and lost the update
-                    Object.assign(upsert, trimUndefined(data.contactUpdates[contact.id]), trimUndefined(contact));
+                    upsert = Object.assign(data.contactUpdates[contact.id], trimUndefined(contact));
                     delete data.contactUpdates[contact.id];
                 }
             }
@@ -526,8 +515,10 @@ eventData, logger) {
             const groupUpdates = eventData;
             for (const update of groupUpdates) {
                 const id = update.id;
-                // merge every update in the window, not just the first
-                data.groupUpdates[id] = Object.assign(data.groupUpdates[id] || {}, update);
+                const groupUpdate = data.groupUpdates[id] || {};
+                if (!data.groupUpdates[id]) {
+                    data.groupUpdates[id] = Object.assign(groupUpdate, update);
+                }
             }
             break;
         default:
@@ -647,4 +638,4 @@ function concatChats(a, b) {
     return Object.assign(a, b);
 }
 const stringifyMessageKey = (key) => `${key.remoteJid},${key.id},${key.fromMe ? '1' : '0'}`;
-//# sourceMappingURL=event-buffer.js.map
+//# sourceMappingURL=event-buffer.js.map

package/lib/Utils/generics.d.ts

@@ -32,20 +32,20 @@ export function generateMessageIDV2(userId: any): string;
 export function generateMessageID(): string;
 export function bindWaitForConnectionUpdate(ev: any): (check: any, timeoutMs: any) => Promise<void>;
 export function fetchLatestBaileysVersion(options?: {}): Promise<{
-    version: [number, number, number];
+    version: number[];
     isLatest: boolean;
     error?: undefined;
 } | {
-    version: [number, number, number];
+    version: number[];
     isLatest: boolean;
     error: unknown;
 }>;
 export function fetchLatestWaWebVersion(options?: {}): Promise<{
-    version: [number, number, number];
+    version: number[];
     isLatest: boolean;
     error?: undefined;
 } | {
-    version: [number, number, number];
+    version: number[];
     isLatest: boolean;
     error: unknown;
 }>;
@@ -61,4 +61,4 @@ export function getCallStatusFromNode({ tag, attrs }: {
 }): string;
 export function getCodeFromWSError(error: any): number;
 export function isWABusinessPlatform(platform: any): boolean;
-//# sourceMappingURL=generics.d.ts.map
+//# sourceMappingURL=generics.d.ts.map

package/lib/Utils/generics.js

@@ -204,13 +204,10 @@ export const fetchLatestWaWebVersion = async (options = {}) => {
             'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36'
         };
         const headers = { ...defaultHeaders, ...options.headers };
-        // bounded: a hung sw.js fetch must not stall the connect path that awaits this
-        const signal = options.signal ?? AbortSignal.timeout(options.timeoutMs ?? 10000);
         const response = await fetch('https://web.whatsapp.com/sw.js', {
             ...options,
             method: 'GET',
-            headers,
-            signal
+            headers
         });
         if (!response.ok) {
             throw new Boom(`Failed to fetch sw.js: ${response.statusText}`, { statusCode: response.status });
@@ -263,32 +260,17 @@ export const getStatusFromReceiptType = (type) => {
     }
     return status;
 };
+const CODE_MAP = {
+    conflict: DisconnectReason.connectionReplaced
+};
 /**
- * Stream errors generally provide a reason, map that to a baileys DisconnectReason.
- * Mirrors zapo-js (src/transport/stream/parse.ts): only conflict means the session is gone;
- * ack / xml-not-well-formed / unknown reasons are transient and must stay reconnectable.
- * The old fallback was badSession (500), which made bots wipe healthy sessions.
+ * Stream errors generally provide a reason, map that to a baileys DisconnectReason
+ * @param reason the string reason given, eg. "conflict"
  */
 export const getErrorCodeFromStreamError = (node) => {
     const [reasonNode] = getAllBinaryNodeChildren(node);
     let reason = reasonNode?.tag || 'unknown';
-    let statusCode;
-    if (reason === 'conflict') {
-        // type="replaced": another client took over; any other type (device_removed): unlinked
-        statusCode = reasonNode.attrs?.type === 'replaced' || !reasonNode.attrs?.type
-            ? DisconnectReason.connectionReplaced
-            : DisconnectReason.loggedOut;
-    }
-    else if (node.attrs.code) {
-        statusCode = +node.attrs.code;
-        // 516 = server-forced logout
-        if (statusCode === 516) {
-            statusCode = DisconnectReason.loggedOut;
-        }
-    }
-    else {
-        statusCode = DisconnectReason.connectionClosed;
-    }
+    const statusCode = +(node.attrs.code || CODE_MAP[reason] || DisconnectReason.badSession);
     if (statusCode === DisconnectReason.restartRequired) {
         reason = 'restart required';
     }

package/lib/Utils/history.d.ts

@@ -73,5 +73,4 @@ export function downloadAndProcessHistorySyncNotification(msg: any, options: any
 }>;
 export function getHistoryMsg(message: any): any;
 import { proto } from '../../WAProto/index.js';
-//# sourceMappingURL=history.d.ts.map
-export function decodeHistorySyncStreaming(buffer: Uint8Array, onConversation: (conversation: proto.IConversation) => void): proto.HistorySync;
+//# sourceMappingURL=history.d.ts.map