baileys-redis-auth 1.1.0 → 2.0.1

package/LOGOUT_GUIDE.md

@@ -22,7 +22,7 @@ Your application MUST manually clear the Redis session when it detects a logout.
 
 ```typescript
 import {deleteKeysWithPattern, useRedisAuthState} from 'baileys-redis-auth'
-import {DisconnectReason} from '@whiskeysockets/baileys'
+import {DisconnectReason} from 'baileys'
 
 const {state, saveCreds, redis} = await useRedisAuthState(redisOptions, 'my-session')
 
@@ -36,7 +36,7 @@ sock.ev.on('connection.update', async (update) => {
       // User logged out - clear the session
       await deleteKeysWithPattern({
         redis,
-        pattern: 'my-session:*',  // Must match your session prefix
+        sessionId: 'my-session',  // Must match your session prefix
         logger: console.log        // Optional: pass logger for debugging
       })
       console.log('Session cleared after logout')
@@ -76,7 +76,7 @@ sock.ev.on('connection.update', async (update) => {
       // Clear HSet-based session
       await deleteHSetKeys({
         redis,
-        key: 'my-session',
+        sessionId: 'my-session',
         logger: console.log  // Optional: pass logger for debugging
       })
       console.log('Session cleared after logout')
@@ -89,7 +89,7 @@ sock.ev.on('connection.update', async (update) => {
 
 ```typescript
 import {deleteKeysWithPattern, useRedisAuthState} from 'baileys-redis-auth'
