@areumtecnologia/wasockets 1.1.6 → 2.0.0

package/lib/Socket/groups.js

@@ -40,8 +40,16 @@ const makeGroupsSocket = (config) => {
     }))
     
     const groupMetadata = async (jid) => {
+        if (config.cachedGroupMetadata) {
+            const cached = await config.cachedGroupMetadata(jid)
+            if (cached) return cached
+        }
         const result = await groupQuery(jid, 'get', [{ tag: 'query', attrs: { request: 'interactive' } }])
-        return extractGroupMetadata(result)
+        const metadata = extractGroupMetadata(result)
+        if (config.cachedGroupMetadata?.set && metadata) {
+            config.cachedGroupMetadata.set(jid, metadata)
+        }
+        return metadata
     }
     
     const groupFetchAllParticipating = async () => {
@@ -79,6 +87,14 @@ const makeGroupsSocket = (config) => {
             }
         }
         
+        if (config.cachedGroupMetadata?.set) {
+            for (const meta of Object.values(data)) {
+                if (meta?.id) {
+                    config.cachedGroupMetadata.set(meta.id, meta)
+                }
+            }
+        }
+
         suki.ev.emit('groups.update', Object.values(data))
         return data
     }
@@ -93,6 +109,31 @@ const makeGroupsSocket = (config) => {
         await cleanDirtyBits('groups')
     })
     
