@zervonex/baileys 3.0.6 → 3.0.8

package/README.md

@@ -350,15 +350,14 @@ Two adapters are available. They do **not** share an identical return shape —
 
 ### File-based (default)
 
-Atomic writes, sha256 checksum integrity, per-file mutex locking, corrupt file recovery, and legacy file upgrade. Best for single-instance bots or local development.
+Atomic writes (tmp → rename with fallback), corrupt file self-healing, and automatic old pre-key cleanup. Best for single-instance bots or local development.
 
 ```javascript
 import { useMultiFileAuthState } from '@zervonex/baileys'
 
 const { state, saveCreds, getStats } = await useMultiFileAuthState('auth_session', {
-    preKeyRetention:   150,  // how many recent prekeys to keep (default: 150)
-    cleanupThreshold:  50,   // new prekeys before a cleanup runs (default: 50)
-    logger,                  // optional — logs checksum mismatches and cleanup events
+    preKeyRetention:  150,  // how many recent prekeys to keep (default: 150)
+    cleanupThreshold: 50,   // new prekeys before a cleanup runs (default: 50)
 })
 
 const sock = makeWASocket({ auth: state })
@@ -369,15 +368,24 @@ const stats = await getStats()
 // { totalFiles: 42, preKeyCount: 150, nextPreKeyId: 3200, lastCleanupAt: '2026-07-05T...' }
 ```
 
-To fully log out and delete a session's files, remove the session folder directly (e.g. `fs.rm(folder, { recursive: true, force: true })`) — there is no `clearSession`/`close` method on this adapter.
+To fully log out and delete a session, remove the session folder directly — there is no `clearSession` method on this adapter:
+
+```javascript
+import { rm } from 'fs/promises'
+await rm('auth_session', { recursive: true, force: true })
+```
+
+---
 
 ### Keyv-based (production)
 
