@juzi/wechaty-puppet-whatsapp 1.0.0

package/src/puppet-whatsapp.ts

@@ -0,0 +1,339 @@
+/**
+ *   Wechaty - https://github.com/chatie/wechaty
+ *
+ *   @copyright 2016-2018 Huan LI <zixia@zixia.net>
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+import * as PUPPET from '@juzi/wechaty-puppet'
+import { log } from '@juzi/wechaty-puppet'
+import type { MemoryCard } from 'memory-card'
+
+import {
+  VERSION,
+}                                     from './config.js'
+
+import Manager from './manager.js'
+import type { RequestManagerAPIs } from './request/request-manager.js'
+import type { ClientOptions, WhatsAppClientType } from './schema/whatsapp-type.js'
+import WAError from './exception/whatsapp-error.js'
+import { WA_ERROR_TYPE } from './exception/error-type.js'
+import { EventName } from './schema/event-name.js'
+import { RequestPool } from './request/request-pool.js'
+import { contactSelfQRCode, contactSelfName, contactSelfSignature } from './puppet-mixin/contact-self.js'
+import { contactAlias, contactPhone, contactCorporationRemark, contactDescription, contactList, contactAvatar, contactRawPayloadParser, contactRawPayload } from './puppet-mixin/contact.js'
+import { conversationReadMark } from './puppet-mixin/conversation.js'
+import { friendshipRawPayload, friendshipRawPayloadParser, friendshipSearchPhone, friendshipSearchWeixin, friendshipAdd, friendshipAccept, friendshipSearchHandle } from './puppet-mixin/friendship.js'
+import { messageContact, messageImage, messageRecall, messageFile, messageUrl, messageMiniProgram, messageSendText, messageSendFile, messageSendContact, messageSendUrl, messageSendMiniProgram, messageForward, messageRawPayloadParser, messageRawPayload, messagePost } from './puppet-mixin/message.js'
+import { roomRawPayloadParser, roomRawPayload, roomList, roomDel, roomAvatar, roomAdd, roomTopic, roomCreate, roomQuit, roomQRCode, roomMemberList, roomMemberRawPayload, roomMemberRawPayloadParser, roomAnnounce, roomInvitationAccept, roomInvitationRawPayload, roomInvitationRawPayloadParser } from './puppet-mixin/room.js'
+import { tagContactAdd, tagContactRemove, tagContactDelete, tagContactList } from './puppet-mixin/tag.js'
+
+// import { Attachment } from './mock/user/types'
+type ManagerWithRequestManager = Manager & RequestManagerAPIs
+
+export type PuppetWhatsAppOptions = PUPPET.PuppetOptions & {
+  memory?: MemoryCard
+  puppeteerOptions?: ClientOptions
+}
+
+const PRE = 'PuppetWhatsapp'
+
+class PuppetWhatsapp extends PUPPET.Puppet {
+
+  static override readonly VERSION = VERSION
+
+  public manager: ManagerWithRequestManager
+
+  constructor (
+    override options: PuppetWhatsAppOptions = {},
+  ) {
+    super(options)
+    log.verbose(PRE, 'constructor()')
+
+    this.manager = new Manager(this.options) as ManagerWithRequestManager
+  }
+
+  override version () {
+    return VERSION
+  }
+
+  override async onStart (): Promise<void> {
+    log.verbose(PRE, 'onStart()')
+
+    let whatsapp: WhatsAppClientType
+    try {
+      whatsapp = await this.startManager(this.manager)
+    } catch (err) {
+      log.error(PRE, `Can not start whatsapp, error: ${(err as Error).message}`)
+      throw WAError(WA_ERROR_TYPE.ERR_INIT, `Can not start whatsapp, error: ${(err as Error).message}`)
+    }
+
+    /**
+     * Huan(202102): Wait for Puppeteer to be inited before resolve start() for robust state management
+     */
+    const future = new Promise<void>(resolve => {
+      function check () {
+        if (whatsapp.pupBrowser) {
+          resolve()
+        } else {
+          setTimeout(check, 100)
+        }
+      }
+
+      check()
+    })
+
+    return Promise.race([
+      future,
+      this.state.stable('inactive'),
+    ])
+  }
+
+  private async startManager (manager: Manager) {
+    manager.on({
+      dirty: this.onDirty.bind(this),
+      error: this.onError.bind(this),
+      friendship: this.onFriendship.bind(this),
+      heartbeat: data => this.emit('heartbeat', {
+        data,
+      }),
+      login: this.onLogin.bind(this),
+      logout: this.onLogout.bind(this),
+      message: this.onMessage.bind(this),
+      ready: this.onReady.bind(this),
+      reset: this.onReset.bind(this),
+      'room-invite': this.onRoomInvite.bind(this),
+      'room-join': this.onRoomJoin.bind(this),
+      'room-leave': this.onRoomLeave.bind(this),
+      'room-topic': this.onRoomTopic.bind(this),
+      scan: this.onScan.bind(this),
+    })
+
+    const memory = this.memory
+    const whatsapp = await this.manager.start(memory)
+    return whatsapp
+  }
+
+  override async onStop (): Promise<void> {
+    log.verbose(PRE, 'onStop()')
+    try {
+      await this.stopManager()
+    } catch (err) {
+      log.error(PRE, `Can not stop, error: ${(err as Error).message}`)
+    }
+  }
+
+  private async stopManager () {
+    this.manager.off('*')
+    await this.manager.stop()
+  }
+
+  /**
+   * Event section: onXXX
+   */
+  private async onLogin (wxid: string): Promise<void> {
+    log.verbose(PRE, 'onLogin(%s)', wxid)
+
+    if (this.isLoggedIn) {
+      log.warn(PRE, 'onLogin(%s) already login? NOOP', wxid)
+      return
+    }
+    log.info(PRE, `${EventName.LOGIN}, ${wxid}`)
+
+    await super.login(wxid)
+    // no need to emit login since super.login will do that
+    // this.emit('login', { contactId: wxid })
+  }
+
+  private async onLogout (wxid: string, message: string): Promise<void> {
+    log.verbose(PRE, 'onLogout(%s, %s)', wxid, message)
+
+    if (!this.isLoggedIn) {
+      log.warn(PRE, 'onLogout(%s) already logged out?', wxid)
+    }
+    log.info(PRE, `${EventName.LOGOUT}, ${wxid}`)
+
+    const requestPool = RequestPool.Instance
+    requestPool.clearPool()
+
+    this.emit('logout', { contactId: wxid, data: message })
+  }
+
+  private async onMessage (message: PUPPET.payloads.EventMessage): Promise<void> {
+    log.verbose(PRE, 'onMessage(%s)', JSON.stringify(message))
+    this.emit('message', message)
+  }
+
+  private async onScan (payload: PUPPET.payloads.EventScan): Promise<void> {
+    log.verbose(PRE, 'onScan(%s)', JSON.stringify(payload))
+
+    log.info(PRE, `${EventName.SCAN}`)
+    this.emit('scan', payload)
+  }
+
+  private async onError (e: string) {
+    log.info(PRE, `${EventName.ERROR}, ${e}`)
+    this.emit('error', {
+      data: e,
+    })
+  }
+
+  private async onReset (reason: string) {
+    log.info(PRE, `${EventName.RESET}, ${reason}`)
+    this.emit('reset', { data: reason } as PUPPET.payloads.EventReset)
+  }
+
+  private async onFriendship (payload: PUPPET.payloads.EventFriendship): Promise<void> {
+    const contactId = await this.messageContact(payload.friendshipId)
+    // NOTE: this function automatically put non-contact into cache
+    await this.contactRawPayload(contactId)
+    this.emit('friendship', payload)
+  }
+
+  private async onRoomJoin (payload: PUPPET.payloads.EventRoomJoin) {
+    const roomId = payload.roomId
+    await this.dirtyPayload(PUPPET.types.Payload.Room, roomId)
+    this.emit('room-join', payload)
+  }
+
+  private async onRoomLeave (payload: PUPPET.payloads.EventRoomLeave) {
+    const roomId = payload.roomId
+    await this.dirtyPayload(PUPPET.types.Payload.Room, roomId)
+    this.emit('room-leave', payload)
+  }
+
+  private async onRoomTopic (payload: PUPPET.payloads.EventRoomTopic) {
+    const roomId = payload.roomId
+    await this.dirtyPayload(PUPPET.types.Payload.Room, roomId)
+    this.emit('room-topic', payload)
+  }
+
+  private async onRoomInvite (payload: PUPPET.payloads.EventRoomInvite) {
+    this.emit('room-invite', payload)
+  }
+
+  private async onReady () {
+    log.verbose(PRE, 'onReady()')
+
+    log.info(PRE, `${EventName.READY}`)
+    this.emit('ready', { data: 'ready' })
+  }
+
+  /**
+   * Override Methods
+   */
+
+  override async logout () {
+    await super.logout()
+    if (!this.isLoggedIn) {
+      log.verbose(PRE, 'logout() do nothing')
+      return
+    }
+    return this.manager.logout()
+  }
+
+  override ding (data?: string): void {
+    log.silly(PRE, 'ding(%s)', data || '')
+    setTimeout(() => this.emit('dong', { data: data || '' }), 1000)
+  }
+
+  /**
+   * ContactSelf
+   */
+  override contactSelfQRCode = contactSelfQRCode
+  override contactSelfName = contactSelfName
+  override contactSelfSignature = contactSelfSignature
+
+  /**
+   * Contact
+   */
+  override contactAlias = contactAlias
+  override contactPhone = contactPhone
+  override contactCorporationRemark = contactCorporationRemark
+  override contactDescription = contactDescription
+  override contactList = contactList
+  override contactAvatar = contactAvatar
+  override contactRawPayloadParser = contactRawPayloadParser
+  override contactRawPayload = contactRawPayload
+
+  /**
+   * Conversation
+   */
+  override conversationReadMark = conversationReadMark
+
+  /**
+   * Message
+   */
+  // FIXME: need to implement in wechaty-puppet
+  messagePost = messagePost
+  override messageContact = messageContact
+  override messageImage = messageImage
+  override messageRecall = messageRecall
+  override messageFile = messageFile
+  override messageUrl = messageUrl
+  override messageMiniProgram = messageMiniProgram
+  override messageSendText = messageSendText
+  override messageSendFile = messageSendFile
+  override messageSendContact = messageSendContact
+  override messageSendUrl = messageSendUrl
+  override messageSendMiniProgram = messageSendMiniProgram
+  override messageForward = messageForward
+
+  override messageRawPayloadParser = messageRawPayloadParser
+  override messageRawPayload = messageRawPayload
+
+  /**
+    * Room
+    */
+  override roomRawPayloadParser = roomRawPayloadParser
+  override roomRawPayload = roomRawPayload
+  override roomList = roomList
+  override roomDel = roomDel
+  override roomAvatar = roomAvatar
+  override roomAdd = roomAdd
+  override roomTopic = roomTopic
+  override roomCreate = roomCreate
+  override roomQuit = roomQuit
+  override roomQRCode = roomQRCode
+  override roomMemberList = roomMemberList
+  override roomMemberRawPayload = roomMemberRawPayload
+  override roomMemberRawPayloadParser = roomMemberRawPayloadParser
+  override roomAnnounce = roomAnnounce
+  override roomInvitationAccept = roomInvitationAccept
+  override roomInvitationRawPayload =  roomInvitationRawPayload
+  override roomInvitationRawPayloadParser = roomInvitationRawPayloadParser
+
+  /**
+    * Friendship
+    */
+  override friendshipRawPayload = friendshipRawPayload
+  override friendshipRawPayloadParser = friendshipRawPayloadParser
+  override friendshipSearchPhone = friendshipSearchPhone
+  override friendshipSearchWeixin = friendshipSearchWeixin
+  override friendshipSearchHandle = friendshipSearchHandle
+  override friendshipAdd = friendshipAdd
+  override friendshipAccept = friendshipAccept
+
+  /**
+    * Tag
+    */
+  override tagContactAdd = tagContactAdd
+  override tagContactRemove = tagContactRemove
+  override tagContactDelete = tagContactDelete
+  override tagContactList = tagContactList
+
+}
+
+export { PuppetWhatsapp }
+export default PuppetWhatsapp

