@ellxz24/baileys 2.0.29 → 2.0.30

package/lib/Signal/lid-mapping.js

@@ -5,6 +5,10 @@ exports.makeLIDMappingStore = void 0;
 const WABinary_1 = require("../WABinary");
 const lru_cache_1 = require("lru-cache");
 
+const isHostedPnUser = (jid) => {
+    const decoded = (0, WABinary_1.jidDecode)(jid);
+    return decoded ? decoded.server === 'hosted' : false;
+};
 const makeLIDMappingStore = (keys, logger, pnToLIDFunc) => {
     const mappingCache = new lru_cache_1.LRUCache({
         ttl: 7 * 24 * 60 * 60 * 1000,
@@ -62,7 +66,8 @@ const makeLIDMappingStore = (keys, logger, pnToLIDFunc) => {
         const successfulPairs = {};
         
         for (const pn of pns) {
-            if (!(0, WABinary_1.isPnUser)(pn) && !(0, WABinary_1.isHostedPnUser)(pn)) continue;
+            // MENGGUNAKAN FALLBACK isHostedPnUser
+            if (!(0, WABinary_1.isPnUser)(pn) && !isHostedPnUser(pn)) continue;
             const decoded = (0, WABinary_1.jidDecode)(pn);
             if (!decoded) continue;
             const pnUser = decoded.user;
@@ -78,7 +83,9 @@ const makeLIDMappingStore = (keys, logger, pnToLIDFunc) => {
                     logger && logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
                     const device = decoded.device || 0;
                     let normalizedPn = (0, WABinary_1.jidNormalizedUser)(pn);
-                    if ((0, WABinary_1.isHostedPnUser)(normalizedPn)) {
+                    
+                    // MENGGUNAKAN FALLBACK isHostedPnUser
+                    if (isHostedPnUser(normalizedPn)) {
                         normalizedPn = `${pnUser}@s.whatsapp.net`;
                     }
                     if (!usyncFetch[normalizedPn]) {

package/lib/Signal/lid-mapping.js.bak

@@ -1,73 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIDMappingStore = void 0;
+exports.makeLIDMappingStore = void 0;
 
 const WABinary_1 = require("../WABinary");
 const lru_cache_1 = require("lru-cache");
 
-class LIDMappingStore {
-    constructor(keys, logger, pnToLIDFunc) {
-        this.mappingCache = new lru_cache_1.LRUCache({
-            ttl: 7 * 24 * 60 * 60 * 1000,
-            ttlAutopurge: true,
-            updateAgeOnGet: true
-        });
-        this.keys = keys;
-        this.pnToLIDFunc = pnToLIDFunc;
-        this.logger = logger;
-    }
+const makeLIDMappingStore = (keys, logger, pnToLIDFunc) => {
+    const mappingCache = new lru_cache_1.LRUCache({
+        ttl: 7 * 24 * 60 * 60 * 1000,
+        ttlAutopurge: true,
+        updateAgeOnGet: true
+    });
 
-    async storeLIDPNMappings(pairs) {
+    const storeLIDPNMappings = async (pairs) => {
         const pairMap = {};
         for (const { lid, pn } of pairs) {
             if (!(((0, WABinary_1.isLidUser)(lid) && (0, WABinary_1.isPnUser)(pn)) || ((0, WABinary_1.isPnUser)(lid) && (0, WABinary_1.isLidUser)(pn)))) {
-                this.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                logger && logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
                 continue;
             }
             const lidDecoded = (0, WABinary_1.jidDecode)(lid);
             const pnDecoded = (0, WABinary_1.jidDecode)(pn);
-            if (!lidDecoded || !pnDecoded) return;
+            if (!lidDecoded || !pnDecoded) continue;
             const pnUser = pnDecoded.user;
             const lidUser = lidDecoded.user;
             
-            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`);
+            let existingLidUser = 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]);
+                logger && logger.trace(`Cache miss for PN user ${pnUser}; checking database`);
+                const stored = await keys.get("lid-mapping", [pnUser]);
                 existingLidUser = stored[pnUser];
                 if (existingLidUser) {
-                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser);
-                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser);
+                    mappingCache.set(`pn:${pnUser}`, existingLidUser);
+                    mappingCache.set(`lid:${existingLidUser}`, pnUser);
                 }
             }
             if (existingLidUser === lidUser) {
-                this.logger.debug({ pnUser, lidUser }, "LID mapping already exists, skipping");
+                logger && logger.debug({ pnUser, lidUser }, "LID mapping already exists, skipping");
                 continue;
             }
             pairMap[pnUser] = lidUser;
         }
         
-        this.logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
-        await this.keys.transaction(async () => {
+        logger && logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`);
+        await keys.transaction(async () => {
             for (const [pnUser, lidUser] of Object.entries(pairMap)) {
-                await this.keys.set({
+                await keys.set({
                     "lid-mapping": {
                         [pnUser]: lidUser,
                         [`${lidUser}_reverse`]: pnUser
                     }
                 });
-                this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                mappingCache.set(`pn:${pnUser}`, lidUser);
+                mappingCache.set(`lid:${lidUser}`, pnUser);
             }
         }, "lid-mapping");
-    }
+    };
 
-    async getLIDForPN(pn) {
-        const result = await this.getLIDsForPNs([pn]);
-        return result?.[0]?.lid || null;
-    }
-
-    async getLIDsForPNs(pns) {
+    const getLIDsForPNs = async (pns) => {
         const usyncFetch = {};
         const successfulPairs = {};
         
@@ -77,15 +67,15 @@ class LIDMappingStore {
             if (!decoded) continue;
             const pnUser = decoded.user;
             
-            let lidUser = this.mappingCache.get(`pn:${pnUser}`);
+            let lidUser = mappingCache.get(`pn:${pnUser}`);
             if (!lidUser) {
-                const stored = await this.keys.get("lid-mapping", [pnUser]);
+                const stored = await keys.get("lid-mapping", [pnUser]);
                 lidUser = stored[pnUser];
                 if (lidUser) {
-                    this.mappingCache.set(`pn:${pnUser}`, lidUser);
-                    this.mappingCache.set(`lid:${lidUser}`, pnUser);
+                    mappingCache.set(`pn:${pnUser}`, lidUser);
+                    mappingCache.set(`lid:${lidUser}`, pnUser);
                 } else {
-                    this.logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
+                    logger && logger.trace(`No LID mapping found for PN user ${pnUser}; batch getting from USync`);
                     const device = decoded.device || 0;
                     let normalizedPn = (0, WABinary_1.jidNormalizedUser)(pn);
                     if ((0, WABinary_1.isHostedPnUser)(normalizedPn)) {
@@ -102,19 +92,19 @@ class LIDMappingStore {
             
             lidUser = lidUser.toString();
             if (!lidUser) {
-                this.logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`);
+                logger && 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})`);
+            logger && logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`);
             successfulPairs[pn] = { lid: deviceSpecificLid, pn };
         }
         
         if (Object.keys(usyncFetch).length > 0) {
-            const result = await this.pnToLIDFunc?.(Object.keys(usyncFetch));
+            const result = await pnToLIDFunc?.(Object.keys(usyncFetch));
             if (result && result.length > 0) {
-                this.storeLIDPNMappings(result);
+                await storeLIDPNMappings(result);
                 for (const pair of result) {
                     const pnDecoded = (0, WABinary_1.jidDecode)(pair.pn);
                     const pnUser = pnDecoded?.user;
@@ -124,7 +114,7 @@ class LIDMappingStore {
                     
                     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})`);
+                        logger && 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 };
                     }
@@ -134,30 +124,43 @@ class LIDMappingStore {
             }
         }
         return Object.values(successfulPairs);
-    }
+    };
 
-    async getPNForLID(lid) {
+    const getLIDForPN = async (pn) => {
+        const result = await getLIDsForPNs([pn]);
+        return result?.[0]?.lid || null;
+    };
+
+    const getPNForLID = async (lid) => {
         if (!(0, WABinary_1.isLidUser)(lid)) return null;
         const decoded = (0, WABinary_1.jidDecode)(lid);
         if (!decoded) return null;
         
         const lidUser = decoded.user;
-        let pnUser = this.mappingCache.get(`lid:${lidUser}`);
+        let pnUser = mappingCache.get(`lid:${lidUser}`);
         
         if (!pnUser || typeof pnUser !== "string") {
-            const stored = await this.keys.get("lid-mapping", [`${lidUser}_reverse`]);
+            const stored = await 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}`);
+                logger && logger.trace(`No reverse mapping found for LID user: ${lidUser}`);
                 return null;
             }
-            this.mappingCache.set(`lid:${lidUser}`, pnUser);
+            mappingCache.set(`lid:${lidUser}`, pnUser);
         }
         
         const lidDevice = decoded.device !== undefined ? decoded.device : 0;
         const pnJid = `${pnUser}:${lidDevice}@${decoded.domainType === WABinary_1.WAJIDDomains.HOSTED_LID ? "hosted" : "s.whatsapp.net"}`;
-        this.logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
+        logger && logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`);
         return pnJid;
-    }
-}
-exports.LIDMappingStore = LIDMappingStore;
+    };
+
+    return {
+        mappingCache,
+        storeLIDPNMappings,
+        getLIDForPN,
+        getLIDsForPNs,
+        getPNForLID
+    };
+};
+exports.makeLIDMappingStore = makeLIDMappingStore;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ellxz24/baileys",
-    "version": "2.0.29",
+    "version": "2.0.30",
     "description": "WhatsApp API Modification By L",
     "publishConfig": {
         "access": "public"