-import makeWASocket, {DisconnectReason} from '@whiskeysockets/baileys'
+import makeWASocket, {DisconnectReason} from 'baileys'
 import type {Boom} from '@hapi/boom'
 
 async function startWhatsApp() {
@@ -119,7 +119,7 @@ async function startWhatsApp() {
         // THIS IS CRITICAL: Clear Redis session on logout
         await deleteKeysWithPattern({
           redis,
-          pattern: `${sessionPrefix}:*`,
+          sessionId: sessionPrefix,
           logger: console.log  // Optional: pass logger for debugging
         })
         console.log('✅ Session cleared successfully')
@@ -164,7 +164,7 @@ await sock.logout()
 
 ```typescript
 await sock.logout()
-await deleteKeysWithPattern({redis, pattern: 'session:*'})
+await deleteKeysWithPattern({redis, sessionId: 'session'})
 // Race condition - might clear before logout message is sent
 ```
 
@@ -173,7 +173,7 @@ await deleteKeysWithPattern({redis, pattern: 'session:*'})
 ```typescript
 sock.ev.on('connection.update', async (update) => {
   if (connection === 'close' && statusCode === DisconnectReason.loggedOut) {
-    await deleteKeysWithPattern({redis, pattern: 'session:*'})
+    await deleteKeysWithPattern({redis, sessionId: 'session'})
   }
 })
 
@@ -188,7 +188,7 @@ await sock.logout() // Cleanup happens automatically
 ```typescript
 deleteKeysWithPattern({
   redis: RedisClient,    // Redis client from useRedisAuthState
-  pattern: string,       // Pattern to match (e.g., 'session:*')
+  sessionId: string,     // Session ID (e.g., 'session')
   logger?: (message: string, ...args: unknown[]) => void  // Optional logger function
 }): Promise<void>
 ```
@@ -198,7 +198,7 @@ deleteKeysWithPattern({
 ```typescript
 deleteHSetKeys({
   redis: RedisClient,    // Redis client from useRedisAuthStateWithHSet
-  key: string,          // Session prefix (e.g., 'session')
+  sessionId: string,    // Session prefix (e.g., 'session')
   logger?: (message: string, ...args: unknown[]) => void  // Optional logger function
 }): Promise<void>
 ```

package/README.md

@@ -1,16 +1,22 @@
 # baileys-redis-auth
 
+✅ **Baileys v7.0.0-rc.9 Compatible** - aligned with current latest npm release
+
 `baileys-redis-auth` is a library designed to seamlessly integrate Redis as an authentication state storage solution for [Baileys](https://github.com/WhiskeySockets/Baileys), the powerful WhatsApp Web API library. By leveraging Redis, this module allows you to persist Baileys sessions, enabling your application to resume connections without needing to re-scan QR codes frequently. This is particularly useful for applications requiring robust and scalable session management.
 
 This library provides flexible ways to store authentication data in Redis, using either simple key-value pairs or Redis Hashes for optimized storage.
 
+## NPM Package
+
+- Package page: https://www.npmjs.com/package/baileys-redis-auth
+
 ## Prerequisites
 
 Before using `baileys-redis-auth`, ensure you have the following installed and configured:
 
-*   **Node.js:** Version 18.x or higher is recommended.
-*   **Redis:** A running Redis server instance. You'll need its connection details (host, port, password if any).
-*   **Baileys:** This library is an auth handler for Baileys, so you should have Baileys as part of your project.
+- **Node.js:** Version 18.x or higher is recommended.
+- **Redis:** A running Redis server instance. You'll need its connection details (host, port, password if any).
+- **Baileys:** This library is an auth handler for Baileys, so you should have Baileys as part of your project.
 
 ## Installation
 
@@ -22,168 +28,295 @@ npm install baileys-redis-auth
 
 ### Using `useRedisAuthStateWithHSet` (Recommended)
 
-This is the recommended method for storing Baileys authentication data in Redis. It utilizes Redis Hashes (HSET) to store all authentication credentials and keys under a single Redis key per session prefix. This approach is generally more efficient and organized, especially when managing multiple Baileys sessions.
+This is the recommended method for storing Baileys authentication data in Redis. It utilizes Redis Hashes (HSET) to store all authentication credentials and keys under a single Redis key per session. This approach is generally more efficient and organized, especially when managing multiple Baileys sessions.
 
 **Parameters:**
-*   `redisOptions`: An object containing your Redis server connection details (e.g., `host`, `port`, `password`). This is passed directly to the `ioredis` constructor.
-*   `prefix`: A string used to namespace your Baileys session data in Redis. For example, if your `prefix` is `'DB1'`, all data for this session will be stored under a Redis key like `authState:DB1`. This allows you to manage multiple independent Baileys sessions in the same Redis database.
-*   `logger` (optional): A function `(message: string, ...args: unknown[]) => void` for logging Redis connection events. Pass `console.log` or your custom logger function.
+
+- `redisOptions`: An object containing your Redis server connection details (e.g., `host`, `port`, `password`). This is passed directly to the `ioredis` constructor.
+- `sessionId`: A string used to identify and namespace your Baileys session data in Redis. For example, if your `sessionId` is `'user-123'`, all data for this session will be stored under a Redis key like `user-123:auth`. This allows you to manage multiple independent Baileys sessions in the same Redis database.
+- `logger` (optional): A function `(message: string, ...args: unknown[]) => void` for logging Redis connection events. Pass `console.log` or your custom logger function.
 
 ```typescript
-import {useRedisAuthStateWithHSet, deleteHSetKeys} from 'baileys-redis-auth';
-import Redis, { RedisOptions } from 'ioredis'; // Assuming ioredis is used like this
+import { useRedisAuthStateWithHSet, deleteHSetKeys } from 'baileys-redis-auth'
+import Redis, { RedisOptions } from 'ioredis'
 
 // Define your Redis connection options
 const redisOptions: RedisOptions = {
-    host: 'localhost',
-    port: 6379,
-    // password: 'your_redis_password', // Uncomment if your Redis has a password
-};
+  host: 'localhost',
+  port: 6379
+  // password: 'your_redis_password', // Uncomment if your Redis has a password
+}
 
-// Define a unique prefix for this Baileys session
-const sessionPrefix = 'baileys_session_1';
+// Define a unique session identifier for this Baileys session
+const sessionId = 'baileys_session_1'
 
 async function initializeBaileysWithHSet() {
-    // Initialize a new Redis client instance if you need to pass it around or use it elsewhere
-    // const redis = new Redis(redisOptions);
-    // redis.on('connect', () => console.log('Connected to Redis for HSet method!'));
-    // Note: useRedisAuthStateWithHSet creates its own Redis instance internally based on redisOptions.
-    // If you pass an existing ioredis instance, it should be the first argument,
-    // and redisOptions the second, though the current library signature seems to expect options first.
-    // For simplicity, we'll let the function create its own connection.
-
-    const {state, saveCreds, redis: authRedisInstance} = await useRedisAuthStateWithHSet(
-        redisOptions,
-        sessionPrefix,
-        console.log  // Optional: pass logger for Redis connection events
-    );
-
-    // 'state' will be used to initialize Baileys
-    // 'saveCreds' is a function to periodically save the authentication state
-    // 'authRedisInstance' is the Redis client instance used by the auth state hook
-
-    console.log('Baileys state loaded using HSet method.');
-
-    // Example: Listen for Redis connection events on the instance returned by the hook
-    authRedisInstance.on('connect', () => console.log(`Redis (from hook) connected for session: ${sessionPrefix}`));
-    authRedisInstance.on('error', (err) => console.error(`Redis (from hook) error for session ${sessionPrefix}:`, err));
-
-    // ... your Baileys setup code using 'state' and 'saveCreds'
-
-    // Example of how to delete all keys for this specific session prefix if needed:
-    // await deleteHSetKeys({redis: authRedisInstance, key: sessionPrefix});
-    // console.log(`Authentication data for session ${sessionPrefix} deleted.`);
+  // useRedisAuthStateWithHSet creates its own Redis instance internally based on redisOptions
+
+  const {
+    state,
+    saveCreds,
+    redis: authRedisInstance
+  } = await useRedisAuthStateWithHSet(
+    redisOptions,
+    sessionId,
+    console.log // Optional: pass logger for Redis connection events
+  )
+
+  // 'state' will be used to initialize Baileys
+  // 'saveCreds' is a function to periodically save the authentication state
+  // 'authRedisInstance' is the Redis client instance used by the auth state hook
+
+  console.log('Baileys state loaded using HSet method.')
+
+  // Example: Listen for Redis connection events on the instance returned by the hook
+  authRedisInstance.on('connect', () =>
+    console.log(`Redis (from hook) connected for session: ${sessionId}`)
+  )
+  authRedisInstance.on('error', (err) =>
+    console.error(`Redis (from hook) error for session ${sessionId}:`, err)
+  )
+
+  // ... your Baileys setup code using 'state' and 'saveCreds'
+
+  // Example of how to delete all data for this specific session if needed:
+  // await deleteHSetKeys({redis: authRedisInstance, sessionId: sessionId});
+  // console.log(`Authentication data for session ${sessionId} deleted.`);
 }
 
-initializeBaileysWithHSet().catch(console.error);
+initializeBaileysWithHSet().catch(console.error)
 ```
 
 #### Deleting Session Data (`deleteHSetKeys`)
 
-To remove all authentication data associated with a specific session prefix used with `useRedisAuthStateWithHSet`, you can use the `deleteHSetKeys` utility function.
+To remove all authentication data associated with a specific session used with `useRedisAuthStateWithHSet`, you can use the `deleteHSetKeys` utility function.
 
 **Usage:**
 
 ```typescript
-import { deleteHSetKeys } from 'baileys-redis-auth';
-import Redis, { RedisOptions } from 'ioredis'; // Or use the instance from useRedisAuthStateWithHSet
+import { deleteHSetKeys } from 'baileys-redis-auth'
+import Redis, { RedisOptions } from 'ioredis' // Or use the instance from useRedisAuthStateWithHSet
 
 // Assuming 'authRedisInstance' is the Redis instance from useRedisAuthStateWithHSet
 // or a new instance configured with the same options.
 // const redisClient = new Redis(redisOptions);
-// const sessionPrefixToDelete = 'baileys_session_1';
+// const sessionIdToDelete = 'baileys_session_1';
 
-// await deleteHSetKeys({redis: authRedisInstance, key: sessionPrefixToDelete});
-// console.log(`All HSet data for prefix '${sessionPrefixToDelete}' deleted.`);
+// await deleteHSetKeys({redis: authRedisInstance, sessionId: sessionIdToDelete});
+// console.log(`All HSet data for session '${sessionIdToDelete}' deleted.`);
 ```
 
 **Parameters:**
-*   `options`: An object with the following properties:
-    *   `redis`: An active `ioredis` client instance.
-    *   `key`: The session `prefix` string (e.g., `'baileys_session_1'`) whose data needs to be deleted. This corresponds to the `prefix` you used with `useRedisAuthStateWithHSet`.
-    *   `logger` (optional): A function for logging deletion operations.
+
+- `options`: An object with the following properties:
+  - `redis`: An active `ioredis` client instance.
+  - `sessionId`: The session identifier string (e.g., `'baileys_session_1'`) whose data needs to be deleted. This corresponds to the `sessionId` you used with `useRedisAuthStateWithHSet`.
+  - `logger` (optional): A function for logging deletion operations.
 
 ### Using `useRedisAuthState`
 
-This method stores each piece of authentication data as a separate key-value pair in Redis, prefixed by the `prefix` string. While functional, it can lead to a larger number of individual keys in your Redis database compared to the HSET method.
+This method stores each piece of authentication data as a separate key-value pair in Redis, prefixed by the `sessionId` string. While functional, it can lead to a larger number of individual keys in your Redis database compared to the HSET method.
 
 **Parameters:**
-*   `redisOptions`: An object containing your Redis server connection details (e.g., `host`, `port`, `password`). This is passed directly to the `ioredis` constructor.
-*   `prefix`: A string used to prefix all Redis keys for this Baileys session. For example, if your `prefix` is `'DB1'`, keys will be stored like `DB1:creds`, `DB1:pre-key-1`, etc.
-*   `logger` (optional): A function `(message: string, ...args: unknown[]) => void` for logging Redis connection events. Pass `console.log` or your custom logger function.
+
+- `redisOptions`: An object containing your Redis server connection details (e.g., `host`, `port`, `password`). This is passed directly to the `ioredis` constructor.
+- `sessionId`: A string used to identify and prefix all Redis keys for this Baileys session. For example, if your `sessionId` is `'user-456'`, keys will be stored like `user-456:creds`, `user-456:pre-key-1`, etc.
+- `logger` (optional): A function `(message: string, ...args: unknown[]) => void` for logging Redis connection events. Pass `console.log` or your custom logger function.
 
 ```typescript
-import {useRedisAuthState, deleteKeysWithPattern} from 'baileys-redis-auth';
-import Redis, { RedisOptions } from 'ioredis'; // Assuming ioredis is used like this
+import { useRedisAuthState, deleteKeysWithPattern } from 'baileys-redis-auth'
+import Redis, { RedisOptions } from 'ioredis'
 
 // Define your Redis connection options
 const redisOptions: RedisOptions = {
-    host: 'localhost',
-    port: 6379,
-    // password: 'your_redis_password', // Uncomment if your Redis has a password
-};
+  host: 'localhost',
+  port: 6379
+  // password: 'your_redis_password', // Uncomment if your Redis has a password
+}
 