+    const groupRequestParticipantsUpdate = async (jid, participants, action) => {
+        const result = await groupQuery(jid, 'set', [{
+                tag: 'membership_requests_action',
+                attrs: {},
+                content: [
+                    {
+                        tag: action,
+                        attrs: {},
+                        content: participants.map(jid => ({
+                            tag: 'participant',
+                            attrs: { jid }
+                        }))
+                    }
+                ]
+            }])
+            
+        const node = getBinaryNodeChild(result, 'membership_requests_action')
+        const nodeAction = getBinaryNodeChild(node, action)
+        const participantsAffected = getBinaryNodeChildren(nodeAction, 'participant')
+        
+        return participantsAffected.map(p => {
+            return { status: p.attrs.error || '200', jid: p.attrs.jid }
+        })
+    }
+
     return {
         ...suki,
         groupQuery, 
@@ -117,6 +158,7 @@ const makeGroupsSocket = (config) => {
             return extractGroupMetadata(result)
         },
         groupLeave: async (id) => {
+            config.cachedGroupMetadata?.delete?.(id)
             await groupQuery('@g.us', 'set', [
                 {
                     tag: 'leave',
@@ -128,6 +170,7 @@ const makeGroupsSocket = (config) => {
             ])
         },
         groupUpdateSubject: async (jid, subject) => {
+            config.cachedGroupMetadata?.delete?.(jid)
             await groupQuery(jid, 'set', [
                 {
                     tag: 'subject',
@@ -149,30 +192,7 @@ const makeGroupsSocket = (config) => {
             
             return participants.map(v => v.attrs)
         },
-        groupRequestParticipantsUpdate: async (jid, participants, action) => {
-            const result = await groupQuery(jid, 'set', [{
-                    tag: 'membership_requests_action',
-                    attrs: {},
-                    content: [
-                        {
-                            tag: action,
-                            attrs: {},
-                            content: participants.map(jid => ({
-                                tag: 'participant',
-                                attrs: { jid }
-                            }))
-                        }
-                    ]
-                }])
-                
-            const node = getBinaryNodeChild(result, 'membership_requests_action')
-            const nodeAction = getBinaryNodeChild(node, action)
-            const participantsAffected = getBinaryNodeChildren(nodeAction, 'participant')
-            
-            return participantsAffected.map(p => {
-                return { status: p.attrs.error || '200', jid: p.attrs.jid }
-            })
-        },
+        groupRequestParticipantsUpdate,
         groupParticipantsUpdate: async (jid, participants, action) => {
             const result = await groupQuery(jid, 'set', [
                 {
@@ -187,11 +207,13 @@ const makeGroupsSocket = (config) => {
             const node = getBinaryNodeChild(result, action)
             const participantsAffected = getBinaryNodeChildren(node, 'participant')
             
+            config.cachedGroupMetadata?.delete?.(jid)
             return participantsAffected.map(p => {
                 return { status: p.attrs.error || '200', jid: p.attrs.jid, content: p }
             })
         },
         groupUpdateDescription: async (jid, description) => {
+            config.cachedGroupMetadata?.delete?.(jid)
             const metadata = await groupMetadata(jid)
             const prev = metadata.descId ? metadata.descId : null
             
@@ -300,13 +322,68 @@ const makeGroupsSocket = (config) => {
             await groupQuery(jid, 'set', [content])
         },
         groupSettingUpdate: async (jid, setting) => {
+            config.cachedGroupMetadata?.delete?.(jid)
             await groupQuery(jid, 'set', [{ tag: setting, attrs: {} }])
         },
         groupMemberAddMode: async (jid, mode) => {
+            config.cachedGroupMetadata?.delete?.(jid)
             await groupQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }])
         },
         groupJoinApprovalMode: async (jid, mode) => {
-            await groupQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state: mode } }] }])
+            config.cachedGroupMetadata?.delete?.(jid)
+            const state = (mode === true || mode === 'on') ? 'on' : (mode === false || mode === 'off' ? 'off' : mode)
+            await groupQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state } }] }])
+        },
+        groupMembershipApprovalMode: async (jid, mode) => {
+            const state = (mode === true || mode === 'on') ? 'on' : 'off'
+            await groupQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state } }] }])
+        },
+        groupApprovePendingParticipants: async (jid, participants) => {
+            const list = Array.isArray(participants) ? participants : [participants]
+            return groupRequestParticipantsUpdate(jid, list, 'approve')
+        },
+        groupRejectPendingParticipants: async (jid, participants) => {
+            const list = Array.isArray(participants) ? participants : [participants]
+            return groupRequestParticipantsUpdate(jid, list, 'reject')
+        },
+        groupUpdatePermissions: async (jid, policies = {}) => {
+            config.cachedGroupMetadata?.delete?.(jid)
+            const results = {}
+            if (typeof policies.announce === 'boolean') {
+                await groupQuery(jid, 'set', [{ tag: policies.announce ? 'announcement' : 'not_announcement', attrs: {} }])
+                results.announce = policies.announce
+            }
+            if (typeof policies.restrict === 'boolean') {
+                await groupQuery(jid, 'set', [{ tag: policies.restrict ? 'locked' : 'unlocked', attrs: {} }])
+                results.restrict = policies.restrict
+            }
+            if (policies.memberAddMode) {
+                await groupQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: policies.memberAddMode }])
+                results.memberAddMode = policies.memberAddMode
+            }
+            if (typeof policies.approvalMode !== 'undefined') {
+                const state = (policies.approvalMode === true || policies.approvalMode === 'on') ? 'on' : 'off'
+                await groupQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'group_join', attrs: { state } }] }])
+                results.approvalMode = state
+            }
+            if (typeof policies.ephemeral !== 'undefined') {
+                const content = policies.ephemeral ?
+                    { tag: 'ephemeral', attrs: { expiration: policies.ephemeral.toString() } } :
+                    { tag: 'not_ephemeral', attrs: {} }
+                await groupQuery(jid, 'set', [content])
+                results.ephemeral = policies.ephemeral
+            }
+            return results
+        },
+        groupGetAdminJids: async (jid) => {
+            const metadata = await groupMetadata(jid)
+            return (metadata.participants || [])
+                .filter(p => !!p.admin)
+                .map(p => p.id)
+        },
+        groupGetParticipants: async (jid) => {
+            const metadata = await groupMetadata(jid)
+            return metadata.participants || []
         },
         groupFetchAllParticipating
     }

package/lib/Socket/index.js

@@ -2,11 +2,12 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
-const { DEFAULT_CONNECTION_CONFIG } = require("../Defaults/connection")
+const { DEFAULT_CONNECTION_CONFIG, createGroupMetadataCache } = require("../Defaults/connection")
 const { makeCommunitiesSocket } = require("./community")
+const { PluginManager } = require("../Plugins")
 
 // export the last socket layer
