@badzz88/baileys 8.4.6 → 8.4.9

package/lib/Socket/username.js

@@ -1,146 +0,0 @@
-import { executeWMexQuery } from './mex.js'
-import { USyncQuery, USyncUser } from '../WAUSync/index.js'
-import { makeNewsletterSocket } from '../Signal/Group/Protocols.js'
-export const USERNAME_QUERY_IDS = {
-	CHECK: '26124072630599520',
-	CHECK_MULTI: '27134626522840290',
-	SET: '27108705368767936',
-	GET: '32618050064506056',
-	GET_RECOMMENDATIONS: '26077456248616956',
-	PIN_SET: '25529696019976770'
-}
-
-export const USERNAME_CHECK_RESULT = {
-	SUCCESS: 'SUCCESS',
-	INVALID: 'INVALID'
-}
-
-export const USERNAME_SOURCE = {
-	FB: 'FB',
-	IG: 'IG',
-	USER_INPUT: 'USER_INPUT',
-	SUGGESTION: 'SUGGESTION'
-}
-
-export const makeUsernameSocket = config => {
-	const sock = makeNewsletterSocket(config)
-	const { query, generateMessageTag, executeUSyncQuery } = sock
-
-	const mexQuery = (variables, queryId, dataPath) =>
-		executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag)
-
-	const checkUsername = async (username, includeSuggestions = true) => {
-		if (!USERNAME_QUERY_IDS.CHECK) {
-			throw new Error('Username CHECK query_id not configured — capture a live WA session to obtain it')
-	}
-		const data = await mexQuery(
-			{ username, include_suggestions: includeSuggestions },
-			USERNAME_QUERY_IDS.CHECK,
-			'xwa2_username_check'
-	)
-		if (data?.result === USERNAME_CHECK_RESULT.SUCCESS) {
-			return { available: true, username }
-	}
-		return {
-			available: false,
-			username,
-			suggestions: data?.suggestions?? [],
-			rejectionReasons: data?.rejection_reasons?? [],
-			suggestionsEligible: data?.suggestions_eligible?? true
-    	}
-	}
-
-	const setUsername = async (username, options = {}) => {
-		if (!USERNAME_QUERY_IDS.SET) {
-			throw new Error('Username SET query_id not configured — capture a live WA session to obtain it')
-	}
-		const { source = USERNAME_SOURCE.USER_INPUT, sessionId, pin } = options
-		const variables = {
-			username,
-			reserved: false,
-			source,
-			...(sessionId? { session_id: sessionId } : {}),
-			...(pin? { pin } : {})
-	}
-		return mexQuery(variables, USERNAME_QUERY_IDS.SET, 'xwa2_username_set')
-	}
-
-	const deleteUsername = async () => {
-		if (!USERNAME_QUERY_IDS.SET) {
-			throw new Error('Username SET query_id not configured — capture a live WA session to obtain it')
-	}
-		return mexQuery({ username: null }, USERNAME_QUERY_IDS.SET, 'xwa2_username_delete')
-	}
-
-	const getMyUsername = async () => {
-		if (!USERNAME_QUERY_IDS.GET) {
-			throw new Error('Username GET query_id not configured — capture a live WA session to obtain it')
-	}
-		const data = await mexQuery({}, USERNAME_QUERY_IDS.GET, 'xwa2_username_get')
-		return data?.username?? null
-	}
-
-	const setUsernamePin = async pin => {
-		if (!USERNAME_QUERY_IDS.PIN_SET) {
-			throw new Error('Username PIN_SET query_id not configured — capture a live WA session to obtain it')
-	}
-		return mexQuery({ pin }, USERNAME_QUERY_IDS.PIN_SET, 'xwa2_username_pin_set')
-	}
-
-	const findUserByUsername = async (username, pin) => {
-		const usyncQuery = new USyncQuery().withContactProtocol()
-		const user = new USyncUser().withUsername(username)
-		if (pin) user.withUsernameKey(pin)
-	usyncQuery.withUser(user)
-		const result = await executeUSyncQuery(usyncQuery)
-		if (!result?.list?.length) return null
-		const entry = result.list[0]
-		return {
-			jid: entry.id,
-			contact: entry.contact?? false
-	}
-	}
-
-
-	const fetchContactUsernames = async (...jids) => {
-		const usyncQuery = new USyncQuery().withUsernameProtocol()
-		for (const jid of jids) {
-			usyncQuery.withUser(new USyncUser().withId(jid))
-	}
-		const result = await executeUSyncQuery(usyncQuery)
-		return result?.list?? []
-	}
-
-	const checkUsernameMulti = async usernames => {
-		const data = await mexQuery(
-			{ usernames },
-			USERNAME_QUERY_IDS.CHECK_MULTI,
-			'xwa2_username_check_multi'
-	)
-		return data
-	}
-
-
-
-	const getUsernameRecommendations = async (source = null) => {
-		const variables = {}
-		if (source) variables.source = source
-		return mexQuery(variables, USERNAME_QUERY_IDS.GET_RECOMMENDATIONS, 'xwa2_username_get_recommendations')
-	}
-
-	return {
-	    ...sock,
-		checkUsername,
-		checkUsernameMulti,
-		setUsername,
-		deleteUsername,
-		getMyUsername,
-		getUsernameRecommendations,
-		setUsernamePin,
-		findUserByUsername,
-		fetchContactUsernames,
-		USERNAME_QUERY_IDS,
-		USERNAME_CHECK_RESULT,
-		USERNAME_SOURCE
-	}
-}

