@areumtecnologia/wasockets 1.1.6 → 2.0.0-alpha.1

package/WAProto/index.d.ts

@@ -0,0 +1,17 @@
+export declare namespace proto {
+    interface IMessage {
+        [key: string]: any
+    }
+    interface IHistorySyncNotification {
+        [key: string]: any
+    }
+    interface IWebMessageInfo {
+        [key: string]: any
+    }
+}
+
+export declare const proto: {
+    [key: string]: any
+}
+
+export default proto

package/lib/Defaults/connection.js

@@ -7,6 +7,33 @@ const { default: logger } = require("../Utils/logger")
 const { makeLibSignalRepository } = require("../Signal/libsignal")
 const { version } = require("./baileys-version.json")
 
+const createGroupMetadataCache = (ttlMs = 300000, maxSize = 250) => {
+    const cache = new Map()
+
+    const get = async (jid) => {
+        const item = cache.get(jid)
+        if (!item) return undefined
+        if (Date.now() - item.time > ttlMs) {
+            cache.delete(jid)
+            return undefined
+        }
+        return item.metadata
+    }
+
+    get.set = (jid, metadata) => {
+        if (cache.size >= maxSize) {
+            const oldestKey = cache.keys().next().value
+            if (oldestKey) cache.delete(oldestKey)
+        }
+        cache.set(jid, { metadata, time: Date.now() })
+    }
+
+    get.delete = (jid) => cache.delete(jid)
+    get.clear = () => cache.clear()
+
+    return get
+}
+
 const DEFAULT_CONNECTION_CONFIG = {
     version, 
     browser: Browsers.windows('Chrome'),
@@ -35,6 +62,10 @@ const DEFAULT_CONNECTION_CONFIG = {
     generateHighQualityLinkPreview: false,
     enableAutoSessionRecreation: true, 
     enableRecentMessageCache: true, 
+    enableMessageQueue: true,
+    messageQueueTtlMs: 300000,
+    maxReconnectAttempts: 15,
+    enableGroupCache: true,
     options: {},
     appStateMacVerification: {
         patch: false,
@@ -42,10 +73,11 @@ const DEFAULT_CONNECTION_CONFIG = {
     },
     countryCode: 'US',
     getMessage: async () => undefined,
-    cachedGroupMetadata: async () => undefined,
+    cachedGroupMetadata: createGroupMetadataCache(),
     makeSignalRepository: makeLibSignalRepository
 }
 
 module.exports = {
-  DEFAULT_CONNECTION_CONFIG
+  DEFAULT_CONNECTION_CONFIG,
+  createGroupMetadataCache
 }

package/lib/Defaults/index.d.ts

@@ -0,0 +1,6 @@
+import { Browsers } from '../Utils'
+import { UserFacingSocketConfig } from '../index'
+
+export { Browsers }
+export declare const DEFAULT_CONNECTION_CONFIG: UserFacingSocketConfig
+export declare function createGroupMetadataCache(ttlMs?: number, maxSize?: number): any

package/lib/Plugins/index.d.ts

@@ -0,0 +1,33 @@
+import { WASocket } from '../index'
+
+export interface PluginMetadata {
+    name: string
+    version?: string
+    description?: string
+    author?: string
+    install?: (sock: WASocket, options?: any, manager?: PluginManager) => void
+}
+
+export type PluginFunction = (sock: WASocket, options?: any, manager?: PluginManager) => void
+export type Plugin = PluginMetadata | PluginFunction
+
+export type MiddlewareHook =
+    | 'beforeSendMessage'
+    | 'afterSendMessage'
+    | 'beforeRecvMessage'
+    | 'afterRecvMessage'
+    | 'connectionUpdate'
+
+export declare class PluginManager {
+    constructor(sock: WASocket)
+    sock: WASocket
+    plugins: Map<string, any>
+    middlewares: Record<string, Function[]>
+
+    use(plugin: Plugin, options?: any): this
+    registerMiddleware(hook: MiddlewareHook, fn: (context: any, sock: WASocket) => Promise<boolean | void> | boolean | void): () => void
+    runMiddlewares(hook: string, context: any): Promise<boolean>
+    hasPlugin(name: string): boolean
+    getPlugin(name: string): any
+    listPlugins(): Array<{ name: string; registeredAt: number; version: string; description: string }>
+}

package/lib/Plugins/index.js

@@ -0,0 +1,125 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+/**
+ * Plugin and Middleware Manager for WaSockets
+ * Enables modular extensions, event interception, and pipeline middleware.
+ */
+class PluginManager {
+    constructor(sock) {
+        this.sock = sock
+        this.plugins = new Map()
+        this.middlewares = {
+            beforeSendMessage: [],
+            afterSendMessage: [],
+            beforeRecvMessage: [],
+            afterRecvMessage: [],
+            connectionUpdate: []
+        }
+    }
+
+    /**
+     * Install a plugin
+     * @param {Object|Function} plugin - Plugin object with install() or function (sock, options)
+     * @param {Object} [options={}] - Options passed to plugin
+     */
+    use(plugin, options = {}) {
+        if (!plugin) return this
+
+        if (typeof plugin === 'function') {
+            plugin(this.sock, options, this)
+            return this
+        }
+
+        const name = plugin.name || `plugin_${this.plugins.size + 1}`
+        if (this.plugins.has(name)) {
+            throw new Error(`Plugin with name "${name}" is already registered`)
+        }
+
+        this.plugins.set(name, {
+            plugin,
+            options,
+            registeredAt: Date.now()
+        })
+
+        if (typeof plugin.install === 'function') {
+            plugin.install(this.sock, options, this)
+        }
+
+        return this
+    }
+
+    /**
+     * Register a middleware hook
+     * @param {'beforeSendMessage'|'afterSendMessage'|'beforeRecvMessage'|'afterRecvMessage'|'connectionUpdate'} hook
+     * @param {Function} fn - Async middleware function
+     * @returns {Function} Unregister function
+     */
+    registerMiddleware(hook, fn) {
+        if (!this.middlewares[hook]) {
+            this.middlewares[hook] = []
+        }
+        this.middlewares[hook].push(fn)
+        return () => {
+            this.middlewares[hook] = this.middlewares[hook].filter(f => f !== fn)
+        }
+    }
+
+    /**
+     * Execute all middlewares for a specific hook
+     * @param {string} hook
+     * @param {Object} context
+     * @returns {Promise<boolean>} returns false if any middleware explicitly returned false (cancelled)
+     */
+    async runMiddlewares(hook, context) {
+        const hooks = this.middlewares[hook] || []
+        for (const fn of hooks) {
+            try {
+                const result = await fn(context, this.sock)
+                if (result === false) {
+                    return false
+                }
+            } catch (error) {
+                if (this.sock.logger) {
+                    this.sock.logger.error({ error, hook }, 'Error executing plugin middleware')
+                } else {
+                    console.error(`[PluginManager] Error executing middleware on hook ${hook}:`, error)
+                }
+            }
+        }
+        return true
+    }
+
+    /**
+     * Check if a plugin is installed
+     * @param {string} name
+     */
+    hasPlugin(name) {
+        return this.plugins.has(name)
+    }
+
+    /**
+     * Retrieve an installed plugin
+     * @param {string} name
+     */
+    getPlugin(name) {
+        return this.plugins.get(name)
+    }
+
+    /**
+     * List all installed plugins
+     */
+    listPlugins() {
+        return Array.from(this.plugins.entries()).map(([name, data]) => ({
+            name,
+            registeredAt: data.registeredAt,
+            version: data.plugin?.version || '1.0.0',
+            description: data.plugin?.description || ''
+        }))
+    }
+}
+
+module.exports = {
+    PluginManager
+}

package/lib/Socket/business.js

@@ -7,6 +7,7 @@ const {
   parseCatalogNode, 
   parseCollectionsNode, 
   parseOrderDetailsNode, 
+  parseProductNode,
   getRawMediaUploadData, 
   uploadingNecessaryImagesOfProduct
 } = require("../Utils")
@@ -408,12 +409,44 @@ const makeBusinessSocket = (config) => {
             deleted: +(productCatalogDelNode?.attrs?.deleted_count || 0) 
         }
     }
+    const getProduct = async (jid, productId) => {
+        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'
+            },
+            content: [
+                {
+                    tag: 'product',
+                    attrs: {
+                        jid
+                    },
+                    content: [
+                        {
+                            tag: 'id',
+                            attrs: {},
+                            content: Buffer.from(productId)
+                        }
+                    ]
+                }
+            ]
+        })
+        const productNode = getBinaryNodeChild(result, 'product')
+        return productNode ? parseProductNode(productNode) : null
+    }
+
     return {
         ...suki,
         logger: config.logger,
         getOrderDetails,
         getCatalog,
         getCollections,
+        getProduct,
         productCreate,
         productDelete,
         productUpdate, 

package/lib/Socket/chats.js

@@ -253,7 +253,19 @@ const makeChatsSocket = (config) => {
         
         const result = await suki.executeUSyncQuery(usyncQuery)
         
-        if (result) {
+        if (result && result.list) {
+            const mappingsToStore = []
+            for (const item of result.list) {
+                const lid = item.lid || item.val
+                if (lid && isPnUser(targetJid)) {
+                    mappingsToStore.push({ lid, pn: targetJid })
+                }
+            }
+            if (mappingsToStore.length && signalRepository?.lidMapping?.storeLIDPNMappings) {
+                await signalRepository.lidMapping.storeLIDPNMappings(mappingsToStore).catch(err => {
+                    logger.debug({ err }, 'Failed to auto-store LID-PN mapping in getLidUser')
+                })
+            }
             return result.list
         }
     }
@@ -286,10 +298,95 @@ const makeChatsSocket = (config) => {
         
         const result = await suki.executeUSyncQuery(usyncQuery)
         
-        if (result) {
+        if (result && result.list) {
+            const mappingsToStore = []
+            for (const item of result.list) {
+                const rawPhone = item.phone_number || item.val
+                if (rawPhone && isLidUser(targetJid)) {
+                    const cleanPhone = rawPhone.replace('+', '')
+                    const pnJid = `${cleanPhone}@s.whatsapp.net`
+                    mappingsToStore.push({ lid: targetJid, pn: pnJid })
+                }
+            }
+            if (mappingsToStore.length && signalRepository?.lidMapping?.storeLIDPNMappings) {
+                await signalRepository.lidMapping.storeLIDPNMappings(mappingsToStore).catch(err => {
+                    logger.debug({ err }, 'Failed to auto-store LID-PN mapping in getPnUser')
+                })
+            }
             return result.list
         }
     }
+
+    const toPn = async (jid, fetchIfMissing = false) => {
+        if (!jid) return null
+        if (isPnUser(jid)) return jidNormalizedUser(jid)
+        if (!isLidUser(jid)) return jidNormalizedUser(jid)
+
+        const normLid = jidNormalizedUser(jid)
+        let pn = await signalRepository?.lidMapping?.getPNForLID(normLid)
+        if (pn) return jidNormalizedUser(pn)
+
+        if (fetchIfMissing) {
+            try {
+                const list = await getPnUser(normLid)
+                if (list && list.length > 0) {
+                    const phone = list[0].phone_number || list[0].val
+                    if (phone) {
+                        return `${phone.replace('+', '')}@s.whatsapp.net`
+                    }
+                }
+            } catch (err) {
+                logger.debug({ err, jid }, 'Failed to fetch PN for LID via USync')
+            }
+        }
+        return null
+    }
+
+    const toLid = async (jid, fetchIfMissing = false) => {
+        if (!jid) return null
+        if (isLidUser(jid)) return jidNormalizedUser(jid)
+        if (!isPnUser(jid)) return jidNormalizedUser(jid)
+
+        const normPn = jidNormalizedUser(jid)
+        let lid = await signalRepository?.lidMapping?.getLIDForPN(normPn)
+        if (lid) return jidNormalizedUser(lid)
+
+        if (fetchIfMissing) {
+            try {
+                const list = await getLidUser(normPn)
+                if (list && list.length > 0) {
+                    const foundLid = list[0].lid || list[0].val
+                    if (foundLid) {
+                        return jidNormalizedUser(foundLid)
+                    }
+                }
+            } catch (err) {
+                logger.debug({ err, jid }, 'Failed to fetch LID for PN via USync')
+            }
+        }
+        return null
+    }
+
+    const resolveJid = async (jid, fetchIfMissing = false) => {
+        if (!jid) return { pn: null, lid: null, jid: null }
+        if (isPnUser(jid)) {
+            const pn = jidNormalizedUser(jid)
+            const lid = await toLid(pn, fetchIfMissing)
+            return { pn, lid, jid: pn }
+        }
+        if (isLidUser(jid)) {
+            const lid = jidNormalizedUser(jid)
+            const pn = await toPn(lid, fetchIfMissing)
+            return { pn, lid, jid: lid }
+        }
+        return { pn: null, lid: null, jid }
+    }
+
+    const storeLidPnMapping = async (pn, lid) => {
+        if (!pn || !lid || !signalRepository?.lidMapping) return false
+        await signalRepository.lidMapping.storeLIDPNMappings([{ pn, lid }])
+        return true
+    }
     
     const fetchStatus = async (...jids) => {
         const usyncQuery = new USyncQuery().withStatusProtocol()
@@ -1325,6 +1422,10 @@ const makeChatsSocket = (config) => {
         notificationMutex, 
         getLidUser, 
         getPnUser, 
+        toPn,
+        toLid,
+        resolveJid,
+        storeLidPnMapping,
         updateFavorite, 
         updateChatNote, 
         removeChatNote, 

package/lib/Socket/community.js

@@ -119,6 +119,76 @@ const makeCommunitiesSocket = (config) => {
     	await cleanDirtyBits('groups') 
     }) 
     
+    const communityRequestParticipantsUpdate = async (jid, participants, action) => {
+        const result = await communityQuery(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 }
+        })
+    }
+
+    const communityFetchLinkedGroups = async (jid) => {
+        let communityJid = jid
+        let isCommunity = false
+        
+        // Try to determine if it is a subgroup or a community
+        const metadata = await groupMetadata(jid)
+        
+        if (metadata.linkedParent) {
+            // It is a subgroup, get the community jid
+            communityJid = metadata.linkedParent
+        } else {
+            // It is a community
+            isCommunity = true
+        }
+        
+        // Fetch all subgroups of the community
+        const result = await communityQuery(communityJid, 'get', [{ tag: 'sub_groups', attrs: {} }])
+        const linkedGroupsData = []
+        const subGroupsNode = getBinaryNodeChild(result, 'sub_groups')
+        
+        if (subGroupsNode) {
+            const groupNodes = getBinaryNodeChildren(subGroupsNode, 'group')
+            
+            for (const groupNode of groupNodes) {
+                const isDefault = groupNode.attrs.default_sub_group === 'true' || !!getBinaryNodeChild(groupNode, 'default_sub_group')
+                linkedGroupsData.push({
+                    id: groupNode.attrs.id ? jidEncode(groupNode.attrs.id, 'g.us') : undefined,
+                    subject: groupNode.attrs.subject || '',
+                    creation: groupNode.attrs.creation ? Number(groupNode.attrs.creation) : undefined,
+                    owner: groupNode.attrs.creator ? jidNormalizedUser(groupNode.attrs.creator) : undefined,
+                    size: groupNode.attrs.size ? Number(groupNode.attrs.size) : undefined,
+                    isDefaultSubGroup: isDefault
+                })
+            }
+        }
+        
+        return {
+            communityJid,
+            isCommunity,
+            linkedGroups: linkedGroupsData
+        }
+    }
+
     return {
         ...suki,
         communityQuery, 
@@ -225,46 +295,15 @@ const makeCommunitiesSocket = (config) => {
                 }
             ])
         },
