@neelegirly/baileys 2.2.16

package/lib/Utils/auth-utils.js

@@ -0,0 +1,205 @@
+"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
+ */
+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 {
+        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)
+                }
+            }
+            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() {
+            cache.flushAll()
+            await store.clear?.call(store)
+        }
+    }
+}
+
+/**
+ * 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) => {
+                    const value = transactionCache[type]?.[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 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
+    }
+}
+
+const initAuthCreds = () => {
+    const identityKey = crypto_2.Curve.generateKeyPair()
+    return {
+        noiseKey: crypto_2.Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: crypto_2.signedKeyPair(identityKey, 1),
+        registrationId: generics_1.generateRegistrationId(),
+        advSecretKey: crypto_1.randomBytes(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: {
+            unarchiveChats: false
+        },
+        registered: false,
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined
+    }
+}
+
+module.exports = {
+  makeCacheableSignalKeyStore, 
+  addTransactionCapability, 
+  initAuthCreds
+}

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,70 @@
+"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
+ */
+const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit
+    // write mutex so data is appended in order
+    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)
+        writeMutex.mutex(async () => {
+            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
+ */
+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 = 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 generics_1.delay(delayIntervalMs)
+            }
+        }
+        fileStream.close()
+    }
+    return {
+        ev,
+        task: fireEvents()
+    }
+}
+
+module.exports = {
+  captureEventStream, 
+  readAndEmitEventStream
+}

package/lib/Utils/branding.d.ts

@@ -0,0 +1,24 @@
+export interface ResolvedVersions {
+    baileysPackage: string;
+    baileysVersion: string;
+    wrapperPackage: string | null;
+    wrapperVersion: string | null;
+    wrapperLatest: string | null;
+    libsignalVersion: string | null;
+}
+export interface VersionUpdateInfo {
+    current: string;
+    latest: string;
+    hasUpdate: boolean;
+    source?: "npm" | "github";
+}
+export interface QrBrandingResult {
+    headerLines: string[];
+    footerLines: string[];
+    versions: ResolvedVersions;
+    update: VersionUpdateInfo | null;
+}
+export declare const getResolvedVersions: () => ResolvedVersions;
+export declare const getBaileysUpdateInfo: () => Promise<VersionUpdateInfo | null>;
+export declare const getQrBranding: () => Promise<QrBrandingResult>;
+export declare const writeBrandingLines: (lines: string[], logger?: any) => void;

package/lib/Utils/branding.js

