@mrlegendbot/baileys 1.2.5 → 1.2.6

package/lib/Utils/auth-utils.js

@@ -4,262 +4,299 @@ import { AsyncLocalStorage } from 'async_hooks';
 import { Mutex } from 'async-mutex';
 import { randomBytes } from 'crypto';
 import PQueue from 'p-queue';
-import { v4 as uuidv4 } from 'uuid';
 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';
+/**
+ * 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,
-    useClones: false,
-    deleteOnExpire: true
-  });
-  const cacheMutex = new Mutex();
-  function getUniqueId(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);
-          }
-        }
-        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;
-              await cache.set(getUniqueId(type, id), item);
-            }
-          }
-        }
-        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;
-          }
-        }
-        logger?.trace({
-          keys
-        }, 'updated cache');
-        await store.set(data);
-      });
-    },
-    async clear() {
-      await cache.flushAll();
-      await store.clear?.();
+    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 getUniqueId(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);
+                    }
+                }
+                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;
+                            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                            await cache.set(getUniqueId(type, id), item);
+                        }
+                    }
+                }
+                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;
+                    }
+                }
+                logger?.trace({ keys }, 'updated cache');
+                await store.set(data);
+            });
+        },
+        async clear() {
+            await cache.flushAll();
+            await store.clear?.();
+        }
+    };
 }
-export const addTransactionCapability = (state, logger, {
-  maxCommitRetries,
-  delayBetweenTriesMs
-}) => {
-  const txStorage = new AsyncLocalStorage();
-  const keyQueues = new Map();
-  const txMutexes = new Map();
-  const txMutexRefCounts = new Map();
-  const preKeyManager = new PreKeyManager(state, logger);
-  function getQueue(key) {
-    if (!keyQueues.has(key)) {
-      keyQueues.set(key, new PQueue({
-        concurrency: 1
-      }));
-    }
-    return keyQueues.get(key);
-  }
-  function getTxMutex(key) {
-    if (!txMutexes.has(key)) {
-      txMutexes.set(key, new Mutex());
-      txMutexRefCounts.set(key, 0);
+/**
+ * Adds DB-like transaction capability to the SignalKeyStore
+ * Uses AsyncLocalStorage for automatic context management
+ * @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 (keyed by signal data type - bounded set)
+    const keyQueues = new Map();
+    // Transaction mutexes with reference counting for cleanup
+    const txMutexes = new Map();
+    const txMutexRefCounts = 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);
     }
-    return txMutexes.get(key);
-  }
-  function acquireTxMutexRef(key) {
-    const count = txMutexRefCounts.get(key) ?? 0;
-    txMutexRefCounts.set(key, count + 1);
-  }
-  function releaseTxMutexRef(key) {
-    const count = (txMutexRefCounts.get(key) ?? 1) - 1;
-    txMutexRefCounts.set(key, count);
-    if (count <= 0) {
-      const mutex = txMutexes.get(key);
-      if (mutex && !mutex.isLocked()) {
-        txMutexes.delete(key);
-        txMutexRefCounts.delete(key);
-      }
+    /**
+     * Get or create a transaction mutex
+     */
+    function getTxMutex(key) {
+        if (!txMutexes.has(key)) {
+            txMutexes.set(key, new Mutex());
+            txMutexRefCounts.set(key, 0);
+        }
+        return txMutexes.get(key);
     }
