@sgintokic/baileys 0.0.2

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,291 @@
+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 * 1e3, // 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: pnUser, lidUser: lidUser },
+          "LID mapping already exists, skipping",
+        );
+        continue;
+      }
+      pairMap[pnUser] = lidUser;
+    }
+    if (Object.keys(pairMap).length === 0) return;
+    this.logger.trace(
+      { pairMap: 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: 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: pn, pnUser: pnUser, decoded: 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: 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: lid, lidUser: lidUser, decoded: 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;
+  }
+}

package/lib/Socket/Client/index.js

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

package/lib/Socket/business.js

@@ -0,0 +1,293 @@
+import { getRawMediaUploadData } from "../Utils/index.js";
+import {
+  parseCatalogNode,
+  parseCollectionsNode,
+  parseOrderDetailsNode,
+  parseProductNode,
+  toProductNode,
+  uploadingNecessaryImagesOfProduct,
+} from "../Utils/business.js";
+import { jidNormalizedUser, S_WHATSAPP_NET } from "../WABinary/index.js";
+import { getBinaryNodeChild } from "../WABinary/generic-utils.js";
+import { makeMessagesRecvSocket } from "./messages-recv.js";
+export const makeBusinessSocket = (config) => {
+  const sock = makeMessagesRecvSocket(config);
+  const { authState, query, waUploadToServer } = sock;
+  const updateBussinesProfile = async (args) => {
+    const node = [];
+    const simpleFields = ["address", "email", "description"];
+    node.push(
+      ...simpleFields
+        .filter((key) => args[key] !== undefined && args[key] !== null)
+        .map((key) => ({ tag: key, attrs: {}, content: args[key] })),
+    );
+    if (args.websites !== undefined) {
+      node.push(
+        ...args.websites.map((website) => ({
+          tag: "website",
+          attrs: {},
+          content: website,
+        })),
+      );
+    }
+    if (args.hours !== undefined) {
+      node.push({
+        tag: "business_hours",
+        attrs: { timezone: args.hours.timezone },
+        content: args.hours.days.map((dayConfig) => {
+          const base = {
+            tag: "business_hours_config",
+            attrs: { day_of_week: dayConfig.day, mode: dayConfig.mode },
+          };
+          if (dayConfig.mode === "specific_hours") {
+            return {
+              ...base,
+              attrs: {
+                ...base.attrs,
+                open_time: dayConfig.openTimeInMinutes,
+                close_time: dayConfig.closeTimeInMinutes,
+              },
+            };
+          }
+          return base;
+        }),
+      });
+    }
+    const result = await query({
+      tag: "iq",
+      attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "w:biz" },
+      content: [
+        {
+          tag: "business_profile",
+          attrs: { v: "3", mutation_type: "delta" },
+          content: node,
+        },
+      ],
+    });
+    return result;
+  };
+  const updateCoverPhoto = async (photo) => {
+    const { fileSha256, filePath } = await getRawMediaUploadData(
+      photo,
+      "biz-cover-photo",
+    );
+    const fileSha256B64 = fileSha256.toString("base64");
+    const { meta_hmac, fbid, ts } = await waUploadToServer(filePath, {
+      fileEncSha256B64: fileSha256B64,
+      mediaType: "biz-cover-photo",
+    });
+    await query({
+      tag: "iq",
+      attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "w:biz" },
+      content: [
+        {
+          tag: "business_profile",
+          attrs: { v: "3", mutation_type: "delta" },
+          content: [
+            {
+              tag: "cover_photo",
+              attrs: {
+                id: String(fbid),
+                op: "update",
+                token: meta_hmac,
+                ts: String(ts),
+              },
+            },
+          ],
+        },
+      ],
+    });
+    return fbid;
+  };
+  const removeCoverPhoto = async (id) => {
+    return await query({
+      tag: "iq",
+      attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "w:biz" },
+      content: [
+        {
+          tag: "business_profile",
+          attrs: { v: "3", mutation_type: "delta" },
+          content: [{ tag: "cover_photo", attrs: { op: "delete", id: id } }],
+        },
+      ],
+    });
+  };
+  const getCatalog = async ({ jid, limit, cursor }) => {
+    jid = jid || authState.creds.me?.id;
+    jid = jidNormalizedUser(jid);
+    const queryParamNodes = [
+      {
+        tag: "limit",
+        attrs: {},
+        content: Buffer.from((limit || 10).toString()),
+      },
+      { tag: "width", attrs: {}, content: Buffer.from("100") },
+      { tag: "height", attrs: {}, content: Buffer.from("100") },
+    ];
+    if (cursor) {
+      queryParamNodes.push({ tag: "after", attrs: {}, content: cursor });
+    }
+    const result = await query({
+      tag: "iq",
+      attrs: { to: S_WHATSAPP_NET, type: "get", xmlns: "w:biz:catalog" },
+      content: [
+        {
+          tag: "product_catalog",
+          attrs: { jid: jid, allow_shop_source: "true" },
+          content: queryParamNodes,
+        },
+      ],
+    });
+    return parseCatalogNode(result);
+  };
+  const getCollections = async (jid, limit = 51) => {
+    jid = jid || authState.creds.me?.id;
+    jid = jidNormalizedUser(jid);
+    const result = await query({
+      tag: "iq",
+      attrs: {
+        to: S_WHATSAPP_NET,
+        type: "get",
+        xmlns: "w:biz:catalog",
+        smax_id: "35",
+      },
+      content: [
+        {
+          tag: "collections",
+          attrs: { biz_jid: jid },
+          content: [
+            {
+              tag: "collection_limit",
+              attrs: {},
+              content: Buffer.from(limit.toString()),
+            },
+            {
+              tag: "item_limit",
+              attrs: {},
+              content: Buffer.from(limit.toString()),
+            },
+            { tag: "width", attrs: {}, content: Buffer.from("100") },
+            { tag: "height", attrs: {}, content: Buffer.from("100") },
+          ],
+        },
+      ],
+    });
+    return parseCollectionsNode(result);
+  };
+  const getOrderDetails = async (orderId, tokenBase64) => {
+    const result = await query({
+      tag: "iq",
+      attrs: {
+        to: S_WHATSAPP_NET,
+        type: "get",
+        xmlns: "fb:thrift_iq",
+        smax_id: "5",
+      },
+      content: [
+        {
+          tag: "order",
+          attrs: { op: "get", id: orderId },
+          content: [
+            {
+              tag: "image_dimensions",
+              attrs: {},
+              content: [
+                { tag: "width", attrs: {}, content: Buffer.from("100") },
+                { tag: "height", attrs: {}, content: Buffer.from("100") },
+              ],
+            },
+            { tag: "token", attrs: {}, content: Buffer.from(tokenBase64) },
+          ],
+        },
+      ],
+    });
+    return parseOrderDetailsNode(result);
+  };
+  const productUpdate = async (productId, update) => {
+    update = await uploadingNecessaryImagesOfProduct(update, waUploadToServer);
+    const editNode = toProductNode(productId, update);
+    const result = await query({
+      tag: "iq",
+      attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "w:biz:catalog" },
+      content: [
+        {
+          tag: "product_catalog_edit",
+          attrs: { v: "1" },
+          content: [
+            editNode,
+            { tag: "width", attrs: {}, content: "100" },
+            { tag: "height", attrs: {}, content: "100" },
+          ],
+        },
+      ],
+    });
+    const productCatalogEditNode = getBinaryNodeChild(
+      result,
+      "product_catalog_edit",
+    );
+    const productNode = getBinaryNodeChild(productCatalogEditNode, "product");
+    return parseProductNode(productNode);
+  };
+  const productCreate = async (create) => {
+    // ensure isHidden is defined
+    create.isHidden = !!create.isHidden;
+    create = await uploadingNecessaryImagesOfProduct(create, waUploadToServer);
+    const createNode = toProductNode(undefined, create);
+    const result = await query({
+      tag: "iq",
+      attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "w:biz:catalog" },
+      content: [
+        {
+          tag: "product_catalog_add",
+          attrs: { v: "1" },
+          content: [
+            createNode,
+            { tag: "width", attrs: {}, content: "100" },
+            { tag: "height", attrs: {}, content: "100" },
+          ],
+        },
+      ],
+    });
+    const productCatalogAddNode = getBinaryNodeChild(
+      result,
+      "product_catalog_add",
+    );
+    const productNode = getBinaryNodeChild(productCatalogAddNode, "product");
+    return parseProductNode(productNode);
+  };
+  const productDelete = async (productIds) => {
+    const result = await query({
+      tag: "iq",
+      attrs: { to: S_WHATSAPP_NET, type: "set", xmlns: "w:biz:catalog" },
+      content: [
+        {
+          tag: "product_catalog_delete",
+          attrs: { v: "1" },
+          content: productIds.map((id) => ({
+            tag: "product",
+            attrs: {},
+            content: [{ tag: "id", attrs: {}, content: Buffer.from(id) }],
+          })),
+        },
+      ],
+    });
+    const productCatalogDelNode = getBinaryNodeChild(
+      result,
+      "product_catalog_delete",
+    );
+    return { deleted: +(productCatalogDelNode?.attrs.deleted_count || 0) };
+  };
+  return {
+    ...sock,
+    logger: config.logger,
+    getOrderDetails: getOrderDetails,
+    getCatalog: getCatalog,
+    getCollections: getCollections,
+    productCreate: productCreate,
+    productDelete: productDelete,
+    productUpdate: productUpdate,
+    updateBussinesProfile: updateBussinesProfile,
+    updateCoverPhoto: updateCoverPhoto,
+    removeCoverPhoto: removeCoverPhoto,
+  };
+};