@skyzopedia/baileys-mod 5.0.8 → 6.0.0

package/lib/Utils/auth-utils.js

@@ -1,219 +1,206 @@
-//=======================================================//
-import { delay, generateRegistrationId } from "./generics.js";
-import { DEFAULT_CACHE_TTLS } from "../Defaults/index.js";
-import { PreKeyManager } from "./pre-key-manager.js";
-import { Curve, signedKeyPair } from "./crypto.js";
-import { AsyncLocalStorage } from "async_hooks";
-import NodeCache from "@cacheable/node-cache";
-import { randomBytes } from "crypto";
-import { Mutex } from "async-mutex";
-import PQueue from "p-queue";
-//=======================================================//
-export function makeCacheableSignalKeyStore(store, logger, _cache) {
-  const cache = _cache ||
-    new NodeCache({
-      stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE,
-      useClones: false,
-      deleteOnExpire: true
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAuthCreds = exports.addTransactionCapability = exports.makeCacheableSignalKeyStore = void 0;
+const crypto_1 = require("crypto");
+const node_cache_1 = __importDefault(require("node-cache"));
+const uuid_1 = require("uuid");
+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
+ */
+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,
     });
-  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;
-              cache.set(getUniqueId(type, id), item);
+    function getUniqueId(type, id) {
+        return `${type}.${id}`;
+    }
+    return {
+        async get(type, ids) {
+            const data = {};
+            const idsToFetch = [];
+            for (const id of ids) {
+                const item = cache.get(getUniqueId(type, id));
+                if (typeof item !== 'undefined') {
+                    data[id] = item;
+                }
+                else {
+                    idsToFetch.push(id);
+                }
             }
-          }
-        }
-        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;
-          }
+            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;
+        },
+        async set(data) {
+            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);
+        },
+        async clear() {
+            var _a;
+            cache.flushAll();
+            await ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store));
         }
-        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 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());
-    }
-    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;
-    }
-    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);
-      }
-    }
-  }
-  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);
-          }
-        }
-        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]);
-        }
-      }
-    },
-    isInTransaction,
-    transaction: async (work, key) => {
-      const existing = txStorage.getStore();
-      if (existing) {
-        logger.trace("reusing existing transaction context");
-        return work();
-      }
-      return getTxMutex(key).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;
+exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
+/**
+ * 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
+ */
+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) => {
+            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) => {
+                    var _a;
+                    const value = (_a = transactionCache[type]) === null || _a === void 0 ? void 0 : _a[id];
+                    if (value) {
+                        dict[id] = value;
+                    }
+                    return dict;
+                }, {});
+            }
+            else {
+                return state.get(type, ids);
+            }
+        },
+        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]);
+                }
+            }
+            else {
+                return state.set(data);
+            }
+        },
+        isInTransaction,
+        async transaction(work) {
+            let result;
+            transactionsInProgress += 1;
+            if (transactionsInProgress === 1) {
+                logger.trace('entering transaction');
+            }
+            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 (0, generics_1.delay)(delayBetweenTriesMs);
+                            }
+                        }
+                    }
+                    else {
+                        logger.trace('no mutations in transaction');
+                    }
+                }
+            }
+            finally {
+                transactionsInProgress -= 1;
+                if (transactionsInProgress === 0) {
+                    transactionCache = {};
+                    mutations = {};
+                    dbQueriesInTransaction = 0;
+                }
+            }
+            return result;
         }
-      });
+    };
+    function isInTransaction() {
+        return transactionsInProgress > 0;
     }
-  };
 };
-//=======================================================//
-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
-  };
+exports.addTransactionCapability = addTransactionCapability;
+const initAuthCreds = () => {
+    const identityKey = crypto_2.Curve.generateKeyPair();
+    return {
+        noiseKey: crypto_2.Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: (0, crypto_2.signedKeyPair)(identityKey, 1),
+        registrationId: (0, generics_1.generateRegistrationId)(),
+        advSecretKey: (0, crypto_1.randomBytes)(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: {
+            unarchiveChats: false
+        },
+        // mobile creds
+        deviceId: Buffer.from((0, uuid_1.v4)().replace(/-/g, ''), 'hex').toString('base64url'),
+        phoneId: (0, uuid_1.v4)(),
+        identityId: (0, crypto_1.randomBytes)(20),
+        registered: false,
+        backupToken: (0, crypto_1.randomBytes)(20),
+        registration: {},
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+    };
 };
-//=======================================================//
+exports.initAuthCreds = initAuthCreds;

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

@@ -0,0 +1,16 @@
+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;
+/**
+ * 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>;
+};

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

@@ -1,44 +1,63 @@
-//=======================================================//
-import { makeMutex } from "./make-mutex.js";
-import { createInterface } from "readline";
-import { writeFile } from "fs/promises";
-import { delay } from "./generics.js";
-import { createReadStream } from "fs";
-import EventEmitter from "events";
-//=======================================================//
-export const captureEventStream = (ev, filename) => {
-  const oldEmit = ev.emit;
-  const writeMutex = makeMutex();
-  ev.emit = function (...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;
-  };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-//=======================================================//
-export const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
-  const ev = new EventEmitter();
-  const fireEvents = async () => {
-    const fileStream = createReadStream(filename);
-    const rl = createInterface({
-      input: fileStream,
-      crlfDelay: Infinity
-    });
-    for await (const line of rl) {
-      if (line) {
-        const { event, data } = JSON.parse(line);
-        ev.emit(event, data);
-        delayIntervalMs && (await delay(delayIntervalMs));
-      }
-    }
-    fileStream.close();
-  };
-  return {
-    ev,
-    task: fireEvents()
-  };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAndEmitEventStream = exports.captureEventStream = void 0;
+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
+ */
+const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit;
+    // write mutex so data is appended in order
+    const writeMutex = (0, 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);
+        writeMutex.mutex(async () => {
+            await (0, promises_1.writeFile)(filename, content, { flag: 'a' });
+        });
+        return result;
+    };
 };
-//=======================================================//
+exports.captureEventStream = captureEventStream;
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+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 = (0, fs_1.createReadStream)(filename);
+        const rl = (0, 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 (0, generics_1.delay)(delayIntervalMs);
+            }
+        }
+        fileStream.close();
+    };
+    return {
+        ev,
+        task: fireEvents()
+    };
+};
+exports.readAndEmitEventStream = readAndEmitEventStream;

package/lib/Utils/business.d.ts

@@ -0,0 +1,22 @@
+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;
+};
+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;
+}[]>;