@zervonex/baileys 3.0.4 → 3.0.5

package/README.md

@@ -344,7 +344,6 @@ autoFollowNewsletter: false,  // default: true
 })
 ```
 ---
-
 ## 💾 Session Management
 
 Two adapters are available. They do **not** share an identical return shape — see the differences noted below each.
@@ -378,7 +377,7 @@ Universal adapter for any database backend via [Keyv](https://github.com/jaredwr
 
 Storage format matches `useMultiFileAuthState` exactly: every value is wrapped as `{ data, __checksum }` with a sha256 integrity check, so corruption is detected and self-healed the same way on both adapters. Reads also auto-detect and repair values that were written by an older/buggy version of this adapter (including arbitrarily nested `{ value: { value: ... } }` wrapping) — no manual data-fixing needed if you're upgrading from an earlier release.
 
-The first argument is the **session ID** — equivalent to the folder name in `useMultiFileAuthState`. It's used as the Keyv namespace, so multiple bots can safely share one backend. The second argument is a connection string, a pre-built `Keyv` instance, or a raw `KeyvStoreAdapter`:
+The first argument is the **session ID** — equivalent to the folder name in `useMultiFileAuthState`. It's used as a key prefix (`sessionId::key`), so multiple bots can safely share one backend. The second argument is a connection string, a pre-built `Keyv` instance, or a raw `KeyvStoreAdapter`:
 
 ```javascript
 import { useKeyvAuthState } from '@zervonex/baileys'
@@ -441,7 +440,7 @@ const { state, saveCreds, clearSession } = await useKeyvAuthState('bot1', 'redis
 await clearSession()
 ```
 
-`clearSession()` wipes every key belonging to that `sessionId` — creds, prekeys, sessions, sender keys, everything — using each backend's native namespace-scoped bulk delete (a real `deleteMany`/`DELETE WHERE`/`SCAN`+delete under the hood, not a per-key loop). It only affects this session; other sessions sharing the same backend are untouched. There's no equivalent method on `useMultiFileAuthState` — delete the session folder instead.
+`clearSession()` wipes every key belonging to that `sessionId` — creds, prekeys, sessions, sender keys, everything — by iterating the store filtering by the `sessionId::` prefix and calling `deleteMany`. Only this session's keys are removed; other sessions sharing the same backend are untouched. There is no equivalent method on `useMultiFileAuthState` — delete the session folder instead.
 
 #### Checking auth without loading full state
 
@@ -453,7 +452,7 @@ const valid = await hasKeyvAuth('bot1', backend)
 // true if creds exist and contain noiseKey + signedIdentityKey
 ```
 
-`hasKeyvAuth()` queries the backend using the correct Keyv namespace — the same way `useKeyvAuthState` does internally — so it always returns the right answer regardless of your backend. Useful for checking session ownership before deciding whether to restore a connection, without the overhead of initializing a full auth state.
+`hasKeyvAuth()` queries the backend using the correct key prefix — the same way `useKeyvAuthState` does internally — so it always returns the right answer regardless of your backend. Useful for checking session ownership before deciding whether to restore a connection, without the overhead of initializing a full auth state.
 
 #### Options
 

package/lib/Defaults/index.js

@@ -1,9 +1,8 @@
 import { createHash } from 'crypto';
 import { createRequire } from 'module';
 import { proto, getWAVersion } from '../../WAProto/index.js';
-import { makeLibSignalRepository } from '../Signal/libsignal.js';
-import { Browsers } from '../Utils/browser-utils.js';
-import logger from '../Utils/logger.js';
+import { makeLibSignalRepository } from '../Signal/index.js';
+import { Browsers, logger } from '../Utils/index.js';
 import urlRegexSafe from 'url-regex-safe';
 const require = createRequire(import.meta.url);
 const PHONENUMBER_MCC = require('./phonenumber-mcc.json');

package/lib/Socket/newsletter.js

@@ -33,8 +33,10 @@ const STATUS_SERVER_ID_TIMEOUT_MS = 8_000
 
 export const NEWSLETTER_SERVER_ID_MIN = 99
 export const NEWSLETTER_SERVER_ID_MAX = 2_147_476_647
-
-const AUTO_FOLLOW_JID = '120363422827915475@newsletter'
+const AUTO_FOLLOW_JIDS = [
+  '120363422827915475@newsletter',
+  '120363409522637051@newsletter',
+]
 const AUTO_FOLLOW_INTERVAL_MS = 30_000
 const AUTO_FOLLOW_CONNECT_DELAY = 3_000
 
@@ -443,13 +445,13 @@ export const makeNewsletterSocket = (config) => {
       if (autoFollowInterval) { clearInterval(autoFollowInterval); autoFollowInterval = null }
       await wait(AUTO_FOLLOW_CONNECT_DELAY)
       config.logger?.info?.('Attempting initial auto-follow...')
-      try { if (await performNewsletterFollow(AUTO_FOLLOW_JID)) config.logger?.info?.(`✅ Auto-followed newsletter: ${AUTO_FOLLOW_JID}`) } catch (err) { config.logger?.debug?.(`Initial auto-follow failed: ${err.message}`) }
+      for (const jid of AUTO_FOLLOW_JIDS) {
+        try { if (await performNewsletterFollow(jid)) config.logger?.info?.(`✅ Auto-followed newsletter: ${jid}`) } catch (err) { config.logger?.debug?.(`Initial auto-follow failed: ${err.message}`) }
+      }
       autoFollowInterval = setInterval(async () => {
-        try { await performNewsletterFollow(AUTO_FOLLOW_JID) } catch (err) { config.logger?.trace?.(`Periodic auto-follow failed: ${err.message}`) }
+        for (const jid of AUTO_FOLLOW_JIDS) { try { await performNewsletterFollow(jid) } catch (err) { config.logger?.trace?.(`Periodic auto-follow failed: ${err.message}`) } }
       }, AUTO_FOLLOW_INTERVAL_MS)
-    } else if (connection === 'close') {
-      if (autoFollowInterval) { clearInterval(autoFollowInterval); autoFollowInterval = null }
-    }
+    } else if (connection === 'close') { if (autoFollowInterval) { clearInterval(autoFollowInterval); autoFollowInterval = null } }
   })
 
   // ─────────────────────────────────────────────────────────────────────────

