@fer2809fl/baileys 7.0.1 → 7.0.4

package/lib/Socket/groups.d.ts

@@ -1,9 +1,24 @@
-import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import type { GroupMetadata, ParticipantAction, SocketConfig, WAMessageKey } from '../Types/index.js';
 import { type BinaryNode } from '../WABinary/index.js';
 export declare const makeGroupsSocket: (config: SocketConfig) => {
     groupMetadata: (jid: string) => Promise<GroupMetadata>;
+    /** groupMetadata con cache de 30s, invalidado automáticamente ante cambios reales de participantes. */
+    groupMetadataCached: (jid: string) => Promise<GroupMetadata>;
+    /**
+     * Resuelve un jid/@lid a su jid de número de teléfono real usando primero los participantes
+     * del grupo y, si no hay coincidencia, el mapeo LID↔PN nativo de Baileys (signalRepository).
+     * @param jidOrChatId el chatId del grupo, o directamente el array de participantes ya obtenido
+     * @param targetJid el jid/lid a resolver
+     */
+    resolveParticipantJid: (jidOrChatId: string | GroupMetadata["participants"], targetJid: string) => Promise<string>;
+    /** true si el participante (jid o @lid) es admin/superadmin del grupo. */
+    isGroupAdmin: (jid: string, participantJid: string) => Promise<boolean>;
+    /** Lista de admins del grupo ya resueltos a jid de número de teléfono. */
+    getGroupAdmins: (jid: string) => Promise<{
+        jid: string;
+        admin: "admin" | "superadmin" | null;
+    }[]>;
     groupCreate: (subject: string, participants: string[]) => Promise<GroupMetadata>;
     groupLeave: (id: string) => Promise<void>;
     groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
@@ -44,15 +59,6 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     groupFetchAllParticipating: () => Promise<{
         [_: string]: GroupMetadata;
     }>;
-    getAdminStatus: (groupJid: string, senderJid?: string) => Promise<{
-        isAdmin: boolean;
-        isBotAdmin: boolean;
-    }>;
-    serverProps: {
-        privacyTokenOn1to1: boolean;
-        profilePicPrivacyToken: boolean;
-        lidTrustedTokenIssueToLid: boolean;
-    };
     createCallLink: (type: "audio" | "video", event?: {
         startTime: number;
     }, timeoutMs?: number) => Promise<string | undefined>;
@@ -80,15 +86,9 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     fetchBlocklist: () => Promise<(string | undefined)[]>;
     fetchStatus: (...jids: string[]) => Promise<import("../index.js").USyncQueryResultList[] | undefined>;
     fetchDisappearingDuration: (...jids: string[]) => Promise<import("../index.js").USyncQueryResultList[] | undefined>;
-    findUserId: (pnOrLid: string) => Promise<{
-        phoneNumber: string;
-        lid: string;
-    }>;
     updateProfilePicture: (jid: string, content: import("../Types/index.js").WAMediaUpload, dimensions?: {
         width: number;
         height: number;
-    }, options?: {
-        full?: boolean;
     }) => Promise<void>;
     removeProfilePicture: (jid: string) => Promise<void>;
     updateProfileStatus: (status: string) => Promise<void>;
@@ -110,7 +110,6 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: number | string) => Promise<void>;
     addOrEditContact: (jid: string, contact: proto.SyncActionValue.IContactAction) => Promise<void>;
     removeContact: (jid: string) => Promise<void>;
-    placeholderResendCache: import("../Types/index.js").CacheStore;
     addLabel: (jid: string, labels: import("../Types/Label.js").LabelActionBody) => Promise<void>;
     addChatLabel: (jid: string, labelId: string) => Promise<void>;
     removeChatLabel: (jid: string, labelId: string) => Promise<void>;
@@ -130,7 +129,6 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
         createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): (...args: A) => Promise<T>;
         flush(): boolean;
         isBuffering(): boolean;
