@alannxd/baileys 6.0.5 → 6.0.6

package/lib/Socket/usync.d.ts

@@ -0,0 +1,36 @@
+import { Boom } from '@hapi/boom';
+import { SocketConfig } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { USyncQuery } from '../WAUSync';
+export declare const makeUSyncSocket: (config: SocketConfig) => {
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../WAUSync").USyncQueryResult | undefined>;
+    type: "md";
+    ws: import("./Client").WebSocketClient;
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): (() => void);
+        buffer(): void;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): ((...args: A) => Promise<T>);
+        flush(force?: boolean): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<any>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | Boom, msg: string) => void;
+    uploadPreKeys: (count?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>;
+};

package/lib/Socket/usync.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUSyncSocket = void 0;
+const boom_1 = require("@hapi/boom");
+const WABinary_1 = require("../WABinary");
+const socket_1 = require("./socket");
+const makeUSyncSocket = (config) => {
+    const sock = (0, socket_1.makeSocket)(config);
+    const { generateMessageTag, query, } = sock;
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol');
+        }
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users;
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined,
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter(a => a !== null)
+            };
+        });
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        };
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        };
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync',
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0',
+                    },
+                    content: [
+                        queryNode,
+                        listNode
+                    ]
+                }
+            ],
+        };
+        const result = await query(iq);
+        return usyncQuery.parseUSyncQueryResult(result);
+    };
+    return {
+        ...sock,
+        executeUSyncQuery,
+    };
+};
+exports.makeUSyncSocket = makeUSyncSocket;

package/lib/Store/index.d.ts

@@ -1,10 +1,3 @@
-export * from './make-cache-manager-store';
-export * from './make-in-memory-store';
-export * from './make-ordered-dictionary';
-export * from './object-repository';
-export * from './keyed-db
-export { default as makeCacheManagerStore } from './make-cache-manager-store';
-export { default as makeInMemoryStore } from './make-in-memory-store';
-export { default as makeOrderedDictionary } from './make-ordered-dictionary';
-export { default as objectRepository } from './object-repository';
-export { default as keyedDB} from './keyed-db';
+import makeCacheManagerAuthState from './make-cache-manager-store';
+import makeInMemoryStore from './make-in-memory-store';
+export { makeInMemoryStore, makeCacheManagerAuthState };

package/lib/Store/index.js

@@ -1,10 +1,10 @@
-export * from './make-cache-manager-store.js';
-export * from './make-in-memory-store.js';
-export * from './make-ordered-dictionary.js';
-export * from './object-repository.js';
-export * from './keyed-db.js';
-export { default as makeCacheManagerStore } from './make-cache-manager-store.js';
-export { default as makeInMemoryStore } from './make-in-memory-store.js';
-export { default as makeOrderedDictionary } from './make-ordered-dictionary.js';
-export { default as objectRepository } from './object-repository.js';
-export { default as keyedDB } from './keyed-db.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCacheManagerAuthState = exports.makeInMemoryStore = void 0;
+const make_cache_manager_store_1 = __importDefault(require("./make-cache-manager-store"));
+exports.makeCacheManagerAuthState = make_cache_manager_store_1.default;
+const make_in_memory_store_1 = __importDefault(require("./make-in-memory-store"));
+exports.makeInMemoryStore = make_in_memory_store_1.default;

package/lib/Store/make-cache-manager-store.d.ts