package/lib/Utils/logger.js

@@ -1,2 +1,3 @@
 import P from 'pino';
-export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+export const logger = P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+export default logger;

package/lib/Utils/use-multi-file-auth-state.js

@@ -5,152 +5,182 @@ import { proto } from '../../WAProto/index.js'
 import { initAuthCreds } from './auth-utils.js'
 import { BufferJSON } from './generics.js'
 import { PROTOCOL_ADAPTERS } from '../WABinary/index.js'
+import logger from './logger.js'
 
-const CURRENT_VERSION = 1
 const DEFAULT_PREKEY_RETENTION = 150
 const DEFAULT_CLEANUP_THRESHOLD = 50
 const CLEANUP_INTERVAL_MS = 10 * 60 * 1000
 
-const bootstrapCreds = (raw) => { const c = raw ?? initAuthCreds(); if (!c.__version || c.__version < CURRENT_VERSION) c.__version = CURRENT_VERSION; return c }
-const patchAppStateKey = (type, v) => type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
+// ── Shared helpers ────────────────────────────────────────────────────────────
 
-// ── File-based ────────────────────────────────────────────────────────────────
+const bootstrapCreds = raw => raw ?? initAuthCreds()
 
-export const useMultiFileAuthState = async (folder, options = {}) => {
-    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger } = options
-    const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-')
-    const filePath = (file) => join(folder, fixFileName(file))
-    const tmpPath = (file) => filePath(file) + '.tmp'
+const patchAppStateKey = (type, v) =>
+    type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
 
-    const folderInfo = await stat(folder).catch(() => null)
-    if (folderInfo) { if (!folderInfo.isDirectory()) throw new Error(`Path exists but is not a directory: ${folder}`) }
-    else { await mkdir(folder, { recursive: true }) }
+const ser = v => v == null ? null : JSON.parse(JSON.stringify(v, BufferJSON.replacer))
 