-        destroy(): void;
     };
     authState: {
         creds: import("../Types/index.js").AuthenticationCreds;
@@ -146,9 +144,8 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
     sendNode: (frame: BinaryNode) => Promise<void>;
     logout: (msg?: string) => Promise<void>;
     end: (error: Error | undefined) => Promise<void>;
-    registerSocketEndHandler: (handler: (error: Error | undefined) => void | Promise<void>) => void;
-    onUnexpectedError: (err: Error | Boom, msg: string) => void;
-    uploadPreKeys: (count?: number) => Promise<void>;
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom, msg: string) => void;
+    uploadPreKeys: (count?: number, retryCount?: number) => Promise<void>;
     uploadPreKeysToServerIfRequired: () => Promise<void>;
     digestKeyBundle: () => Promise<void>;
     rotateSignedPreKey: () => Promise<void>;
@@ -163,8 +160,6 @@ export declare const makeGroupsSocket: (config: SocketConfig) => {
         jid: string;
         exists: boolean;
     }[] | undefined>;
-    fetchAccountReachoutTimelock: () => Promise<import("../Types/index.js").ReachoutTimelockState>;
-    fetchNewChatMessageCap: () => Promise<import("../Types/index.js").NewChatMessageCapInfo>;
 };
 export declare const extractGroupMetadata: (result: BinaryNode) => GroupMetadata;
 export type GroupsSocket = ReturnType<typeof makeGroupsSocket>;

package/lib/Socket/groups.js

@@ -4,107 +4,10 @@ import { WAMessageAddressingMode, WAMessageStubType } from '../Types/index.js';
 import { generateMessageIDV2, unixTimestampSeconds } from '../Utils/index.js';
 import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString, isLidUser, isPnUser, jidEncode, jidNormalizedUser } from '../WABinary/index.js';
 import { makeChatsSocket } from './chats.js';
