@zervonex/baileys 3.0.5 → 3.0.7

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,20 @@ 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 and cached automatically, no manual adapter imports needed.
 
-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.
+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'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`:
+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`:
 
 ```javascript
 import { useKeyvAuthState } from '@zervonex/baileys'
@@ -407,52 +411,56 @@ 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:
+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:
 
 ```javascript
-import { useKeyvAuthState } from '@zervonex/baileys'
 import KeyvMongo from '@keyv/mongo'
+import KeyvDynamo from '@keyv/dynamo'
+
+// share one connection 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.
+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.
 
-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',
 })
 ```
 
-> 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.
+> 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.
 
 #### 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, disconnects the store
 ```
 
-`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.
+`clearSession()` removes every key scoped to that session's namespace — creds, prekeys, sessions, sender keys, everything. Other sessions sharing the same backend are untouched.
 
 #### 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 — opens no full auth state, just checks for valid creds under the session's namespace.
 
 #### Options
 
@@ -460,8 +468,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` | `"keyv"` | Custom collection/table name (Keyv adapter only, ignored for in-memory and pre-built instances) |
 
 #### Return values
 
@@ -471,7 +478,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'
@@ -11,21 +11,16 @@ const DEFAULT_PREKEY_RETENTION = 150
 const DEFAULT_CLEANUP_THRESHOLD = 50
 const CLEANUP_INTERVAL_MS = 10 * 60 * 1000
 
-// ── 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 (e) { logger.warn({ err: e.message }, '[Auth] failed to parse stored value'); 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
@@ -34,7 +29,9 @@ const deser = raw => {
 
 // ── Adapter resolution ────────────────────────────────────────────────────────
 
+// Only adapters that accept a named collection/table — redis, valkey, etcd, memcache, dynamo do not
 const COLLECTION_KEY = { '@keyv/mongo': 'collection', '@keyv/postgres': 'table', '@keyv/mysql': 'table', '@keyv/sqlite': 'table' }
+
 const _adapterCache = new Map()
 export const clearAdapterCache = () => _adapterCache.clear()
 
@@ -44,7 +41,7 @@ const resolveAdapter = async (conn, col) => {
     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}`)
@@ -58,12 +55,25 @@ const resolveAdapter = async (conn, col) => {
     return adapter
 }
 
-const resolveStore = async (backend, col) => {
+// 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 (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, store } = 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
+}
+
+const makeKeyv = (store, namespace) => {
+    const keyv = store ? new Keyv({ store, namespace }) : new Keyv({ namespace })
+    keyv.setMaxListeners?.(0)
+    return keyv
 }
 
 // ── File-based auth state ─────────────────────────────────────────────────────
@@ -77,13 +87,12 @@ 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
+    // 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,7 +105,6 @@ export const useMultiFileAuthState = async (folder, opts = {}) => {
             return null
         }
     }
-
     const remove = f => unlink(fp(f)).catch(() => { })
 
     let creds = bootstrapCreds(await read('creds.json'))
@@ -114,11 +122,9 @@ export const useMultiFileAuthState = async (folder, opts = {}) => {
                 .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 }
+        } catch (e) { logger.warn({ err: e.message }, 'prekey cleanup failed') }
+        finally { cleanupRunning = false }
     }
-
     cleanOldPreKeys().catch(() => { })
 
     return {
@@ -153,20 +159,14 @@ export const useMultiFileAuthState = async (folder, opts = {}) => {
 
 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 }) : new Keyv()
-    keyv.setMaxListeners?.(0)
+    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'))
 
-    // all keys prefixed sessionId:: to isolate sessions on a shared store
-    const kn = (type, id) => `${sessionId}::${type}-${id}`
-    const credsKey = `${sessionId}::creds`
-
+    const kn = (type, id) => `${type}-${id}`
+    const credsKey = '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 () => {
         if (cleanupRunning || Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) return
@@ -176,13 +176,11 @@ 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 keyv.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 = {
@@ -196,58 +194,35 @@ export const useKeyvAuthState = async (sessionId, backend, opts = {}) => {
             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) }
+                    if (v != null) sets.push({ key: k, value: ser(v) })
+                    else dels.push(k)
                 }
-            await Promise.all([
-                sets.length ? keyv.setMany(sets) : null,
-                dels.length ? keyv.deleteMany(dels) : null
-            ])
+            await 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))
     }
 
     const clearSession = async () => {
-        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()
-        }
+        try {
+            const isolated = makeKeyv(store, sessionId)
+            await isolated.clear()
+            isolated.removeAllListeners?.()
+        } catch (e) { logger.warn({ err: e.message, sessionId }, '[Auth] clearSession failed') }
         keyv.removeAllListeners?.()
     }
 
     return { state: { creds, keys }, saveCreds, clearSession }
 }
 
-// check if valid creds exist for a session without fully loading it
+// Checks 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 }) : new Keyv()
-        const parsed = deser(await keyv.get(`${sessionId}::creds`))
+        const keyv = makeKeyv(await resolveStore(backend, opts.collectionName, sessionId), sessionId)
+        const parsed = deser(await keyv.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.5                                        │',
+    '│  ◆  Version  ›  3.0.7                                        │',
     '│  ◆  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.5",
+  "version": "3.0.7",
   "description": "Advanced WhatsApp Web API built on Baileys — interactive messages, buttons, carousels, products, events, payments, polls, albums, sticker packs and more.",
   "keywords": [
     "baileys",