-        communityFetchLinkedGroups: async (jid) => {
-            let communityJid = jid
-            let isCommunity = false
-            
-            // Try to determine if it is a subgroup or a community
-            const metadata = await groupMetadata(jid)
-            
-            if (metadata.linkedParent) {
-                // It is a subgroup, get the community jid
-                communityJid = metadata.linkedParent
-            }
-            
-            else {
-                // It is a community
-                isCommunity = true
-            }
-            
-            // Fetch all subgroups of the community
-            const result = await communityQuery(communityJid, 'get', [{ tag: 'sub_groups', attrs: {} }])
-            const linkedGroupsData = []
-            const subGroupsNode = getBinaryNodeChild(result, 'sub_groups')
-            
-            if (subGroupsNode) {
-                const groupNodes = getBinaryNodeChildren(subGroupsNode, 'group')
-                
-                for (const groupNode of groupNodes) {
-                    linkedGroupsData.push({
-                        id: groupNode.attrs.id ? jidEncode(groupNode.attrs.id, 'g.us') : undefined,
-                        subject: groupNode.attrs.subject || '',
-                        creation: groupNode.attrs.creation ? Number(groupNode.attrs.creation) : undefined,
-                        owner: groupNode.attrs.creator ? jidNormalizedUser(groupNode.attrs.creator) : undefined,
-                        size: groupNode.attrs.size ? Number(groupNode.attrs.size) : undefined
-                    })
-                }
-            }
-            
+        communityFetchLinkedGroups,
+        communityFetchSubGroups: async (jid) => {
+            const data = await communityFetchLinkedGroups(jid)
+            const defaultSubGroup = data.linkedGroups.find(g => g.isDefaultSubGroup) || null
+            const subGroups = data.linkedGroups.filter(g => !g.isDefaultSubGroup)
             return {
-                communityJid,
-                isCommunity,
-                linkedGroups: linkedGroupsData
+                ...data,
+                defaultSubGroup,
+                subGroups
             }
         },
         communityRequestParticipantsList: async (jid) => {
@@ -280,32 +319,7 @@ const makeCommunitiesSocket = (config) => {
             
             return participants.map(v => v.attrs)
         },
-        communityRequestParticipantsUpdate: async (jid, participants, action) => {
-            const result = await communityQuery(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 }
-            })
-        },
+        communityRequestParticipantsUpdate,
         communityParticipantsUpdate: async (jid, participants, action) => {
             const result = await communityQuery(jid, 'set', [
                 {
@@ -442,10 +456,53 @@ const makeCommunitiesSocket = (config) => {
             await communityQuery(jid, 'set', [{ tag: 'member_add_mode', attrs: {}, content: mode }])
         },
         communityJoinApprovalMode: async (jid, mode) => {
+            const state = (mode === true || mode === 'on') ? 'on' : (mode === false || mode === 'off' ? 'off' : mode)
             await communityQuery(jid, 'set', [
-                { tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'community_join', attrs: { state: mode } }] }
+                { tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'community_join', attrs: { state } }] }
             ])
         },