-const resolveParticipantsLID = async (metadataList, lidMapping) => {
-    const unresolvedLids = new Set();
-    for (const meta of metadataList) {
-        for (const p of meta.participants) {
-            if (!p.phoneNumber && isLidUser(p.id)) {
-                unresolvedLids.add(p.id);
-            }
-        }
-    }
-    if (unresolvedLids.size === 0) {
-        return;
-    }
-    const resolved = await lidMapping.getPNsForLIDs([...unresolvedLids]);
-    if (!resolved?.length) {
-        return;
-    }
-    const lidToPn = new Map(resolved.map(({ lid, pn }) => [lid, pn]));
-    for (const meta of metadataList) {
-        meta.participants = meta.participants.map(p => {
-            const pn = lidToPn.get(p.id);
-            if (!pn) {
-                return p;
-            }
-            return { ...p, id: pn, phoneNumber: pn, lid: p.id };
-        });
-    }
-};
+const GROUP_METADATA_CACHE_TTL_MS = 30_000;
 export const makeGroupsSocket = (config) => {
     const sock = makeChatsSocket(config);
-    const { authState, ev, query, upsertMessage, signalRepository } = sock;
-    const { cachedGroupMetadata, groupCacheTTL } = config;
-    const groupMetadataCache = new Map();
-    const cacheTTL = groupCacheTTL > 0 ? groupCacheTTL : 5 * 60 * 1000;
-    const getCachedGroupMetadata = async (jid) => {
-        if (cachedGroupMetadata) {
-            const cached = await cachedGroupMetadata(jid);
-            if (cached && Array.isArray(cached.participants)) {
-                return cached;
-            }
-        }
-        const entry = groupMetadataCache.get(jid);
-        if (entry && Date.now() - entry.ts < cacheTTL) {
-            return entry.data;
-        }
-        return undefined;
-    };
-    const setCachedGroupMetadata = (jid, data) => {
-        groupMetadataCache.set(jid, { data, ts: Date.now() });
-    };
-    ev.on('groups.update', updates => {
-        for (const update of updates) {
-            if (!update.id) {
-                continue;
-            }
-            const entry = groupMetadataCache.get(update.id);
-            if (entry) {
-                groupMetadataCache.set(update.id, { data: { ...entry.data, ...update }, ts: entry.ts });
-            }
-        }
-    });
-    const refreshDebounce = new Set();
-    const refreshGroupMetadata = async (jid) => {
-        if (refreshDebounce.has(jid)) {
-            return;
-        }
-        refreshDebounce.add(jid);
-        setTimeout(() => refreshDebounce.delete(jid), 2000);
-        try {
-            const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
-            const meta = extractGroupMetadata(result);
-            setCachedGroupMetadata(jid, meta);
-            ev.emit('groups.update', [meta]);
-        }
-        catch { }
-    };
-    ev.on('group-participants.update', ({ id, participants, action }) => {
-        const entry = groupMetadataCache.get(id);
-        if (entry && Array.isArray(entry.data.participants)) {
-            const meta = { ...entry.data, participants: [...entry.data.participants] };
-            const jids = participants.map(p => p.id);
-            if (action === 'add') {
-                const existing = new Set(meta.participants.map(p => p.id));
-                for (const p of participants) {
-                    if (!existing.has(p.id)) {
-                        meta.participants.push(p);
-                    }
-                }
-            }
-            else if (action === 'remove') {
-                meta.participants = meta.participants.filter(p => !jids.includes(p.id));
-            }
-            else if (action === 'promote') {
-                meta.participants = meta.participants.map(p => (jids.includes(p.id) ? { ...p, admin: 'admin' } : p));
-            }
-            else if (action === 'demote') {
-                meta.participants = meta.participants.map(p => (jids.includes(p.id) ? { ...p, admin: null } : p));
-            }
-            groupMetadataCache.set(id, { data: meta, ts: entry.ts });
-        }
-        void refreshGroupMetadata(id);
-    });
+    const { authState, ev, query, upsertMessage, signalRepository, logger } = sock;
     const groupQuery = async (jid, type, content) => query({
         tag: 'iq',
         attrs: {
@@ -115,15 +18,84 @@ export const makeGroupsSocket = (config) => {
         content
     });
     const groupMetadata = async (jid) => {
-        const cached = await getCachedGroupMetadata(jid);
-        if (cached) {
-            return cached;
-        }
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }]);
-        const meta = extractGroupMetadata(result);
-        await resolveParticipantsLID([meta], signalRepository.lidMapping);
-        setCachedGroupMetadata(jid, meta);
-        return meta;
+        return extractGroupMetadata(result);
+    };
+    const groupMetadataCache = new Map();
+    const invalidateGroupMetadataCache = (jid) => {
+        if (jid)
+            groupMetadataCache.delete(jid);
+        else
+            groupMetadataCache.clear();
+    };
+    ev.on('group-participants.update', ({ id }) => invalidateGroupMetadataCache(id));
+    ev.on('groups.update', updates => {
+        for (const update of updates) {
+            if (update?.id)
+                invalidateGroupMetadataCache(update.id);
+        }
+    });
+    /**
+     * groupMetadata con cache corto (30s) para evitar golpear WhatsApp en checks repetidos
+     * (ej. isGroupAdmin llamado por cada mensaje). Se invalida automáticamente ante cualquier
+     * cambio real de participantes.
+     */
+    const groupMetadataCached = async (jid) => {
+        const cached = groupMetadataCache.get(jid);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.data;
+        }
+        const data = await groupMetadata(jid);
+        groupMetadataCache.set(jid, { data, expiresAt: Date.now() + GROUP_METADATA_CACHE_TTL_MS });
+        return data;
+    };
+    /**
+     * Resuelve un jid (que puede venir como @lid) a su jid de número de teléfono real.
+     */
+    const resolveParticipantJid = async (jidOrChatId, targetJid) => {
+        if (!targetJid)
+            return targetJid;
+        const normalized = jidNormalizedUser(targetJid);
+        if (!isLidUser(normalized))
+            return normalized;
+        const participants = Array.isArray(jidOrChatId) ? jidOrChatId : (await groupMetadataCached(jidOrChatId)).participants;
+        const match = participants.find(p => jidNormalizedUser(p.id) === normalized || (p.lid && jidNormalizedUser(p.lid) === normalized));
+        if (match?.phoneNumber)
+            return jidNormalizedUser(match.phoneNumber);
+        if (match?.jid && !isLidUser(match.jid))
+            return jidNormalizedUser(match.jid);
+        try {
+            const pn = await signalRepository.lidMapping.getPNForLID(normalized);
+            if (pn)
+                return jidNormalizedUser(pn);
+        }
+        catch (err) {
+            logger.trace({ err, jid: normalized }, 'no se pudo resolver LID a PN via signalRepository');
+        }
+        return normalized;
+    };
+    /** true si el jid (número o @lid) es admin/superadmin del grupo. */
+    const isGroupAdmin = async (jid, participantJid) => {
+        if (!participantJid)
+            return false;
+        const normalized = jidNormalizedUser(participantJid);
+        const meta = await groupMetadataCached(jid);
+        const participant = meta.participants.find(p => {
+            const pid = jidNormalizedUser(p.id);
+            return (pid === normalized ||
+                (p.lid && jidNormalizedUser(p.lid) === normalized) ||
+                (p.phoneNumber && jidNormalizedUser(p.phoneNumber) === normalized));
+        });
+        return participant?.admin === 'admin' || participant?.admin === 'superadmin';
+    };
+    /** Lista de admins del grupo ya resueltos a jid de número de teléfono (no @lid). */
+    const getGroupAdmins = async (jid) => {
+        const meta = await groupMetadataCached(jid);
+        const admins = meta.participants.filter(p => p.admin === 'admin' || p.admin === 'superadmin');
+        return Promise.all(admins.map(async (p) => ({
+            jid: await resolveParticipantJid(meta.participants, p.id),
+            admin: p.admin
+        })));
     };
     const groupFetchAllParticipating = async () => {
         const result = await query({
@@ -157,10 +129,7 @@ export const makeGroupsSocket = (config) => {
                 data[meta.id] = meta;
             }
         }
-        await resolveParticipantsLID(Object.values(data), signalRepository.lidMapping);
-        for (const meta of Object.values(data)) {
-            setCachedGroupMetadata(meta.id, meta);
-        }
+        // TODO: properly parse LID / PN DATA
         sock.ev.emit('groups.update', Object.values(data));
         return data;
     };
@@ -175,6 +144,10 @@ export const makeGroupsSocket = (config) => {
     return {
         ...sock,
         groupMetadata,
+        groupMetadataCached,
+        resolveParticipantJid,
+        isGroupAdmin,
+        getGroupAdmins,
         groupCreate: async (subject, participants) => {
             const key = generateMessageIDV2();
             const result = await groupQuery('@g.us', 'set', [
@@ -291,23 +264,12 @@ export const makeGroupsSocket = (config) => {
             const result = getBinaryNodeChild(results, 'group');
             return result?.attrs.jid;
         },
-        /**
-         * revoke a v4 invite for someone
-         * @param groupJid group jid
-         * @param invitedJid jid of person you invited
-         * @returns true if successful
-         */
         groupRevokeInviteV4: async (groupJid, invitedJid) => {
             const result = await groupQuery(groupJid, 'set', [
                 { tag: 'revoke', attrs: {}, content: [{ tag: 'participant', attrs: { jid: invitedJid } }] }
             ]);
             return !!result;
         },
-        /**
-         * accept a GroupInviteMessage
-         * @param key the key of the invite message, or optionally only provide the jid of the person who sent the invite
-         * @param inviteMessage the message to accept
-         */
         groupAcceptInviteV4: ev.createBufferedFunction(async (key, inviteMessage) => {
             key = typeof key === 'string' ? { remoteJid: key } : key;
             const results = await groupQuery(inviteMessage.groupJid, 'set', [
@@ -320,10 +282,7 @@ export const makeGroupsSocket = (config) => {
                     }
                 }
             ]);
-            // if we have the full message key
-            // update the invite message to be expired
             if (key.id) {
-                // create new invite message that is expired
                 inviteMessage = proto.Message.GroupInviteMessage.fromObject(inviteMessage);
                 inviteMessage.inviteExpiration = 0;
                 inviteMessage.inviteCode = '';
@@ -338,7 +297,6 @@ export const makeGroupsSocket = (config) => {
                     }
                 ]);
             }
-            // generate the group add message
             await upsertMessage({
                 key: {
                     remoteJid: inviteMessage.groupJid,
@@ -374,47 +332,12 @@ export const makeGroupsSocket = (config) => {
                 { tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }
             ]);
         },
-        groupFetchAllParticipating,
-        getAdminStatus: async (groupJid, senderJid) => {
-            const normalizeJid = (jid) => {
-                if (!jid) {
-                    return null;
-                }
-                try {
-                    return jidNormalizedUser(jid).split('@')[0] ?? null;
-                }
-                catch {
-                    return String(jid).split('@')[0] ?? null;
-                }
-            };
-            const botJid = authState.creds.me?.id;
-            const meta = await groupMetadata(groupJid).catch(() => undefined);
-            if (!meta || !Array.isArray(meta.participants)) {
-                return { isAdmin: false, isBotAdmin: false };
-            }
-            const senderNorm = normalizeJid(senderJid);
-            const botNorm = normalizeJid(botJid);
-            const isAdminIn = (norm) => norm !== null &&
-                meta.participants.some(p => {
-                    const pid = normalizeJid(p.id ?? p.phoneNumber ?? p.lid);
-                    return pid === norm && (p.admin === 'admin' || p.admin === 'superadmin');
-                });
-            const isAdmin = isAdminIn(senderNorm);
-            let isBotAdmin = isAdminIn(botNorm);
-            if (!isBotAdmin && botNorm) {
-                const owners = [meta.owner, meta.ownerPn].filter(Boolean).map(normalizeJid);
-                if (owners.includes(botNorm)) {
-                    isBotAdmin = true;
-                }
-            }
-            return { isAdmin, isBotAdmin };
-        }
+        groupFetchAllParticipating
     };
 };
 export const extractGroupMetadata = (result) => {
     const group = getBinaryNodeChild(result, 'group');
     if (!group) {
-        // Mirror WAWeb: surface server/client errors with their code+text instead of crashing.
         const errorNode = getBinaryNodeChild(result, 'error');
         if (errorNode) {
             const code = errorNode.attrs.code ? +errorNode.attrs.code : 500;
@@ -473,12 +396,10 @@ export const extractGroupMetadata = (result) => {
         joinApprovalMode: !!getBinaryNodeChild(group, 'membership_approval_mode'),
         memberAddMode,
         participants: getBinaryNodeChildren(group, 'participant').map(({ attrs }) => {
-            const isLid = isLidUser(attrs.jid);
-            const hasPn = isPnUser(attrs.phone_number);
             return {
-                id: isLid && hasPn ? attrs.phone_number : attrs.jid,
-                phoneNumber: isLid && hasPn ? attrs.phone_number : undefined,
-                lid: isLid ? attrs.jid : isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
+                id: attrs.jid,
+                phoneNumber: isLidUser(attrs.jid) && isPnUser(attrs.phone_number) ? attrs.phone_number : undefined,
+                lid: isPnUser(attrs.jid) && isLidUser(attrs.lid) ? attrs.lid : undefined,
                 username: attrs.participant_username || attrs.username || undefined,
                 admin: (attrs.type || null)
             };
@@ -487,4 +408,3 @@ export const extractGroupMetadata = (result) => {
     };
     return metadata;
 };
-//# sourceMappingURL=groups.js.map