@areumtecnologia/wasockets 2.0.0 → 2.3.0

package/lib/Client/Context/CallContext.js

@@ -0,0 +1,96 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class CallContext {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     * @param {Object} callData - Inbound call offer or active call metadata
+     * @param {Object} [activeCallInstance] - Low-level WebAssembly ActiveCall instance
+     */
+    constructor(client, callData, activeCallInstance = null) {
+        this.client = client
+        this.raw = callData || {}
+
+        this.id = this.raw.id || this.raw.callId || ''
+        this.from = this.raw.from || this.raw.chatId || ''
+        this.fromNumber = JidNormalizer.toPhoneNumber(this.from)
+        this.isVideo = Boolean(this.raw.isVideo)
+        this.status = this.raw.status || 'calling'
+        this.startTime = this.raw.date ? new Date(this.raw.date).getTime() : Date.now()
+        this.instance = activeCallInstance || null
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Atende a chamada recebida via WebAssembly VoIP
+     * @param {Object} [options={}]
+     */
+    async accept(options = {}) {
+        const sock = this._getSock()
+        if (!sock.acceptCall) {
+            throw new Error('VoIP stack is not initialized on the underlying socket.')
+        }
+
+        const callOptions = {
+            isVideo: this.isVideo,
+            ...options
+        }
+
+        const activeCall = await sock.acceptCall(this.id, this.from, callOptions)
+        this.instance = activeCall
+        this.status = 'connected'
+        return activeCall
+    }
+
+    /**
+     * Rejeita a chamada recebida
+     * @param {number|string} [reason=0]
+     */
+    async reject(reason = 0) {
+        const sock = this._getSock()
+        if (sock.rejectCall) {
+            await sock.rejectCall(this.id, this.from, reason)
+        }
+        this.status = 'rejected'
+    }
+
+    /**
+     * Encerra a chamada em andamento
+     */
+    async hangup() {
+        if (this.instance && typeof this.instance.terminate === 'function') {
+            await this.instance.terminate()
+        } else if (this.instance && typeof this.instance.end === 'function') {
+            await this.instance.end()
+        } else {
+            const sock = this._getSock()
+            if (sock.rejectCall) {
+                await sock.rejectCall(this.id, this.from, 0)
+            }
+        }
+        this.status = 'ended'
+    }
+
+    /**
+     * Transmite áudio na chamada conectada
+     * @param {string|Buffer} audioPathOrBuffer
+     */
+    async playAudio(audioPathOrBuffer) {
+        if (this.instance && typeof this.instance.playAudio === 'function') {
+            return this.instance.playAudio(audioPathOrBuffer)
+        }
+        throw new Error('No active audio stream or call is not connected yet.')
+    }
+}
+
+exports.CallContext = CallContext
+exports.default = CallContext

package/lib/Client/Context/MediaObject.js

@@ -0,0 +1,155 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { promises: fsPromises } = require("fs")
+const { dirname } = require("path")
+const { downloadContentFromMessage } = require("../../Utils/messages-media")
+
+class MediaObject {
+    /**
+     * @param {Object} mediaNode - Raw protobuf media node (imageMessage, videoMessage, etc.)
+     * @param {string} canonicalType - Canonical message type ('image', 'video', 'voice', 'audio', 'document', 'sticker')
+     */
+    constructor(mediaNode, canonicalType) {
+        this.mediaNode = mediaNode || {}
+        this.rawType = canonicalType || 'unknown'
+        this.mediaType = this._resolveMediaType(canonicalType)
+
+        this.mimetype = this.mediaNode.mimetype || this._defaultMimetype(this.mediaType)
+        this.fileLength = Number(this.mediaNode.fileLength || 0)
+        this.fileName = this.mediaNode.fileName || ''
+        this.seconds = Number(this.mediaNode.seconds || 0)
+        this.isVoice = Boolean(this.mediaNode.ptt)
+        this.isAnimated = Boolean(this.mediaNode.gifPlayback || this.mediaNode.isAnimated)
+        this.extension = this._inferExtension()
+
+        this._bufferCache = null
+    }
+
+    _resolveMediaType(type) {
+        if (type === 'voice' || type === 'audio') return 'audio'
+        if (type === 'gif' || type === 'video') return 'video'
+        if (type === 'image') return 'image'
+        if (type === 'sticker') return 'sticker'
+        if (type === 'document') return 'document'
+        return 'document'
+    }
+
+    _defaultMimetype(mediaType) {
+        switch (mediaType) {
+            case 'image': return 'image/jpeg'
+            case 'video': return 'video/mp4'
+            case 'audio': return 'audio/ogg; codecs=opus'
+            case 'sticker': return 'image/webp'
+            default: return 'application/octet-stream'
+        }
+    }
+
+    _inferExtension() {
+        if (this.fileName && this.fileName.includes('.')) {
+            const ext = this.fileName.split('.').pop()
+            if (ext) return ext.toLowerCase()
+        }
+        if (!this.mimetype) return 'bin'
+
+        const base = this.mimetype.split(';')[0].trim().toLowerCase()
+        const sub = base.split('/')[1] || 'bin'
+
+        if (sub === 'jpeg') return 'jpg'
+        if (sub.includes('ogg') || sub.includes('opus')) return 'ogg'
+        if (sub === 'pdf') return 'pdf'
+        if (sub === 'webp') return 'webp'
+        if (sub === 'mp4') return 'mp4'
+        if (sub === 'mpeg') return 'mp3'
+
+        return sub.replace(/[^a-z0-9]/gi, '') || 'bin'
+    }
+
+    /**
+     * Downloads media as a Node.js Readable stream
+     * @param {Object} [options={}]
+     * @returns {Promise<import('stream').Readable>}
+     */
+    async toStream(options = {}) {
+        if (!this.mediaNode.mediaKey && !this.mediaNode.directPath && !this.mediaNode.url) {
+            throw new Error('Media node does not contain valid decryption keys or download URL.')
+        }
+
+        return downloadContentFromMessage(this.mediaNode, this.mediaType, options)
+    }
+
+    /**
+     * Downloads media and returns decrypted Buffer (caches in memory)
+     * @param {Object} [options={}]
+     * @returns {Promise<Buffer>}
+     */
+    async toBuffer(options = {}) {
+        if (this._bufferCache) {
+            return this._bufferCache
+        }
+
+        const stream = await this.toStream(options)
+        const chunks = []
+
+        for await (const chunk of stream) {
+            chunks.push(chunk)
+        }
+
+        this._bufferCache = Buffer.concat(chunks)
+        return this._bufferCache
+    }
+
+    /**
+     * Saves the downloaded media directly to disk
+     * @param {string} destinationPath - Full or relative file path to save
+     * @param {Object} [options={}]
+     * @returns {Promise<string>} Saved destination path
+     */
+    async save(destinationPath, options = {}) {
+        const buffer = await this.toBuffer(options)
+        const dir = dirname(destinationPath)
+        await fsPromises.mkdir(dir, { recursive: true })
+        await fsPromises.writeFile(destinationPath, buffer)
+        return destinationPath
+    }
+
+    /**
+     * Returns Base64 encoded string of the media
+     * @param {Object} [options={}]
+     * @returns {Promise<string>}
+     */
+    async toBase64(options = {}) {
+        const buffer = await this.toBuffer(options)
+        return buffer.toString('base64')
+    }
+
+    /**
+     * Returns a Data URI string (e.g. data:image/jpeg;base64,...)
+     * @param {Object} [options={}]
+     * @returns {Promise<string>}
+     */
+    async toDataUri(options = {}) {
+        const base64 = await this.toBase64(options)
+        return `data:${this.mimetype};base64,${base64}`
+    }
+
+    /**
+     * Returns a Sharp instance for image processing (requires sharp installed)
+     * @param {Object} [options={}]
+     */
+    async toSharp(options = {}) {
+        let sharp
+        try {
+            sharp = require('sharp')
+        } catch {
+            throw new Error('The "sharp" package is required to use toSharp(). Run "npm install sharp" to add it.')
+        }
+
+        const buffer = await this.toBuffer(options)
+        return sharp(buffer)
+    }
+}
+
+exports.MediaObject = MediaObject
+exports.default = MediaObject

package/lib/Client/Context/MessageContext.js

@@ -0,0 +1,146 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+const { MessageNormalizer } = require("../Normalizers/MessageNormalizer")
+const { MediaObject } = require("./MediaObject")
+
+class MessageContext {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     * @param {Object} rawMessage - proto.IWebMessageInfo
+     */
+    constructor(client, rawMessage) {
+        this.client = client
+        this.raw = rawMessage
+
+        const key = rawMessage.key || {}
+        this.id = key.id || ''
+        this.chatId = key.remoteJid || ''
+        this.isFromMe = Boolean(key.fromMe)
+        this.isGroup = JidNormalizer.isGroup(this.chatId)
+        this.isChannel = JidNormalizer.isNewsletter(this.chatId)
+        this.isBroadcast = JidNormalizer.isBroadcast(this.chatId)
+
+        // Sender determination (group participant vs 1:1 chat remoteJid)
+        this.sender = this.isGroup
+            ? (key.participant || rawMessage.participant || this.chatId)
+            : this.chatId
+        this.senderNumber = JidNormalizer.toPhoneNumber(this.sender)
+        this.senderName = rawMessage.pushName || this.senderNumber || 'Desconhecido'
+
+        // Content Extraction
+        const messageContent = rawMessage.message || null
+        this.type = MessageNormalizer.extractType(messageContent)
+        this.body = MessageNormalizer.extractBody(messageContent)
+        this.mediaNode = MessageNormalizer.extractMediaNode(messageContent)
+        this.hasMedia = Boolean(this.mediaNode)
+        this.media = this.hasMedia ? new MediaObject(this.mediaNode, this.type) : null
+        this.timestamp = Number(rawMessage.messageTimestamp || Math.floor(Date.now() / 1000))
+
+        // Context info & mentions
+        this.contextInfo = MessageNormalizer.extractContextInfo(messageContent)
+        this.mentionedJids = this.contextInfo?.mentionedJid || []
+
+        // Quoted message parsing
+        this.quoted = null
+        if (this.contextInfo?.quotedMessage) {
+            const quotedMsg = this.contextInfo.quotedMessage
+            this.quoted = {
+                id: this.contextInfo.stanzaId,
+                sender: this.contextInfo.participant,
+                senderNumber: JidNormalizer.toPhoneNumber(this.contextInfo.participant),
+                type: MessageNormalizer.extractType(quotedMsg),
+                body: MessageNormalizer.extractBody(quotedMsg),
+                raw: quotedMsg
+            }
+        }
+    }
+
+    /**
+     * Responde citando esta mensagem automaticamente
+     * @param {string|Object} content - Texto ou objeto de mensagem do WaSockets
+     * @param {Object} [options={}] - Opções adicionais de envio
+     */
+    async reply(content, options = {}) {
+        const payload = typeof content === 'string' ? { text: content } : content
+        return this.client.sendMessage(this.chatId, payload, {
+            quoted: this.raw,
+            ...options
+        })
+    }
+
+    /**
+     * Reage à mensagem com um emoji
+     * @param {string} emoji - Emoji único (ex: '👍', '❤️', '🔥')
+     */
+    async react(emoji) {
+        return this.client.sendMessage(this.chatId, {
+            react: {
+                text: emoji || '',
+                key: this.raw.key
+            }
+        })
+    }
+
+    /**
+     * Remove qualquer reação anteriormente atribuída a esta mensagem
+     */
+    async removeReaction() {
+        return this.react('')
+    }
+
+    /**
+     * Apaga esta mensagem para todos na conversa (revoke)
+     */
+    async delete() {
+        return this.client.sendMessage(this.chatId, {
+            delete: this.raw.key
+        })
+    }
+
+    /**
+     * Marca esta mensagem como lida (ticks azuis)
+     */
+    async markRead() {
+        if (!this.client.sock?.readMessages) return
+        return this.client.sock.readMessages([this.raw.key])
+    }
+
+    /**
+     * Encaminha esta mensagem para outro destinatário
+     * @param {string} targetJid - Destinatário
+     * @param {Object} [options={}]
+     */
+    async forward(targetJid, options = {}) {
+        return this.client.sendMessage(
+            targetJid,
+            { forward: this.raw, ...options }
+        )
+    }
+
+    /**
+     * Fixa a mensagem no chat com duração configurável
+     * @param {number} [durationInSeconds=86400] - 86400 (24h), 604800 (7d), 2592000 (30d)
+     */
+    async pin(durationInSeconds = 86400) {
+        if (!this.client.sock?.pinInChatMessage) {
+            throw new Error('Método pinInChatMessage indisponível no socket.')
+        }
+        return this.client.sock.pinInChatMessage(this.chatId, this.raw.key, 1, durationInSeconds)
+    }
+
+    /**
+     * Desafixa a mensagem do topo da conversa
+     */
+    async unpin() {
+        if (!this.client.sock?.pinInChatMessage) {
+            throw new Error('Método pinInChatMessage indisponível no socket.')
+        }
+        return this.client.sock.pinInChatMessage(this.chatId, this.raw.key, 2)
+    }
+}
+
+exports.MessageContext = MessageContext
+exports.default = MessageContext

package/lib/Client/Modules/BusinessManager.js

@@ -0,0 +1,155 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class BusinessManager {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     */
+    constructor(client) {
+        this.client = client
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Cria um produto no catálogo comercial
+     * @param {Object} product
+     * @param {string} product.name
+     * @param {string} [product.description]
+     * @param {number} product.price
+     * @param {string} [product.currency='BRL']
+     * @param {Array<string|Buffer>} [product.images=[]]
+     * @param {string} [product.retailerId]
+     * @param {string} [product.url]
+     * @param {boolean} [product.isHidden=false]
+     */
+    async createProduct(product) {
+        const sock = this._getSock()
+        if (!sock.productCreate) {
+            throw new Error('productCreate indisponível no socket.')
+        }
+
+        const formattedImages = (product.images || []).map(img => (
+            typeof img === 'string' ? { url: img } : img
+        ))
+
+        const payload = {
+            name: product.name,
+            description: product.description || '',
+            price: Math.round((Number(product.price) || 0) * 1000), // Preço em milésimos
+            currency: product.currency || 'BRL',
+            images: formattedImages,
+            retailerId: product.retailerId || undefined,
+            url: product.url || undefined,
+            isHidden: Boolean(product.isHidden)
+        }
+
+        return sock.productCreate(payload)
+    }
+
+    /**
+     * Atualiza dados de um produto existente no catálogo
+     * @param {string} productId
+     * @param {Object} update
+     */
+    async updateProduct(productId, update = {}) {
+        const sock = this._getSock()
+        if (!sock.productUpdate) {
+            throw new Error('productUpdate indisponível no socket.')
+        }
+
+        const payload = { ...update }
+        if (typeof update.price !== 'undefined') {
+            payload.price = Math.round((Number(update.price) || 0) * 1000)
+        }
+        if (Array.isArray(update.images)) {
+            payload.images = update.images.map(img => (
+                typeof img === 'string' ? { url: img } : img
+            ))
+        }
+
+        return sock.productUpdate(productId, payload)
+    }
+
+    /**
+     * Exclui um ou mais produtos do catálogo
+     * @param {string|string[]} productIds
+     * @returns {Promise<{ deleted: number }>}
+     */
+    async deleteProduct(productIds) {
+        const sock = this._getSock()
+        if (!sock.productDelete) {
+            throw new Error('productDelete indisponível no socket.')
+        }
+        const ids = Array.isArray(productIds) ? productIds : [productIds]
+        return sock.productDelete(ids)
+    }
+
+    /**
+     * Obtém detalhes de um produto específico
+     * @param {string} productId
+     * @param {string} [merchantJid] - JID da empresa (ou self se omitido)
+     */
+    async getProduct(productId, merchantJid) {
+        const sock = this._getSock()
+        if (!sock.getProduct) {
+            throw new Error('getProduct indisponível no socket.')
+        }
+        const targetJid = merchantJid ? JidNormalizer.toJid(merchantJid) : undefined
+        return sock.getProduct(targetJid, productId)
+    }
+
+    /**
+     * Lista produtos do catálogo
+     * @param {Object} [options={}]
+     * @param {string} [options.jid] - JID do comerciante
+     * @param {number} [options.limit=20]
+     * @param {string} [options.cursor]
+     */
+    async getCatalog(options = {}) {
+        const sock = this._getSock()
+        if (!sock.getCatalog) {
+            throw new Error('getCatalog indisponível no socket.')
+        }
+        const jid = options.jid ? JidNormalizer.toJid(options.jid) : undefined
+        return sock.getCatalog({ ...options, jid })
+    }
+
+    /**
+     * Lista coleções de produtos
+     * @param {string} [merchantJid]
+     * @param {number} [limit=20]
+     */
+    async getCollections(merchantJid, limit = 20) {
+        const sock = this._getSock()
+        if (!sock.getCollections) {
+            throw new Error('getCollections indisponível no socket.')
+        }
+        const targetJid = merchantJid ? JidNormalizer.toJid(merchantJid) : undefined
+        return sock.getCollections(targetJid, limit)
+    }
+
+    /**
+     * Obtém os detalhes de um pedido de checkout
+     * @param {string} orderId
+     * @param {string} orderToken - Token base64 do pedido
+     */
+    async getOrderDetails(orderId, orderToken) {
+        const sock = this._getSock()
+        if (!sock.getOrderDetails) {
+            throw new Error('getOrderDetails indisponível no socket.')
+        }
+        return sock.getOrderDetails(orderId, orderToken)
+    }
+}
+
+exports.BusinessManager = BusinessManager
+exports.default = BusinessManager

package/lib/Client/Modules/ChannelManager.js

@@ -0,0 +1,144 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class ChannelManager {
+    /**
+     * @param {import('../WaClient').WaClient} client
+     */
+    constructor(client) {
+        this.client = client
+    }
+
+    _getSock() {
+        if (!this.client.sock) {
+            throw new Error('Socket is not connected.')
+        }
+        return this.client.sock
+    }
+
+    /**
+     * Cria um novo canal / Newsletter
+     * @param {string} name
+     * @param {string} [description='']
+     */
+    async create(name, description = '') {
+        const sock = this._getSock()
+        return sock.newsletterCreate(name, description)
+    }
+
+    /**
+     * Obtém metadados de um canal por JID ou código de convite
+     * @param {string} channelJidOrInvite
+     */
+    async getMetadata(channelJidOrInvite) {
+        const sock = this._getSock()
+        const isInvite = !channelJidOrInvite.includes('@')
+        const type = isInvite ? 'invite' : 'jid'
+        return sock.newsletterMetadata(type, channelJidOrInvite)
+    }
+
+    /**
+     * Segue / Inscreve-se em um canal
+     * @param {string} channelJid
+     */
+    async subscribe(channelJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(channelJid)
+        return sock.newsletterFollow(targetJid)
+    }
+
+    /**
+     * Deixa de seguir um canal
+     * @param {string} channelJid
+     */
+    async unsubscribe(channelJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(channelJid)
+        return sock.newsletterUnfollow(targetJid)
+    }
+
+    /**
+     * Silencia notificações do canal
+     * @param {string} channelJid
+     */
+    async mute(channelJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(channelJid)
+        return sock.newsletterMute(targetJid)
+    }
+
+    /**
+     * Reativa notificações do canal
+     * @param {string} channelJid
+     */
+    async unmute(channelJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(channelJid)
+        return sock.newsletterUnmute(targetJid)
+    }
+
+    /**
+     * Retorna a lista de todos os canais inscritos da conta
+     */
+    async listSubscribed() {
+        const sock = this._getSock()
+        return sock.newsletterSubscribed()
+    }
+
+    /**
+     * Busca mensagens recentes do canal
+     * @param {string} channelJid
+     * @param {number} [count=20]
+     * @param {number} [sinceTimestamp]
+     */
+    async fetchMessages(channelJid, count = 20, sinceTimestamp) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(channelJid)
+        if (!sock.newsletterFetchMessages) {
+            throw new Error('newsletterFetchMessages indisponível no socket.')
+        }
+        return sock.newsletterFetchMessages(targetJid, count, sinceTimestamp)
+    }
+
+    /**
+     * Busca as reações de uma mensagem do canal
+     * @param {string} channelJid
+     * @param {string} messageServerId
+     */
+    async fetchReactions(channelJid, messageServerId) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(channelJid)
+        if (!sock.newsletterFetchReactions) {
+            throw new Error('newsletterFetchReactions indisponível no socket.')
+        }
+        return sock.newsletterFetchReactions(targetJid, messageServerId)
+    }
+
+    /**
+     * Altera o nome do canal
+     * @param {string} channelJid
+     * @param {string} name
+     */
+    async setName(channelJid, name) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(channelJid)
+        return sock.newsletterUpdate(targetJid, { name })
+    }
+
+    /**
+     * Altera a descrição do canal
+     * @param {string} channelJid
+     * @param {string} description
+     */
+    async setDescription(channelJid, description) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(channelJid)
+        return sock.newsletterUpdate(targetJid, { description })
+    }
+}
+
+exports.ChannelManager = ChannelManager
+exports.default = ChannelManager