gifted-baileys 1.5.5 → 1.5.7

package/{src/Types/Socket.ts → lib/Types/Socket.d.ts}

@@ -1,123 +1,116 @@
-
-import { AxiosRequestConfig } from 'axios'
-import type { Agent } from 'https'
-import type { Logger } from 'pino'
-import type { URL } from 'url'
-import { proto } from '../../WAProto'
-import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth'
-import { MediaConnInfo } from './Message'
-import { SignalRepository } from './Signal'
-
-export type WAVersion = [number, number, number]
-export type WABrowserDescription = [string, string, string]
-
+import { AxiosRequestConfig } from 'axios';
+import type { Agent } from 'https';
+import type { Logger } from 'pino';
+import type { URL } from 'url';
+import { proto } from '../../WAProto';
+import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth';
+import { GroupMetadata } from './GroupMetadata';
+import { MediaConnInfo } from './Message';
+import { SignalRepository } from './Signal';
+export type WAVersion = [number, number, number];
+export type WABrowserDescription = [string, string, string];
 export type CacheStore = {
     /** get a cached key and change the stats */
-    get<T>(key: string): T | undefined
+    get<T>(key: string): T | undefined;
     /** set a key in the cache */
-    set<T>(key: string, value: T): void
+    set<T>(key: string, value: T): void;
     /** delete a key from the cache */
-    del(key: string): void
+    del(key: string): void;
     /** flush all data */
-    flushAll(): void
-}
-
+    flushAll(): void;
+};
 export type SocketConfig = {
     /** the WS url to connect to WA */
-    waWebSocketUrl: string | URL
+    waWebSocketUrl: string | URL;
     /** Fails the connection if the socket times out in this interval */
-    connectTimeoutMs: number
+    connectTimeoutMs: number;
     /** Default timeout for queries, undefined for no timeout */
-    defaultQueryTimeoutMs: number | undefined
+    defaultQueryTimeoutMs: number | undefined;
     /** ping-pong interval for WS connection */
-    keepAliveIntervalMs: number
-	/** should baileys use the mobile api instead of the multi device api */
-	mobile?: boolean
+    keepAliveIntervalMs: number;
+    /** should baileys use the mobile api instead of the multi device api */
+    mobile?: boolean;
     /** proxy agent */
-    agent?: Agent
+    agent?: Agent;
     /** pino logger */
-    logger: Logger
+    logger: Logger;
     /** version to connect with */
-    version: WAVersion
+    version: WAVersion;
     /** override browser config */
-    browser: WABrowserDescription
+    browser: WABrowserDescription;
     /** agent used for fetch requests -- uploading/downloading media */
-    fetchAgent?: Agent
+    fetchAgent?: Agent;
     /** should the QR be printed in the terminal */
-    printQRInTerminal: boolean
+    printQRInTerminal: boolean;
     /** should events be emitted for actions done by this socket connection */
-    emitOwnEvents: boolean
+    emitOwnEvents: boolean;
     /** custom upload hosts to upload media to */
-    customUploadHosts: MediaConnInfo['hosts']
+    customUploadHosts: MediaConnInfo['hosts'];
     /** time to wait between sending new retry requests */
-    retryRequestDelayMs: number
+    retryRequestDelayMs: number;
     /** max retry count */
-    maxMsgRetryCount: number
+    maxMsgRetryCount: number;
     /** time to wait for the generation of the next QR in ms */
-    qrTimeout?: number
+    qrTimeout?: number;
     /** provide an auth state object to maintain the auth state */
-    auth: AuthenticationState
+    auth: AuthenticationState;
     /** manage history processing with this control; by default will sync up everything */
-    shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean
+    shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean;
     /** transaction capability options for SignalKeyStore */
-    transactionOpts: TransactionCapabilityOptions
+    transactionOpts: TransactionCapabilityOptions;
     /** marks the client as online whenever the socket successfully connects */
-    markOnlineOnConnect: boolean
-
+    markOnlineOnConnect: boolean;
+    /** alphanumeric country code (USA -> US) for the number used */
+    countryCode: string;
     /** provide a cache to store media, so does not have to be re-uploaded */
-    mediaCache?: CacheStore
+    mediaCache?: CacheStore;
     /**
      * map to store the retry counts for failed messages;
      * used to determine whether to retry a message or not */
-    msgRetryCounterCache?: CacheStore
+    msgRetryCounterCache?: CacheStore;
     /** provide a cache to store a user's device list */
-    userDevicesCache?: CacheStore
+    userDevicesCache?: CacheStore;
     /** cache to store call offers */
-    callOfferCache?: CacheStore
+    callOfferCache?: CacheStore;
+    /** cache to track placeholder resends */
+    placeholderResendCache?: CacheStore;
     /** width for link preview images */
-    linkPreviewImageThumbnailWidth: number
+    linkPreviewImageThumbnailWidth: number;
     /** Should Baileys ask the phone for full history, will be received async */
-    syncFullHistory: boolean
+    syncFullHistory: boolean;
     /** Should baileys fire init queries automatically, default true */
-    fireInitQueries: boolean
+    fireInitQueries: boolean;
     /**
      * generate a high quality link preview,
      * entails uploading the jpegThumbnail to WA
      * */
-    generateHighQualityLinkPreview: boolean
-
+    generateHighQualityLinkPreview: boolean;
     /**
      * Returns if a jid should be ignored,
      * no event for that jid will be triggered.
      * Messages from that jid will also not be decrypted
      * */
-    shouldIgnoreJid: (jid: string) => boolean | undefined
-
+    shouldIgnoreJid: (jid: string) => boolean | undefined;
     /**
      * Optionally patch the message before sending out
      * */
-    patchMessageBeforeSending: (
-        msg: proto.IMessage,
-        recipientJids: string[],
-    ) => Promise<proto.IMessage> | proto.IMessage
-
+    patchMessageBeforeSending: (msg: proto.IMessage, recipientJids: string[]) => Promise<proto.IMessage> | proto.IMessage;
     /** verify app state MACs */
     appStateMacVerification: {
-        patch: boolean
-        snapshot: boolean
-    }
-
+        patch: boolean;
+        snapshot: boolean;
+    };
     /** options for axios */