@@ -1,19 +1,13 @@
-import { Store } from 'cache-manager';
-import { proto as WAProto } from '../../WAProto';
-
-interface AuthState {
-  clearState: () => Promise<void>;
-  saveCreds: () => Promise<void>;
-  state: {
-    creds: any;
-    keys: {
-      get: (type: string, ids: string[]) => Promise<{ [id: string]: any }>;
-      set: (data: { [category: string]: { [id: string]: any } }) => Promise<void>;
+import { AuthenticationCreds } from '../Types';
+declare const makeCacheManagerAuthState: (store: Storage, sessionKey: string) => Promise<{
+    clearState: () => Promise<void>;
+    saveCreds: () => Promise<void>;
+    state: {
+        creds: AuthenticationCreds;
+        keys: {
+            get: (type: string, ids: string[]) => Promise<{}>;
+            set: (data: any) => Promise<void>;
+        };
     };
-  };
-}
-
-declare function makeCacheManagerAuthState(store: Store, sessionKey: string): Promise<AuthState>;
-
+}>;
 export default makeCacheManagerAuthState;
-export { makeCacheManagerAuthState };

package/lib/Store/make-cache-manager-store.js

@@ -1,74 +1,71 @@
-import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-const cacheManager = require("cache-manager");
-
-import * as WAProto_1 from "../../WAProto/index.js";
-import * as Utils_1 from "../Utils/index.js";
-import logger from "../Utils/logger.js";
-
-export default async function makeCacheManagerAuthState(store, sessionKey) {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cache_manager_1 = require("cache-manager");
+const WAProto_1 = require("../../WAProto");
+const Utils_1 = require("../Utils");
+const logger_1 = __importDefault(require("../Utils/logger"));
+const makeCacheManagerAuthState = async (store, sessionKey) => {
     const defaultKey = (file) => `${sessionKey}:${file}`;
-    const databaseConn = await cacheManager.caching(store);
-
+    const databaseConn = await (0, cache_manager_1.caching)(store);
     const writeData = async (file, data) => {
         let ttl = undefined;
-        if (file === "creds") ttl = 63115200; // 2 years
-        await databaseConn.set(
-            defaultKey(file),
-            JSON.stringify(data, Utils_1.BufferJSON.replacer),
-            ttl
-        );
+        if (file === 'creds') {
+            ttl = 63115200; // 2 years
+        }
+        await databaseConn.set(defaultKey(file), JSON.stringify(data, Utils_1.BufferJSON.replacer), ttl);
     };
-
     const readData = async (file) => {
         try {
             const data = await databaseConn.get(defaultKey(file));
-            if (data) return JSON.parse(data, Utils_1.BufferJSON.reviver);
+            if (data) {
+                return JSON.parse(data, Utils_1.BufferJSON.reviver);
+            }
             return null;
-        } catch (error) {
-            logger.error(error);
+        }
+        catch (error) {
+            logger_1.default.error(error);
             return null;
         }
     };
-
     const removeData = async (file) => {
         try {
             return await databaseConn.del(defaultKey(file));
-        } catch {
-            logger.error(`Error removing ${file} from session ${sessionKey}`);
+        }
+        catch (_a) {
+            logger_1.default.error(`Error removing ${file} from session ${sessionKey}`);
         }
     };
-
     const clearState = async () => {
         try {
             const result = await databaseConn.store.keys(`${sessionKey}*`);
-            await Promise.all(result.map(async (key) => databaseConn.del(key)));
-        } catch {}
+            await Promise.all(result.map(async (key) => await databaseConn.del(key)));
+        }
+        catch (err) {
+        }
     };
-
-    const creds = (await readData("creds")) || Utils_1.initAuthCreds();
-
+    const creds = (await readData('creds')) || (0, Utils_1.initAuthCreds)();
     return {
         clearState,
-        saveCreds: () => writeData("creds", creds),
+        saveCreds: () => writeData('creds', creds),
         state: {
             creds,
             keys: {
                 get: async (type, ids) => {
                     const data = {};
-                    await Promise.all(
-                        ids.map(async (id) => {
-                            let value = await readData(`${type}-${id}`);
-                            if (type === "app-state-sync-key" && value) {
-                                value =
-                                    WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
-                            }
-                            data[id] = value;
-                        })
-                    );
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
                     return data;
                 },
                 set: async (data) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     const tasks = [];
                     for (const category in data) {
                         for (const id in data[category]) {
@@ -78,8 +75,9 @@ export default async function makeCacheManagerAuthState(store, sessionKey) {
                         }
                     }
                     await Promise.all(tasks);
-                }
+                },
             }
         }
     };
-}
+};
+exports.default = makeCacheManagerAuthState;

package/lib/Store/make-in-memory-store.d.ts