-const makeWASocket = (config) => {
+const makeWASocket = (config = {}) => {
 	const newConfig = {
     	...DEFAULT_CONNECTION_CONFIG,
    	 ...config
@@ -18,7 +19,30 @@ const makeWASocket = (config) => {
         newConfig.shouldSyncHistoryMessage = () => !!newConfig.syncFullHistory
     }
 
-    return makeCommunitiesSocket(newConfig)
+    if (!config.cachedGroupMetadata && newConfig.enableGroupCache) {
+        newConfig.cachedGroupMetadata = createGroupMetadataCache()
+    }
+
+    const sock = makeCommunitiesSocket(newConfig)
+    const pluginManager = new PluginManager(sock)
+
+    sock.plugins = pluginManager
+    sock.use = (plugin, options) => {
+        pluginManager.use(plugin, options)
+        return sock
+    }
+    sock.registerMiddleware = (hook, fn) => pluginManager.registerMiddleware(hook, fn)
+    sock.hasPlugin = (name) => pluginManager.hasPlugin(name)
+    sock.listPlugins = () => pluginManager.listPlugins()
+
+    // Auto-install plugins passed in configuration
+    if (Array.isArray(config.plugins)) {
+        for (const p of config.plugins) {
+            sock.use(p)
+        }
+    }
+
+    return sock
 }
 
 exports.default = makeWASocket

package/lib/Socket/messages-send.js

@@ -105,6 +105,41 @@ const makeMessagesSocket = (config) => {
     // Initialize message retry manager if enabled
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null
     
+    // Pending message queue for transient disconnections
+    const pendingMessagesQueue = []
+    let isDrainingQueue = false
+
+    const drainPendingMessages = async () => {
+        if (isDrainingQueue || !pendingMessagesQueue.length) {
+            return
+        }
+        isDrainingQueue = true
+        logger.debug({ queueLength: pendingMessagesQueue.length }, 'draining pending messages queue')
+        try {
+            while (pendingMessagesQueue.length && suki.ws?.isOpen) {
+                const item = pendingMessagesQueue.shift()
+                if (Date.now() - item.queuedAt > (config.messageQueueTtlMs || 300000)) {
+                    item.reject(new Boom('Message queue TTL expired', { statusCode: 408 }))
+                    continue
+                }
+                try {
+                    const result = await sendMessage(item.jid, item.content, item.options)
+                    item.resolve(result)
+                } catch (err) {
+                    item.reject(err)
+                }
+            }
+        } finally {
+            isDrainingQueue = false
+        }
+    }
+
+    ev.on('connection.update', ({ connection }) => {
+        if (connection === 'open') {
+            drainPendingMessages()
+        }
+    })
+
     // Prevent race conditions in Signal session encryption by user
     const encryptionMutex = makeKeyedMutex()
 
@@ -510,6 +545,15 @@ const makeMessagesSocket = (config) => {
         return didFetchNewSession
     }
     
+    const repairSession = async (jid) => {
+        logger.info({ jid }, 'repairing Signal session')
+        const signalId = signalRepository.jidToSignalProtocolAddress(jid)
+        peerSessionsCache.delete(signalId)
+        await signalRepository.deleteSession([jid])
+        await assertSessions([jid], true)
+        logger.info({ jid }, 'signal session repaired successfully')
+    }
+    
     const sendPeerDataOperationMessage = async (pdoMessage) => {
         //TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
         if (!authState.creds.me?.id) {
@@ -1395,6 +1439,8 @@ const makeMessagesSocket = (config) => {
         ...suki,
         getPrivacyTokens,
         assertSessions,
+        repairSession,
+        drainPendingMessages,
         profilePictureUrl, 
         relayMessage,
         sendReceipt,
@@ -1670,7 +1716,50 @@ const makeMessagesSocket = (config) => {
                 edit: eventKey
             })
         },
+        sendAlbumMessage: async (jid, medias, options = {}) => {
+            return sendMessage(jid, { album: medias }, options)
+        },
+        groupSendMentionAll: async (jid, content, options = {}) => {
+            const metadata = await suki.groupMetadata(jid)
+            let participants = metadata.participants || []
+            if (options.adminsOnly) {
+                participants = participants.filter(p => !!p.admin)
+            }
+            if (options.excludeMe && authState.creds.me?.id) {
+                const myPn = jidNormalizedUser(authState.creds.me.id)
+                participants = participants.filter(p => jidNormalizedUser(p.id) !== myPn && (!p.lid || jidNormalizedUser(p.lid) !== myPn))
+            }
+            const mentionJids = participants.map(p => p.id || p.lid).filter(Boolean)
+            const msgContent = typeof content === 'string' ? { text: content } : { ...content }
+            msgContent.mentions = [...new Set([...(msgContent.mentions || []), ...mentionJids])]
+            return sendMessage(jid, msgContent, options)
+        },
         sendMessage: async (jid, content, options = {}) => {
+            if (config.enableMessageQueue && (!suki.ws || !suki.ws.isOpen)) {
+                logger.info({ jid }, 'WebSocket connection not open, queuing message')
+                return new Promise((resolve, reject) => {
+                    pendingMessagesQueue.push({
+                        jid,
+                        content,
+                        options,
+                        queuedAt: Date.now(),
+                        resolve,
+                        reject
+                    })
+                })
+            }
+
+            const sendContext = { jid, content, options }
+            if (suki.plugins) {
+                const allowed = await suki.plugins.runMiddlewares('beforeSendMessage', sendContext)
+                if (allowed === false) {
+                    logger.info({ jid }, 'Message sending cancelled by plugin middleware')
+                    return
+                }
+            }
+            content = sendContext.content
+            options = sendContext.options
+
             const userJid = authState.creds.me.id
             const additionalAttributes = {}
 
@@ -1681,6 +1770,24 @@ const makeMessagesSocket = (config) => {
                  }
             }
             
+            if (isJidGroup(jid) && typeof content === 'object' && (content?.mentionAll || options?.mentionAll)) {
+                try {
+                    const metadata = await suki.groupMetadata(jid)
+                    let participants = metadata.participants || []
+                    if (options.adminsOnly || content.adminsOnly) {
+                        participants = participants.filter(p => !!p.admin)
+                    }
+                    if ((options.excludeMe || content.excludeMe) && authState.creds.me?.id) {
+                        const myPn = jidNormalizedUser(authState.creds.me.id)
+                        participants = participants.filter(p => jidNormalizedUser(p.id) !== myPn && (!p.lid || jidNormalizedUser(p.lid) !== myPn))
+                    }
+                    const mentionJids = participants.map(p => p.id || p.lid).filter(Boolean)
+                    content.mentions = [...new Set([...(content.mentions || []), ...mentionJids])]
+                } catch (err) {
+                    logger.warn({ err, jid }, 'Failed to resolve group participants for mentionAll')
+                }
+            }
+
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
                 typeof content['disappearingMessagesInChat'] !== 'undefined' &&
@@ -1783,6 +1890,10 @@ const makeMessagesSocket = (config) => {
                     })
                 }
 
+                if (suki.plugins) {
+                    await suki.plugins.runMiddlewares('afterSendMessage', { jid, content, options, fullMsg })
+                }
+
                 return fullMsg
             }
         }

