@alannxd/baileys 6.0.5 → 6.0.6

package/lib/Signal/lid-mapping.d.ts

@@ -1,23 +0,0 @@
-import type { LIDMapping, SignalKeyStoreWithTransaction } from '../Types/index.js';
-import type { ILogger } from '../Utils/logger.js';
-export declare class LIDMappingStore {
-    private readonly mappingCache;
-    private readonly keys;
-    private readonly logger;
-    private pnToLIDFunc?;
-    private readonly inflightLIDLookups;
-    private readonly inflightPNLookups;
-    constructor(keys: SignalKeyStoreWithTransaction, logger: ILogger, pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>);
-    storeLIDPNMappings(pairs: LIDMapping[]): Promise<void>;
-    getLIDForPN(pn: string): Promise<string | null>;
-    getLIDsForPNs(pns: string[]): Promise<LIDMapping[] | null>;
-    private _getLIDsForPNsImpl;
-    getPNForLID(lid: string): Promise<string | null>;
-    getPNsForLIDs(lids: string[]): Promise<LIDMapping[] | null>;
-    private _getPNsForLIDsImpl;
-    /**
-     * Close the cache and release resources
-     */
-    close(): void;
-}
-//# sourceMappingURL=lid-mapping.d.ts.map

package/lib/Signal/lid-mapping.js