package/src/request/rate-manager.ts

@@ -0,0 +1,118 @@
+import { EventEmitter } from 'events'
+import { log } from '../config.js'
+import { WA_ERROR_TYPE } from '../exception/error-type.js'
+import WAError from '../exception/whatsapp-error.js'
+import { sleep } from '../helper/miscellaneous.js'
+
+interface FunctionObj {
+  func: () => any,
+  resolve: (data: any) => void,
+  reject: (e: any) => void,
+  delayBefore?: number,
+  delayAfter?: number,
+  uniqueKey?: string,
+}
+
+export interface RateOptions {
+  queueId?: string,
+  delayBefore?: number,
+  delayAfter?: number,
+  uniqueKey?: string,
+}
+
+type RateManagerEvents = 'error'
+
+const MAX_QUEUE_SIZE = 5000
+
+export class RateManager extends EventEmitter {
+
+  private counter = 0
+
+  public override emit(event: 'error', error: string): boolean
+  public override emit(event: never, ...args: never[]): never
+  public override emit (event: RateManagerEvents, ...args: any[]): boolean {
+    return super.emit(event, ...args)
+  }
+
+  public override on(event: 'error', listener: (error: string) => void): this
+  public override on(event: never, listener: never): never
+  public override on (event: RateManagerEvents, listener: (...args: any[]) => void): this {
+    super.on(event, listener)
+    return this
+  }
+
+  private functionQueueMap: { [id: string]: FunctionObj[] } = {}
+  private runningMap: { [id: string]: boolean } = {}
+
+  public getQueueLength (queueId: string) {
+    if (!this.functionQueueMap[queueId]) {
+      return 0
+    }
+    return this.functionQueueMap[queueId]!.length
+  }
+
+  public async exec<T> (func: () => T, options: RateOptions = {}) {
+    const queueId = options.queueId || 'default'
+    const { delayAfter, delayBefore, uniqueKey } = options
+
+    if (!this.functionQueueMap[queueId]) {
+      this.functionQueueMap[queueId] = []
+    }
+
+    if (this.functionQueueMap[queueId]!.length > MAX_QUEUE_SIZE) {
+      if (this.counter % MAX_QUEUE_SIZE === 0) {
+        log.error(`EXCEED_QUEUE_SIZE: Max queue size for id: ${queueId} reached: ${this.functionQueueMap[queueId]!.length} > ${MAX_QUEUE_SIZE}(max queue size). Drop these tasks.`)
+        this.counter = 0
+      }
+      this.counter++
+    }
+
+    return new Promise<T>((resolve, reject) => {
+      this.functionQueueMap[queueId]!.push({ delayAfter, delayBefore, func, reject, resolve, uniqueKey })
+      if (!this.runningMap[queueId]) {
+        this.runningMap[queueId] = true
+        void this.execNext(queueId)
+      }
+    })
+  }
+
+  private async execNext (queueId: string) {
+    const queue = this.functionQueueMap[queueId]
+    if (!queue) {
+      return
+    }
+
+    const funcObj = queue.shift()
+    if (!funcObj) {
+      throw WAError(WA_ERROR_TYPE.ERR_RATE_FUNCTION_NOT_FOUND, `can not get funcObj from queue with id: ${queueId}.`)
+    }
+    const { delayAfter, delayBefore, func, resolve, reject, uniqueKey } = funcObj
+    await sleep(delayBefore)
+    try {
+      const result = await func()
+      resolve(result)
+      /**
+       * If uniqueKey is given, will resolve functions with same key in the queue
+       */
+      if (uniqueKey) {
+        const sameFuncIndexes = queue.map((f, index) => ({ func: f, index }))
+          .filter(o => o.func.uniqueKey === uniqueKey)
+          .map(o => o.index)
+          .sort((a, b) => b - a)
+        for (const index of sameFuncIndexes) {
+          const [sameFunc] = queue.splice(index, 1)
+          sameFunc!.resolve(result)
+        }
+      }
+    } catch (e) {
+      reject(e)
+    }
+    await sleep(delayAfter)
+    if (queue.length > 0) {
+      await this.execNext(queueId)
+    } else {
+      delete this.runningMap[queueId]
+    }
+  }
+
+}