-// Define a unique prefix for this Baileys session
-const sessionPrefix = 'baileys_session_2';
+// Define a unique session identifier for this Baileys session
+const sessionId = 'baileys_session_2'
 
 async function initializeBaileysSimple() {
-    // Initialize a new Redis client instance if you need to pass it around
-    // const redis = new Redis(redisOptions);
-    // redis.on('connect', () => console.log('Connected to Redis for simple method!'));
-    // As with HSet, useRedisAuthState creates its own Redis instance.
-
-    const {state, saveCreds, redis: authRedisInstance} = await useRedisAuthState(
-        redisOptions,
-        sessionPrefix,
-        console.log  // Optional: pass logger for Redis connection events
-    );
-
-    // 'state' will be used to initialize Baileys
-    // 'saveCreds' is a function to periodically save the authentication state
-    // 'authRedisInstance' is the Redis client instance used by the auth state hook
-
-    console.log('Baileys state loaded using simple key-value method.');
-    
-    // Example: Listen for Redis connection events on the instance returned by the hook
-    authRedisInstance.on('connect', () => console.log(`Redis (from hook) connected for session: ${sessionPrefix}`));
-    authRedisInstance.on('error', (err) => console.error(`Redis (from hook) error for session ${sessionPrefix}:`, err));
-
-    // ... your Baileys setup code using 'state' and 'saveCreds'
-
-    // Example of how to delete all keys for this specific session prefix if needed:
-    // The pattern should match the prefix used.
-    // await deleteKeysWithPattern({redis: authRedisInstance, pattern: `${sessionPrefix}:*`});
-    // console.log(`Authentication data for session ${sessionPrefix} (pattern: ${sessionPrefix}:*) deleted.`);
+  // useRedisAuthState creates its own Redis instance internally based on redisOptions
+
+  const {
+    state,
+    saveCreds,
+    redis: authRedisInstance
+  } = await useRedisAuthState(
+    redisOptions,
+    sessionId,
+    console.log // Optional: pass logger for Redis connection events
+  )
+
+  // 'state' will be used to initialize Baileys
+  // 'saveCreds' is a function to periodically save the authentication state
+  // 'authRedisInstance' is the Redis client instance used by the auth state hook
+
+  console.log('Baileys state loaded using simple key-value method.')
+
+  // Example: Listen for Redis connection events on the instance returned by the hook
+  authRedisInstance.on('connect', () =>
+    console.log(`Redis (from hook) connected for session: ${sessionId}`)
+  )
+  authRedisInstance.on('error', (err) =>
+    console.error(`Redis (from hook) error for session ${sessionId}:`, err)
+  )
+
+  // ... your Baileys setup code using 'state' and 'saveCreds'
+
+  // Example of how to delete all keys for this specific session if needed:
+  // await deleteKeysWithPattern({redis: authRedisInstance, sessionId: sessionId});
+  // console.log(`Authentication data for session ${sessionId} deleted.`);
 }
 
-initializeBaileysSimple().catch(console.error);
+initializeBaileysSimple().catch(console.error)
 ```
 
 #### Deleting Session Data (`deleteKeysWithPattern`)
 
-To remove all authentication data associated with a specific session prefix used with `useRedisAuthState`, you can use the `deleteKeysWithPattern` utility function. This function deletes all Redis keys matching a given pattern.
+To remove all authentication data associated with a specific session used with `useRedisAuthState`, you can use the `deleteKeysWithPattern` utility function. This function deletes all Redis keys for the given session.
 
 **Usage:**
 
 ```typescript
-import { deleteKeysWithPattern } from 'baileys-redis-auth';
-import Redis, { RedisOptions } from 'ioredis'; // Or use the instance from useRedisAuthState
+import { deleteKeysWithPattern } from 'baileys-redis-auth'
+import Redis, { RedisOptions } from 'ioredis' // Or use the instance from useRedisAuthState
 
 // Assuming 'authRedisInstance' is the Redis instance from useRedisAuthState
 // or a new instance configured with the same options.
 // const redisClient = new Redis(redisOptions);
-// const sessionPrefixToDelete = 'baileys_session_2';
+// const sessionIdToDelete = 'baileys_session_2';
 