-Universal adapter for any database backend via [Keyv](https://github.com/jaredwray/keyv). Pass a connection string — the matching backend driver is resolved and imported automatically, no manual adapter imports needed.
+Universal adapter for any database backend via [Keyv](https://www.npmjs.com/package/keyv). Pass a connection string — the matching backend driver is resolved, instantiated, and **cached automatically per session** — no manual adapter imports needed.
+
+Both adapters use the same `BufferJSON` serialization format and auto-detect legacy `{ value: { value: ... } }` double-wrapping from older versions — no manual data migration needed when upgrading.
 
-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 is used as a Keyv namespace so multiple bots can safely share one backend without key collisions. 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 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`:
+#### Basic usage
 
 ```javascript
 import { useKeyvAuthState } from '@zervonex/baileys'
@@ -407,52 +415,86 @@ const { state, saveCreds } = await useKeyvAuthState('bot1', 'memcache://localhos
 const { state, saveCreds } = await useKeyvAuthState('test')
 ```
 
-Supported connection string protocols: `redis:`/`rediss:`, `mongodb:`/`mongodb+srv:`, `postgres:`/`postgresql:`, `mysql:`, `sqlite:`, `etcd:`, `memcache:`/`memcached:`. All matching driver packages (`@keyv/redis`, `@keyv/mongo`, `@keyv/postgres`, `@keyv/mysql`, `@keyv/sqlite`, `@keyv/etcd`, `@keyv/memcache`) ship as regular dependencies of this package — nothing extra to install.
+Supported protocols: `redis:`/`rediss:`, `mongodb:`/`mongodb+srv:`, `postgres:`/`postgresql:`, `mysql:`, `sqlite:`, `etcd:`, `memcache:`/`memcached:`. All matching driver packages ship as dependencies — nothing extra to install.
 
-For backends without a connection string (e.g. DynamoDB), or to reuse one connection across multiple `useKeyvAuthState` calls yourself, pass a pre-built adapter or `Keyv` instance instead of a string:
+#### How adapter caching works
+
+Connection strings are cached **per `conn::collection::sessionId`** — each session gets its own isolated adapter instance so `clearSession()` and namespace operations never bleed across sessions. Underlying database drivers (MongoDB, pg, mysql2, ioredis) manage their own internal connection pools, so multiple adapter instances pointing at the same URI still share one real connection — no connection explosion across 50+ sessions.
+
+```javascript
+// these two calls resolve to separate adapter instances but share one MongoDB connection internally
+const bot1 = await useKeyvAuthState('session_111', 'mongodb://localhost/baileys')
+const bot2 = await useKeyvAuthState('session_222', 'mongodb://localhost/baileys')
+```
+
+#### Sharing a pre-built adapter
+
+For backends without a connection string (e.g. DynamoDB), or when you need full control over the connection, pass a pre-built adapter or `Keyv` instance directly:
 
 ```javascript
-import { useKeyvAuthState } from '@zervonex/baileys'
 import KeyvMongo from '@keyv/mongo'
+import KeyvDynamo from '@keyv/dynamo'
+
+// share one adapter instance across sessions
+const mongo = new KeyvMongo('mongodb://localhost/baileys')
+const { state: s1 } = await useKeyvAuthState('bot1', mongo)
+const { state: s2 } = await useKeyvAuthState('bot2', mongo)
 
-const backend = new KeyvMongo('mongodb://localhost/baileys') // build once, share across sessions
-const { state, saveCreds } = await useKeyvAuthState('bot1', backend)
+// DynamoDB (no connection string protocol)
+const dynamo = new KeyvDynamo({ region: 'us-east-1', table: 'baileys_auth' })
+const { state, saveCreds } = await useKeyvAuthState('bot1', dynamo)
 ```
 
-Same connection string passed as a plain string is automatically cached and reused across every `useKeyvAuthState` call in the process — you don't need to build the instance yourself just to avoid opening duplicate connections, but you can if you want the reference for other purposes.
+#### Custom collection/table name
 
-By default, Mongo/Postgres/MySQL/SQLite store everything in a collection/table named `keyv` (each adapter's own default). Set `collectionName` to use your own name instead — it's mapped to whatever each backend actually calls it (`collection` for Mongo, `table` for Postgres/MySQL/SQLite):
+By default, Mongo/Postgres/MySQL/SQLite store everything in a collection/table named `keyv`. Pass `collectionName` to use your own:
 
 ```javascript
 const { state, saveCreds } = await useKeyvAuthState('bot1', 'mongodb://localhost/baileys', {
-    collectionName: 'baileys_auth', // instead of the default "keyv" collection
+    collectionName: 'baileys_auth',
+})
+```
+
+#### Multi-backend routing
+
+Route different key types to different backends — e.g. keep creds on Postgres and prekeys on Redis:
+
+```javascript
+const { state, saveCreds, clearSession } = await useKeyvAuthState('bot1', {
+    'creds':                  'postgresql://user:pass@localhost/db',
+    'pre-key':                'redis://localhost:6379',
+    'session':                'redis://localhost:6379',
+    'app-state-sync-key':     'mongodb://localhost/baileys',
+    'app-state-sync-version': 'mongodb://localhost/baileys',
+    'sender-key':             'redis://localhost:6379',
+    'sender-key-memory':      'redis://localhost:6379',
 })
 ```
 
-> Per-type backend routing (e.g. prekeys on SQLite, sessions on Postgres) is not currently supported — one `useKeyvAuthState` call uses one backend for every key type.
+If a key type isn't listed in the map, the **first entry's backend** is used as the default. Backends that appear more than once in the map are deduplicated — one adapter instance, one connection.
+
+`clearSession()` on a multi-backend session clears all backends in the map, each scoped to that session's namespace only.
 
 #### Clearing a session (logout)
 
 ```javascript
 const { state, saveCreds, clearSession } = await useKeyvAuthState('bot1', 'redis://localhost:6379')
 
-// on logout / when you want to wipe this session's auth entirely:
-await clearSession()
+await clearSession() // wipes all keys for this session only — other sessions untouched
 ```
 
-`clearSession()` wipes every key belonging to that `sessionId` — creds, prekeys, sessions, sender keys, everything — by calling `keyv.clear()` which removes all keys scoped to that session's namespace. 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.
+`clearSession()` removes every key scoped to that session's namespace — creds, prekeys, sessions, sender keys, app state, everything. Sessions sharing the same backend are never affected.
 
 #### Checking auth without loading full state
 
 ```javascript
 import { hasKeyvAuth } from '@zervonex/baileys'
 
-// Check if a session has valid auth (lightweight — no full state load)
 const valid = await hasKeyvAuth('bot1', backend)
 // true if creds exist and contain noiseKey + signedIdentityKey
 ```
 
-`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.
+Lightweight — does not initialize full auth state, just checks for valid creds under the session's namespace. Accepts the same backend types as `useKeyvAuthState` including multi-backend maps (checks the first entry where creds live).
 
 #### Options
 
@@ -460,8 +502,7 @@ const valid = await hasKeyvAuth('bot1', backend)
 |--------|------|---------|-------------|
 | `preKeyRetention` | `number` | `150` | Number of recent prekeys to keep |
 | `cleanupThreshold` | `number` | `50` | New prekeys generated before cleanup runs |
-| `logger` | `object` | `undefined` | Logger with `.info` / `.warn` methods |
-| `collectionName` | `string` | adapter's own default (`"keyv"`) | Custom collection/table name — Keyv-based adapter only, ignored for connection-string-less (in-memory) and pre-built adapter/`Keyv` instances |
+| `collectionName` | `string` | `"zervonex"` | Custom collection/table name — ignored for in-memory, pre-built instances, and backends without collection support (redis, etcd, memcache) |support (redis, etcd, memcache) |
 
 #### Return values
 
@@ -471,7 +512,6 @@ const valid = await hasKeyvAuth('bot1', backend)
 | `saveCreds` | ✅ | ✅ |
 | `getStats` | ✅ | ❌ |
 | `clearSession` | ❌ (delete the folder instead) | ✅ |
-| `close` | ❌ | ✅ (drops local listeners; safe to call, does not disconnect a shared backend) |
 
 ---
 

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

@@ -1,6 +1,6 @@
 import { mkdir, readFile, rename, stat, unlink, writeFile, readdir } from 'fs/promises'
 import { join } from 'path'
-import { Keyv } from 'keyv'
+import { Keyv, detectKeyvStorage } from 'keyv'
 import { proto } from '../../WAProto/index.js'
 import { initAuthCreds } from './auth-utils.js'
 import { BufferJSON } from './generics.js'
@@ -10,23 +10,21 @@ import logger from './logger.js'
 const DEFAULT_PREKEY_RETENTION = 150
 const DEFAULT_CLEANUP_THRESHOLD = 50
 const CLEANUP_INTERVAL_MS = 10 * 60 * 1000
+const DEFAULT_COLLECTION_NAME = 'zervonex'
 
-// ── Shared helpers ────────────────────────────────────────────────────────────
+// ── Helpers ───────────────────────────────────────────────────────────────────
 
 const bootstrapCreds = raw => raw ?? initAuthCreds()
-
-const patchAppStateKey = (type, v) =>
-    type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
-
+const patchAppStateKey = (type, v) => type === 'app-state-sync-key' && v ? proto.Message.AppStateSyncKeyData.fromObject(v) : v
 const ser = v => v == null ? null : JSON.parse(JSON.stringify(v, BufferJSON.replacer))
-
 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 } })()