package/src/request/request-manager.ts

@@ -0,0 +1,174 @@
+import type {
+  WhatsAppClientType,
+  WhatsAppContact,
+  InviteV4Data,
+  MessageContent,
+  MessageSendOptions,
+  CreateGroupResult,
+} from '../schema/whatsapp-type.js'
+import { RateManager } from './rate-manager.js'
+
+export class RequestManager {
+
+  private whatsapp: WhatsAppClientType
+  private rateManager: RateManager
+
+  constructor (whatsapp: WhatsAppClientType) {
+    this.whatsapp = whatsapp
+    this.rateManager = new RateManager()
+  }
+
+  public logout () {
+    return this.whatsapp.logout()
+  }
+
+  public acceptPrivateRoomInvite (invitation: InviteV4Data) {
+    return this.whatsapp.acceptGroupV4Invite(invitation)
+  }
+
+  public acceptRoomInvite (inviteCode: string) {
+    return this.whatsapp.acceptInvite(inviteCode)
+  }
+
+  public archiveChat (chatId: string) {
+    return this.whatsapp.archiveChat(chatId)
+  }
+
+  public unarchiveChat (chatId: string) {
+    return this.whatsapp.unarchiveChat(chatId)
+  }
+
+  public createRoom (name: string, participants: WhatsAppContact[] | string[]): Promise<CreateGroupResult> {
+    return this.whatsapp.createGroup(name, participants) as unknown as Promise<CreateGroupResult>
+  }
+
+  public destroy () {
+    return this.whatsapp.destroy()
+  }
+
+  public getBLockedContacts () {
+    return this.whatsapp.getBlockedContacts()
+  }
+
+  public getChatById (chatId: string) {
+    return this.whatsapp.getChatById(chatId)
+  }
+
+  public getChatLabels (chatId: string) {
+    return this.whatsapp.getChatLabels(chatId)
+  }
+
+  public getChats () {
+    return this.whatsapp.getChats()
+  }
+
+  public getChatsByLabelId (labelId: string) {
+    return this.whatsapp.getChatsByLabelId(labelId)
+  }
+
+  public getContactById (contactId: string) {
+    return this.whatsapp.getContactById(contactId)
+  }
+
+  public getContacts () {
+    return this.whatsapp.getContacts()
+  }
+
+  public getCountryCode (whatsappId: string) {
+    return this.whatsapp.getCountryCode(whatsappId)
+  }
+
+  public getFormattedNumber (whatsappId: string) {
+    return this.whatsapp.getFormattedNumber(whatsappId)
+  }
+
+  public getInviteInfo (inviteId: string) {
+    return this.whatsapp.getInviteInfo(inviteId)
+  }
+
+  public getLabelById (labelId: string) {
+    return this.whatsapp.getLabelById(labelId)
+  }
+
+  public getLabels () {
+    return this.whatsapp.getLabels()
+  }
+
+  public getWhatsappIdByNumber (number: string) {
+    return this.whatsapp.getNumberId(number)
+  }
+
+  public getAvatarUrl (contactId: string) {
+    return this.whatsapp.getProfilePicUrl(contactId)
+  }
+
+  public getState () {
+    return this.whatsapp.getState()
+  }
+
+  public getWhatsAppVersion () {
+    return this.whatsapp.getWWebVersion()
+  }
+
+  public init () {
+    return this.whatsapp.initialize()
+  }
+
+  public isWhatsappUser (contactId: string) {
+    return this.whatsapp.isRegisteredUser(contactId)
+  }
+
+  public markChatUnread (chatId: string) {
+    return this.whatsapp.markChatUnread(chatId)
+  }
+
+  public muteChat (chatId: string) {
+    return this.whatsapp.muteChat(chatId)
+  }
+
+  public unmuteChat (chatId: string) {
+    return this.whatsapp.unmuteChat(chatId)
+  }
+
+  public pinChat (chatId: string) {
+    return this.whatsapp.pinChat(chatId)
+  }
+
+  public unpinChat (chatId: string) {
+    return this.whatsapp.unpinChat(chatId)
+  }
+
+  public resetConnection () {
+    return this.whatsapp.resetState()
+  }
+
+  public searchMessage (query: string, options?: { chatId?: string, page?: number, limit?: number }) {
+    return this.whatsapp.searchMessages(query, options)
+  }
+
+  public sendMessage (chatId: string, content: MessageContent, options?: MessageSendOptions) {
+    return this.rateManager.exec(async () => {
+      return this.whatsapp.sendMessage(chatId, content, options)
+    }, { delayAfter: 1, queueId: chatId })
+  }
+
+  public sendPresenceAvailable () {
+    return this.whatsapp.sendPresenceAvailable()
+  }
+
+  public markChatRead (chatId: string) {
+    return this.whatsapp.sendSeen(chatId)
+  }
+
+  public setNickname (name: string) {
+    return this.whatsapp.setDisplayName(name)
+  }
+
+  public setStatusMessage (status: string) {
+    return this.whatsapp.setStatus(status)
+  }
+
+}
+
+export type RequestManagerAPIs = Pick<RequestManager, {readonly [K in keyof RequestManager]: RequestManager[K] extends Function ? K : never}[keyof RequestManager]>
+export const requestManagerKeys = Object.getOwnPropertyNames(RequestManager.prototype)