package/lib/Socket/usync.js

@@ -1,69 +0,0 @@
-"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');
-        }
-
-        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.js

@@ -1,10 +0,0 @@
-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';

package/lib/Store/keyed-db.js

@@ -1,108 +0,0 @@
-export default class KeyedDB {
-    constructor(compareFn, idGetter) {
-        if (typeof compareFn !== "function" || typeof idGetter !== "function") {
-            throw new Error("KeyedDB requires compare and idGetter functions");
-        }
-        this._compare = compareFn;
-        this._idGetter = idGetter;
-        this._array = [];
-        this._dict = {};
-    }
-    get length() {
-        return this._array.length;
-    }
-    get(id) {
-        return this._dict[id];
-    }
-    insert(entry, mode = "insert") {
-        const id = this._idGetter(entry);
-        const existing = this._dict[id];
-        if (existing && mode === "insert") {
-            return false;
-        }
-        this._dict[id] = entry;
-        let inserted = false;
-        for (let i = 0; i < this._array.length; i++) {
-            const cmp = this._compare(this._idGetter(this._array[i]), id);
-            if (cmp < 0) {
-                this._array.splice(i, 0, entry);
-                inserted = true;
-                break;
-            }
-        }
-        if (!inserted) this._array.push(entry);
-        return true;
-    }
-    insertIfAbsent(...entries) {
-        const added = [];
-        for (const entry of entries) {
-            if (!this._dict[this._idGetter(entry)]) {
-                this.insert(entry);
-                added.push(entry);
-            }
-        }
-        return added;
-    }
-    upsert(...entries) {
-        const added = [];
-        for (const entry of entries) {
-            const id = this._idGetter(entry);
-            if (this._dict[id]) {
-                const idx = this._array.findIndex(e => this._idGetter(e) === id);
-                if (idx >= 0) this._array[idx] = entry;
-                this._dict[id] = entry;
-            } else {
-                this.insert(entry);
-                added.push(entry);
-            }
-        }
-        return added;
-    }
-    update(id, updater) {
-        const item = this._dict[id];
-        if (!item) return false;
-        updater(item);
-        const idx = this._array.findIndex(e => this._idGetter(e) === id);
-        if (idx >= 0) this._array[idx] = item;
-        return true;
-    }
-    updateAssign(id, update) {
-        const item = this._dict[id];
-        if (!item) return false;
-        Object.assign(item, update);
-        const idx = this._array.findIndex(e => this._idGetter(e) === id);
-        if (idx >= 0) this._array[idx] = item;
-        return true;
-    }
-    deleteById(id) {
-        if (!this._dict[id]) return false;
-        delete this._dict[id];
-        const idx = this._array.findIndex(e => this._idGetter(e) === id);
-        if (idx >= 0) this._array.splice(idx, 1);
-        return true;
-    }
-    clear() {
-        this._array = [];
-        this._dict = {};
-    }
-    all() {
-        return [...this._array];
-    }
-    filter(predicate) {
-        this._array = this._array.filter(predicate);
-        this._dict = {};
-        for (const entry of this._array) {
-            this._dict[this._idGetter(entry)] = entry;
-        }
-    }
-    count() {
-        return this._array.length;
-    }
-    toJSON() {
-        return this._array;
-    }
-    fromJSON(array) {
-        this.clear();
-        for (const entry of array) this.insert(entry);
-    }
-}

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

