violetics 7.0.0-alpha → 7.0.2-alpha

package/lib/Signal/lid-mapping.js

@@ -1,185 +1,270 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIDMappingStore = void 0;
-const lru_cache_1 = require("lru-cache");
-const jid_utils_1 = require("../WABinary/jid-utils");
-
-class LIDMappingStore {
+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 lru_cache_1.LRUCache({
-            ttl: 3 * 24 * 60 * 60 * 1000,
+        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.logger = logger;
         this.pnToLIDFunc = pnToLIDFunc;
+        this.logger = logger;
     }
-
     async storeLIDPNMappings(pairs) {
-        const pairMap = {};
+        if (pairs.length === 0)
+            return;
+        const validatedPairs = [];
         for (const { lid, pn } of pairs) {
-            if (!lid || !pn) continue;
-            const lidDecoded = (0, jid_utils_1.jidDecode)(lid);
-            const pnDecoded = (0, jid_utils_1.jidDecode)(pn);
-            if (!lidDecoded || !pnDecoded) continue;
-            const pnUser = pnDecoded.user;
-            const lidUser = lidDecoded.user;
-            if (!pnUser || !lidUser || typeof pnUser !== 'string' || typeof lidUser !== 'string') continue;
-            const existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
-            if (existingLidUser === lidUser) continue;
-            pairMap[pnUser] = lidUser;
+            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 (Object.keys(pairMap).length === 0) return;
-        try {
-            await this.keys.transaction(async () => {
-                for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-                    await this.keys.set({
-                        'lid-mapping': {
-                            [`pn:${pnUser}`]: lidUser,
-                            [`lid:${lidUser}`]: pnUser
-                        }
-                    });
-                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        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);
                 }
-            }, 'lid-mapping');
-        } catch (e) {
-            if (this.logger) this.logger.warn({ e }, 'failed to store LID-PN mappings');
+            }
+        }
+        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) {
-        if (!pn) return null;
-        if (this.inflightPNLookups.has(pn)) {
-            return this.inflightPNLookups.get(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.getLIDsForPNs([pn]).then(r => r?.[0]?.lid || null);
-        this.inflightPNLookups.set(pn, promise);
+        const promise = this._getLIDsForPNsImpl(pns);
+        this.inflightLIDLookups.set(cacheKey, promise);
         try {
             return await promise;
-        } finally {
-            this.inflightPNLookups.delete(pn);
+        }
+        finally {
+            this.inflightLIDLookups.delete(cacheKey);
         }
     }
-
-    async getLIDsForPNs(pns) {
+    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 (!pn) continue;
-            const decoded = (0, jid_utils_1.jidDecode)(pn);
-            if (!decoded?.user) continue;
+            if (!isPnUser(pn) && !isHostedPnUser(pn))
+                continue;
+            const decoded = jidDecode(pn);
+            if (!decoded)
+                continue;
             const pnUser = decoded.user;
-            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
-            if (!lidUser) {
-                try {
-                    const stored = await this.keys.get('lid-mapping', [`pn:${pnUser}`]);
-                    lidUser = stored[`pn:${pnUser}`];
-                    if (lidUser) {
-                        this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                        this.mappingCache.set(`lid:${lidUser}`, pnUser);
-                    } else {
-                        const device = decoded.device || 0;
-                        const normalizedPn = `${pnUser}@s.whatsapp.net`;
-                        if (!usyncFetch[normalizedPn]) {
-                            usyncFetch[normalizedPn] = [device];
-                        } else {
-                            usyncFetch[normalizedPn].push(device);
-                        }
+            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;
                     }
-                } catch (e) { 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 (typeof lidUser !== 'string' || !lidUser) continue;
-            const pnDevice = decoded.device || 0;
-            const deviceSpecificLid = `${lidUser}${pnDevice ? `:${pnDevice}` : ''}@lid`;
-            successfulPairs[pn] = { lid: deviceSpecificLid, pn };
         }
         if (Object.keys(usyncFetch).length > 0) {
-            try {
-                const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
-                if (result && result.length > 0) {
-                    await this.storeLIDPNMappings(result);
-                    for (const pair of result) {
-                        const pnDecoded = (0, jid_utils_1.jidDecode)(pair.pn);
-                        const pnUser = pnDecoded?.user;
-                        if (!pnUser) continue;
-                        const lidUser = (0, jid_utils_1.jidDecode)(pair.lid)?.user;
-                        if (!lidUser) continue;
-                        for (const device of (usyncFetch[pair.pn] || [])) {
-                            const deviceSpecificLid = `${lidUser}${device ? `:${device}` : ''}@lid`;
-                            const deviceSpecificPn = `${pnUser}${device ? `:${device}` : ''}@s.whatsapp.net`;
-                            successfulPairs[deviceSpecificPn] = { lid: deviceSpecificLid, pn: deviceSpecificPn };
-                        }
+            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 {
-                    return null;
                 }
-            } catch (e) {
-                return null;
+            }
+            else {
+                this.logger.warn('USync fetch yielded no results for pending PNs');
             }
         }
-        return Object.values(successfulPairs);
+        return Object.values(successfulPairs).length > 0 ? Object.values(successfulPairs) : null;
+    }
+    async getPNForLID(lid) {
+        return (await this.getPNsForLIDs([lid]))?.[0]?.pn || null;
     }
-
     async getPNsForLIDs(lids) {
-        const result = [];
-        const missingLids = [];
+        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 (!lid) continue;
-            const decoded = (0, jid_utils_1.jidDecode)(lid);
-            if (!decoded?.user) continue;
+            if (!isLidUser(lid))
+                continue;
+            const decoded = jidDecode(lid);
+            if (!decoded)
+                continue;
             const lidUser = decoded.user;
-            const pnUser = this.mappingCache.get(`lid:${lidUser}`);
-            if (!pnUser || typeof pnUser !== 'string') {
-                missingLids.push(lidUser);
-            } else {
-                const lidDevice = decoded.device || 0;
-                const pnJid = `${pnUser}${lidDevice ? `:${lidDevice}` : ''}@s.whatsapp.net`;
-                result.push({ lid, pn: pnJid });
+            const cached = this.mappingCache.get(`lid:${lidUser}`);
+            if (cached && typeof cached === 'string') {
+                addResolvedPair(lid, decoded, cached);
+                continue;
             }
+            pending.push({ lid, lidUser, decoded });
         }
-        if (missingLids.length > 0) {
-            try {
-                const dbKeys = missingLids.map(l => `lid:${l}`);
-                const stored = await this.keys.get('lid-mapping', dbKeys);
-                for (const lidUser of missingLids) {
-                    const pnUser = stored[`lid:${lidUser}`];
+        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);
-                        for (const lid of lids) {
-                            if (lid.startsWith(lidUser)) {
-                                const decoded = (0, jid_utils_1.jidDecode)(lid);
-                                if (decoded) {
-                                    const lidDevice = decoded.device || 0;
-                                    const pnJid = `${pnUser}${lidDevice ? `:${lidDevice}` : ''}@s.whatsapp.net`;
-                                    result.push({ lid, pn: pnJid });
-                                }
-                            }
-                        }
+                        this.mappingCache.set(`pn:${pnUser}`, lidUser);
                     }
                 }
-            } catch (e) {}
-        }
-        return result;
-    }
-
-    async getPNForLID(lid) {
-        if (!lid) return null;
-        if (this.inflightLIDLookups.has(lid)) {
-            return this.inflightLIDLookups.get(lid);
-        }
-        const promise = this.getPNsForLIDs([lid]).then(r => r?.[0]?.pn || null);
-        this.inflightLIDLookups.set(lid, promise);
-        try {
-            return await promise;
-        } finally {
-            this.inflightLIDLookups.delete(lid);
+                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;
     }
-}
-
-exports.LIDMappingStore = LIDMappingStore;
+}

package/lib/Socket/Client/index.js

@@ -1,19 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./abstract-socket-client"), exports);
-__exportStar(require("./mobile-socket-client"), exports);
-__exportStar(require("./web-socket-client"), exports);
+export * from './types.js';
+export * from './websocket.js';

package/lib/Socket/Client/types.js

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

package/lib/Socket/Client/websocket.js

@@ -0,0 +1,53 @@
+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);
+    }
+}