@@ -0,0 +1,209 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeBrandingLines = exports.getQrBranding = exports.getBaileysUpdateInfo = exports.getResolvedVersions = void 0;
+
+const fs = require("fs");
+const path = require("path");
+const { checkNpmVersion } = require("./check-npm-version");
+
+const BRAND = Object.freeze({
+  name: "Neelegirly 💖",
+  headerClaim: "Girly Glow-Up fuer WhatsApp Web",
+  footerClaim: "QR Love · Stable Sessions · Update Glow",
+  footerTagline: "Powered by Neelegirly for the cutest WhatsApp Web flow"
+});
+
+const ANSI = Object.freeze({
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+  yellow: "\x1b[33m",
+  gray: "\x1b[90m"
+});
+
+const color = (value, ansiColor) => `${ansiColor}${value}${ANSI.reset}`;
+
+let packageMetaCache = null;
+let updateCheckPromise = null;
+let updateInfoCache = null;
+let hasShownBaileysUpdateHint = false;
+let hasShownWrapperUpdateHint = false;
+
+const readJson = (filePath) => {
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(content);
+  } catch (_error) {
+    return null;
+  }
+};
+
+const readBaileysMeta = () => {
+  if (packageMetaCache) {
+    return packageMetaCache;
+  }
+
+  const filePath = path.join(__dirname, "..", "..", "package.json");
+  const parsed = readJson(filePath) || {};
+
+  packageMetaCache = {
+    name: parsed.name || "@neelegirly/baileys",
+    version: parsed.version || process.env.npm_package_version || "0.0.0"
+  };
+
+  return packageMetaCache;
+};
+
+const safeRequireVersion = (pkg) => {
+  try {
+    const resolved = require.resolve(`${pkg}/package.json`, { paths: [process.cwd(), __dirname] });
+    const parsed = readJson(resolved);
+    return parsed?.version ? String(parsed.version) : null;
+  } catch (_error) {
+    return null;
+  }
+};
+
+const getResolvedVersions = () => {
+  const meta = readBaileysMeta();
+  const wrapperPackage = process.env.NEELEGIRLY_WRAPPER_PACKAGE || "";
+  const wrapperVersion = process.env.NEELEGIRLY_WRAPPER_VERSION || "";
+  const libsignalVersion = safeRequireVersion("@neelegirly/libsignal") || "";
+
+  return {
+    baileysPackage: meta.name,
+    baileysVersion: meta.version,
+    wrapperPackage: wrapperPackage || null,
+    wrapperVersion: wrapperVersion || null,
+    wrapperLatest: process.env.NEELEGIRLY_WRAPPER_UPDATE || null,
+    libsignalVersion: libsignalVersion || null
+  };
+};
+
+exports.getResolvedVersions = getResolvedVersions;
+
+const getBaileysUpdateInfo = async () => {
+  if (updateInfoCache) {
+    return updateInfoCache;
+  }
+
+  if (!updateCheckPromise) {
+    const { baileysPackage, baileysVersion } = getResolvedVersions();
+    updateCheckPromise = checkNpmVersion(baileysPackage, baileysVersion, {
+      githubRepo: "neelegirly/baileys",
+      timeoutMs: 5000
+    }).catch(() => null);
+  }
+
+  updateInfoCache = await updateCheckPromise;
+  return updateInfoCache;
+};
+
+exports.getBaileysUpdateInfo = getBaileysUpdateInfo;
+
+const buildDivider = () => color("============================================================", ANSI.gray);
+
+const getQrBranding = async () => {
+  const versions = getResolvedVersions();
+  const update = await getBaileysUpdateInfo();
+  const shouldShowBaileysUpdateHint = Boolean(update?.hasUpdate) && !hasShownBaileysUpdateHint;
+  const shouldShowWrapperUpdateHint =
+    Boolean(versions.wrapperPackage && versions.wrapperLatest) && !hasShownWrapperUpdateHint;
+
+  const headerLines = [
+    buildDivider(),
+    color(`${ANSI.bold}${BRAND.name}${ANSI.reset} | ${BRAND.headerClaim}`, ANSI.magenta),
+    color(`Neelegirly Glow Version: ${versions.baileysVersion}`, ANSI.cyan),
+    color(`Paket: ${versions.baileysPackage} v${versions.baileysVersion}`, ANSI.cyan)
+  ];
+
+  if (versions.wrapperPackage && versions.wrapperVersion) {
+    headerLines.push(
+      color(`Wrapper: ${versions.wrapperPackage} v${versions.wrapperVersion}`, ANSI.cyan)
+    );
+  }
+
+  if (versions.libsignalVersion) {
+    headerLines.push(color(`Signal-Core: @neelegirly/libsignal v${versions.libsignalVersion}`, ANSI.cyan));
+  }
+
+  if (shouldShowBaileysUpdateHint) {
+    const source = update.source || "npm";
+    headerLines.push(
+      color(
+        `Update verfuegbar (${versions.baileysPackage}): ${update.latest} | Quelle: ${source}`,
+        ANSI.yellow
+      )
+    );
+  }
+
+  if (shouldShowWrapperUpdateHint) {
+    headerLines.push(
+      color(
+        `Update verfuegbar (${versions.wrapperPackage}): ${versions.wrapperLatest}`,
+        ANSI.yellow
+      )
+    );
+  }
+
+  const footerLines = [
+    color(`💖 ${BRAND.footerClaim}`, ANSI.magenta),
+    color(`Powered by ${BRAND.name}`, ANSI.cyan),
+    color(BRAND.footerTagline, ANSI.cyan),
+    color(`Aktive Basis: ${versions.baileysPackage} v${versions.baileysVersion}`, ANSI.gray)
+  ];
+
+  if (shouldShowBaileysUpdateHint) {
+    footerLines.push(
+      color(`Du nutzt ${update.current}, neu ist ${update.latest}.`, ANSI.yellow)
+    );
+  }
+
+  if (shouldShowWrapperUpdateHint) {
+    footerLines.push(
+      color(
+        `Du nutzt ${versions.wrapperVersion} (${versions.wrapperPackage}), neu ist ${versions.wrapperLatest}.`,
+        ANSI.yellow
+      )
+    );
+  }
+
+  if (shouldShowBaileysUpdateHint) {
+    hasShownBaileysUpdateHint = true;
+  }
+  if (shouldShowWrapperUpdateHint) {
+    hasShownWrapperUpdateHint = true;
+  }
+
+  footerLines.push(buildDivider());
+
+  return {
+    headerLines,
+    footerLines,
+    versions,
+    update
+  };
+};
+
+exports.getQrBranding = getQrBranding;
+
+const writeBrandingLines = (lines, logger) => {
+  if (!Array.isArray(lines) || !lines.length) {
+    return;
+  }
+
+  for (const line of lines) {
+    if (!line) continue;
+
+    if (logger && typeof logger.info === "function" && logger.level && logger.level !== "silent") {
+      logger.info(line);
+      continue;
+    }
+
+    console.log(line);
+  }
+};
+
+exports.writeBrandingLines = writeBrandingLines;

package/lib/Utils/business.d.ts

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