-// The pattern must match how useRedisAuthState stores keys, typically `prefix:*`
-// await deleteKeysWithPattern({redis: authRedisInstance, pattern: `${sessionPrefixToDelete}:*`});
-// console.log(`All keys matching pattern '${sessionPrefixToDelete}:*' deleted.`);
+// await deleteKeysWithPattern({redis: authRedisInstance, sessionId: sessionIdToDelete});
+// console.log(`All keys for session '${sessionIdToDelete}' deleted.`);
 ```
 
 **Parameters:**
-*   `options`: An object with the following properties:
-    *   `redis`: An active `ioredis` client instance.
-    *   `pattern`: The key pattern to delete (e.g., `'baileys_session_2:*'`). This should align with the `prefix` used in `useRedisAuthState`, followed by `:*` to match all related keys.
-    *   `logger` (optional): A function for logging deletion operations.
+
+- `options`: An object with the following properties:
+  - `redis`: An active `ioredis` client instance.
+  - `sessionId`: The session identifier string (e.g., `'baileys_session_2'`) whose data needs to be deleted. This corresponds to the `sessionId` you used with `useRedisAuthState`.
+  - `logger` (optional): A function for logging deletion operations.
+
+## Listing Active Sessions
+
+The library provides utility functions to discover all active sessions stored in Redis. This is useful for managing multiple WhatsApp connections or performing administrative tasks.
+
+### `listHSetSessions` - List Hash-Based Sessions
+
+Lists all session identifiers stored using the `useRedisAuthStateWithHSet` method.
+
+**Usage:**
+
+```typescript
+import { listHSetSessions } from 'baileys-redis-auth'
+import Redis from 'ioredis'
+
+const redis = new Redis({ host: 'localhost', port: 6379 })
+
+async function showAllHashSessions() {
+  const sessions = await listHSetSessions({
+    redis,
+    logger: console.log // Optional: pass logger for debugging
+  })
+
+  console.log('Active Hash-based sessions:', sessions)
+  // Output: ['baileys_session_1', 'user-123', 'bot-789']
+
+  // You can now iterate and manage these sessions
+  for (const sessionId of sessions) {
+    console.log(`Found session: ${sessionId}`)
+  }
+}
+
+showAllHashSessions().catch(console.error)
+```
+
+**Parameters:**
+
+- `options`: An object with the following properties:
+  - `redis`: An active `ioredis` client instance.
+  - `logger` (optional): A function for logging scan operations.
+
+**Returns:** `Promise<string[]>` - An array of session identifiers.
+
+### `listSessions` - List Key-Value Based Sessions
+
+Lists all session identifiers stored using the `useRedisAuthState` method.
+
+**Usage:**
+
+```typescript
+import { listSessions } from 'baileys-redis-auth'
+import Redis from 'ioredis'
+
+const redis = new Redis({ host: 'localhost', port: 6379 })
+
+async function showAllKeyValueSessions() {
+  const sessions = await listSessions({
+    redis,
+    logger: console.log // Optional: pass logger for debugging
+  })
+
+  console.log('Active key-value based sessions:', sessions)
+  // Output: ['baileys_session_2', 'user-456', 'bot-012']
+
+  // You can now iterate and manage these sessions
+  for (const sessionId of sessions) {
+    console.log(`Found session: ${sessionId}`)
+  }
+}
+
+showAllKeyValueSessions().catch(console.error)
+```
+
+**Parameters:**
+
+- `options`: An object with the following properties:
+  - `redis`: An active `ioredis` client instance.
+  - `logger` (optional): A function for logging scan operations.
+
+**Returns:** `Promise<string[]>` - An array of unique session identifiers.
+
+### Practical Example: Managing Multiple Sessions
+
+```typescript
+import {
+  listHSetSessions,
+  listSessions,
+  deleteHSetKeys,
+  deleteKeysWithPattern
+} from 'baileys-redis-auth'
+import Redis from 'ioredis'
+
+const redis = new Redis({ host: 'localhost', port: 6379 })
+
+async function manageAllSessions() {
+  // List all Hash-based sessions
+  const hashSessions = await listHSetSessions({ redis })
+  console.log('Hash-based sessions:', hashSessions)
+
+  // List all key-value based sessions
+  const kvSessions = await listSessions({ redis })
+  console.log('Key-value based sessions:', kvSessions)
+
+  // Delete a specific Hash session
+  if (hashSessions.includes('old-session')) {
+    await deleteHSetKeys({ redis, sessionId: 'old-session' })
+    console.log('Deleted old-session')
+  }
+
+  // Delete a specific key-value session
+  if (kvSessions.includes('inactive-session')) {
+    await deleteKeysWithPattern({ redis, sessionId: 'inactive-session' })
+    console.log('Deleted inactive-session')
+  }
+}
+
+manageAllSessions().catch(console.error)
+```
 
 ## Logout and Session Cleanup
 
@@ -192,18 +325,22 @@ import Redis, { RedisOptions } from 'ioredis'; // Or use the instance from useRe
 ### Proper Logout Implementation
 
 ```typescript
-import {deleteKeysWithPattern, useRedisAuthState} from 'baileys-redis-auth'
-import makeWASocket, {DisconnectReason} from '@whiskeysockets/baileys'
-import type {Boom} from '@hapi/boom'
+import { deleteKeysWithPattern, useRedisAuthState } from 'baileys-redis-auth'
+import makeWASocket, { DisconnectReason } from 'baileys'
+import type { Boom } from '@hapi/boom'
 
-const sessionPrefix = 'my-session'
-const {state, saveCreds, redis} = await useRedisAuthState(redisOptions, sessionPrefix, console.log)
+const sessionId = 'my-session'
+const { state, saveCreds, redis } = await useRedisAuthState(
+  redisOptions,
+  sessionId,
+  console.log
+)
 