-    options: AxiosRequestConfig<{}>
+    options: AxiosRequestConfig<{}>;
     /**
      * fetch a message from your store
      * implement this so that messages failed to send
      * (solves the "this message can take a while" issue) can be retried
      * */
-    getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>
-
-    makeSignalRepository: (auth: SignalAuthState) => SignalRepository
-
+    getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>;
+    /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
+    cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>;
+    makeSignalRepository: (auth: SignalAuthState) => SignalRepository;
     /** Socket passthrough */
-    socket?: any
-}
+    socket?: any;
+};

package/lib/Types/State.d.ts

@@ -0,0 +1,27 @@
+import { Contact } from './Contact';
+export type WAConnectionState = 'open' | 'connecting' | 'close';
+export type ConnectionState = {
+    /** connection is now open, connecting or closed */
+    connection: WAConnectionState;
+    /** the error that caused the connection to close */
+    lastDisconnect?: {
+        error: Error | undefined;
+        date: Date;
+    };
+    /** is this a new login */
+    isNewLogin?: boolean;
+    /** the current QR code */
+    qr?: string;
+    /** has the device received all pending notifications while it was offline */
+    receivedPendingNotifications?: boolean;
+    /** legacy connection options */
+    legacy?: {
+        phoneConnected: boolean;
+        user?: Contact;
+    };
+    /**
+     * if the client is shown as an active, online client.
+     * If this is false, the primary phone and other devices will receive notifs
+     * */
+    isOnline?: boolean;
+};

package/lib/Types/USync.d.ts

@@ -0,0 +1,25 @@
+import { BinaryNode } from '../WABinary';
+import { USyncUser } from '../WAUSync';
+/**
+ * Defines the interface for a USyncQuery protocol
+ */
+export interface USyncQueryProtocol {
+    /**
+     * The name of the protocol
+     */
+    name: string;
+    /**
+     * Defines what goes inside the query part of a USyncQuery
+     */
+    getQueryElement: () => BinaryNode;
+    /**
+     * Defines what goes inside the user part of a USyncQuery
+     */
+    getUserElement: (user: USyncUser) => BinaryNode | null;
+    /**
+     * Parse the result of the query
+     * @param data Data from the result
+     * @returns Whatever the protocol is supposed to return
+     */
+    parser: (data: BinaryNode) => unknown;
+}

package/lib/Types/index.d.ts

