@zervonex/baileys 3.0.7 → 3.0.8

package/README.md

@@ -375,13 +375,17 @@ 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://www.npmjs.com/package/keyv). Pass a connection string — the matching backend driver is resolved and cached 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.
 
-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 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`.
+
+#### Basic usage
 
 ```javascript
 import { useKeyvAuthState } from '@zervonex/baileys'
@@ -413,13 +417,25 @@ const { state, saveCreds } = await useKeyvAuthState('test')
 
 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 share one connection across multiple sessions, pass a pre-built adapter or `Keyv` instance:
+#### 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 KeyvMongo from '@keyv/mongo'
 import KeyvDynamo from '@keyv/dynamo'
 
-// share one connection across sessions
+// 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)
@@ -429,7 +445,7 @@ const dynamo = new KeyvDynamo({ region: 'us-east-1', table: 'baileys_auth' })
 const { state, saveCreds } = await useKeyvAuthState('bot1', dynamo)
 ```
 
-Connection strings passed as plain strings are automatically cached and reused across every `useKeyvAuthState` call in the process — no need to build the instance yourself just to avoid duplicate connections.
+#### Custom collection/table name
 
 By default, Mongo/Postgres/MySQL/SQLite store everything in a collection/table named `keyv`. Pass `collectionName` to use your own:
 
@@ -439,17 +455,35 @@ const { state, saveCreds } = await useKeyvAuthState('bot1', 'mongodb://localhost
 })
 ```
 
-> Per-type backend routing (e.g. prekeys on SQLite, sessions on Postgres) is not currently supported — one `useKeyvAuthState` call uses one backend for all key types.
+#### 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',
+})
+```
+
+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')
 
-await clearSession() // wipes all keys for this session, disconnects the store
+await clearSession() // wipes all keys for this session only — other sessions untouched
 ```
 
-`clearSession()` removes every key scoped to that session's namespace — creds, prekeys, sessions, sender keys, everything. Other sessions sharing the same backend are untouched.
+`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
 
@@ -460,7 +494,7 @@ const valid = await hasKeyvAuth('bot1', backend)
 // true if creds exist and contain noiseKey + signedIdentityKey
 ```
 
-Lightweight — opens no full auth state, just checks for valid creds under the session's namespace.
+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
 
@@ -468,7 +502,7 @@ Lightweight — opens no full auth state, just checks for valid creds under the
 |--------|------|---------|-------------|
 | `preKeyRetention` | `number` | `150` | Number of recent prekeys to keep |
 | `cleanupThreshold` | `number` | `50` | New prekeys generated before cleanup runs |
-| `collectionName` | `string` | `"keyv"` | Custom collection/table name (Keyv adapter only, ignored for in-memory and pre-built 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
 

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

@@ -10,6 +10,7 @@ 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'
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -19,9 +20,11 @@ const ser = v => v == null ? null : JSON.parse(JSON.stringify(v, BufferJSON.repl
 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'); return null } })()
+        ? (() => { try { return JSON.parse(raw) } catch { return raw } })()  // ← return raw string on parse fail, don't warn
         : raw
-    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)
@@ -29,14 +32,17 @@ const deser = raw => {
 
 // ── Adapter resolution ────────────────────────────────────────────────────────
 
-// Only adapters that accept a named collection/table — redis, valkey, etcd, memcache, dynamo do not
+// 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}"`) }
@@ -51,23 +57,21 @@ 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
 }
 
-// Object.create scoping only needed for mapLike stores — keyvStorage and asyncMap have namespace managed by Keyv/bridge
 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
-    const { compatible, store } = detectKeyvStorage(backend)
+    const { compatible } = detectKeyvStorage(backend)
     if (!compatible) throw new Error('[Auth] backend must be a connection string, Keyv instance, or KeyvStoreAdapter')
-    if (store === 'mapLike') {
-        const scoped = Object.create(backend)
-        if (namespace) scoped.namespace = namespace
-        return scoped
-    }
-    return backend
+    // 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) => {
@@ -76,6 +80,40 @@ const makeKeyv = (store, namespace) => {
     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 ─────────────────────────────────────────────────────
 
 export const useMultiFileAuthState = async (folder, opts = {}) => {
@@ -87,7 +125,6 @@ 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)
@@ -108,22 +145,24 @@ export const useMultiFileAuthState = async (folder, opts = {}) => {
     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(() => { })
 
@@ -158,14 +197,14 @@ 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, sessionId)
-    const keyv = makeKeyv(store, sessionId)
-    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
 
     const cleanOldPreKeys = async () => {
@@ -176,7 +215,7 @@ 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 keyv.deleteMany(ids)
+            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 }
@@ -186,43 +225,49 @@ export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
     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) })
-                    else dels.push(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(() => { })
-        await keyv.set(credsKey, ser(creds))
+        await credsKeyv.set(credsKey, ser(creds))
     }
 
     const clearSession = async () => {
-        try {
-            const isolated = makeKeyv(store, sessionId)
-            await isolated.clear()
-            isolated.removeAllListeners?.()
-        } catch (e) { logger.warn({ err: e.message, sessionId }, '[Auth] clearSession failed') }
-        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 }
 }
 
-// Checks 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 keyv = makeKeyv(await resolveStore(backend, opts.collectionName, sessionId), 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.7                                        │',
+    '│  ◆  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.7",
+  "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",