-const sock = makeWASocket({auth: state})
+const sock = makeWASocket({ auth: state })
 
 // Handle connection updates
 sock.ev.on('connection.update', async (update) => {
-  const {connection, lastDisconnect} = update
+  const { connection, lastDisconnect } = update
 
   if (connection === 'close') {
     const statusCode = (lastDisconnect?.error as Boom)?.output?.statusCode
@@ -212,8 +349,8 @@ sock.ev.on('connection.update', async (update) => {
       // Clear Redis session on logout
       await deleteKeysWithPattern({
         redis,
-        pattern: `${sessionPrefix}:*`,
-        logger: console.log  // Optional: pass logger for debugging
+        sessionId: sessionId,
+        logger: console.log // Optional: pass logger for debugging
       })
       console.log('Session cleared')
     }
@@ -231,12 +368,14 @@ For detailed logout implementation guide, see [LOGOUT_GUIDE.md](./LOGOUT_GUIDE.m
 This project includes an example script to demonstrate the usage of `baileys-redis-auth`. To run it:
 
 1.  **Clone the repository (if you haven't already):**
+
     ```bash
     git clone https://github.com/hbinduni/baileys-redis-auth.git
     cd baileys-redis-auth
     ```
 
 2.  **Install dependencies:**
+
     ```bash
     npm install
     # or
@@ -248,12 +387,14 @@ This project includes an example script to demonstrate the usage of `baileys-red
 3.  **Ensure you have a Redis server running** and accessible on `localhost:6379` (or update the example script with your Redis configuration).
 
 4.  **Configure environment variables:**
+
     ```bash
     cp .env.example .env
     # Edit .env with your Redis configuration
     ```
 
 5.  **Run the example script:**
+
     ```bash
     npm run example
     # or
@@ -261,10 +402,12 @@ This project includes an example script to demonstrate the usage of `baileys-red
     # or
     # bun run example
     ```
-    This command executes `ts-node -r tsconfig-paths/register example/example.ts`.
+
+    This command executes `tsx example/example.ts`.
     The example will guide you through connecting to WhatsApp using Baileys with Redis for authentication storage. You'll see a QR code in your terminal to scan with WhatsApp.
 
     **Interactive Commands:**
+
     - `send <phone> <message>` - Send a WhatsApp message
     - `logout` - Logout and clear session
     - `help` - Show available commands
@@ -286,4 +429,7 @@ Please ensure your code adheres to the existing style and that any new functiona
 ## License
 
 This project is licensed under the MIT License. Refer to the license information in the `package.json` for details.
+
+```
+
 ```

package/lib/index.d.ts

@@ -1,42 +1,221 @@
-import { type AuthenticationState } from '@whiskeysockets/baileys';
-import { type RedisOptions, type Redis as RedisClient } from 'ioredis';
+import { type AuthenticationState } from 'baileys';
+import { Redis, type RedisOptions } from 'ioredis';
+type RedisClient = Redis;
+/**
+ * Options for deleting Hash-based authentication state
+ */
 interface IDeleteHSetKeyOptions {
+    /** Active Redis client instance */
     redis: RedisClient;
-    key: string;
+    /** The session identifier to delete */
+    sessionId: string;
+    /** Optional logging function for debugging */
     logger?: (message: string, ...args: unknown[]) => void;
 }
+/**
+ * Options for deleting key-value based authentication state
+ */
 interface IDeleteKeysOptions {
+    /** Active Redis client instance */
     redis: RedisClient;
-    pattern: string;
+    /** The session identifier to delete */
+    sessionId: string;
+    /** Optional logging function for debugging */
+    logger?: (message: string, ...args: unknown[]) => void;
+}
+/**
+ * Options for listing sessions
+ */
+interface IListSessionsOptions {
+    /** Active Redis client instance */
+    redis: RedisClient;
+    /** Optional logging function for debugging */
     logger?: (message: string, ...args: unknown[]) => void;
 }
 /**
  * Redis-based authentication state storage using Hash (HSET) - Recommended
- * Stores all authentication data in a single Redis Hash per prefix
- * More efficient than key-value approach for Redis memory and operations
+ *
+ * Stores all authentication data in a single Redis Hash per session.
+ * This approach is more efficient than key-value storage for Redis memory and operations.
+ * All authentication state (credentials, keys, and signals) is stored under a single hash key.
+ *
+ * @param redisOptions - Configuration options for the Redis client connection
+ * @param sessionId - Session identifier for the Redis hash key (default: 'session'). The hash key will be `${sessionId}:auth`
+ * @param logger - Optional logging function for debugging and monitoring Redis operations
+ *
+ * @returns Promise that resolves to an object containing:
+ *   - `state`: The Baileys AuthenticationState object with creds and keys methods
+ *   - `saveCreds`: Function to manually save credentials to Redis
+ *   - `redis`: The Redis client instance for manual operations
+ *
+ * @example
+ * ```typescript
+ * const { state, saveCreds, redis } = await useRedisAuthStateWithHSet(
+ *   { host: 'localhost', port: 6379 },
+ *   'my-whatsapp-session',
+ *   console.log
+ * );
+ *
+ * const conn = makeWASocket({ auth: state });
+ * // Credentials are automatically saved on state changes
+ * ```
+ *
+ * @see {@link useRedisAuthState} for key-value based storage alternative
  */
-export declare const useRedisAuthStateWithHSet: (redisOptions: RedisOptions, prefix?: string, logger?: (message: string, ...args: unknown[]) => void) => Promise<{
+export declare const useRedisAuthStateWithHSet: (redisOptions: RedisOptions, sessionId?: string, logger?: (message: string, ...args: unknown[]) => void) => Promise<{
     state: AuthenticationState;
     saveCreds: () => Promise<void>;
     redis: RedisClient;
 }>;
 /**
- * Deletes all authentication data for a specific prefix using Hash (HSET)
+ * Deletes all authentication data for a specific session using Hash (HSET)
+ *
+ * Removes the entire Redis hash containing all authentication state for the given session.
+ * This is the cleanup function for sessions created with `useRedisAuthStateWithHSet`.
+ *
+ * @param options - Configuration object
+ * @param options.redis - Active Redis client instance
+ * @param options.sessionId - The session identifier to delete (e.g., 'session', 'my-whatsapp-session')
+ * @param options.logger - Optional logging function for debugging
+ *
+ * @returns Promise that resolves when the deletion is complete
+ *
+ * @throws {Error} If Redis deletion operation fails
+ *
+ * @example
+ * ```typescript
+ * const { redis } = await useRedisAuthStateWithHSet({ host: 'localhost' }, 'session-123');
+ *
+ * // Later, to logout and clean up:
+ * await deleteHSetKeys({
+ *   redis,
+ *   sessionId: 'session-123',
+ *   logger: console.log
+ * });
+ * ```
+ *
+ * @see {@link useRedisAuthStateWithHSet} for the corresponding storage function
  */
-export declare const deleteHSetKeys: ({ redis, key, logger }: IDeleteHSetKeyOptions) => Promise<void>;
+export declare const deleteHSetKeys: ({ redis, sessionId, logger }: IDeleteHSetKeyOptions) => Promise<void>;
 /**
  * Redis-based authentication state storage using key-value pairs
- * Stores each piece of authentication data as a separate Redis key
- * Less efficient than Hash approach but more compatible with existing systems
+ *
+ * Stores each piece of authentication data as a separate Redis key with the pattern `${sessionId}:${key}`.
+ * This approach is less efficient than the Hash-based storage but offers more compatibility with
+ * existing systems and allows for more granular key management and expiration.
+ *
+ * @param redisOptions - Configuration options for the Redis client connection
+ * @param sessionId - Session identifier for Redis keys (default: 'session'). Each key will be `${sessionId}:${keyname}`
+ * @param logger - Optional logging function for debugging and monitoring Redis operations
+ *
+ * @returns Promise that resolves to an object containing:
+ *   - `state`: The Baileys AuthenticationState object with creds and keys methods
+ *   - `saveCreds`: Function to manually save credentials to Redis
+ *   - `redis`: The Redis client instance for manual operations
+ *
+ * @example
+ * ```typescript
+ * const { state, saveCreds, redis } = await useRedisAuthState(
+ *   { host: 'localhost', port: 6379 },
+ *   'my-whatsapp-session',
+ *   console.log
+ * );
+ *
+ * const conn = makeWASocket({ auth: state });
+ * // Credentials are automatically saved on state changes
+ * ```
+ *
+ * @see {@link useRedisAuthStateWithHSet} for the recommended Hash-based storage alternative
  */
-export declare const useRedisAuthState: (redisOptions: RedisOptions, prefix?: string, logger?: (message: string, ...args: unknown[]) => void) => Promise<{
+export declare const useRedisAuthState: (redisOptions: RedisOptions, sessionId?: string, logger?: (message: string, ...args: unknown[]) => void) => Promise<{
     state: AuthenticationState;
     saveCreds: () => Promise<void>;
     redis: RedisClient;
 }>;
 /**
- * Deletes all authentication keys matching a pattern using key-value approach
- * Uses SCAN to safely iterate through keys without blocking Redis
+ * Deletes all authentication keys for a specific session using key-value approach
+ *
+ * Uses Redis SCAN command to safely iterate through keys without blocking the Redis server.
+ * This is the cleanup function for sessions created with `useRedisAuthState`.
+ * The SCAN operation is cursor-based and processes keys in batches of 100.
+ *
+ * @param options - Configuration object
+ * @param options.redis - Active Redis client instance
+ * @param options.sessionId - The session identifier to delete (e.g., 'session', 'my-whatsapp-session')
+ * @param options.logger - Optional logging function for debugging and monitoring deletion progress
+ *
+ * @returns Promise that resolves when all matching keys have been deleted
+ *
+ * @throws {Error} If Redis SCAN or UNLINK operations fail
+ *
+ * @example
+ * ```typescript
+ * const { redis } = await useRedisAuthState({ host: 'localhost' }, 'session-123');
+ *
+ * // Later, to logout and clean up all keys for this session:
+ * await deleteKeysWithPattern({
+ *   redis,
+ *   sessionId: 'session-123',
+ *   logger: console.log
+ * });
+ * ```
+ *
+ * @see {@link useRedisAuthState} for the corresponding storage function
+ * @see {@link deleteHSetKeys} for Hash-based storage cleanup
+ */
+export declare const deleteKeysWithPattern: ({ redis, sessionId, logger }: IDeleteKeysOptions) => Promise<void>;
+/**
+ * Lists all session identifiers stored using Hash (HSET) approach
+ *
+ * Scans Redis for all hash keys with the pattern `*:auth` and extracts the session identifiers.
+ * This is useful for discovering all active sessions created with `useRedisAuthStateWithHSet`.
+ *
+ * @param options - Configuration object
+ * @param options.redis - Active Redis client instance
+ * @param options.logger - Optional logging function for debugging
+ *
+ * @returns Promise that resolves to an array of session identifiers
+ *
+ * @throws {Error} If Redis SCAN operation fails
+ *
+ * @example
+ * ```typescript
+ * const redis = new Redis({ host: 'localhost' });
+ *
+ * const sessions = await listHSetSessions({ redis, logger: console.log });
+ * console.log('Active sessions:', sessions);
+ * // Output: ['session-123', 'user-456', 'bot-789']
+ * ```
+ *
+ * @see {@link useRedisAuthStateWithHSet} for the corresponding storage function
+ * @see {@link listSessions} for key-value based session listing
+ */
+export declare const listHSetSessions: ({ redis, logger }: IListSessionsOptions) => Promise<string[]>;
+/**
+ * Lists all session identifiers stored using key-value approach
+ *
+ * Scans Redis for all keys with the pattern `*:creds` and extracts unique session identifiers.
+ * This is useful for discovering all active sessions created with `useRedisAuthState`.
+ *
+ * @param options - Configuration object
+ * @param options.redis - Active Redis client instance
+ * @param options.logger - Optional logging function for debugging
+ *
+ * @returns Promise that resolves to an array of unique session identifiers
+ *
+ * @throws {Error} If Redis SCAN operation fails
+ *
+ * @example
+ * ```typescript
+ * const redis = new Redis({ host: 'localhost' });
+ *
+ * const sessions = await listSessions({ redis, logger: console.log });
+ * console.log('Active sessions:', sessions);
+ * // Output: ['session-123', 'user-456', 'bot-789']
+ * ```
+ *
+ * @see {@link useRedisAuthState} for the corresponding storage function
+ * @see {@link listHSetSessions} for Hash-based session listing
  */
-export declare const deleteKeysWithPattern: ({ redis, pattern, logger }: IDeleteKeysOptions) => Promise<void>;
+export declare const listSessions: ({ redis, logger }: IListSessionsOptions) => Promise<string[]>;
 export {};

package/lib/index.js

@@ -1,40 +1,76 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteKeysWithPattern = exports.useRedisAuthState = exports.deleteHSetKeys = exports.useRedisAuthStateWithHSet = void 0;
-const baileys_1 = require("@whiskeysockets/baileys");
-const ioredis_1 = __importDefault(require("ioredis"));
+import { BufferJSON, initAuthCreds, proto, } from 'baileys';
+import { Redis } from 'ioredis';
 /**
  * Sanitizes a string to make it safe for use as a Redis key
- * Replaces "/" with "__" and ":" with "-"
+ *
+ * Replaces problematic characters that might cause issues in Redis keys:
+ * - Forward slashes (/) are replaced with double underscores (__)
+ * - Colons (:) are replaced with hyphens (-)
+ *
+ * @param file - The string to sanitize
+ * @returns The sanitized string safe for use as a Redis key component
+ *
+ * @internal
  */
 const fixFileName = (file) => file.replace(/\//g, '__').replace(/:/g, '-');
-const createKey = (key, prefix) => `${prefix}:${key}`;
+/**
+ * Creates a namespaced Redis key by combining sessionId and key
+ *
+ * @param key - The key name
+ * @param sessionId - The session identifier
+ * @returns The combined key in the format `${sessionId}:${key}`
+ *
+ * @internal
+ */
+const createKey = (key, sessionId) => `${sessionId}:${key}`;
 /**
  * Redis-based authentication state storage using Hash (HSET) - Recommended
- * Stores all authentication data in a single Redis Hash per prefix
- * More efficient than key-value approach for Redis memory and operations
+ *
+ * Stores all authentication data in a single Redis Hash per session.
+ * This approach is more efficient than key-value storage for Redis memory and operations.
+ * All authentication state (credentials, keys, and signals) is stored under a single hash key.
+ *
+ * @param redisOptions - Configuration options for the Redis client connection
+ * @param sessionId - Session identifier for the Redis hash key (default: 'session'). The hash key will be `${sessionId}:auth`
+ * @param logger - Optional logging function for debugging and monitoring Redis operations
+ *
+ * @returns Promise that resolves to an object containing:
+ *   - `state`: The Baileys AuthenticationState object with creds and keys methods
+ *   - `saveCreds`: Function to manually save credentials to Redis
+ *   - `redis`: The Redis client instance for manual operations
+ *
+ * @example
+ * ```typescript
+ * const { state, saveCreds, redis } = await useRedisAuthStateWithHSet(
+ *   { host: 'localhost', port: 6379 },
+ *   'my-whatsapp-session',
+ *   console.log
+ * );
+ *
+ * const conn = makeWASocket({ auth: state });
+ * // Credentials are automatically saved on state changes
+ * ```
+ *
+ * @see {@link useRedisAuthState} for key-value based storage alternative
  */
-const useRedisAuthStateWithHSet = async (redisOptions, prefix = 'session', logger) => {
-    const redis = new ioredis_1.default(redisOptions);
+export const useRedisAuthStateWithHSet = async (redisOptions, sessionId = 'session', logger) => {
+    const redis = new Redis(redisOptions);
     redis.on('connect', async () => {
-        const redisClientName = `baileys-auth-${prefix}`;
+        const redisClientName = `baileys-auth-${sessionId}`;
         await redis.client('SETNAME', redisClientName);
-        logger === null || logger === void 0 ? void 0 : logger(`Redis client name set to ${redisClientName}`);
+        logger?.(`Redis client name set to ${redisClientName}`);
     });
     const writeData = async (key, data) => {
-        await redis.hset(createKey('auth', prefix), key, JSON.stringify(data, baileys_1.BufferJSON.replacer));
+        await redis.hset(createKey('auth', sessionId), key, JSON.stringify(data, BufferJSON.replacer));
     };
     const readData = async (key) => {
-        const data = await redis.hget(createKey('auth', prefix), key);
-        return data ? JSON.parse(data, baileys_1.BufferJSON.reviver) : null;
+        const data = await redis.hget(createKey('auth', sessionId), key);
+        return data ? JSON.parse(data, BufferJSON.reviver) : null;
     };
     const removeData = async (key) => {
-        await redis.hdel(createKey('auth', prefix), key);
+        await redis.hdel(createKey('auth', sessionId), key);
     };
-    const creds = (await readData('creds')) || (0, baileys_1.initAuthCreds)();
+    const creds = (await readData('creds')) || initAuthCreds();
     return {
         state: {
             creds,
@@ -45,7 +81,7 @@ const useRedisAuthStateWithHSet = async (redisOptions, prefix = 'session', logge
                         const key = `${type}-${fixFileName(id)}`;
                         const value = await readData(key);
                         if (value) {
-                            data[id] = (type === 'app-state-sync-key' ? baileys_1.proto.Message.AppStateSyncKeyData.fromObject(value) : value);
+                            data[id] = (type === 'app-state-sync-key' ? proto.Message.AppStateSyncKeyData.fromObject(value) : value);
                         }
                     }));
                     return data;
@@ -74,46 +110,94 @@ const useRedisAuthStateWithHSet = async (redisOptions, prefix = 'session', logge
         redis,
     };
 };
-exports.useRedisAuthStateWithHSet = useRedisAuthStateWithHSet;
 /**
- * Deletes all authentication data for a specific prefix using Hash (HSET)
+ * Deletes all authentication data for a specific session using Hash (HSET)
+ *
+ * Removes the entire Redis hash containing all authentication state for the given session.
+ * This is the cleanup function for sessions created with `useRedisAuthStateWithHSet`.
+ *
+ * @param options - Configuration object
+ * @param options.redis - Active Redis client instance
+ * @param options.sessionId - The session identifier to delete (e.g., 'session', 'my-whatsapp-session')
+ * @param options.logger - Optional logging function for debugging
+ *
+ * @returns Promise that resolves when the deletion is complete
+ *
+ * @throws {Error} If Redis deletion operation fails
+ *
+ * @example
+ * ```typescript
+ * const { redis } = await useRedisAuthStateWithHSet({ host: 'localhost' }, 'session-123');
+ *
+ * // Later, to logout and clean up:
+ * await deleteHSetKeys({
+ *   redis,
+ *   sessionId: 'session-123',
+ *   logger: console.log
+ * });
+ * ```
+ *
+ * @see {@link useRedisAuthStateWithHSet} for the corresponding storage function
  */
-const deleteHSetKeys = async ({ redis, key, logger }) => {
+export const deleteHSetKeys = async ({ redis, sessionId, logger }) => {
     try {
-        logger === null || logger === void 0 ? void 0 : logger('Removing auth state keys for prefix:', key);
-        await redis.del(createKey('auth', key));
+        logger?.('Removing auth state for session:', sessionId);
+        await redis.del(createKey('auth', sessionId));
     }
     catch (err) {
         const error = err;
-        logger === null || logger === void 0 ? void 0 : logger('Error deleting keys:', error.message);
+        logger?.('Error deleting session:', error.message);
         throw error;
     }
 };
-exports.deleteHSetKeys = deleteHSetKeys;
 /**
  * Redis-based authentication state storage using key-value pairs
- * Stores each piece of authentication data as a separate Redis key
- * Less efficient than Hash approach but more compatible with existing systems
+ *
+ * Stores each piece of authentication data as a separate Redis key with the pattern `${sessionId}:${key}`.
+ * This approach is less efficient than the Hash-based storage but offers more compatibility with
+ * existing systems and allows for more granular key management and expiration.
+ *
+ * @param redisOptions - Configuration options for the Redis client connection
+ * @param sessionId - Session identifier for Redis keys (default: 'session'). Each key will be `${sessionId}:${keyname}`
+ * @param logger - Optional logging function for debugging and monitoring Redis operations
+ *
+ * @returns Promise that resolves to an object containing:
+ *   - `state`: The Baileys AuthenticationState object with creds and keys methods
+ *   - `saveCreds`: Function to manually save credentials to Redis
+ *   - `redis`: The Redis client instance for manual operations
+ *
+ * @example
+ * ```typescript
+ * const { state, saveCreds, redis } = await useRedisAuthState(
+ *   { host: 'localhost', port: 6379 },
+ *   'my-whatsapp-session',
+ *   console.log
+ * );
+ *
+ * const conn = makeWASocket({ auth: state });
+ * // Credentials are automatically saved on state changes
+ * ```
+ *
+ * @see {@link useRedisAuthStateWithHSet} for the recommended Hash-based storage alternative
  */
-const useRedisAuthState = async (redisOptions, prefix = 'session', logger) => {
-    var _a;
-    const redis = new ioredis_1.default(redisOptions);
+export const useRedisAuthState = async (redisOptions, sessionId = 'session', logger) => {
+    const redis = new Redis(redisOptions);
     redis.on('connect', async () => {
-        const redisClientName = `baileys-auth-${prefix}`;
+        const redisClientName = `baileys-auth-${sessionId}`;
         await redis.client('SETNAME', redisClientName);
-        logger === null || logger === void 0 ? void 0 : logger(`Redis client name set to ${redisClientName}`);
+        logger?.(`Redis client name set to ${redisClientName}`);
     });
     const writeData = async (key, data) => {
-        await redis.set(createKey(key, prefix), JSON.stringify(data, baileys_1.BufferJSON.replacer));
+        await redis.set(createKey(key, sessionId), JSON.stringify(data, BufferJSON.replacer));
     };
     const readData = async (key) => {
-        const data = await redis.get(createKey(key, prefix));
-        return data ? JSON.parse(data, baileys_1.BufferJSON.reviver) : null;
+        const data = await redis.get(createKey(key, sessionId));
+        return data ? JSON.parse(data, BufferJSON.reviver) : null;
     };
     const removeData = async (key) => {
-        await redis.del(createKey(key, prefix));
+        await redis.del(createKey(key, sessionId));
     };
-    const creds = (_a = (await readData('creds'))) !== null && _a !== void 0 ? _a : (0, baileys_1.initAuthCreds)();
+    const creds = (await readData('creds')) ?? initAuthCreds();
     return {
         state: {
             creds,
@@ -124,7 +208,7 @@ const useRedisAuthState = async (redisOptions, prefix = 'session', logger) => {
                         const key = `${type}-${fixFileName(id)}`;
                         const value = await readData(key);
                         if (value) {
-                            data[id] = (type === 'app-state-sync-key' ? baileys_1.proto.Message.AppStateSyncKeyData.fromObject(value) : value);
+                            data[id] = (type === 'app-state-sync-key' ? proto.Message.AppStateSyncKeyData.fromObject(value) : value);
                         }
                     }));
                     return data;
@@ -153,28 +237,157 @@ const useRedisAuthState = async (redisOptions, prefix = 'session', logger) => {
         redis,
     };
 };
-exports.useRedisAuthState = useRedisAuthState;
 /**
- * Deletes all authentication keys matching a pattern using key-value approach
- * Uses SCAN to safely iterate through keys without blocking Redis
+ * Deletes all authentication keys for a specific session using key-value approach
+ *
+ * Uses Redis SCAN command to safely iterate through keys without blocking the Redis server.
+ * This is the cleanup function for sessions created with `useRedisAuthState`.
+ * The SCAN operation is cursor-based and processes keys in batches of 100.
+ *
+ * @param options - Configuration object
+ * @param options.redis - Active Redis client instance
+ * @param options.sessionId - The session identifier to delete (e.g., 'session', 'my-whatsapp-session')
+ * @param options.logger - Optional logging function for debugging and monitoring deletion progress
+ *
+ * @returns Promise that resolves when all matching keys have been deleted
+ *
+ * @throws {Error} If Redis SCAN or UNLINK operations fail
+ *
+ * @example
+ * ```typescript
+ * const { redis } = await useRedisAuthState({ host: 'localhost' }, 'session-123');
+ *
+ * // Later, to logout and clean up all keys for this session:
+ * await deleteKeysWithPattern({
+ *   redis,
+ *   sessionId: 'session-123',
+ *   logger: console.log
+ * });
+ * ```
+ *
+ * @see {@link useRedisAuthState} for the corresponding storage function
+ * @see {@link deleteHSetKeys} for Hash-based storage cleanup
  */
-const deleteKeysWithPattern = async ({ redis, pattern, logger }) => {
+export const deleteKeysWithPattern = async ({ redis, sessionId, logger }) => {
     try {
-        logger === null || logger === void 0 ? void 0 : logger('Removing auth state keys matching pattern:', pattern);
+        const pattern = `${sessionId}:*`;
+        logger?.('Removing auth state for session:', sessionId);
         let cursor = 0;
         do {
             const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
             cursor = Number.parseInt(nextCursor, 10);
             if (keys.length > 0) {
                 await redis.unlink(...keys);
-                logger === null || logger === void 0 ? void 0 : logger(`Deleted keys: ${keys.join(', ')}`);
+                logger?.(`Deleted ${keys.length} keys for session: ${sessionId}`);
+            }
+        } while (cursor !== 0);
+    }
+    catch (err) {
+        const error = err;
+        logger?.('Error deleting session:', error.message);
+        throw error;
+    }
+};
+/**
+ * Lists all session identifiers stored using Hash (HSET) approach
+ *
+ * Scans Redis for all hash keys with the pattern `*:auth` and extracts the session identifiers.
+ * This is useful for discovering all active sessions created with `useRedisAuthStateWithHSet`.
+ *
+ * @param options - Configuration object
+ * @param options.redis - Active Redis client instance
+ * @param options.logger - Optional logging function for debugging
+ *
+ * @returns Promise that resolves to an array of session identifiers
+ *
+ * @throws {Error} If Redis SCAN operation fails
+ *
+ * @example
+ * ```typescript
+ * const redis = new Redis({ host: 'localhost' });
+ *
+ * const sessions = await listHSetSessions({ redis, logger: console.log });
+ * console.log('Active sessions:', sessions);
+ * // Output: ['session-123', 'user-456', 'bot-789']
+ * ```
+ *
+ * @see {@link useRedisAuthStateWithHSet} for the corresponding storage function
+ * @see {@link listSessions} for key-value based session listing
+ */
+export const listHSetSessions = async ({ redis, logger }) => {
+    try {
+        const sessions = [];
+        let cursor = 0;
+        logger?.('Scanning for Hash-based sessions...');
+        do {
+            const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', '*:auth', 'COUNT', 100);
+            cursor = Number.parseInt(nextCursor, 10);
+            for (const key of keys) {
+                // Extract sessionId from "sessionId:auth" pattern
+                const sessionId = key.replace(':auth', '');
+                if (sessionId) {
+                    sessions.push(sessionId);
+                }
+            }
+        } while (cursor !== 0);
+        logger?.(`Found ${sessions.length} Hash-based sessions`);
+        return sessions;
+    }
+    catch (err) {
+        const error = err;
+        logger?.('Error listing sessions:', error.message);
+        throw error;
+    }
+};
+/**
+ * Lists all session identifiers stored using key-value approach
+ *
+ * Scans Redis for all keys with the pattern `*:creds` and extracts unique session identifiers.
+ * This is useful for discovering all active sessions created with `useRedisAuthState`.
+ *
+ * @param options - Configuration object
+ * @param options.redis - Active Redis client instance
+ * @param options.logger - Optional logging function for debugging
+ *
+ * @returns Promise that resolves to an array of unique session identifiers
+ *
+ * @throws {Error} If Redis SCAN operation fails
+ *
+ * @example
+ * ```typescript
+ * const redis = new Redis({ host: 'localhost' });
+ *
+ * const sessions = await listSessions({ redis, logger: console.log });
+ * console.log('Active sessions:', sessions);
+ * // Output: ['session-123', 'user-456', 'bot-789']
+ * ```
+ *
+ * @see {@link useRedisAuthState} for the corresponding storage function
+ * @see {@link listHSetSessions} for Hash-based session listing
+ */
+export const listSessions = async ({ redis, logger }) => {
+    try {
+        const sessionsSet = new Set();
+        let cursor = 0;
+        logger?.('Scanning for key-value based sessions...');
+        do {
+            const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', '*:creds', 'COUNT', 100);
+            cursor = Number.parseInt(nextCursor, 10);
+            for (const key of keys) {
+                // Extract sessionId from "sessionId:creds" pattern
+                const sessionId = key.replace(':creds', '');
+                if (sessionId) {
+                    sessionsSet.add(sessionId);
+                }
             }
         } while (cursor !== 0);
+        const sessions = Array.from(sessionsSet);
+        logger?.(`Found ${sessions.length} key-value based sessions`);
+        return sessions;
     }
     catch (err) {
         const error = err;
-        logger === null || logger === void 0 ? void 0 : logger('Error deleting keys:', error.message);
+        logger?.('Error listing sessions:', error.message);
         throw error;
     }
 };
-exports.deleteKeysWithPattern = deleteKeysWithPattern;

package/package.json

@@ -1,20 +1,28 @@
 {
   "name": "baileys-redis-auth",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "description": "Redis Auth for Baileys",
   "author": "heriyanto binduni <hbinduni@gmail.com>",
   "license": "MIT",
+  "type": "module",
   "main": "lib/index.js",
+  "module": "lib/index.js",
   "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
   "homepage": "https://github.com/hbinduni/baileys-redis-auth",
   "repository": {
-    "url": "https://github.com/hbinduni/baileys-redis-auth.git"
+    "url": "git+https://github.com/hbinduni/baileys-redis-auth.git"
   },
   "scripts": {
     "clean": "rm -rf lib",
     "build": "bun run clean && tsc -p tsconfig.json",
     "prebuild": "bun run check:all",
-    "example": "ts-node -r tsconfig-paths/register example/example.ts",
+    "example": "tsx example/example.ts",
     "example:no-all": "bun run example -- --no-store --no-reply",
     "typecheck": "bun x tsc --noEmit -p tsconfig.json",
     "format": "biome format --write .",
@@ -36,21 +44,27 @@
     "auth"
   ],
   "devDependencies": {
-    "@adiwajshing/keyed-db": "^0.2.4",
     "@biomejs/biome": "^1.9.4",
     "@hapi/boom": "^10.0.1",
-    "@types/node": "^24.7.0",
+    "@types/node": "^24.10.4",
+    "baileys": "^7.0.0-rc.9",
     "dotenv": "^17.2.3",
     "node-cache": "^5.1.2",
-    "pino": "^9.13.1",
-    "pino-pretty": "^13.1.1",
+    "pino": "^9.14.0",
+    "pino-pretty": "^13.1.3",
     "qrcode-terminal": "^0.12.0",
-    "ts-node": "^10.9.2",
-    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.19.0",
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@whiskeysockets/baileys": "^6.7.20",
-    "ioredis": "^5.8.1"
+    "ioredis": "^5.8.2"
+  },
+  "peerDependencies": {
+    "baileys": ">=7.0.0-rc.9"
+  },
+  "peerDependenciesMeta": {
+    "baileys": {
+      "optional": false
+    }
   }
 }