@@ -0,0 +1,66 @@
+export * from './Auth';
+export * from './GroupMetadata';
+export * from './Chat';
+export * from './Contact';
+export * from './State';
+export * from './Message';
+export * from './Newsletter';
+export * from './Socket';
+export * from './Events';
+export * from './Product';
+export * from './Call';
+export * from './Signal';
+import { AuthenticationState } from './Auth';
+import { SocketConfig } from './Socket';
+export type UserFacingSocketConfig = Partial<SocketConfig> & {
+    auth: AuthenticationState;
+};
+export type BrowsersMap = {
+    ubuntu(browser: string): [string, string, string];
+    macOS(browser: string): [string, string, string];
+    baileys(browser: string): [string, string, string];
+    windows(browser: string): [string, string, string];
+    iOS(browser: string): [string, string, string];
+    linux(browser: string): [string, string, string];
+    appropriate(browser: string): [string, string, string];
+};
+export declare enum DisconnectReason {
+    connectionClosed = 428,
+    connectionLost = 408,
+    connectionReplaced = 440,
+    timedOut = 408,
+    loggedOut = 401,
+    badSession = 500,
+    restartRequired = 515,
+    multideviceMismatch = 411,
+    forbidden = 403,
+    unavailableService = 503
+}
+export type WAInitResponse = {
+    ref: string;
+    ttl: number;
+    status: 200;
+};
+export type WABusinessHoursConfig = {
+    day_of_week: string;
+    mode: string;
+    open_time?: number;
+    close_time?: number;
+};
+export type WABusinessProfile = {
+    description: string;
+    email: string | undefined;
+    business_hours: {
+        timezone?: string;
+        config?: WABusinessHoursConfig[];
+        business_config?: WABusinessHoursConfig[];
+    };
+    website: string[];
+    category?: string;
+    wid?: string;
+    address?: string;
+};
+export type CurveKeyPair = {
+    private: Uint8Array;
+    public: Uint8Array;
+};

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

@@ -0,0 +1,18 @@
+import type { Logger } from 'pino';
+import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types';
+/**
+ * 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 declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger: Logger, _cache?: CacheStore): SignalKeyStore;
+/**
+ * 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 declare const addTransactionCapability: (state: SignalKeyStore, logger: Logger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction;
+export declare const initAuthCreds: () => AuthenticationCreds;

package/{src → lib}/Utils/auth-utils.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -36,52 +27,46 @@ function makeCacheableSignalKeyStore(store, logger, _cache) {
         return `${type}.${id}`;
     }
     return {
-        get(type, ids) {
-            return __awaiter(this, void 0, void 0, function* () {
-                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);
-                    }
+        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;
                 }
-                if (idsToFetch.length) {
-                    logger.trace({ items: idsToFetch.length }, 'loading from store');
-                    const fetched = yield 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;
         },
-        set(data) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let keys = 0;
-                for (const type in data) {
-                    for (const id in data[type]) {
-                        cache.set(getUniqueId(type, id), data[type][id]);
-                        keys += 1;
-                    }
+        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');
-                yield store.set(data);
-            });
+            }
+            logger.trace({ keys }, 'updated cache');
+            await store.set(data);
         },
-        clear() {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                cache.flushAll();
-                yield ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store));
-            });
+        async clear() {
+            var _a;
+            cache.flushAll();
+            await ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store));
         }
     };
 }
@@ -100,7 +85,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
     let mutations = {};
     let transactionsInProgress = 0;
     return {
-        get: (type, ids) => __awaiter(void 0, void 0, void 0, function* () {
+        get: async (type, ids) => {
             if (isInTransaction()) {
                 const dict = transactionCache[type];
                 const idsRequiringFetch = dict
@@ -109,7 +94,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                 // only fetch if there are any items to fetch
                 if (idsRequiringFetch.length) {
                     dbQueriesInTransaction += 1;
-                    const result = yield state.get(type, idsRequiringFetch);
+                    const result = await state.get(type, idsRequiringFetch);
                     transactionCache[type] || (transactionCache[type] = {});
                     Object.assign(transactionCache[type], result);
                 }
@@ -125,7 +110,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             else {
                 return state.get(type, ids);
             }
-        }),
+        },
         set: data => {
             if (isInTransaction()) {
                 logger.trace({ types: Object.keys(data) }, 'caching in transaction');
@@ -141,50 +126,48 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             }
         },
         isInTransaction,
-        transaction(work) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let result;
-                transactionsInProgress += 1;
+        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) {
-                    logger.trace('entering transaction');
-                }
-                try {
-                    result = yield 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 {
-                                    yield state.set(mutations);
-                                    logger.trace({ dbQueriesInTransaction }, 'committed transaction');
-                                    break;
-                                }
-                                catch (error) {
-                                    logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
-                                    yield (0, generics_1.delay)(delayBetweenTriesMs);
-                                }
+                    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;
+                    else {
+                        logger.trace('no mutations in transaction');
                     }
                 }
-                return result;
-            });
+            }
+            finally {
+                transactionsInProgress -= 1;
+                if (transactionsInProgress === 0) {
+                    transactionCache = {};
+                    mutations = {};
+                    dbQueriesInTransaction = 0;
+                }
+            }
+            return result;
         }
     };
     function isInTransaction() {

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

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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: any;
+};
+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;
+}[]>;