package/lib/Socket/newsletter.js

@@ -2,12 +2,13 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
+const { proto } = require("../../WAProto")
 const {
     QueryIds,
     XWAPaths
 } = require("../Types")
 const { generateProfilePicture } = require("../Utils")
-const { getBinaryNodeChild } = require("../WABinary")
+const { getBinaryNodeChild, getBinaryNodeChildren } = require("../WABinary")
 const { makeGroupsSocket } = require("./groups")
 const { executeWMexQuery: genericExecuteWMexQuery } = require("./mex")
 
@@ -132,13 +133,14 @@ const makeNewsletterSocket = (config) => {
             return await newsletterUpdate(jid, { picture: '' })
         },
         newsletterReactMessage: async (jid, serverId, reaction) => {
+            const targetServerId = typeof serverId === 'object' ? (serverId.server_id || serverId.id) : serverId
             await query({
                 tag: 'message',
                 attrs: {
                     to: jid,
                     ...(reaction ? {} : { edit: '7' }),
                     type: 'reaction',
-                    server_id: serverId,
+                    server_id: targetServerId?.toString(),
                     id: generateMessageTag()
                 },
                 content: [
@@ -149,7 +151,87 @@ const makeNewsletterSocket = (config) => {
                 ]
             })
         },
-        newsletterFetchMessages: async (jid, count, since, after) => {
+        newsletterFetchReactions: async (jid, serverId) => {
+            const targetServerId = typeof serverId === 'object' ? (serverId.server_id || serverId.id) : serverId
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    id: generateMessageTag(),
+                    type: 'get',
+                    xmlns: 'newsletter',
+                    to: jid
+                },
+                content: [
+                    {
+                        tag: 'reactions',
+                        attrs: {
+                            server_id: targetServerId?.toString()
+                        }
+                    }
+                ]
+            })
+
+            const reactionsNode = getBinaryNodeChild(result, 'reactions')
+            if (!reactionsNode) return []
+            const reactionChildren = getBinaryNodeChildren(reactionsNode, 'reaction')
+            return reactionChildren.map(r => ({
+                code: r.attrs.code,
+                count: parseInt(r.attrs.count || '0', 10)
+            }))
+        },
+        newsletterFetchMessage: async (jid, serverId) => {
+            const targetServerId = typeof serverId === 'object' ? (serverId.server_id || serverId.id) : serverId
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    id: generateMessageTag(),
+                    type: 'get',
+                    xmlns: 'newsletter',
+                    to: jid
+                },
+                content: [
+                    {
+                        tag: 'message',
+                        attrs: {
+                            server_id: targetServerId?.toString()
+                        }
+                    }
+                ]
+            })
+
+            const messageNode = getBinaryNodeChild(result, 'message')
+            if (!messageNode) return null
+
+            const plaintextNode = getBinaryNodeChild(messageNode, 'plaintext')
+            let messageProto
+            if (plaintextNode?.content) {
+                try {
+                    const buffer = Buffer.isBuffer(plaintextNode.content)
+                        ? plaintextNode.content
+                        : Buffer.from(plaintextNode.content)
+                    messageProto = proto.Message.decode(buffer)
+                } catch (e) {
+                    // ignore decode error
+                }
+            }
+
+            const reactionsNode = getBinaryNodeChild(messageNode, 'reactions')
+            const reactions = reactionsNode
+                ? getBinaryNodeChildren(reactionsNode, 'reaction').map(r => ({
+                    code: r.attrs.code,
+                    count: parseInt(r.attrs.count || '0', 10)
+                }))
+                : []
+
+            return {
+                server_id: messageNode.attrs.server_id,
+                messageTimestamp: +messageNode.attrs.t,
+                views: messageNode.attrs.views ? +messageNode.attrs.views : undefined,
+                message: messageProto,
+                reactions
+            }
+        },
+        newsletterFetchMessages: async (jid, count = 20, since, after) => {
             const messageUpdateAttrs = {
                 count: count.toString()
             }
@@ -178,8 +260,48 @@ const makeNewsletterSocket = (config) => {
                 ]
             })
 