package/src/request/request-pool.spec.ts

@@ -0,0 +1,36 @@
+import { RequestPool } from './request-pool.js'
+import { test } from 'tstest'
+
+test('RequestPool request resolve test', async t => {
+  try {
+    const requestPool = RequestPool.Instance
+    t.ok(requestPool instanceof RequestPool)
+
+    const time = Date.now()
+    setTimeout(() => {
+      requestPool.resolveRequest('testRequest')
+    }, 3000)
+    // eslint-disable-next-line promise/always-return
+    await requestPool.pushRequest('testRequest')
+    t.ok(Math.abs(Date.now() - time - 3000) < 20)
+
+    t.pass('RequestPool request resolve test pass')
+  } catch (e) {
+    t.fail(e as any)
+  }
+})
+
+test('RequestPool clear test', async t => {
+  try {
+    const requestPool = RequestPool.Instance
+    t.ok(requestPool instanceof RequestPool)
+
+    void requestPool.pushRequest('testRequest')
+    requestPool.clearPool()
+    // @ts-ignore
+    t.ok(Object.getOwnPropertyNames(requestPool.poolMap).length === 0)
+    t.pass('testRequest clear test pass')
+  } catch (e) {
+    t.fail(e as any)
+  }
+})

package/src/request/request-pool.ts