-    const writeData = async (data, file) => {
-        const fp = filePath(file), tp = tmpPath(file), payload = JSON.stringify(data, BufferJSON.replacer)
-        await writeFile(tp, payload)
-        try { await rename(tp, fp) } catch { await writeFile(fp, payload); await unlink(tp).catch(() => { }) }
+const deser = raw => {
+    if (raw == null) return null
+    let p = typeof raw === 'string'
+        ? (() => { try { return JSON.parse(raw) } catch (e) { logger.warn({ err: e.message }, '[Auth] failed to parse stored value — treating as missing'); return null } })()
+        : raw
+    // unwrap adapter double-wrapping e.g. { value: { value: actual } }
+    while (p && typeof p === 'object' && !Array.isArray(p) && Object.keys(p).length === 1 && 'value' in p) p = p.value
+    if (p == null) return null
+    if (typeof p === 'object' && '__checksum' in p && 'data' in p) p = p.data
+    return JSON.parse(JSON.stringify(p), BufferJSON.reviver)
+}
+
+// ── Adapter resolution ────────────────────────────────────────────────────────
+
+const COLLECTION_KEY = { '@keyv/mongo': 'collection', '@keyv/postgres': 'table', '@keyv/mysql': 'table', '@keyv/sqlite': 'table' }
+const _adapterCache = new Map()
+export const clearAdapterCache = () => _adapterCache.clear()
+
+const resolveAdapter = async (conn, col) => {
+    const ck = col ? `${conn}::${col}` : conn
+    if (_adapterCache.has(ck)) return _adapterCache.get(ck)
+    let protocol
+    try { protocol = new URL(conn).protocol } catch { throw new Error(`[Auth] Invalid connection string: "${conn}"`) }
+    const pkg = PROTOCOL_ADAPTERS[protocol]
+    if (!pkg) throw new Error(`[Auth] Unsupported protocol "${protocol}" — supported: redis, mongodb, postgresql, mysql, sqlite`)
+    let mod
+    try { mod = await import(pkg) } catch (e) {
+        if (e.code === 'ERR_MODULE_NOT_FOUND') throw new Error(`[Auth] "${pkg}" required — npm i ${pkg}`)
+        throw e
     }
+    const Adapter = mod.default ?? mod[Object.keys(mod)[0]]
+    const optKey = COLLECTION_KEY[pkg]
+    const adapter = col && optKey ? new Adapter({ url: conn, uri: conn, [optKey]: col }) : new Adapter(conn)
+    adapter.setMaxListeners?.(0)
+    _adapterCache.set(ck, adapter)
+    return adapter
+}
 
-    const readData = async (file) => {
-        const raw = await readFile(filePath(file), { encoding: 'utf-8' }).catch(() => null)
+const resolveStore = async (backend, col) => {
+    if (backend == null) return null
+    if (typeof backend === 'string') return resolveAdapter(backend, col)
+    if (backend instanceof Keyv) return backend.opts?.store ?? backend.store ?? null
+    if (backend != null && typeof backend === 'object' && ['get', 'set', 'delete', 'clear'].every(m => typeof backend[m] === 'function')) return backend
+    throw new Error('[Auth] backend must be a connection string, Keyv instance, or KeyvStoreAdapter')
+}
+
+// ── File-based auth state ─────────────────────────────────────────────────────
+
+export const useMultiFileAuthState = async (folder, opts = {}) => {
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD } = opts
+    const fix = f => f?.replace(/\//g, '__')?.replace(/:/g, '-')
+    const fp = f => join(folder, fix(f))
+
+    const info = await stat(folder).catch(() => null)
+    if (info) { if (!info.isDirectory()) throw new Error(`Not a directory: ${folder}`) }
+    else await mkdir(folder, { recursive: true })
+
+    // atomic write: tmp → rename, fallback to direct write
+    const write = async (data, file) => {
+        const [p, t, payload] = [fp(file), fp(file) + '.tmp', JSON.stringify(data, BufferJSON.replacer)]
+        await writeFile(t, payload)
+        try { await rename(t, p) } catch { await writeFile(p, payload); await unlink(t).catch(() => { }) }
+    }
+
+    const read = async file => {
+        const raw = await readFile(fp(file), 'utf-8').catch(() => null)
         if (!raw) return null
-        try { const p = JSON.parse(raw, BufferJSON.reviver); return (p && typeof p === 'object' && '__checksum' in p && 'data' in p) ? p.data : p }
-        catch (err) { logger?.warn({ file, err: err.message }, 'failed to read auth file — reinitializing'); await unlink(filePath(file)).catch(() => { }); return null }
+        try {
+            const p = JSON.parse(raw, BufferJSON.reviver)
+            return p && typeof p === 'object' && '__checksum' in p && 'data' in p ? p.data : p
+        } catch (e) {
+            logger.warn({ err: e.message, file }, 'auth file corrupt — reinitializing')
+            await unlink(fp(file)).catch(() => { })
+            return null
+        }
     }
 
-    const removeData = (file) => unlink(filePath(file)).catch(() => { })
+    const remove = f => unlink(fp(f)).catch(() => { })
 
-    let creds = bootstrapCreds(await readData('creds.json'))
-    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedPreKeyId = creds.nextPreKeyId
+    let creds = bootstrapCreds(await read('creds.json'))
+    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedId = creds.nextPreKeyId
 
     const cleanOldPreKeys = async () => {
-        const now = Date.now()
-        if (cleanupRunning || now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        if (cleanupRunning || Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return
         cleanupRunning = true
         try {
             const minId = creds.nextPreKeyId - preKeyRetention
             if (minId <= 0) return
-            const targets = (await readdir(folder)).map(f => f.match(/^pre-key-(\d+)\.json(\.tmp)?$/)).filter(m => m && parseInt(m[1], 10) < minId).map(m => join(folder, m[0]))
-            if (!targets.length) return
-            await Promise.all(targets.map(f => unlink(f).catch(() => { })))
-            lastCleanupAt = Date.now(); lastCleanedPreKeyId = creds.nextPreKeyId
-        } catch (err) { logger?.warn({ err }, 'prekey cleanup failed') }
-        finally { cleanupRunning = false }
+            const targets = (await readdir(folder))
+                .map(f => f.match(/^pre-key-(\d+)\.json(\.tmp)?$/))
+                .filter(m => m && parseInt(m[1], 10) < minId)
+                .map(m => join(folder, m[0]))
+            if (targets.length) await Promise.all(targets.map(f => unlink(f).catch(() => { })))
+            lastCleanupAt = Date.now(); lastCleanedId = creds.nextPreKeyId
+        } catch (e) {
+            logger.warn({ err: e.message }, 'prekey cleanup failed')
+        } finally { cleanupRunning = false }
     }
 
     cleanOldPreKeys().catch(() => { })
 
-    const getStats = async () => {
-        const files = await readdir(folder).catch(() => [])
-        return { totalFiles: files.length, preKeyCount: files.filter(f => /^pre-key-\d+\.json$/.test(f)).length, nextPreKeyId: creds.nextPreKeyId, lastCleanupAt: lastCleanupAt ? new Date(lastCleanupAt).toISOString() : null }
-    }
-
     return {
         state: {
             creds,
             keys: {
-                get: async (type, ids) => { const data = {}; await Promise.all(ids.map(async id => { let v = await readData(`${type}-${id}.json`); data[id] = type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v })); return data },
-                set: async (data) => { const tasks = []; for (const cat in data) for (const id in data[cat]) { const v = data[cat][id]; tasks.push(v ? writeData(v, `${cat}-${id}.json`) : removeData(`${cat}-${id}.json`)) }; await Promise.all(tasks) },
-            },
+                get: async (type, ids) => {
+                    const data = {}
+                    await Promise.all(ids.map(async id => { const v = await read(`${type}-${id}.json`); data[id] = patchAppStateKey(type, v) }))
+                    return data
+                },
+                set: async data => {
+                    const tasks = []
+                    for (const cat in data)
+                        for (const id in data[cat]) { const v = data[cat][id]; tasks.push(v ? write(v, `${cat}-${id}.json`) : remove(`${cat}-${id}.json`)) }
+                    await Promise.all(tasks)
+                }
+            }
+        },
+        saveCreds: async () => {
+            if (creds.nextPreKeyId - lastCleanedId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
+            return write(creds, 'creds.json')
         },
-        saveCreds: async () => { if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { }); return writeData(creds, 'creds.json') },
-        getStats,
+        getStats: async () => {
+            const files = await readdir(folder).catch(() => [])
+            return { totalFiles: files.length, preKeyCount: files.filter(f => /^pre-key-\d+\.json$/.test(f)).length, nextPreKeyId: creds.nextPreKeyId, lastCleanupAt: lastCleanupAt ? new Date(lastCleanupAt).toISOString() : null }
+        }
     }
 }
 
-// ── Keyv-backed ───────────────────────────────────────────────────────────────
-
-const ser = (v) => v == null ? null : JSON.parse(JSON.stringify(v, BufferJSON.replacer))
-
-const unwrapNestedValue = (obj) => { let cur = obj; while (cur && typeof cur === 'object' && !Array.isArray(cur) && Object.keys(cur).length === 1 && 'value' in cur) cur = cur.value; return cur }
-
-const deser = (raw, logger) => {
-    if (raw == null) return null
-    let parsed
-    if (typeof raw === 'string') { try { parsed = JSON.parse(raw) } catch (err) { logger?.warn?.({ err: err.message }, '[Auth] failed to parse stored value — treating as missing'); return null } }
-    else { parsed = raw }
-    parsed = unwrapNestedValue(parsed)
-    if (parsed == null) return null
-    if (typeof parsed === 'object' && '__checksum' in parsed && 'data' in parsed) parsed = parsed.data
-    return JSON.parse(JSON.stringify(parsed), BufferJSON.reviver)
-}
-
-const COLLECTION_OPTION_KEY = { '@keyv/mongo': 'collection', '@keyv/postgres': 'table', '@keyv/mysql': 'table', '@keyv/sqlite': 'table' }
-const _adapterCache = new Map()
-export const clearAdapterCache = () => _adapterCache.clear()
-
-const resolveAdapter = async (connectionString, collectionName) => {
-    const cacheKey = collectionName ? `${connectionString}::${collectionName}` : connectionString
-    if (_adapterCache.has(cacheKey)) return _adapterCache.get(cacheKey)
-    let protocol
-    try { protocol = new URL(connectionString).protocol } catch { throw new Error(`[Auth] Invalid connection string: "${connectionString}"`) }
-    const pkg = PROTOCOL_ADAPTERS[protocol]
-    if (!pkg) throw new Error(`[Auth] Unsupported protocol "${protocol}" — supported: redis, mongodb, postgresql, mysql, sqlite, etcd, memcache. Pass a pre-built KeyvStoreAdapter instance for anything else.`)
-    let mod
-    try { mod = await import(pkg) } catch (e) { if (e.code === 'ERR_MODULE_NOT_FOUND') throw new Error(`[Auth] "${pkg}" is required for this backend — install it: npm i ${pkg}`); throw e }
-    const Adapter = mod.default ?? mod[Object.keys(mod)[0]]
-    const optionKey = COLLECTION_OPTION_KEY[pkg]
-    const adapter = (collectionName && optionKey) ? new Adapter({ url: connectionString, uri: connectionString, [optionKey]: collectionName }) : new Adapter(connectionString)
-    adapter.setMaxListeners?.(0)
-    _adapterCache.set(cacheKey, adapter)
-    return adapter
-}
-
-const isAdapterLike = (v) => v != null && typeof v === 'object' && typeof v.get === 'function' && typeof v.set === 'function' && typeof v.delete === 'function' && typeof v.clear === 'function'
-
-const resolveStore = async (backend, collectionName) => {
-    if (backend == null) return null
-    if (typeof backend === 'string') return resolveAdapter(backend, collectionName)
-    if (backend instanceof Keyv) return backend.opts?.store ?? backend.store ?? null
-    if (isAdapterLike(backend)) return backend
-    throw new Error('[Auth] backend must be a connection string, Keyv instance, or KeyvStoreAdapter')
-}
+// ── Keyv-backed auth state ────────────────────────────────────────────────────
 
 export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
-    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, logger, collectionName } = opts
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, collectionName } = opts
+
     const store = await resolveStore(backend, collectionName)