@@ -1,277 +0,0 @@
-import { LRUCache } from 'lru-cache';
-import { isHostedPnUser, isLidUser, isPnUser, jidDecode, jidNormalizedUser, WAJIDDomains } from '../WABinary/index.js';
-export class LIDMappingStore {
-    constructor(keys, logger, pnToLIDFunc) {
-        this.mappingCache = new LRUCache({
-            ttl: 3 * 24 * 60 * 60 * 1000, // 7 days
-            ttlAutopurge: true,
-            updateAgeOnGet: true
-        });
-        this.inflightLIDLookups = new Map();
-        this.inflightPNLookups = new Map();
-        this.keys = keys;
-        this.pnToLIDFunc = pnToLIDFunc;
-        this.logger = logger;
-    }
-    async storeLIDPNMappings(pairs) {
-        if (pairs.length === 0)
-            return;
-        const validatedPairs = [];
-        for (const { lid, pn } of pairs) {
-            if (!((isLidUser(lid) && isPnUser(pn)) || (isPnUser(lid) && isLidUser(pn)))) {
-                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
-                continue;
-            }
-            const lidDecoded = jidDecode(lid);
-            const pnDecoded = jidDecode(pn);
-            if (!lidDecoded || !pnDecoded)
-                continue;
-            validatedPairs.push({ pnUser: pnDecoded.user, lidUser: lidDecoded.user });
-        }
-        if (validatedPairs.length === 0)
-            return;
-        const cacheMissSet = new Set();
-        const existingMappings = new Map();
-        for (const { pnUser } of validatedPairs) {
-            const cached = this.mappingCache.get(`pn:${pnUser}`);
-            if (cached) {
-                existingMappings.set(pnUser, cached);
-            }
-            else {
-                cacheMissSet.add(pnUser);
-            }
-        }
-        if (cacheMissSet.size > 0) {
-            const cacheMisses = [...cacheMissSet];
-            this.logger.trace(`Batch fetching ${cacheMisses.length} LID mappings from database`);
-            const stored = await this.keys.get('lid-mapping', cacheMisses);
-            for (const pnUser of cacheMisses) {
-                const existingLidUser = stored[pnUser];
-                if (existingLidUser) {
-                    existingMappings.set(pnUser, existingLidUser);
-                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
-                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
-                }
-            }
-        }
-        const pairMap = {};
-        for (const { pnUser, lidUser } of validatedPairs) {
-            const existingLidUser = existingMappings.get(pnUser);
-            if (existingLidUser === lidUser) {
-                this.logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping');
-                continue;
-            }
-            pairMap[pnUser] = lidUser;
-        }
-        if (Object.keys(pairMap).length === 0)
-            return;
-        this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
-        const batchData = {};
-        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-            batchData[pnUser] = lidUser;
-            batchData[`${lidUser}_reverse`] = pnUser;
-        }
-        await this.keys.transaction(async () => {
-            await this.keys.set({ 'lid-mapping': batchData });
-        }, 'lid-mapping');
-        // Update cache after successful DB write
-        for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-            this.mappingCache.set(`pn:${pnUser}`, lidUser);
-            this.mappingCache.set(`lid:${lidUser}`, pnUser);
-        }
-    }
-    async getLIDForPN(pn) {
-        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
-    }
-    async getLIDsForPNs(pns) {
-        if (pns.length === 0)
-            return null;
-        const sortedPns = [...new Set(pns)].sort();
-        const cacheKey = sortedPns.join(',');
-        const inflight = this.inflightLIDLookups.get(cacheKey);
-        if (inflight) {
-            this.logger.trace(`Coalescing getLIDsForPNs request for ${sortedPns.length} PNs`);
-            return inflight;
-        }
-        const promise = this._getLIDsForPNsImpl(pns);
-        this.inflightLIDLookups.set(cacheKey, promise);
-        try {
-            return await promise;
-        }
-        finally {
-            this.inflightLIDLookups.delete(cacheKey);
-        }
-    }
-    async _getLIDsForPNsImpl(pns) {
-        const usyncFetch = {};
-        const successfulPairs = {};
-        const pending = [];
-        const addResolvedPair = (pn, decoded, lidUser) => {
-            const normalizedLidUser = lidUser.toString();
-            if (!normalizedLidUser) {
-                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
-                return false;
-            }
-            // Push the PN device ID to the LID to maintain device separation
-            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
-            const deviceSpecificLid = `${normalizedLidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === 'hosted' ? 'hosted.lid' : 'lid'}`;
-            this.logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
-            successfulPairs[pn] = { lid: deviceSpecificLid, pn };
-            return true;
-        };
-        for (const pn of pns) {
-            if (!isPnUser(pn) && !isHostedPnUser(pn))
-                continue;
-            const decoded = jidDecode(pn);
-            if (!decoded)
-                continue;
-            const pnUser = decoded.user;
-            const cached = this.mappingCache.get(`pn:${pnUser}`);
-            if (cached && typeof cached === 'string') {
-                if (!addResolvedPair(pn, decoded, cached)) {
-                    this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
-                    continue;
-                }
-                continue;
-            }
-            pending.push({ pn, pnUser, decoded });
-        }
-        if (pending.length) {
-            const pnUsers = [...new Set(pending.map(item => item.pnUser))];
-            const stored = await this.keys.get('lid-mapping', pnUsers);
-            for (const pnUser of pnUsers) {
-                const lidUser = stored[pnUser];
-                if (lidUser && typeof lidUser === 'string') {
-                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
-                }
-            }
-            for (const { pn, pnUser, decoded } of pending) {
-                const cached = this.mappingCache.get(`pn:${pnUser}`);
-                if (cached && typeof cached === 'string') {
-                    if (!addResolvedPair(pn, decoded, cached)) {
-                        this.logger.warn(`Invalid entry for ${pn} (pair not resolved)`);
-                        continue;
-                    }
-                }
-                else {
-                    this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
-                    const device = decoded.device || 0;
-                    let normalizedPn = jidNormalizedUser(pn);
-                    if (isHostedPnUser(normalizedPn)) {
-                        normalizedPn = `${pnUser}@s.whatsapp.net`;
-                    }
-                    if (!usyncFetch[normalizedPn]) {
-                        usyncFetch[normalizedPn] = [device];
-                    }
-                    else {
-                        usyncFetch[normalizedPn]?.push(device);
-                    }
-                }
-            }
-        }
-        if (Object.keys(usyncFetch).length > 0) {
-            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch)); // this function already adds LIDs to mapping
-            if (result && result.length > 0) {
-                await this.storeLIDPNMappings(result);
-                for (const pair of result) {
-                    const pnDecoded = jidDecode(pair.pn);
-                    const pnUser = pnDecoded?.user;
-                    if (!pnUser)
-                        continue;
-                    const lidUser = jidDecode(pair.lid)?.user;
-                    if (!lidUser)
-                        continue;
-                    for (const device of usyncFetch[pair.pn]) {
-                        const deviceSpecificLid = `${lidUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted.lid' : 'lid'}`;
-                        this.logger.trace(`getLIDForPN: USYNC success for ${pair.pn} → ${deviceSpecificLid} (user mapping with device ${device})`);
-                        const deviceSpecificPn = `${pnUser}${!!device ? `:${device}` : ``}@${device === 99 ? 'hosted' : 's.whatsapp.net'}`;
-                        successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
-                    }
-                }
-            }
-            else {
-                this.logger.warn('USync fetch yielded no results for pending PNs');
-            }
-        }
-        return Object.values(successfulPairs).length > 0 ? Object.values(successfulPairs) : null;
-    }
-    async getPNForLID(lid) {
-        return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null;
-    }
-    async getPNsForLIDs(lids) {
-        if (lids.length === 0)
-            return null;
-        const sortedLids = [...new Set(lids)].sort();
-        const cacheKey = sortedLids.join(',');
-        const inflight = this.inflightPNLookups.get(cacheKey);
-        if (inflight) {
-            this.logger.trace(`Coalescing getPNsForLIDs request for ${sortedLids.length} LIDs`);
-            return inflight;
-        }
-        const promise = this._getPNsForLIDsImpl(lids);
-        this.inflightPNLookups.set(cacheKey, promise);
-        try {
-            return await promise;
-        }
-        finally {
-            this.inflightPNLookups.delete(cacheKey);
-        }
-    }
-    async _getPNsForLIDsImpl(lids) {
-        const successfulPairs = {};
-        const pending = [];
-        const addResolvedPair = (lid, decoded, pnUser) => {
-            if (!pnUser || typeof pnUser !== 'string') {
-                return false;
-            }
-            const lidDevice = decoded.device !== undefined ? decoded.device : 0;
-            const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WAJIDDomains.HOSTED_LID ? 'hosted' : 's.whatsapp.net'}`;
-            this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
-            successfulPairs[lid] = { lid, pn: pnJid };
-            return true;
-        };
-        for (const lid of lids) {
-            if (!isLidUser(lid))
-                continue;
-            const decoded = jidDecode(lid);
-            if (!decoded)
-                continue;
-            const lidUser = decoded.user;
-            const cached = this.mappingCache.get(`lid:${lidUser}`);
-            if (cached && typeof cached === 'string') {
-                addResolvedPair(lid, decoded, cached);
-                continue;
-            }
-            pending.push({ lid, lidUser, decoded });
-        }
-        if (pending.length) {
-            const reverseKeys = [...new Set(pending.map(item => `${item.lidUser}_reverse`))];
-            const stored = await this.keys.get('lid-mapping', reverseKeys);
-            for (const { lid, lidUser, decoded } of pending) {
-                let pnUser = this.mappingCache.get(`lid:${lidUser}`);
-                if (!pnUser || typeof pnUser !== 'string') {
-                    pnUser = stored[`${lidUser}_reverse`];
-                    if (pnUser && typeof pnUser === 'string') {
-                        this.mappingCache.set(`lid:${lidUser}`, pnUser);
-                        this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                    }
-                }
-                if (pnUser && typeof pnUser === 'string') {
-                    addResolvedPair(lid, decoded, pnUser);
-                }
-                else {
-                    this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
-                }
-            }
-        }
-        return Object.values(successfulPairs).length ? Object.values(successfulPairs) : null;
-    }
-    /**
-     * Close the cache and release resources
-     */
-    close() {
-        this.mappingCache.clear();
-    }
-}
-//# sourceMappingURL=lid-mapping.js.map

package/lib/Socket/Client/types.js

@@ -1,11 +0,0 @@
-import { EventEmitter } from 'events';
-import { URL } from 'url';
-export class AbstractSocketClient extends EventEmitter {
-    constructor(url, config) {
-        super();
-        this.url = url;
-        this.config = config;
-        this.setMaxListeners(0);
-    }
-}
-//# sourceMappingURL=types.js.map

package/lib/Socket/Client/websocket.js

@@ -1,54 +0,0 @@
-import WebSocket from 'ws';
-import { DEFAULT_ORIGIN } from '../../Defaults/index.js';
-import { AbstractSocketClient } from './types.js';
-export class WebSocketClient extends AbstractSocketClient {
-    constructor() {
-        super(...arguments);
-        this.socket = null;
-    }
-    get isOpen() {
-        return this.socket?.readyState === WebSocket.OPEN;
-    }
-    get isClosed() {
-        return this.socket === null || this.socket?.readyState === WebSocket.CLOSED;
-    }
-    get isClosing() {
-        return this.socket === null || this.socket?.readyState === WebSocket.CLOSING;
-    }
-    get isConnecting() {
-        return this.socket?.readyState === WebSocket.CONNECTING;
-    }
-    connect() {
-        if (this.socket) {
-            return;
-        }
-        this.socket = new WebSocket(this.url, {
-            origin: DEFAULT_ORIGIN,
-            headers: this.config.options?.headers,
-            handshakeTimeout: this.config.connectTimeoutMs,
-            timeout: this.config.connectTimeoutMs,
-            agent: this.config.agent
-        });
-        this.socket.setMaxListeners(0);
-        const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
-        for (const event of events) {
-            this.socket?.on(event, (...args) => this.emit(event, ...args));
-        }
-    }
-    async close() {
-        if (!this.socket) {
-            return;
-        }
-        const closePromise = new Promise(resolve => {
-            this.socket?.once('close', resolve);
-        });
-        this.socket.close();
-        await closePromise;
-        this.socket = null;
-    }
-    send(str, cb) {
-        this.socket?.send(str, cb);
-        return Boolean(this.socket);
-    }
-}
-//# sourceMappingURL=websocket.js.map

package/lib/Socket/mex.d.ts

@@ -1,3 +0,0 @@
-import type { BinaryNode } from '../WABinary/index.js';
-export declare const executeWMexQuery: <T>(variables: Record<string, unknown>, queryId: string, dataPath: string, query: (node: BinaryNode) => Promise<BinaryNode>, generateMessageTag: () => string) => Promise<T>;
-//# sourceMappingURL=mex.d.ts.map

package/lib/Socket/mex.js

@@ -1,42 +0,0 @@
-import { Boom } from '@hapi/boom';
-import { getBinaryNodeChild, S_WHATSAPP_NET } from '../WABinary/index.js';
-const wMexQuery = (variables, queryId, query, generateMessageTag) => {
-    return query({
-        tag: 'iq',
-        attrs: {
-            id: generateMessageTag(),
-            type: 'get',
-            to: S_WHATSAPP_NET,
-            xmlns: 'w:mex'
-        },
-        content: [
-            {
-                tag: 'query',
-                attrs: { query_id: queryId },
-                content: Buffer.from(JSON.stringify({ variables }), 'utf-8')
-            }
-        ]
-    });
-};
-export const executeWMexQuery = async (variables, queryId, dataPath, query, generateMessageTag) => {
-    const result = await wMexQuery(variables, queryId, query, generateMessageTag);
-    const child = getBinaryNodeChild(result, 'result');
-    if (child?.content) {
-        const data = JSON.parse(child.content.toString());
-        if (data.errors && data.errors.length > 0) {
-            const errorMessages = data.errors.map((err) => err.message || 'Unknown error').join(', ');
-            const firstError = data.errors[0];
-            const errorCode = firstError.extensions?.error_code || 400;
-            throw new Boom(`GraphQL server error: ${errorMessages}`, { statusCode: errorCode, data: firstError });
-        }
-        const response = dataPath ? data?.data?.[dataPath] : data?.data;
-        if (typeof response !== 'undefined') {
-            return response;
-        }
-    }
-    const action = (dataPath || '').startsWith('xwa2_')
-        ? dataPath.substring(5).replace(/_/g, ' ')
-        : dataPath?.replace(/_/g, ' ');
-    throw new Boom(`Failed to ${action}, unexpected response structure.`, { statusCode: 400, data: result });
-};
-//# sourceMappingURL=mex.js.map

package/lib/Store/keyed-db.d.ts

@@ -1,22 +0,0 @@
-declare class KeyedDB<T> {
-  private _compare: (a: string, b: string) => number;
-  private _idGetter: (item: T) => string;
-  private _array: T[];
-  private _dict: { [id: string]: T };
-  constructor(compareFn: (a: string, b: string) => number, idGetter: (item: T) => string);
-  get length(): number;
-  get(id: string): T | undefined;
-  insert(entry: T, mode?: 'insert'): boolean;
-  insertIfAbsent(...entries: T[]): T[];
-  upsert(...entries: T[]): T[];
-  update(id: string, updater: (item: T) => void): boolean;
-  updateAssign(id: string, update: Partial<T>): boolean;
-  deleteById(id: string): boolean;
-  clear(): void;
-  all(): T[];
-  filter(predicate: (item: T) => boolean): void;
-  count(): number;
-  toJSON(): T[];
-  fromJSON(array: T[]): void;
-}
-export default KeyedDB;

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/Types/Bussines.d.ts

@@ -1,25 +0,0 @@
-import type { proto } from '../../WAProto';
-export type DayOfWeekBussines = 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
-export type HoursDay = {
-    day: DayOfWeekBussines;
-    mode: 'specific_hours';
-    openTimeInMinutes: string;
-    closeTimeInMinutes: string;
-} | {
-    day: DayOfWeekBussines;
-    mode: 'open_24h' | 'appointment_only';
-};
-export type UpdateBussinesProfileProps = {
-    address?: string;
-    websites?: string[];
-    email?: string;
-    description?: string;
-    hours?: {
-        timezone: string;
-        days: HoursDay[];
-    };
-};
-export type QuickReplyAction = proto.SyncActionValue.IQuickReplyAction & {
-    timestamp?: string;
-};
-//# sourceMappingURL=Bussines.d.ts.map

package/lib/Types/Bussines.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Bussines.js.map