@@ -1,85 +0,0 @@
-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) {
-    const defaultKey = (file) => `${sessionKey}:${file}`;
-    const databaseConn = await cacheManager.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
-        );
-    };
-
-    const readData = async (file) => {
-        try {
-            const data = await databaseConn.get(defaultKey(file));
-            if (data) return JSON.parse(data, Utils_1.BufferJSON.reviver);
-            return null;
-        } catch (error) {
-            logger.error(error);
-            return null;
-        }
-    };
-
-    const removeData = async (file) => {
-        try {
-            return await databaseConn.del(defaultKey(file));
-        } catch {
-            logger.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 {}
-    };
-
-    const creds = (await readData("creds")) || Utils_1.initAuthCreds();
-
-    return {
-        clearState,
-        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;
-                        })
-                    );
-                    return data;
-                },
-                set: async (data) => {
-                    const tasks = [];
-                    for (const category in data) {
-                        for (const id in data[category]) {
-                            const value = data[category][id];
-                            const key = `${category}-${id}`;
-                            tasks.push(value ? writeData(key, value) : removeData(key));
-                        }
-                    }
-                    await Promise.all(tasks);
-                }
-            }
-        }
-    };
-}

package/lib/Store/make-in-memory-store.js

@@ -1,198 +0,0 @@
-import * as WAProto_1 from "../../WAProto/index.js";
-import * as Defaults_1 from "../Defaults/index.js";
-import { LabelAssociationType } from "../Types/LabelAssociation.js";
-import * as Utils_1 from "../Utils/index.js";
-import * as WABinary_1 from "../WABinary/index.js";
-import makeOrderedDictionary from "./make-ordered-dictionary.js";
-import { ObjectRepository } from "./object-repository.js";
-import KeyedDB from "./keyed-db.js";
-
-const waChatKey = (pin) => ({
-    key: (c) =>
-        (pin ? (c.pinned ? "1" : "0") : "") +
-        (c.archived ? "0" : "1") +
-        (c.conversationTimestamp
-            ? c.conversationTimestamp.toString(16).padStart(8, "0")
-            : "") +
-        c.id,
-    compare: (k1, k2) => k2.localeCompare(k1)
-});
-
-export const waMessageID = (m) => m.key.id || "";
-
-export const waLabelAssociationKey = {
-    key: (la) =>
-        la.type === LabelAssociationType.Chat
-            ? la.chatId + la.labelId
-            : la.chatId + la.messageId + la.labelId,
-    compare: (k1, k2) => k2.localeCompare(k1)
-};
-
-const makeMessagesDictionary = () => makeOrderedDictionary(waMessageID);
-
-export default function makeInMemoryStore(config) {
-    const socket = config.socket;
-    const chatKey = config.chatKey || waChatKey(true);
-    const labelAssociationKey = config.labelAssociationKey || waLabelAssociationKey;
-    const logger =
-        config.logger ||
-        Defaults_1.DEFAULT_CONNECTION_CONFIG.logger.child({
-            stream: "in-mem-store"
-        });
-
-    const chats = new KeyedDB(chatKey.compare, chatKey.key);
-    const messages = {};
-    const contacts = {};
-    const groupMetadata = {};
-    const presences = {};
-    const state = { connection: "close" };
-    const labels = new ObjectRepository();
-    const labelAssociations = new KeyedDB(labelAssociationKey.compare, labelAssociationKey.key);
-
-    const assertMessageList = (jid) => {
-        if (!messages[jid]) messages[jid] = makeMessagesDictionary();
-        return messages[jid];
-    };
-
-    const contactsUpsert = (newContacts) => {
-        const oldContacts = new Set(Object.keys(contacts));
-        for (const contact of newContacts) {
-            oldContacts.delete(contact.id);
-            contacts[contact.id] = { ...(contacts[contact.id] || {}), ...contact };
-        }
-        return oldContacts;
-    };
-
-    const labelsUpsert = (newLabels) => {
-        for (const label of newLabels) labels.upsertById(label.id, label);
-    };
-
-    const bind = (ev) => {
-        ev.on("connection.update", (update) => Object.assign(state, update));
-
-        ev.on("messaging-history.set", ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
-            if (syncType === WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND) return;
-            if (isLatest) {
-                chats.clear();
-                for (const id in messages) delete messages[id];
-            }
-            chats.insertIfAbsent(...newChats);
-            const oldContacts = contactsUpsert(newContacts);
-            if (isLatest) for (const jid of oldContacts) delete contacts[jid];
-            for (const msg of newMessages) {
-                const jid = msg.key.remoteJid;
-                const list = assertMessageList(jid);
-                list.upsert(msg, "prepend");
-            }
-        });
-
-        ev.on("contacts.upsert", contactsUpsert);
-
-        ev.on("contacts.update", async (updates) => {
-            for (const update of updates) {
-                const contact = contacts[update.id];
-                if (contact) Object.assign(contact, update);
-            }
-        });
-
-        ev.on("chats.upsert", (newChats) => chats.upsert(...newChats));
-
-        ev.on("chats.update", (updates) => {
-            for (let update of updates) {
-                chats.update(update.id, (chat) => Object.assign(chat, update));
-            }
-        });
-
-        ev.on("labels.edit", (label) => {
-            if (label.deleted) return labels.deleteById(label.id);
-            if (labels.count() < 20) labels.upsertById(label.id, label);
-        });
-
-        ev.on("labels.association", ({ type, association }) => {
-            if (type === "add") labelAssociations.upsert(association);
-            if (type === "remove") labelAssociations.delete(association);
-        });
-
-        ev.on("presence.update", ({ id, presences: update }) => {
-            presences[id] = presences[id] || {};
-            Object.assign(presences[id], update);
-        });
-
-        ev.on("chats.delete", (deletions) => {
-            for (const item of deletions) chats.deleteById(item);
-        });
-
-        ev.on("messages.upsert", ({ messages: newMessages, type }) => {
-            if (type !== "append" && type !== "notify") return;
-            for (const msg of newMessages) {
-                const jid = WABinary_1.jidNormalizedUser(msg.key.remoteJid);
-                const list = assertMessageList(jid);
-                list.upsert(msg, "append");
-                if (type === "notify" && !chats.get(jid))
-                    ev.emit("chats.upsert", [
-                        {
-                            id: jid,
-                            conversationTimestamp: Utils_1.toNumber(msg.messageTimestamp),
-                            unreadCount: 1
-                        }
-                    ]);
-            }
-        });
-
-        ev.on("messages.update", (updates) => {
-            for (const { update, key } of updates) {
-                const list = assertMessageList(WABinary_1.jidNormalizedUser(key.remoteJid));
-                list.updateAssign(key.id, update);
-            }
-        });
-
-        ev.on("messages.delete", (item) => {
-            if ("all" in item) messages[item.jid]?.clear();
-            else {
-                const jid = item.keys[0].remoteJid;
-                const list = messages[jid];
-                if (list) {
-                    const idSet = new Set(item.keys.map((k) => k.id));
-                    list.filter((m) => !idSet.has(m.key.id));
-                }
-            }
-        });
-    };
-
-    const toJSON = () => ({
-        chats,
-        contacts,
-        messages,
-        labels,
-        labelAssociations
-    });
-
-    const fromJSON = (json) => {
-        chats.upsert(...json.chats);
-        labelAssociations.upsert(...(json.labelAssociations || []));
-        contactsUpsert(Object.values(json.contacts));
-        labelsUpsert(Object.values(json.labels || {}));
-        for (const jid in json.messages) {
-            const list = assertMessageList(jid);
-            for (const msg of json.messages[jid])
-                list.upsert(WAProto_1.proto.WebMessageInfo.fromObject(msg), "append");
-        }
-    };
-    const loadMessage = async (jid, id) => {
-        return messages[jid]?.get(id)
-    }
-    return {
-        chats,
-        contacts,
-        messages,
-        groupMetadata,
-        state,
-        presences,
-        labels,
-        labelAssociations,
-        bind,
-        toJSON,
-        fromJSON,
-        loadMessage
-    };
-}