-  }
-  function isInTransaction() {
-    return !!txStorage.getStore();
-  }
-  async function commitWithRetry(mutations) {
-    if (Object.keys(mutations).length === 0) {
-      logger.trace('no mutations in transaction');
-      return;
+    /**
+     * Acquire a reference to a transaction mutex
+     */
+    function acquireTxMutexRef(key) {
+        const count = txMutexRefCounts.get(key) ?? 0;
+        txMutexRefCounts.set(key, count + 1);
     }
-    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;
+    /**
+     * Release a reference to a transaction mutex and cleanup if no longer needed
+     */
+    function releaseTxMutexRef(key) {
+        const count = (txMutexRefCounts.get(key) ?? 1) - 1;
+        txMutexRefCounts.set(key, count);
+        // Cleanup if no more references and mutex is not locked
+        if (count <= 0) {
+            const mutex = txMutexes.get(key);
+            if (mutex && !mutex.isLocked()) {
+                txMutexes.delete(key);
+                txMutexRefCounts.delete(key);
+            }
         }
-        await delay(delayBetweenTriesMs);
-      }
     }
-  }
-  return {
-    get: async (type, ids) => {
-      const ctx = txStorage.getStore();
-      if (!ctx) {
-        return state.get(type, ids);
-      }
-      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));
-        ctx.cache[type] = ctx.cache[type] || {};
-        Object.assign(ctx.cache[type], fetched);
-      }
-      const result = {};
-      for (const id of ids) {
-        const value = ctx.cache[type]?.[id];
-        if (value !== undefined && value !== null) {
-          result[id] = value;
-        }
-      }
-      return result;
-    },
-    set: async data => {
-      const ctx = txStorage.getStore();
-      if (!ctx) {
-        const types = Object.keys(data);
-        for (const type_ of types) {
-          const type = type_;
-          if (type === 'pre-key') {
-            await preKeyManager.validateDeletions(data, type);
-          }
+    /**
+     * 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;
         }
-        await Promise.all(types.map(type => getQueue(type).add(async () => {
-          const typeData = {
-            [type]: data[type]
-          };
-          await state.set(typeData);
-        })));
-        return;
-      }
-      logger.trace({
-        types: Object.keys(data)
-      }, 'caching in transaction');
-      for (const key_ in data) {
-        const key = key_;
-        ctx.cache[key] = ctx.cache[key] || {};
-        ctx.mutations[key] = ctx.mutations[key] || {};
-        if (key === 'pre-key') {
-          await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true);
-        } else {
-          Object.assign(ctx.cache[key], data[key]);
-          Object.assign(ctx.mutations[key], data[key]);
+        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);
+            }
         }
-      }
-    },
-    isInTransaction,
-    transaction: async (work, key) => {
-      const existing = txStorage.getStore();
-      if (existing) {
-        logger.trace('reusing existing transaction context');
-        return work();
-      }
-      const mutex = getTxMutex(key);
-      acquireTxMutexRef(key);
-      try {
-        return await mutex.runExclusive(async () => {
-          const ctx = {
-            cache: {},
-            mutations: {},
-            dbQueries: 0
-          };
-          logger.trace('entering transaction');
-          try {
-            const result = await txStorage.run(ctx, work);
-            await commitWithRetry(ctx.mutations);
-            logger.trace({
-              dbQueries: ctx.dbQueries
-            }, 'transaction completed');
-            return result;
-          } catch (error) {
-            logger.error({
-              error
-            }, 'transaction failed, rolling back');
-            throw error;
-          }
-        });
-      } finally {
-        releaseTxMutexRef(key);
-      }
     }
-  };
+    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;
+                }
+            }
+            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);
+                    }
+                }
+                // 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]);
+                }
+            }
+        },
+        isInTransaction,
+        transaction: async (work, key) => {
+            const existing = txStorage.getStore();
+            // Nested transaction - reuse existing context
+            if (existing) {
+                logger.trace('reusing existing transaction context');
+                return work();
+            }
+            // New transaction - acquire mutex and create context
+            const mutex = getTxMutex(key);
+            acquireTxMutexRef(key);
+            try {
+                return await mutex.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;
+                    }
+                    catch (error) {
+                        logger.error({ error }, 'transaction failed, rolling back');
+                        throw error;
+                    }
+                });
+            }
+            finally {
+                releaseTxMutexRef(key);
+            }
+        }
+    };
 };
-export const assertMeId = creds => {
-  const id = creds.me?.id;
-  if (!id) {
-    throw new Boom('Cannot proceed: socket is not authenticated yet (creds.me.id is missing)', {
-      statusCode: 401
-    });
-  }
-  return id;
+/**
+ * Returns the authenticated user's JID, or throws a Boom-401 if creds are not yet authenticated.
+ * Use this anywhere we'd otherwise reach for `creds.me!.id` to fail fast with a descriptive error.
+ */
+export const assertMeId = (creds) => {
+    const id = creds.me?.id;
+    if (!id) {
+        throw new Boom('Cannot proceed: socket is not authenticated yet (creds.me.id is missing)', { statusCode: 401 });
+    }
+    return id;
 };
 export const initAuthCreds = () => {
-  const identityKey = Curve.generateKeyPair();
-  return {
-    noiseKey: Curve.generateKeyPair(),
-    pairingEphemeralKeyPair: Curve.generateKeyPair(),
-    signedIdentityKey: identityKey,
-    signedPreKey: signedKeyPair(identityKey, 1),
-    registrationId: generateRegistrationId(),
-    advSecretKey: randomBytes(32).toString('base64'),
-    processedHistoryMessages: [],
-    nextPreKeyId: 1,
-    firstUnuploadedPreKeyId: 1,
-    accountSyncCounter: 0,
-    accountSettings: {
-      unarchiveChats: false
-    },
-    registered: false,
-    pairingCode: undefined,
-    lastPropHash: undefined,
-    routingInfo: undefined,
-    additionalData: undefined
-  };
+    const identityKey = Curve.generateKeyPair();
+    return {
+        noiseKey: Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: signedKeyPair(identityKey, 1),
+        registrationId: generateRegistrationId(),
+        advSecretKey: randomBytes(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: {
+            unarchiveChats: false
+        },
+        registered: false,
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+        additionalData: undefined
+    };
 };
+//# sourceMappingURL=auth-utils.js.map

package/lib/Utils/browser-utils.d.ts

@@ -0,0 +1,4 @@
+import type { BrowsersMap } from '../Types/index.js';
+export declare const Browsers: BrowsersMap;
+export declare const getPlatformId: (browser: string) => string;
+//# sourceMappingURL=browser-utils.d.ts.map

package/lib/Utils/browser-utils.js

@@ -1,26 +1,29 @@
 import { platform, release } from 'os';
-import { proto } from '../../WAProto/compiler.js';
+import { proto } from '../../WAProto/index.js';
 const PLATFORM_MAP = {
-  aix: 'AIX',
-  darwin: 'Mac OS',
-  win32: 'Windows',
-  android: 'Android',
-  freebsd: 'FreeBSD',
-  openbsd: 'OpenBSD',
-  sunos: 'Solaris',
-  linux: undefined,
-  haiku: undefined,
-  cygwin: undefined,
-  netbsd: undefined
+    aix: 'AIX',
+    darwin: 'Mac OS',
+    win32: 'Windows',
+    android: 'Android',
+    freebsd: 'FreeBSD',
+    openbsd: 'OpenBSD',
+    sunos: 'Solaris',
+    linux: undefined,
+    haiku: undefined,
+    cygwin: undefined,
+    netbsd: undefined
 };
 export const Browsers = {
-  ubuntu: browser => ['Ubuntu', browser, '22.04.4'],
-  macOS: browser => ['Mac OS', browser, '14.4.1'],
-  baileys: browser => ['Baileys', browser, '6.5.0'],
-  windows: browser => ['Windows', browser, '10.0.22631'],
-  appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
+    ubuntu: browser => ['Ubuntu', browser, '22.04.4'],
+    macOS: browser => ['Mac OS', browser, '14.4.1'],
+    baileys: browser => ['Baileys', browser, '6.5.0'],
+    windows: browser => ['Windows', browser, '10.0.22631'],
+    android: browser => [browser, 'Android', ''],
+    /** The appropriate browser based on your OS & release */
+    appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
 };
-export const getPlatformId = browser => {
-  const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
-  return platformType ? platformType.toString() : '1';
+export const getPlatformId = (browser) => {
+    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+    return platformType ? platformType.toString() : '1'; //chrome
 };
+//# sourceMappingURL=browser-utils.js.map

package/lib/Utils/business.d.ts

@@ -0,0 +1,23 @@
+import type { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate, WAMediaUpload, WAMediaUploadFunction } from '../Types/index.js';
+import { type BinaryNode } from '../WABinary/index.js';
+export declare const parseCatalogNode: (node: BinaryNode) => {
+    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;
+/**
+ * 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>;
+/**
+ * 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