@@ -1,39 +1,118 @@
-import { proto as WAProto } from '../../WAProto';
-import { LabelAssociationType } from '../Types/LabelAssociation';
-
-interface StoreConfig {
-  socket: any;
-  chatKey?: any;
-  labelAssociationKey?: any;
-  logger?: any;
-}
-
-interface Store {
-  chats: any;
-  contacts: any;
-  messages: any;
-  groupMetadata: any;
-  state: any;
-  presences: any;
-  labels: any;
-  labelAssociations: any;
-  bind: (ev: any) => void;
-  loadMessages: (jid: string, count: number, cursor: any) => Promise<any[]>;
-  getLabels: () => any[];
-  getChatLabels: (chatId: string) => any[];
-  getMessageLabels: (messageId: string) => any[];
-  loadMessage: (jid: string, id: string) => Promise<any>;
-  mostRecentMessage: (jid: string) => Promise<any>;
-  fetchImageUrl: (jid: string, sock: any) => Promise<string | undefined>;
-  fetchGroupMetadata: (jid: string, sock: any) => Promise<any>;
-  fetchMessageReceipts: (opts: { remoteJid: string; id: string }) => Promise<any[] | undefined>;
-  toJSON: () => any;
-  fromJSON: (json: any) => void;
-  writeToFile: (path: string) => void;
-  readFromFile: (path: string) => void;
-}
-
-declare function makeStore(config: StoreConfig): Store;
-
-export default makeStore;
-export { makeStore, waChatKey, waMessageID, waLabelAssociationKey };
+import type KeyedDB from '@adiwajshing/keyed-db';
+import type { Comparable } from '@adiwajshing/keyed-db/lib/Types';
+import type { Logger } from 'pino';
+import { proto } from '../../WAProto';
+import type makeMDSocket from '../Socket';
+import type { BaileysEventEmitter, Chat, ConnectionState, Contact, GroupMetadata, PresenceData, WAMessage, WAMessageCursor, WAMessageKey } from '../Types';
+import { Label } from '../Types/Label';
+import { LabelAssociation } from '../Types/LabelAssociation';
+import { ObjectRepository } from './object-repository';
+type WASocket = ReturnType<typeof makeMDSocket>;
+export declare const waChatKey: (pin: boolean) => {
+    key: (c: Chat) => string;
+    compare: (k1: string, k2: string) => number;
+};
+export declare const waMessageID: (m: WAMessage) => string;
+export declare const waLabelAssociationKey: Comparable<LabelAssociation, string>;
+export type BaileysInMemoryStoreConfig = {
+    chatKey?: Comparable<Chat, string>;
+    labelAssociationKey?: Comparable<LabelAssociation, string>;
+    logger?: Logger;
+    socket?: WASocket;
+};
+declare const _default: (config: BaileysInMemoryStoreConfig) => {
+    chats: KeyedDB<Chat, string>;
+    contacts: {
+        [_: string]: Contact;
+    };
+    messages: {
+        [_: string]: {
+            array: proto.IWebMessageInfo[];
+            get: (id: string) => proto.IWebMessageInfo | undefined;
+            upsert: (item: proto.IWebMessageInfo, mode: "append" | "prepend") => void;
+            update: (item: proto.IWebMessageInfo) => boolean;
+            remove: (item: proto.IWebMessageInfo) => boolean;
+            updateAssign: (id: string, update: Partial<proto.IWebMessageInfo>) => boolean;
+            clear: () => void;
+            filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void;
+            toJSON: () => proto.IWebMessageInfo[];
+            fromJSON: (newItems: proto.IWebMessageInfo[]) => void;
+        };
+    };
+    groupMetadata: {
+        [_: string]: GroupMetadata;
+    };
+    state: ConnectionState;
+    presences: {
+        [id: string]: {
+            [participant: string]: PresenceData;
+        };
+    };
+    labels: ObjectRepository<Label>;
+    labelAssociations: KeyedDB<LabelAssociation, string>;
+    bind: (ev: BaileysEventEmitter) => void;
+    /** loads messages from the store, if not found -- uses the legacy connection */
+    loadMessages: (jid: string, count: number, cursor: WAMessageCursor) => Promise<proto.IWebMessageInfo[]>;
+    /**
+     * Get all available labels for profile
+     *
+     * Keep in mind that the list is formed from predefined tags and tags
+     * that were "caught" during their editing.
+     */
+    getLabels: () => ObjectRepository<Label>;
+    /**
+     * Get labels for chat
+     *
+     * @returns Label IDs
+     **/
+    getChatLabels: (chatId: string) => LabelAssociation[];
+    /**
+     * Get labels for message
+     *
+     * @returns Label IDs
+     **/
+    getMessageLabels: (messageId: string) => string[];
+    loadMessage: (jid: string, id: string) => Promise<proto.IWebMessageInfo | undefined>;
+    mostRecentMessage: (jid: string) => Promise<proto.IWebMessageInfo>;
+    fetchImageUrl: (jid: string, sock: WASocket | undefined) => Promise<string | null | undefined>;
+    fetchGroupMetadata: (jid: string, sock: WASocket | undefined) => Promise<GroupMetadata>;
+    fetchMessageReceipts: ({ remoteJid, id }: WAMessageKey) => Promise<proto.IUserReceipt[] | null | undefined>;
+    toJSON: () => {
+        chats: KeyedDB<Chat, string>;
+        contacts: {
+            [_: string]: Contact;
+        };
+        messages: {
+            [_: string]: {
+                array: proto.IWebMessageInfo[];
+                get: (id: string) => proto.IWebMessageInfo | undefined;
+                upsert: (item: proto.IWebMessageInfo, mode: "append" | "prepend") => void;
+                update: (item: proto.IWebMessageInfo) => boolean;
+                remove: (item: proto.IWebMessageInfo) => boolean;
+                updateAssign: (id: string, update: Partial<proto.IWebMessageInfo>) => boolean;
+                clear: () => void;
+                filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void;
+                toJSON: () => proto.IWebMessageInfo[];
+                fromJSON: (newItems: proto.IWebMessageInfo[]) => void;
+            };
+        };
+        labels: ObjectRepository<Label>;
+        labelAssociations: KeyedDB<LabelAssociation, string>;
+    };
+    fromJSON: (json: {
+        chats: Chat[];
+        contacts: {
+            [id: string]: Contact;
+        };
+        messages: {
+            [id: string]: proto.IWebMessageInfo[];
+        };
+        labels: {
+            [labelId: string]: Label;
+        };
+        labelAssociations: LabelAssociation[];
+    }) => void;
+    writeToFile: (path: string) => void;
+    readFromFile: (path: string) => void;
+};
+export default _default;