+        ? (() => { try { return JSON.parse(raw) } catch { return raw } })()  // ← return raw string on parse fail, don't warn
         : 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
+    // some adapters double-wrap in { value: { value: ... } } — unwrap up to 3 levels
+    let depth = 0
+    while (depth++ < 3 && 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)
@@ -34,17 +32,22 @@ const deser = raw => {
 
 // ── Adapter resolution ────────────────────────────────────────────────────────
 
+// Only these adapters accept a named collection/table — redis, valkey, etcd etc do not
 const COLLECTION_KEY = { '@keyv/mongo': 'collection', '@keyv/postgres': 'table', '@keyv/mysql': 'table', '@keyv/sqlite': 'table' }
+
+// Cached per conn::col::namespace — each session gets its own adapter instance so
+// clear() never bleeds across sessions. Underlying drivers manage their own connection
+// pools so multiple adapters on the same URI still share one real connection.
 const _adapterCache = new Map()
 export const clearAdapterCache = () => _adapterCache.clear()
 
-const resolveAdapter = async (conn, col) => {
-    const ck = col ? `${conn}::${col}` : conn
+const resolveAdapter = async (conn, col, namespace) => {
+    const ck = `${conn}::${col ?? ''}::${namespace ?? ''}`
     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`)
+    if (!pkg) throw new Error(`[Auth] Unsupported protocol "${protocol}" — supported: ${Object.keys(PROTOCOL_ADAPTERS).map(p => p.replace(':', '')).join(', ')}`)
     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}`)
@@ -54,16 +57,61 @@ const resolveAdapter = async (conn, col) => {
     const optKey = COLLECTION_KEY[pkg]
     const adapter = col && optKey ? new Adapter({ url: conn, uri: conn, [optKey]: col }) : new Adapter(conn)
     adapter.setMaxListeners?.(0)
+    if (namespace) adapter.namespace = namespace
     _adapterCache.set(ck, adapter)
     return adapter
 }
 
-const resolveStore = async (backend, col) => {
+const resolveStore = async (backend, col, namespace) => {
     if (backend == null) return null
-    if (typeof backend === 'string') return resolveAdapter(backend, col)
+    if (typeof backend === 'string') return resolveAdapter(backend, col, namespace)
     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')
+    const { compatible } = detectKeyvStorage(backend)
+    if (!compatible) throw new Error('[Auth] backend must be a connection string, Keyv instance, or KeyvStoreAdapter')
+    // scope namespace via prototype so we don't mutate the original store instance
+    const scoped = Object.create(backend)
+    if (namespace) scoped.namespace = namespace
+    return scoped
+}
+
+const makeKeyv = (store, namespace) => {
+    const keyv = store ? new Keyv({ store, namespace }) : new Keyv({ namespace })
+    keyv.setMaxListeners?.(0)
+    return keyv
+}
+
+// ── Multi-backend support ─────────────────────────────────────────────────────
+
+// Multi-backend map: { 'creds': pgBackend, 'pre-key': mongoBackend, ... }
+// Anything else (string, Keyv, raw store adapter) is treated as single backend
+const isMultiBackend = backend =>
+    backend !== null
+    && typeof backend === 'object'
+    && !Array.isArray(backend)
+    && !(backend instanceof Keyv)
+    && !detectKeyvStorage(backend).compatible
+
+// Returns { get(type) → Keyv, all → Keyv[] }
+// get(type) falls back to first entry if type not in map
+// all is deduplicated — shared backends only clear once
+const resolveBackendMap = async (backend, sessionId, collectionName) => {
+    if (!isMultiBackend(backend)) {
+        const store = await resolveStore(backend, collectionName, sessionId)
+        const keyv = makeKeyv(store, sessionId)
+        return { get: () => keyv, all: [keyv] }
+    }
+    const entries = Object.entries(backend)
+    if (!entries.length) throw new Error('[Auth] backend map must have at least one entry')
+    const resolved = new Map()
+    for (const [, b] of entries) {
+        if (!resolved.has(b)) {
+            const store = await resolveStore(b, collectionName, sessionId)
+            resolved.set(b, makeKeyv(store, sessionId))
+        }
+    }
+    const typeMap = Object.fromEntries(entries.map(([type, b]) => [type, resolved.get(b)]))
+    const defaultKeyv = resolved.get(entries[0][1])
+    return { get: type => typeMap[type] ?? defaultKeyv, all: [...new Set(resolved.values())] }
 }
 
 // ── File-based auth state ─────────────────────────────────────────────────────
@@ -77,13 +125,11 @@ export const useMultiFileAuthState = async (folder, opts = {}) => {
     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
@@ -96,29 +142,28 @@ export const useMultiFileAuthState = async (folder, opts = {}) => {
             return null
         }
     }
-
     const remove = f => unlink(fp(f)).catch(() => { })
 
     let creds = bootstrapCreds(await read('creds.json'))
-    let cleanupRunning = false, lastCleanupAt = 0, lastCleanedId = creds.nextPreKeyId
+    let cleanupPromise = null, lastCleanupAt = 0, lastCleanedId = creds.nextPreKeyId
 
     const cleanOldPreKeys = async () => {
-        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) 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 }
+        if (cleanupPromise || Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return
+        cleanupPromise = (async () => {
+            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) 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 { cleanupPromise = null }
+        })()
+        await cleanupPromise
     }
-
     cleanOldPreKeys().catch(() => { })
 
     return {
@@ -152,20 +197,15 @@ export const useMultiFileAuthState = async (folder, opts = {}) => {
 // ── Keyv-backed auth state ────────────────────────────────────────────────────
 
 export const useKeyvAuthState = async (sessionId, backend, 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.setMaxListeners?.(0)
-    keyv.on('error', err => logger.warn({ err: err?.message, sessionId }, '[Auth] store error'))
+    const { preKeyRetention = DEFAULT_PREKEY_RETENTION, cleanupThreshold = DEFAULT_CLEANUP_THRESHOLD, collectionName = DEFAULT_COLLECTION_NAME } = opts
+    const bmap = await resolveBackendMap(backend, sessionId, collectionName)
+    const credsKeyv = bmap.get('creds')
+    credsKeyv.on('error', err => logger.warn({ err: err?.message, sessionId }, '[Auth] store error'))
 
     const kn = (type, id) => `${type}-${id}`
     const credsKey = 'creds'
-
-    let creds = bootstrapCreds(deser(await keyv.get(credsKey)))
+    let creds = bootstrapCreds(deser(await credsKeyv.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 () => {
         if (cleanupRunning || Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return
@@ -175,56 +215,59 @@ export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
             if (minId <= 0) return
             const ids = []
             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(() => { })))
+            if (ids.length) await bmap.get('pre-key').deleteMany(ids)
             lastCleanupAt = Date.now(); lastCleanedId = creds.nextPreKeyId
-        } catch (e) {
-            logger.warn({ err: e.message, sessionId }, '[Auth] prekey cleanup failed')
-        } finally { cleanupRunning = false }
+        } catch (e) { logger.warn({ err: e.message, sessionId }, '[Auth] prekey cleanup failed') }
+        finally { cleanupRunning = false }
     }
-
     cleanOldPreKeys().catch(() => { })
 
     const keys = {
         get: async (type, ids) => {
             if (!ids.length) return {}
+            const keyv = bmap.get(type)
             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)
+            // group by Keyv instance to batch writes per backend
+            const byKeyv = new Map()
+            for (const type in data) {
+                const keyv = bmap.get(type)
+                if (!byKeyv.has(keyv)) byKeyv.set(keyv, { sets: [], dels: [] })
+                const bucket = byKeyv.get(keyv)
                 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) }
+                    if (v != null) bucket.sets.push({ key: k, value: ser(v) })
+                    else bucket.dels.push(k)
                 }
-            await Promise.all([
-                sets.length ? keyv.setMany(sets) : null,
-                dels.length ? keyv.deleteMany(dels) : null
-            ])
+            }
+            await Promise.all([...byKeyv.entries()].map(([keyv, { sets, dels }]) =>
+                Promise.all([sets.length ? keyv.setMany(sets) : null, dels.length ? keyv.deleteMany(dels) : null])
+            ))
         }
     }
 
     const saveCreds = async () => {
         if (creds.nextPreKeyId - lastCleanedId >= cleanupThreshold) cleanOldPreKeys().catch(() => { })
-        _writtenKeys.add(credsKey)
-        await keyv.set(credsKey, ser(creds))
+        await credsKeyv.set(credsKey, ser(creds))
     }
 
     const clearSession = async () => {
-        await keyv.clear()
-        keyv.removeAllListeners?.()
+        try { await Promise.all(bmap.all.map(keyv => keyv.clear())) }
+        catch (e) { logger.warn({ err: e.message, sessionId }, '[Auth] clearSession failed') }
+        bmap.all.forEach(keyv => keyv.removeAllListeners?.())
     }
 
     return { state: { creds, keys }, saveCreds, clearSession }
 }
 
-// check if valid creds exist for a session without fully loading it
+// Lightweight check — reads only the creds key without full state init
 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 parsed = deser(await keyv.get('creds'))
+        const b = isMultiBackend(backend) ? Object.values(backend)[0] : backend
+        const bmap = await resolveBackendMap(b, sessionId, opts.collectionName ?? DEFAULT_COLLECTION_NAME)
+        const parsed = deser(await bmap.get('creds').get('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.6                                        │',
+    '│  ◆  Version  ›  3.0.8                                        │',
     '│  ◆  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.6",
+  "version": "3.0.8",
   "description": "Advanced WhatsApp Web API built on Baileys — interactive messages, buttons, carousels, products, events, payments, polls, albums, sticker packs and more.",
   "keywords": [
     "baileys",