@areumtecnologia/wasockets 1.1.5 → 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

@@ -30,6 +30,7 @@ const {
 const { makeMutex } = require("../Utils/make-mutex")
 const {
   isPnUser, 
+  isLidUser, 
   getBinaryNodeChild, 
   getBinaryNodeChildren, 
   jidDecode, 
@@ -252,11 +253,141 @@ 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
         }
     }
     
+    const getPnUser = async (jid) => {
+        if (!jid) {
+            throw new Boom('Please input a jid user')
+        }
+        
+        if (!isLidUser(jid)) {
+            throw new Boom('Invalid JID: Not a LID user!')
+        }
+        
+        const targetJid = jidNormalizedUser(jid)
+        
+        const usyncQuery = new USyncQuery()
+        usyncQuery.protocols.push({
+            name: 'phone_number',
+            getQueryElement: () => ({
+                tag: 'phone_number',
+                attrs: {},
+                content: undefined
+            }),
+            getUserElement: () => null,
+            parser: (node) => node.attrs.phone_number || node.attrs.val
+        })
+        usyncQuery.users.push({
+            id: targetJid
+        })
+        
+        const result = await suki.executeUSyncQuery(usyncQuery)
+        
+        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()
         
@@ -914,6 +1045,39 @@ const makeChatsSocket = (config) => {
          }, jid) 
      }
     
+    /**
+     * Set or unset a chat as Favorite
+     */
+    const updateFavorite = (jid, favorite = true) => {
+        return chatModify({
+            favorite
+        }, jid)
+    }
+
+    /**
+     * Add or update a note for a chat (contact notes)
+     */
+    const updateChatNote = (jid, text) => {
+        return chatModify({
+            note: {
+                text,
+                deleted: false,
+                createdAt: Date.now()
+            }
+        }, jid)
+    }
+
+    /**
+     * Remove note for a chat
+     */
+    const removeChatNote = (jid) => {
+        return chatModify({
+            note: {
+                deleted: true
+            }
+        }, jid)
+    }
+    
     /**
      * Adds label
      */
@@ -1257,6 +1421,14 @@ const makeChatsSocket = (config) => {
         appStatePatchMutex, 
         notificationMutex, 
         getLidUser, 
+        getPnUser, 
+        toPn,
+        toLid,
+        resolveJid,
+        storeLidPnMapping,
+        updateFavorite, 
+        updateChatNote, 
+        removeChatNote, 
         fetchBlocklist,
         fetchStatus,
         fetchDisappearingDuration,