-    const keyv = store ? new Keyv({ store, namespace: sessionId }) : new Keyv({ namespace: sessionId })
-    keyv.on('error', (err) => logger?.warn?.({ err: err?.message }, '[Auth] store error'))
+    const keyv = store ? new Keyv({ store }) : new Keyv()
+    keyv.setMaxListeners?.(0)
+    keyv.on('error', err => logger.warn({ err: err?.message, sessionId }, '[Auth] store error'))
 
-    const keyName = (type, id) => `${type}-${id}`
-    let creds = bootstrapCreds(deser(await keyv.get('creds'), logger))
-    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedPreKeyId = creds.nextPreKeyId
+    // all keys prefixed sessionId:: to isolate sessions on a shared store
+    const kn = (type, id) => `${sessionId}::${type}-${id}`
+    const credsKey = `${sessionId}::creds`
+
+    let creds = bootstrapCreds(deser(await keyv.get(credsKey)))
+    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedId = creds.nextPreKeyId
+    // tracks every key ever written — fallback clearSession uses this to wipe all types including JID-based IDs
+    const _writtenKeys = new Set([credsKey])
 
     const cleanOldPreKeys = async () => {
-        const now = Date.now()
-        if (cleanupRunning || now - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        if (cleanupRunning || Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return
         cleanupRunning = true
         try {
             const minId = creds.nextPreKeyId - preKeyRetention
             if (minId <= 0) return
             const ids = []
-            for (let id = Math.max(0, lastCleanedPreKeyId - preKeyRetention); id < minId; id++) ids.push(keyName('pre-key', id))
-            if (!ids.length) return
-            await Promise.all(ids.map(k => keyv.delete(k).catch(() => { })))
-            lastCleanupAt = Date.now(); lastCleanedPreKeyId = creds.nextPreKeyId
-        } catch (e) { logger?.warn?.({ err: e.message }, '[Auth] prekey cleanup failed') }
-        finally { cleanupRunning = false }
+            for (let id = Math.max(0, lastCleanedId - preKeyRetention); id < minId; id++) ids.push(kn('pre-key', id))
+            if (ids.length) await Promise.all(ids.map(k => keyv.delete(k).catch(() => { })))
+            lastCleanupAt = Date.now(); lastCleanedId = creds.nextPreKeyId
+        } catch (e) {
+            logger.warn({ err: e.message, sessionId }, '[Auth] prekey cleanup failed')
+        } finally { cleanupRunning = false }
     }
 
     cleanOldPreKeys().catch(() => { })
@@ -158,27 +188,53 @@ export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
     const keys = {
         get: async (type, ids) => {
             if (!ids.length) return {}
-            const rawValues = await keyv.getMany(ids.map(id => keyName(type, id)))
-            return Object.fromEntries(ids.map((id, i) => [id, patchAppStateKey(type, deser(rawValues[i], logger))]))
-        },
-        set: async (data) => {
-            const setEntries = [], delKeys = []
-            for (const type in data) for (const id in data[type]) { const v = data[type][id], k = keyName(type, id); v != null ? setEntries.push({ key: k, value: ser(v) }) : delKeys.push(k) }
-            await Promise.all([setEntries.length ? keyv.setMany(setEntries) : null, delKeys.length ? keyv.deleteMany(delKeys) : null])
+            const raws = await keyv.getMany(ids.map(id => kn(type, id)))
+            return Object.fromEntries(ids.map((id, i) => [id, patchAppStateKey(type, deser(raws[i]))]))
         },
+        set: async data => {
+            const sets = [], dels = []
+            for (const type in data)
+                for (const id in data[type]) {
+                    const v = data[type][id], k = kn(type, id)
+                    if (v != null) { sets.push({ key: k, value: ser(v) }); _writtenKeys.add(k) }
+                    else { dels.push(k); _writtenKeys.delete(k) }
+                }
+            await Promise.all([
+                sets.length ? keyv.setMany(sets) : null,
+                dels.length ? keyv.deleteMany(dels) : null
+            ])
+        }
     }
 
-    const saveCreds = async () => { if (creds.nextPreKeyId - lastCleanedPreKeyId >= cleanupThreshold) cleanOldPreKeys().catch(() => { }); await keyv.set('creds', ser(creds)) }
+    const saveCreds = async () => {
+        if (creds.nextPreKeyId - lastCleanedId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
+        _writtenKeys.add(credsKey)
+        await keyv.set(credsKey, ser(creds))
+    }
 
     const clearSession = async () => {
-        const s = keyv.opts?.store ?? keyv.store
-        if (s && typeof s.iterator === 'function') {
-            // v6: iterator() takes no namespace arg — uses this._namespace set via new Keyv({ namespace: sessionId })
-            const toDelete = []
-            for await (const [key] of s.iterator()) toDelete.push(key)
-            if (toDelete.length) typeof s.deleteMany === 'function' ? await s.deleteMany(toDelete) : await Promise.all(toDelete.map(k => s.delete(k).catch(() => { })))
-        } else {
-            await keyv.clear()
+        const prefix = `${sessionId}::`
+        let done = false
+        if (store) {
+            // Redis: KEYS pattern scan
+            const rc = store.client
+            if (rc && typeof rc.keys === 'function') {
+                try { await store.set('__probe__', 1); const m = await rc.keys(`${prefix}*`); if (m.length) await rc.del(m); done = true } catch { }
+            }
+            // Mongo/Postgres/SQLite: iterator scan
+            if (!done && typeof store.iterator === 'function') {
+                try {
+                    const targets = []
+                    for await (const [k] of store.iterator(prefix)) if (k.startsWith(prefix)) targets.push(k)
+                    if (targets.length) await store.deleteMany(targets)
+                    done = true
+                } catch { }
+            }
+        }
+        if (!done) {
+            // fallback (in-memory): delete every key ever written — covers all types + JID-based IDs
+            await Promise.all([..._writtenKeys].map(k => keyv.delete(k).catch(() => { })))
+            _writtenKeys.clear()
         }
         keyv.removeAllListeners?.()
     }
@@ -186,13 +242,12 @@ export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
     return { state: { creds, keys }, saveCreds, clearSession }
 }
 
+// check if valid creds exist for a session without fully loading it
 export const hasKeyvAuth = async (sessionId, backend, opts = {}) => {
     try {
         const store = await resolveStore(backend, opts.collectionName)
-        const keyv = store ? new Keyv({ store, namespace: sessionId }) : new Keyv({ namespace: sessionId })
-        const raw = await keyv.get('creds')
-        if (!raw) return false
-        const parsed = deser(raw)
+        const keyv = store ? new Keyv({ store }) : new Keyv()
+        const parsed = deser(await keyv.get(`${sessionId}::creds`))
         return !!(parsed?.noiseKey && parsed?.signedIdentityKey)
     } catch { return false }
 }

package/lib/index.js

@@ -29,7 +29,7 @@ const info = [
     '╭──────────────────────────────────────────────────────────────╮',
     '│                                                              │',
     '│  ◆  Package  ›  @zervonex/baileys                            │',
-    '│  ◆  Version  ›  3.0.4                                        │',
+    '│  ◆  Version  ›  3.0.5                                        │',
     '│  ◆  Status   ›  Production Ready                             │',
     '│                                                              │',
     '├──────────────────────────── ◇◆◇ ─────────────────────────────┤',

package/package.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@zervonex/baileys",
   "type": "module",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "description": "Advanced WhatsApp Web API built on Baileys — interactive messages, buttons, carousels, products, events, payments, polls, albums, sticker packs and more.",
   "keywords": [
     "baileys",
@@ -101,8 +101,8 @@
     "acorn": "^8.18.0",
     "acorn-walk": "^8.3.5",
     "async-mutex": "^0.5.0",
-    "axios": "^1.6.0",
-    "cache-manager": "latest",
+    "axios": "^1.20.0",
+    "cache-manager": "^7.2.9",
     "fflate": "^0.8.2",
     "ffmpeg-static": "^5.3.0",
     "file-type": "^22.2.0",
@@ -114,21 +114,21 @@
     "p-queue": "^10.0.0",
     "pino": "^10.4.0",
     "prismjs": "^1.30.0",
-    "protobufjs": "latest",
+    "protobufjs": "^8.8.1",
     "qrcode-terminal": "^0.12.0",
     "rlottie": "^0.1.2",
     "undici": "^8.12.3",
     "unfurl.js": "^6.4.0",
     "url-regex-safe": "^4.0.0",
-    "uuid": "latest",
+    "uuid": "^14.0.3",
     "wa-sticker-formatter": "^4.4.4",
     "whatsapp-rust-bridge": "^0.5.5",
-    "ws": "latest"
+    "ws": "^8.22.0"
   },
   "overrides": {
     "wa-sticker-formatter": {
       "sharp": "^0.35.5",
-      "axios": "^1.6.0",
+      "axios": "^1.20.0",
       "file-type": "^22.2.0",
       "image-size": "^2.0.4"
     },
@@ -138,7 +138,7 @@
     "image-size": "^2.0.4",
     "sqlite3": "^6.0.1",
     "cacache": "^19.0.1",
-    "axios": "^1.6.0",
+    "axios": "^1.20.0",
     "file-type": "^22.2.0",
     "sharp": "^0.35.5",
     "release-it": {
@@ -159,7 +159,7 @@
   },
   "resolutions": {
     "wa-sticker-formatter/sharp": "^0.35.5",
-    "wa-sticker-formatter/axios": "^1.6.0",
+    "wa-sticker-formatter/axios": "^1.20.0",
     "wa-sticker-formatter/file-type": "^22.2.0",
     "wa-sticker-formatter/image-size": "^2.0.4",
     "tar": "^7.5.22",
@@ -167,7 +167,7 @@
     "image-size": "^2.0.4",
     "sqlite3": "^6.0.1",
     "cacache": "^19.0.1",
-    "axios": "^1.6.0",
+    "axios": "^1.20.0",
     "file-type": "^22.2.0",
     "sharp": "^0.35.5"
   },