@pontalabs/baileys 1.0.10 → 1.1.0

package/lib/Signal/lid-mapping.js

@@ -1,184 +1,164 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const lru_cache_1 = require("lru-cache")
-const WABinary_1 = require("../WABinary")
-
-class LIDMappingStore {
-	constructor(keys, onWhatsAppFunc, logger) {
-		this.mappingCache = new lru_cache_1.LRUCache({
-            ttl: 7 * 24 * 60 * 60 * 1000, // 7 days
-            ttlAutopurge: true,
-            updateAgeOnGet: true
-        })
-		this.keys = keys
-		this.logger = logger
-		this.onWhatsAppFunc = onWhatsAppFunc // needed to get LID from PN if not found
-	}
-	/**
-     * Store LID-PN mapping - USER LEVEL
-     */
-    async storeLIDPNMappings(pairs) {
-        // Validate inputs
-        const pairMap = {}
-        const logger = this.logger
-        
-        for (const { lid, pn } of pairs) {
-            if (!((WABinary_1.isLidUser(lid) && WABinary_1.isJidUser(pn)) || (WABinary_1.isJidUser(lid) && WABinary_1.isLidUser(pn)))) {
-                logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`)
-                continue
-            }
-            
-            const [lidJid, pnJid] = WABinary_1.isLidUser(lid) ? [lid, pn] : [pn, lid]
-            const lidDecoded = WABinary_1.jidDecode(lidJid)
-            const pnDecoded = WABinary_1.jidDecode(pnJid)
-            
-            if (!lidDecoded || !pnDecoded) return
-            
-            const pnUser = pnDecoded.user
-            const lidUser = lidDecoded.user
-            
-            // Check if mapping already exists (cache first, then database)
-            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`)
-            
-            if (!existingLidUser) {
-                // Cache miss - check database
-                const stored = await this.keys.get('lid-mapping', [pnUser])
-                
-                existingLidUser = stored[pnUser]
-                
-                if (existingLidUser) {
-                    // Update cache with database value
-                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser)
-                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser)
-                }
-            }
-            
-            if (existingLidUser === lidUser) {
-                logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping')
-                continue
-            }
-            
-            pairMap[pnUser] = lidUser
-        }
-        
-        logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`)
-        
-        await this.keys.transaction(async () => {
-            for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-                await this.keys.set({
-                    'lid-mapping': {
-                        [pnUser]: lidUser, // "554396160286" -> "102765716062358"
-                        [`${lidUser}_reverse`]: pnUser // "102765716062358_reverse" -> "554396160286"
-                    }
-                })
-                
-                // Update cache with both directions
-                this.mappingCache.set(`pn:${pnUser}`, lidUser)
-                this.mappingCache.set(`lid:${lidUser}`, pnUser)
-            }
-        }, 'lid-mapping')
-    }
-    /**
-     * Get LID for PN - Returns device-specific LID based on user mapping
-     */
-    async getLIDForPN(pn) {
-        if (!WABinary_1.isJidUser(pn)) return null
-        
-        const logger = this.logger
-        const decoded = WABinary_1.jidDecode(pn)
-        
-        if (!decoded) return null
-        
-        // Check cache first for PN → LID mapping
-        const pnUser = decoded.user
-        
-        let lidUser = this.mappingCache.get(`pn:${pnUser}`)
-        
-        if (!lidUser) {
-            // Cache miss - check database
-            const stored = await this.keys.get('lid-mapping', [pnUser])
-            
-            lidUser = stored[pnUser]
-            
-            if (lidUser) {
-                // Cache the database result
-                this.mappingCache.set(`pn:${pnUser}`, lidUser)
-            }
-            
-            else {
-                // Not in database - try USync
-                logger.trace(`No LID mapping found for PN user ${pnUser}; getting from USync`)
-                
-                const { exists, lid } = (await this.onWhatsAppFunc?.(pn))?.[0] // this function already adds LIDs to mapping
-                
-                if (exists && lid) {
-                    lidUser = WABinary_1.jidDecode(lid)?.user
-                    
-                    if (lidUser) {
-                        // Cache the USync result
-                        this.mappingCache.set(`pn:${pnUser}`, lidUser)
-                    }
-                }
-                
-                else {
-                    return null
-                }
-            }
-        }
-        
-        if (typeof lidUser !== 'string' || !lidUser) {
-            logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`)
-            return null
-        }
-        
-        // Push the PN device ID to the LID to maintain device separation
-        const pnDevice = decoded.device !== undefined ? decoded.device : 0
-        const deviceSpecificLid = `${lidUser}:${pnDevice}@lid`
-        
-        logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`)
-        
-        return deviceSpecificLid
-    }
-    /**
-     * Get PN for LID - USER LEVEL with device construction
-     */
-     async getPNForLID(lid) {
-        if (!WABinary_1.isLidUser(lid)) return null
-        
-        const logger = this.logger
-        const decoded = WABinary_1.jidDecode(lid)
-        
-        if (!decoded) return null
-        
-        // Check cache first for LID → PN mapping
-        const lidUser = decoded.user
-        
-        let pnUser = this.mappingCache.get(`lid:${lidUser}`)
-        
-        if (!pnUser || typeof pnUser !== 'string') {
-            // Cache miss - check database
-            const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`]);
-            pnUser = stored[`${lidUser}_reverse`]
-            
-            if (!pnUser || typeof pnUser !== 'string') {
-                logger.trace(`No reverse mapping found for LID user: ${lidUser}`)
-                return null
-            }
-            
-            this.mappingCache.set(`lid:${lidUser}`, pnUser)
-        }
-        
-        // Construct device-specific PN JID
-        const lidDevice = decoded.device !== undefined ? decoded.device : 0
-        const pnJid = `${pnUser}:${lidDevice}@s.whatsapp.net`
-        logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`)
-        
-        return pnJid
-    }
-}
-
-module.exports = {
-  LIDMappingStore
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { LRUCache: LRUCache } = require("lru-cache");
+const {
+    isHostedPnUser: isHostedPnUser,
+    isLidUser: isLidUser,
+    isPnUser: isPnUser,
+    jidDecode: jidDecode,
+    jidNormalizedUser: jidNormalizedUser,
+    WAJIDDomains: WAJIDDomains,
+} = require("../WABinary");
+class LIDMappingStore {
+    constructor(keys, logger, pnToLIDFunc) {
+        this.mappingCache = new LRUCache({
+            ttl: 3 * 24 * 60 * 60 * 1e3,
+            ttlAutopurge: true,
+            updateAgeOnGet: true,
+        });
+        this.keys = keys;
+        this.pnToLIDFunc = pnToLIDFunc;
+        this.logger = logger;
+    }
+    async storeLIDPNMappings(pairs) {
+        const pairMap = {};
+        for (const { lid: lid, pn: 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) return;
+            const pnUser = pnDecoded.user;
+            const lidUser = lidDecoded.user;
+            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+            if (!existingLidUser) {
+                this.logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
+                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                existingLidUser = stored[pnUser];
+                if (existingLidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                }
+            }
+            if (existingLidUser === lidUser) {
+                this.logger.debug(
+                    { pnUser: pnUser, lidUser: lidUser },
+                    "LID mapping already exists, skipping"
+                );
+                continue;
+            }
+            pairMap[pnUser] = lidUser;
+        }
+        this.logger.trace(
+            { pairMap: pairMap },
+            `Storing ${Object.keys(pairMap).length} pn mappings`
+        );
+        await this.keys.transaction(async () => {
+            for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+                await this.keys.set({
+                    "lid-mapping": { [pnUser]: lidUser, [`${lidUser}_reverse`]: pnUser },
+                });
+                this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                this.mappingCache.set(`lid:${lidUser}`, pnUser);
+            }
+        }, "lid-mapping");
+    }
+    async getLIDForPN(pn) {
+        return (await this.getLIDsForPNs([pn]))?.[0]?.lid || null;
+    }
+    async getLIDsForPNs(pns) {
+        const usyncFetch = {};
+        const successfulPairs = {};
+        for (const pn of pns) {
+            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) {
+                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                lidUser = stored[pnUser];
+                if (lidUser) {
+                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
+                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                } 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);
+                    }
+                    continue;
+                }
+            }
+            lidUser = lidUser.toString();
+            if (!lidUser) {
+                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+                return null;
+            }
+            const pnDevice = decoded.device !== undefined ? decoded.device : 0;
+            const deviceSpecificLid = `${lidUser}${!!pnDevice ? `:${pnDevice}` : ``}@${decoded.server === "hosted" ? "hosted.lid" : "lid"}`;
+            this.logger.trace(
+                `getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`
+            );
+            successfulPairs[pn] = { lid: deviceSpecificLid, pn: pn };
+        }
+        if (Object.keys(usyncFetch).length > 0) {
+            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+            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;
+            }
+        }
+        return Object.values(successfulPairs);
+    }
+    async getPNForLID(lid) {
+        if (!isLidUser(lid)) return null;
+        const decoded = jidDecode(lid);
+        if (!decoded) return null;
+        const lidUser = decoded.user;
+        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+        if (!pnUser || typeof pnUser !== "string") {
+            const stored = await this.keys.get("lid-mapping", [`${lidUser}_reverse`]);
+            pnUser = stored[`${lidUser}_reverse`];
+            if (!pnUser || typeof pnUser !== "string") {
+                this.logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
+                return null;
+            }
+            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+        }
+        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}`);
+        return pnJid;
+    }
+}
+module.exports = { LIDMappingStore: LIDMappingStore };

