@neelegirl/baileys 1.5.6 → 1.5.8

package/lib/Utils/auth-utils.js

@@ -1,245 +1,189 @@
-import NodeCache from '@cacheable/node-cache';
-import { AsyncLocalStorage } from 'async_hooks';
-import { Mutex } from 'async-mutex';
-import { randomBytes } from 'crypto';
-import PQueue from 'p-queue';
-import { DEFAULT_CACHE_TTLS } from '../Defaults/index.js';
-import { Curve, signedKeyPair } from './crypto.js';
-import { delay, generateRegistrationId } from './generics.js';
-import { PreKeyManager } from './pre-key-manager.js';
+"use strict"
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod }
+}
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const crypto_1 = require("crypto")
+const node_cache_1 = __importDefault(require("@cacheable/node-cache"))
+const Defaults_1 = require("../Defaults")
+const crypto_2 = require("./crypto")
+const generics_1 = require("./generics")
+
 /**
  * Adds caching capability to a SignalKeyStore
  * @param store the store to add caching to
  * @param logger to log trace events
  * @param _cache cache store to use
  */
-export function makeCacheableSignalKeyStore(store, logger, _cache) {
-    const cache = _cache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
-            useClones: false,
-            deleteOnExpire: true
-        });
-    // Mutex for protecting cache operations
-    const cacheMutex = new Mutex();
+function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache = _cache || new node_cache_1.default({
+        stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        useClones: false,
+        deleteOnExpire: true,
+    })
     function getUniqueId(type, id) {
-        return `${type}.${id}`;
+        return `${type}.${id}`
     }
     return {
         async get(type, ids) {
-            return cacheMutex.runExclusive(async () => {
-                const data = {};
-                const idsToFetch = [];
-                for (const id of ids) {
-                    const item = (await cache.get(getUniqueId(type, id)));
-                    if (typeof item !== 'undefined') {
-                        data[id] = item;
-                    }
-                    else {
-                        idsToFetch.push(id);
-                    }
+            const data = {}
+            const idsToFetch = []
+            for (const id of ids) {
+                const item = cache.get(getUniqueId(type, id))
+                if (typeof item !== 'undefined') {
+                    data[id] = item
                 }
-                if (idsToFetch.length) {
-                    logger?.trace({ items: idsToFetch.length }, 'loading from store');
-                    const fetched = await store.get(type, idsToFetch);
-                    for (const id of idsToFetch) {
-                        const item = fetched[id];
-                        if (item) {
-                            data[id] = item;
-                            cache.set(getUniqueId(type, id), item);
-                        }
+                else {
+                    idsToFetch.push(id)
+                }
+            }
+            if (idsToFetch.length) {
+                logger?.trace({ items: idsToFetch.length }, 'loading from store')
+                const fetched = await store.get(type, idsToFetch)
+                for (const id of idsToFetch) {
+                    const item = fetched[id]
+                    if (item) {
+                        data[id] = item
+                        cache.set(getUniqueId(type, id), item)
                     }
                 }
-                return data;
-            });
+            }
+            return data
         },
         async set(data) {
-            return cacheMutex.runExclusive(async () => {
-                let keys = 0;
-                for (const type in data) {
-                    for (const id in data[type]) {
-                        await cache.set(getUniqueId(type, id), data[type][id]);
-                        keys += 1;
-                    }
+            let keys = 0
+            for (const type in data) {
+                for (const id in data[type]) {
+                    cache.set(getUniqueId(type, id), data[type][id])
+                    keys += 1
                 }
-                logger?.trace({ keys }, 'updated cache');
-                await store.set(data);
-            });
+            }
+            logger?.trace({ keys }, 'updated cache')
+            await store.set(data)
         },
         async clear() {
-            await cache.flushAll();
-            await store.clear?.();
+            cache.flushAll()
+            await store.clear?.call(store)
         }
-    };
+    }
 }
+
 /**
- * Adds DB-like transaction capability to the SignalKeyStore
- * Uses AsyncLocalStorage for automatic context management
+ * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
+ * this allows batch read & write operations & improves the performance of the lib
  * @param state the key store to apply this capability to
  * @param logger logger to log events
  * @returns SignalKeyStore with transaction capability
  */
-export const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
-    const txStorage = new AsyncLocalStorage();
-    // Queues for concurrency control
-    const keyQueues = new Map();
-    const txMutexes = new Map();
-    // Pre-key manager for specialized operations
-    const preKeyManager = new PreKeyManager(state, logger);
-    /**
-     * Get or create a queue for a specific key type
-     */
-    function getQueue(key) {
-        if (!keyQueues.has(key)) {
-            keyQueues.set(key, new PQueue({ concurrency: 1 }));
-        }
-        return keyQueues.get(key);
-    }
-    /**
-     * Get or create a transaction mutex
-     */
-    function getTxMutex(key) {
-        if (!txMutexes.has(key)) {
-            txMutexes.set(key, new Mutex());
-        }
-        return txMutexes.get(key);
-    }
-    /**
-     * Check if currently in a transaction
-     */
-    function isInTransaction() {
-        return !!txStorage.getStore();
-    }
-    /**
-     * Commit transaction with retries
-     */
-    async function commitWithRetry(mutations) {
-        if (Object.keys(mutations).length === 0) {
-            logger.trace('no mutations in transaction');
-            return;
-        }
-        logger.trace('committing transaction');
-        for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
-            try {
-                await state.set(mutations);
-                logger.trace({ mutationCount: Object.keys(mutations).length }, 'committed transaction');
-                return;
-            }
-            catch (error) {
-                const retriesLeft = maxCommitRetries - attempt - 1;
-                logger.warn(`failed to commit mutations, retries left=${retriesLeft}`);
-                if (retriesLeft === 0) {
-                    throw error;
-                }
-                await delay(delayBetweenTriesMs);
-            }
-        }
-    }
+const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    // number of queries made to the DB during the transaction
+    // only there for logging purposes
+    let dbQueriesInTransaction = 0
+    let transactionCache = {}
+    let mutations = {}
+    let transactionsInProgress = 0
     return {
         get: async (type, ids) => {
-            const ctx = txStorage.getStore();
-            if (!ctx) {
-                // No transaction - direct read without exclusive lock for concurrency
-                return state.get(type, ids);
-            }
-            // In transaction - check cache first
-            const cached = ctx.cache[type] || {};
-            const missing = ids.filter(id => !(id in cached));
-            if (missing.length > 0) {
-                ctx.dbQueries++;
-                logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction');
-                const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing));
-                // Update cache
-                ctx.cache[type] = ctx.cache[type] || {};
-                Object.assign(ctx.cache[type], fetched);
-            }
-            // Return requested ids from cache
-            const result = {};
-            for (const id of ids) {
-                const value = ctx.cache[type]?.[id];
-                if (value !== undefined && value !== null) {
-                    result[id] = value;
+            if (isInTransaction()) {
+                const dict = transactionCache[type]
+                const idsRequiringFetch = dict
+                    ? ids.filter(item => typeof dict[item] === 'undefined')
+                    : ids
+                // only fetch if there are any items to fetch
+                if (idsRequiringFetch.length) {
+                    dbQueriesInTransaction += 1
+                    const result = await state.get(type, idsRequiringFetch)
+                    transactionCache[type] || (transactionCache[type] = {})
+                    Object.assign(transactionCache[type], result)
                 }
+                return ids.reduce((dict, id) => {
+                    const value = transactionCache[type]?.[id]
+                    if (value) {
+                        dict[id] = value
+                    }
+                    return dict
+                }, {})
+            }
+            else {
+                return state.get(type, ids)
             }
-            return result;
         },
-        set: async (data) => {
-            const ctx = txStorage.getStore();
-            if (!ctx) {
-                // No transaction - direct write with queue protection
-                const types = Object.keys(data);
-                // Process pre-keys with validation
-                for (const type_ of types) {
-                    const type = type_;
-                    if (type === 'pre-key') {
-                        await preKeyManager.validateDeletions(data, type);
-                    }
+        set: data => {
+            if (isInTransaction()) {
+                logger.trace({ types: Object.keys(data) }, 'caching in transaction')
+                for (const key in data) {
+                    transactionCache[key] = transactionCache[key] || {}
+                    Object.assign(transactionCache[key], data[key])
+                    mutations[key] = mutations[key] || {}
+                    Object.assign(mutations[key], data[key])
                 }
-                // Write all data in parallel
-                await Promise.all(types.map(type => getQueue(type).add(async () => {
-                    const typeData = { [type]: data[type] };
-                    await state.set(typeData);
-                })));
-                return;
             }
-            // In transaction - update cache and mutations
-            logger.trace({ types: Object.keys(data) }, 'caching in transaction');
-            for (const key_ in data) {
-                const key = key_;
-                // Ensure structures exist
-                ctx.cache[key] = ctx.cache[key] || {};
-                ctx.mutations[key] = ctx.mutations[key] || {};
-                // Special handling for pre-keys
-                if (key === 'pre-key') {
-                    await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true);
-                }
-                else {
-                    // Normal key types
-                    Object.assign(ctx.cache[key], data[key]);
-                    Object.assign(ctx.mutations[key], data[key]);
-                }
+            else {
+                return state.set(data)
             }
         },
         isInTransaction,
-        transaction: async (work, key) => {
-            const existing = txStorage.getStore();
-            // Nested transaction - reuse existing context
-            if (existing) {
-                logger.trace('reusing existing transaction context');
-                return work();
+        async transaction(work) {
+            let result
+            transactionsInProgress += 1
+            if (transactionsInProgress === 1) {
+                logger.trace('entering transaction')
             }
-            // New transaction - acquire mutex and create context
-            return getTxMutex(key).runExclusive(async () => {
-                const ctx = {
-                    cache: {},
-                    mutations: {},
-                    dbQueries: 0
-                };
-                logger.trace('entering transaction');
-                try {
-                    const result = await txStorage.run(ctx, work);
-                    // Commit mutations
-                    await commitWithRetry(ctx.mutations);
-                    logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed');
-                    return result;
+            try {
+                result = await work()
+                // commit if this is the outermost transaction
+                if (transactionsInProgress === 1) {
+                    if (Object.keys(mutations).length) {
+                        logger.trace('committing transaction')
+                        // retry mechanism to ensure we've some recovery
+                        // in case a transaction fails in the first attempt
+                        let tries = maxCommitRetries
+                        while (tries) {
+                            tries -= 1
+                            try {
+                                await state.set(mutations)
+                                logger.trace({ dbQueriesInTransaction }, 'committed transaction')
+                                break
+                            }
+                            catch (error) {
+                                logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`)
+                                await generics_1.delay(delayBetweenTriesMs)
+                            }
+                        }
+                    }
+                    else {
+                        logger.trace('no mutations in transaction')
+                    }
                 }
-                catch (error) {
-                    logger.error({ error }, 'transaction failed, rolling back');
-                    throw error;
+            }
+            finally {
+                transactionsInProgress -= 1
+                if (transactionsInProgress === 0) {
+                    transactionCache = {}
+                    mutations = {}
+                    dbQueriesInTransaction = 0
                 }
-            });
+            }
+            return result
         }
-    };
-};
-export const initAuthCreds = () => {
-    const identityKey = Curve.generateKeyPair();
+    }
+    function isInTransaction() {
+        return transactionsInProgress > 0
+    }
+}
+
+const initAuthCreds = () => {
+    const identityKey = crypto_2.Curve.generateKeyPair()
     return {
-        noiseKey: Curve.generateKeyPair(),
-        pairingEphemeralKeyPair: Curve.generateKeyPair(),
+        noiseKey: crypto_2.Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
         signedIdentityKey: identityKey,
-        signedPreKey: signedKeyPair(identityKey, 1),
-        registrationId: generateRegistrationId(),
-        advSecretKey: randomBytes(32).toString('base64'),
+        signedPreKey: crypto_2.signedKeyPair(identityKey, 1),
+        registrationId: generics_1.generateRegistrationId(),
+        advSecretKey: crypto_1.randomBytes(32).toString('base64'),
         processedHistoryMessages: [],
         nextPreKeyId: 1,
         firstUnuploadedPreKeyId: 1,
@@ -250,8 +194,12 @@ export const initAuthCreds = () => {
         registered: false,
         pairingCode: undefined,
         lastPropHash: undefined,
-        routingInfo: undefined,
-        additionalData: undefined
-    };
-};
-//# sourceMappingURL=auth-utils.js.map
+        routingInfo: undefined
+    }
+}
+
+module.exports = {
+  makeCacheableSignalKeyStore, 
+  addTransactionCapability, 
+  initAuthCreds
+}

package/lib/Utils/baileys-event-stream.d.ts

@@ -1,17 +1,18 @@
-import type { BaileysEventEmitter } from '../Types/index.js';
+import type { BaileysEventEmitter } from '../Types'
+
 /**
  * Captures events from a baileys event emitter & stores them in a file
  * @param ev The event emitter to read events from
  * @param filename File to save to
  */
-export declare const captureEventStream: (ev: BaileysEventEmitter, filename: string) => void;
+export declare const captureEventStream: (ev: BaileysEventEmitter, filename: string) => void
+
 /**
  * Read event file and emit events from there
  * @param filename filename containing event data
  * @param delayIntervalMs delay between each event emit
  */
 export declare const readAndEmitEventStream: (filename: string, delayIntervalMs?: number) => {
-    ev: BaileysEventEmitter;
-    task: Promise<void>;
-};
-//# sourceMappingURL=baileys-event-stream.d.ts.map
+    ev: BaileysEventEmitter
+    task: Promise<void>
+}

package/lib/Utils/baileys-event-stream.js

@@ -1,56 +1,70 @@
-import EventEmitter from 'events';
-import { createReadStream } from 'fs';
-import { writeFile } from 'fs/promises';
-import { createInterface } from 'readline';
-import { delay } from './generics.js';
-import { makeMutex } from './make-mutex.js';
+"use strict"
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod }
+}
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const events_1 = __importDefault(require("events"))
+const fs_1 = require("fs")
+const promises_1 = require("fs/promises")
+const readline_1 = require("readline")
+const generics_1 = require("./generics")
+const make_mutex_1 = require("./make-mutex")
+
 /**
  * Captures events from a baileys event emitter & stores them in a file
  * @param ev The event emitter to read events from
  * @param filename File to save to
  */
-export const captureEventStream = (ev, filename) => {
-    const oldEmit = ev.emit;
+const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit
     // write mutex so data is appended in order
-    const writeMutex = makeMutex();
+    const writeMutex = make_mutex_1.makeMutex()
     // monkey patch eventemitter to capture all events
     ev.emit = function (...args) {
-        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n';
-        const result = oldEmit.apply(ev, args);
+        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n'
+        const result = oldEmit.apply(ev, args)
         writeMutex.mutex(async () => {
-            await writeFile(filename, content, { flag: 'a' });
-        });
-        return result;
-    };
-};
+            await promises_1.writeFile(filename, content, { flag: 'a' })
+        })
+        return result
+    }
+}
+
 /**
  * Read event file and emit events from there
  * @param filename filename containing event data
  * @param delayIntervalMs delay between each event emit
  */
-export const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
-    const ev = new EventEmitter();
+const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new events_1.default()
     const fireEvents = async () => {
         // from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
-        const fileStream = createReadStream(filename);
-        const rl = createInterface({
+        const fileStream = fs_1.createReadStream(filename)
+        const rl = readline_1.createInterface({
             input: fileStream,
             crlfDelay: Infinity
-        });
+        })
         // Note: we use the crlfDelay option to recognize all instances of CR LF
         // ('\r\n') in input.txt as a single line break.
         for await (const line of rl) {
             if (line) {
-                const { event, data } = JSON.parse(line);
-                ev.emit(event, data);
-                delayIntervalMs && (await delay(delayIntervalMs));
+                const { event, data } = JSON.parse(line)
+                ev.emit(event, data)
+                delayIntervalMs && await generics_1.delay(delayIntervalMs)
             }
         }
-        fileStream.close();
-    };
+        fileStream.close()
+    }
     return {
         ev,
         task: fireEvents()
-    };
-};
-//# sourceMappingURL=baileys-event-stream.js.map
+    }
+}
+
+module.exports = {
+  captureEventStream, 
+  readAndEmitEventStream
+}

package/lib/Utils/business.d.ts

@@ -1,23 +1,29 @@
-import type { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate, WAMediaUpload, WAMediaUploadFunction } from '../Types/index.js';
-import { type BinaryNode } from '../WABinary/index.js';
+import { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate, WAMediaUpload, WAMediaUploadFunction } from '../Types'
+import { BinaryNode } from '../WABinary'
+
 export declare const parseCatalogNode: (node: BinaryNode) => {
-    products: Product[];
-    nextPageCursor: string | undefined;
-};
+    products: Product[]
+    nextPageCursor: string | undefined
+}
+
 export declare const parseCollectionsNode: (node: BinaryNode) => {
-    collections: CatalogCollection[];
-};
-export declare const parseOrderDetailsNode: (node: BinaryNode) => OrderDetails;
-export declare const toProductNode: (productId: string | undefined, product: ProductCreate | ProductUpdate) => BinaryNode;
-export declare const parseProductNode: (productNode: BinaryNode) => Product;
+    collections: CatalogCollection[]
+}
+
+export declare const parseOrderDetailsNode: (node: BinaryNode) => OrderDetails
+
+export declare const toProductNode: (productId: string | undefined, product: ProductCreate | ProductUpdate) => BinaryNode
+
+export declare const parseProductNode: (productNode: BinaryNode) => Product
+
 /**
  * Uploads images not already uploaded to WA's servers
  */
-export declare function uploadingNecessaryImagesOfProduct<T extends ProductUpdate | ProductCreate>(product: T, waUploadToServer: WAMediaUploadFunction, timeoutMs?: number): Promise<T>;
+export declare function uploadingNecessaryImagesOfProduct<T extends ProductUpdate | ProductCreate>(product: T, waUploadToServer: WAMediaUploadFunction, timeoutMs?: number): Promise<T>
+
 /**
  * Uploads images not already uploaded to WA's servers
  */
 export declare const uploadingNecessaryImages: (images: WAMediaUpload[], waUploadToServer: WAMediaUploadFunction, timeoutMs?: number) => Promise<{
-    url: string;
-}[]>;
-//# sourceMappingURL=business.d.ts.map
+    url: string
+}[]>