@areumtecnologia/wasockets 2.2.3 → 2.3.1

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

package/lib/Client/Modules/ChatManager.js

@@ -0,0 +1,113 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class ChatManager {
+    /**
+     * @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
+    }
+
+    /**
+     * Fixa a conversa no topo
+     * @param {string} jid
+     */
+    async pin(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.chatModify({ pin: true }, targetJid)
+    }
+
+    /**
+     * Desafixa a conversa do topo
+     * @param {string} jid
+     */
+    async unpin(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.chatModify({ pin: false }, targetJid)
+    }
+
+    /**
+     * Silencia notificações do chat
+     * @param {string} jid
+     * @param {number} [durationMs=86400000] - Duração em ms (padrão: 24h, null para permanente)
+     */
+    async mute(jid, durationMs = 86400000) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.chatModify({ mute: durationMs }, targetJid)
+    }
+
+    /**
+     * Reativa o som do chat
+     * @param {string} jid
+     */
+    async unmute(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.chatModify({ mute: null }, targetJid)
+    }
+
+    /**
+     * Arquiva uma conversa
+     * @param {string} jid
+     */
+    async archive(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.chatModify({ archive: true }, targetJid)
+    }
+
+    /**
+     * Desarquiva uma conversa
+     * @param {string} jid
+     */
+    async unarchive(jid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        return sock.chatModify({ archive: false }, targetJid)
+    }
+
+    /**
+     * Marca ou desmarca o chat como favorito
+     * @param {string} jid
+     * @param {boolean} [isFavorite=true]
+     */
+    async setFavorite(jid, isFavorite = true) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        if (!sock.updateFavorite) {
+            throw new Error('updateFavorite indisponível no socket.')
+        }
+        return sock.updateFavorite(targetJid, isFavorite)
+    }
+
+    /**
+     * Salva uma anotação interna no contato (recurso exclusivo WaSockets)
+     * @param {string} jid
+     * @param {string} note
+     */
+    async setChatNote(jid, note) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(jid)
+        if (!sock.updateChatNote) {
+            throw new Error('updateChatNote indisponível no socket.')
+        }
+        return sock.updateChatNote(targetJid, note)
+    }
+}
+
+exports.ChatManager = ChatManager
+exports.default = ChatManager

package/lib/Client/Modules/CommunityManager.js

@@ -0,0 +1,136 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { JidNormalizer } = require("../Normalizers/JidNormalizer")
+
+class CommunityManager {
+    /**
+     * @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 uma nova comunidade (grupo pai de avisos)
+     * @param {string} subject - Nome da comunidade
+     * @param {string} [description=''] - Descrição da comunidade
+     */
+    async create(subject, description = '') {
+        const sock = this._getSock()
+        if (!sock.communityCreate) {
+            throw new Error('communityCreate indisponível no socket.')
+        }
+        return sock.communityCreate(subject, description)
+    }
+
+    /**
+     * Obtém metadados da comunidade
+     * @param {string} communityJid
+     */
+    async getMetadata(communityJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(communityJid)
+        if (!sock.communityMetadata) {
+            throw new Error('communityMetadata indisponível no socket.')
+        }
+        return sock.communityMetadata(targetJid)
+    }
+
+    /**
+     * Cria um novo subgrupo já vinculado à comunidade
+     * @param {string} communityJid
+     * @param {string} subject - Nome do subgrupo
+     * @param {string[]} [participants=[]]
+     */
+    async createSubgroup(communityJid, subject, participants = []) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(communityJid)
+        const jids = participants.map(JidNormalizer.toJid)
+        if (!sock.communityCreateGroup) {
+            throw new Error('communityCreateGroup indisponível no socket.')
+        }
+        return sock.communityCreateGroup(subject, jids, targetJid)
+    }
+
+    /**
+     * Vincula um grupo existente à comunidade
+     * @param {string} communityJid
+     * @param {string} groupJid
+     */
+    async linkSubgroup(communityJid, groupJid) {
+        const sock = this._getSock()
+        const parentJid = JidNormalizer.toJid(communityJid)
+        const childJid = JidNormalizer.toJid(groupJid)
+        if (!sock.communityLinkGroup) {
+            throw new Error('communityLinkGroup indisponível no socket.')
+        }
+        return sock.communityLinkGroup(childJid, parentJid)
+    }
+
+    /**
+     * Desvincula um subgrupo da comunidade
+     * @param {string} communityJid
+     * @param {string} groupJid
+     */
+    async unlinkSubgroup(communityJid, groupJid) {
+        const sock = this._getSock()
+        const parentJid = JidNormalizer.toJid(communityJid)
+        const childJid = JidNormalizer.toJid(groupJid)
+        if (!sock.communityUnlinkGroup) {
+            throw new Error('communityUnlinkGroup indisponível no socket.')
+        }
+        return sock.communityUnlinkGroup(childJid, parentJid)
+    }
+
+    /**
+     * Retorna a lista de subgrupos vinculados à comunidade
+     * @param {string} communityJid
+     */
+    async getSubgroups(communityJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(communityJid)
+        if (!sock.communityFetchLinkedGroups) {
+            throw new Error('communityFetchLinkedGroups indisponível no socket.')
+        }
+        return sock.communityFetchLinkedGroups(targetJid)
+    }
+
+    /**
+     * Sai da comunidade
+     * @param {string} communityJid
+     */
+    async leave(communityJid) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(communityJid)
+        if (!sock.communityLeave) {
+            throw new Error('communityLeave indisponível no socket.')
+        }
+        return sock.communityLeave(targetJid)
+    }
+
+    /**
+     * Altera o nome da comunidade
+     * @param {string} communityJid
+     * @param {string} subject
+     */
+    async setName(communityJid, subject) {
+        const sock = this._getSock()
+        const targetJid = JidNormalizer.toJid(communityJid)
+        if (!sock.communityUpdateSubject) {
+            throw new Error('communityUpdateSubject indisponível no socket.')
+        }
+        return sock.communityUpdateSubject(targetJid, subject)
+    }
+}
+
+exports.CommunityManager = CommunityManager
+exports.default = CommunityManager