package/lib/Socket/Client/index.js

@@ -1,22 +1,31 @@
-"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("./types"), exports)
-__exportStar(require("./websocket"), exports)
+"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("./types"), exports);
+__exportStar(require("./websocket"), exports);

package/lib/Socket/Client/types.js

@@ -1,18 +1,12 @@
-"use strict"
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const events_1 = require("events")
-
-class AbstractSocketClient extends events_1.EventEmitter {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { EventEmitter: EventEmitter } = require("events");
+class AbstractSocketClient extends EventEmitter {
     constructor(url, config) {
-        super()
-        this.url = url
-        this.config = config
-        this.setMaxListeners(0)
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
     }
 }
-
-module.exports = {
-  AbstractSocketClient
-}
+module.exports = { AbstractSocketClient: AbstractSocketClient };

package/lib/Socket/Client/websocket.js

@@ -1,62 +1,67 @@
-"use strict"
-
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod }
-}
-
-Object.defineProperty(exports, "__esModule", { value: true })
-
-const ws_1 = __importDefault(require("ws"))
-const Defaults_1 = require("../../Defaults")
-const types_1 = require("./types")
-
-class WebSocketClient extends types_1.AbstractSocketClient {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const {
+    OPEN: OPEN,
+    CLOSED: CLOSED,
+    CLOSING: CLOSING,
+    CONNECTING: CONNECTING,
+    WebSocket: WebSocket,
+} = require("ws");
+const { DEFAULT_ORIGIN: DEFAULT_ORIGIN } = require("../../Defaults/constants");
+const { AbstractSocketClient: AbstractSocketClient } = require("./types");
+class WebSocketClient extends AbstractSocketClient {
     constructor() {
-        super(...arguments)
-        this.socket = null
+        super(...arguments);
+        this.socket = null;
     }
     get isOpen() {
-        return this.socket?.readyState === ws_1.default.OPEN
+        return this.socket?.readyState === OPEN;
     }
     get isClosed() {
-        return this.socket?.readyState === ws_1.default.CLOSED
+        return this.socket?.readyState === CLOSED;
     }
     get isClosing() {
-        this.socket?.readyState === ws_1.default.CLOSING
+        this.socket?.readyState === CLOSING;
     }
     get isConnecting() {
-        this.socket?.readyState === ws_1.default.CONNECTING
+        this.socket?.readyState === CONNECTING;
     }
-    async connect() {
+    connect() {
         if (this.socket) {
-            return
+            return;
         }
-        this.socket = new ws_1.default(this.url, {
-            origin: Defaults_1.DEFAULT_ORIGIN,
+        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']
+        });
+        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))
+            this.socket?.on(event, (...args) => this.emit(event, ...args));
         }
     }
-    async close() {
+    close() {
         if (!this.socket) {
-            return
+            return;
         }
-        this.socket.close()
-        this.socket = null
+        this.socket.close();
+        this.socket = null;
     }
     send(str, cb) {
-        this.socket?.send(str, cb)
-        return Boolean(this.socket)
+        this.socket?.send(str, cb);
+        return Boolean(this.socket);
     }
 }
-
-module.exports = {
-  WebSocketClient
-}
+module.exports = { WebSocketClient: WebSocketClient };