+        communityMembershipApprovalMode: async (jid, mode) => {
+            const state = (mode === true || mode === 'on') ? 'on' : 'off'
+            await communityQuery(jid, 'set', [
+                { tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'community_join', attrs: { state } }] }
+            ])
+        },
+        communityApprovePendingParticipants: async (jid, participants) => {
+            const list = Array.isArray(participants) ? participants : [participants]
+            return communityRequestParticipantsUpdate(jid, list, 'approve')
+        },
+        communityRejectPendingParticipants: async (jid, participants) => {
+            const list = Array.isArray(participants) ? participants : [participants]
+            return communityRequestParticipantsUpdate(jid, list, 'reject')
+        },
+        communityUpdatePermissions: async (jid, policies = {}) => {
+            const results = {}
+            if (typeof policies.announce === 'boolean') {
+                await communityQuery(jid, 'set', [{ tag: policies.announce ? 'announcement' : 'not_announcement', attrs: {} }])
+                results.announce = policies.announce
+            }
+            if (typeof policies.restrict === 'boolean') {
+                await communityQuery(jid, 'set', [{ tag: policies.restrict ? 'locked' : 'unlocked', attrs: {} }])
+                results.restrict = policies.restrict
+            }
+            if (policies.memberAddMode) {
+                await communityQuery(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 communityQuery(jid, 'set', [{ tag: 'membership_approval_mode', attrs: {}, content: [{ tag: 'community_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 communityQuery(jid, 'set', [content])
+                results.ephemeral = policies.ephemeral
+            }
+            return results
+        },
         communityFetchAllParticipating
     }
 }
@@ -489,12 +546,12 @@ const extractCommunityMetadata = (result) => {
         memberAddMode,
         participants: getBinaryNodeChildren(community, 'participant').map(({ attrs }) => {
             return {
-                id: mode === WAMessageAddressingMode.LID ? community.phone_number : attrs.jid,
-                lid: mode === WAMessageAddressingMode.LID ? community.jid : attrs.lid, 
+                id: mode === WAMessageAddressingMode.LID ? attrs.phone_number : attrs.jid,
+                lid: mode === WAMessageAddressingMode.LID ? attrs.jid : attrs.lid, 
                 admin: (attrs.type || null),
             }
         }),
-        ephemeralDuration: eph ? Number(ph) : undefined, 
+        ephemeralDuration: eph ? Number(eph) : undefined, 
         addressingMode: mode
     }