+            const messageUpdatesNode = getBinaryNodeChild(result, 'message_updates')
+            const messageNodes = getBinaryNodeChildren(messageUpdatesNode, 'message')
+
+            const messages = messageNodes.map(node => {
+                const plaintextNode = getBinaryNodeChild(node, 'plaintext')
+                let messageProto
+                if (plaintextNode?.content) {
+                    try {
+                        const buffer = Buffer.isBuffer(plaintextNode.content)
+                            ? plaintextNode.content
+                            : Buffer.from(plaintextNode.content)
+                        messageProto = proto.Message.decode(buffer)
+                    } catch (e) {
+                        // ignore decode errors
+                    }
+                }
+
+                const reactionsNode = getBinaryNodeChild(node, 'reactions')
+                const reactions = reactionsNode
+                    ? getBinaryNodeChildren(reactionsNode, 'reaction').map(r => ({
+                        code: r.attrs.code,
+                        count: parseInt(r.attrs.count || '0', 10)
+                    }))
+                    : []
+
+                return {
+                    server_id: node.attrs.server_id,
+                    messageTimestamp: +node.attrs.t,
+                    views: node.attrs.views ? +node.attrs.views : undefined,
+                    message: messageProto,
+                    reactions
+                }
+            })
+
+            result.messages = messages
             return result
         },
+        newsletterToggleMute: async (jid, mute = true) => {
+            return mute
+                ? executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.MUTE_V2)
+                : executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.UNMUTE_V2)
+        },
         subscribeNewsletterUpdates: async (jid) => {
             const result = await query({
                 tag: 'iq',

package/lib/Store/index.d.ts

@@ -0,0 +1,4 @@
+import { InMemoryStore, InMemoryStoreConfig } from '../index'
+
+export declare function makeInMemoryStore(config?: InMemoryStoreConfig): InMemoryStore
+export declare function makeCacheManagerAuthState(store: any, sessionKey: string): Promise<any>