@@ -0,0 +1,45 @@
+import { WA_ERROR_TYPE } from '../exception/error-type.js'
+import WAError from '../exception/whatsapp-error.js'
+export class RequestPool {
+
+  private static _instance?: RequestPool
+  private poolMap: {[id: string]: Function[]} = {}
+  private constructor () {}
+
+  public static get Instance () {
+    if (!this._instance) {
+      this._instance = new RequestPool()
+    }
+    return this._instance
+  }
+
+  public pushRequest (id: string, timeout?: number) {
+    const callback = new Promise<void>((resolve, reject) => {
+      if (!this.poolMap[id]) {
+        this.poolMap[id] = []
+      }
+      this.poolMap[id]!.push(resolve)
+      if (timeout) {
+        setTimeout(reject, timeout)
+      }
+    }).catch(() => {
+      delete this.poolMap[id]
+      throw WAError(WA_ERROR_TYPE.ERR_REQUEST_TIMEOUT, `TIMEOUT when processing request :${id}`)
+    })
+    return callback
+  }
+
+  public resolveRequest (id: string) {
+    const callbacks = this.poolMap[id]
+    if (!callbacks || callbacks.length === 0) {
+      return
+    }
+    callbacks.forEach(cb => cb())
+    delete this.poolMap[id]
+  }
+
+  public clearPool () {
+    this.poolMap = {}
+  }
+
+}