package/lib/Store/make-ordered-dictionary.js

@@ -1,75 +0,0 @@
-export default function makeOrderedDictionary(idGetter) {
-    const array = [];
-    const dict = {};
-
-    const get = (id) => dict[id];
-
-    const update = (item) => {
-        const id = idGetter(item);
-        const idx = array.findIndex(i => idGetter(i) === id);
-        if (idx >= 0) {
-            array[idx] = item;
-            dict[id] = item;
-        }
-        return false;
-    };
-
-    const upsert = (item, mode) => {
-        const id = idGetter(item);
-        if (get(id)) {
-            update(item);
-        } else {
-            if (mode === 'append') array.push(item);
-            else array.unshift(item);
-            dict[id] = item;
-        }
-    };
-
-    const remove = (item) => {
-        const id = idGetter(item);
-        const idx = array.findIndex(i => idGetter(i) === id);
-        if (idx >= 0) {
-            array.splice(idx, 1);
-            delete dict[id];
-            return true;
-        }
-        return false;
-    };
-
-    return {
-        array,
-        get,
-        upsert,
-        update,
-        remove,
-        updateAssign: (id, update) => {
-            const item = get(id);
-            if (item) {
-                Object.assign(item, update);
-                delete dict[id];
-                dict[idGetter(item)] = item;
-                return true;
-            }
-            return false;
-        },
-        clear: () => {
-            array.length = 0;
-            for (const key of Object.keys(dict)) delete dict[key];
-        },
-        filter: (contain) => {
-            let i = 0;
-            while (i < array.length) {
-                if (!contain(array[i])) {
-                    delete dict[idGetter(array[i])];
-                    array.splice(i, 1);
-                } else {
-                    i++;
-                }
-            }
-        },
-        toJSON: () => array,
-        fromJSON: (newItems) => {
-            array.splice(0, array.length, ...newItems);
-        }
-    };
-}