@juzi/wechaty 1.0.18 → 1.0.22

package/src/schemas/wechaty-events.ts

@@ -12,17 +12,27 @@ import type {
   ContactInterface,
   MessageInterface,
   PostInterface,
+  TagInterface,
 }                       from '../user-modules/mod.js'
+import type { InfoUpdateInterface } from './update.js'
 
 const WECHATY_EVENT_DICT = {
   ...PUPPET.types.CHAT_EVENT_DICT,
-  dong      : 'Should be emitted after we call `Wechaty.ding()`',
-  error     : "Will be emitted when there's an Error occurred.",
-  heartbeat : 'Will be emitted periodically after the Wechaty started. If not, means that the Wechaty had died.',
-  puppet    : 'Will be emitted when the puppet has been set.',
-  ready     : 'All underlined data source are ready for use.',
-  start     : 'Will be emitted after the Wechaty had been started.',
-  stop      : 'Will be emitted after the Wechaty had been stopped.',
+  dong                 : 'Should be emitted after we call `Wechaty.ding()`',
+  error                : "Will be emitted when there's an Error occurred.",
+  heartbeat            : 'Will be emitted periodically after the Wechaty started. If not, means that the Wechaty had died.',
+  puppet               : 'Will be emitted when the puppet has been set.',
+  ready                : 'All underlined data source are ready for use.',
+  start                : 'Will be emitted after the Wechaty had been started.',
+  stop                 : 'Will be emitted after the Wechaty had been stopped.',
+  update               : 'Will be emitted when some info has been changed.',
+  'contact-tag-add'    : 'Will be emitted when contact has new tags.',
+  'contact-tag-remove' : 'Will be emitted when contact has some tags removed.',
+  'contact-name'       : 'Will be emitted when contact name has been changed.',
+  'contact-alias'      : 'Will be emitted when contact alias has been changed.',
+  'contact-phone'      : 'Will be emitted when contact phone has been changed.',
+  'contact-description': 'Will be emitted when contact description has been changed.',
+  'room-owner'         : 'Will be emitted when room owner has been changed.',
 } as const
 
 type WechatyEventName  = keyof typeof WECHATY_EVENT_DICT
@@ -30,22 +40,30 @@ type WechatyEventName  = keyof typeof WECHATY_EVENT_DICT
 /**
  * Wechaty Event Listener Interfaces
  */
-type WechatyEventListenerDong       = (data?: string)                                                                                   => void | Promise<void>
-type WechatyEventListenerError      = (error: GError)                                                                     => void | Promise<void>
-type WechatyEventListenerFriendship = (friendship: FriendshipInterface)                                                                 => void | Promise<void>
-type WechatyEventListenerHeartbeat  = (data: any)                                                                                       => void | Promise<void>
-type WechatyEventListenerLogin      = (user: ContactSelfInterface)                                                                      => void | Promise<void>
-type WechatyEventListenerLogout     = (user: ContactSelfInterface, reason?: string)                                                     => void | Promise<void>
-type WechatyEventListenerMessage    = (message: MessageInterface)                                                                       => void | Promise<void>
-type WechatyEventListenerPost       = (post: PostInterface)                                                                       => void | Promise<void>
-type WechatyEventListenerPuppet     = (puppet: PUPPET.impls.PuppetInterface)                                                             => void | Promise<void>
-type WechatyEventListenerReady      = ()                                                                                                => void | Promise<void>
-type WechatyEventListenerRoomInvite = (roomInvitation: RoomInvitationInterface)                                                         => void | Promise<void>
-type WechatyEventListenerRoomJoin   = (room: RoomInterface, inviteeList: ContactInterface[], inviter: ContactInterface,  date?: Date)   => void | Promise<void>
-type WechatyEventListenerRoomLeave  = (room: RoomInterface, leaverList: ContactInterface[],  remover?: ContactInterface, date?: Date)   => void | Promise<void>
-type WechatyEventListenerRoomTopic  = (room: RoomInterface, newTopic: string, oldTopic: string, changer: ContactInterface, date?: Date) => void | Promise<void>
-type WechatyEventListenerScan       = (qrcode: string, status: PUPPET.types.ScanStatus, data?: string)                                   => void | Promise<void>
-type WechatyEventListenerStartStop  = ()                                                                                                => void | Promise<void>
+type WechatyEventListenerDong               = (data?: string) => void | Promise<void>
+type WechatyEventListenerError              = (error: GError) => void | Promise<void>
+type WechatyEventListenerFriendship         = (friendship: FriendshipInterface) => void | Promise<void>
+type WechatyEventListenerHeartbeat          = (data: any) => void | Promise<void>
+type WechatyEventListenerLogin              = (user: ContactSelfInterface) => void | Promise<void>
+type WechatyEventListenerLogout             = (user: ContactSelfInterface, reason?: string) => void | Promise<void>
+type WechatyEventListenerMessage            = (message: MessageInterface) => void | Promise<void>
+type WechatyEventListenerPost               = (post: PostInterface) => void | Promise<void>
+type WechatyEventListenerPuppet             = (puppet: PUPPET.impls.PuppetInterface) => void | Promise<void>
+type WechatyEventListenerReady              = () => void | Promise<void>
+type WechatyEventListenerRoomInvite         = (roomInvitation: RoomInvitationInterface) => void | Promise<void>
+type WechatyEventListenerRoomJoin           = (room: RoomInterface, inviteeList: ContactInterface[], inviter: ContactInterface, date?: Date) => void | Promise<void>
+type WechatyEventListenerRoomLeave          = (room: RoomInterface, leaverList: ContactInterface[], remover?: ContactInterface, date?: Date) => void | Promise<void>
+type WechatyEventListenerRoomTopic          = (room: RoomInterface, newTopic: string, oldTopic: string, changer: ContactInterface, date?: Date) => void | Promise<void>
+type WechatyEventListenerRoomOwner          = (room: RoomInterface, newOwner: ContactInterface, oldOwner: ContactInterface) => void | Promise<void>
+type WechatyEventListenerScan               = (qrcode: string, status: PUPPET.types.ScanStatus, data?: string) => void | Promise<void>
+type WechatyEventListenerStartStop          = () => void | Promise<void>
+type WechatyEventListenerUpdate             = (info: InfoUpdateInterface) => void | Promise<void>
+type WechatyEventListenerContactTagAdd      = (contact: ContactInterface, tagList: TagInterface[]) => void | Promise<void>
+type WechatyEventListenerContactTagRemove   = (contact: ContactInterface, tagList: TagInterface[]) => void | Promise<void>
+type WechatyEventListenerContactName        = (contact: ContactInterface, newName: string, oldName: string) => void | Promise<void>
+type WechatyEventListenerContactPhone       = (contact: ContactInterface, newPhoneList: string[], oldPhoneList: []) => void | Promise<void>
+type WechatyEventListenerContactAlias       = (contact: ContactInterface, newAlias: string, oldAlias: string) => void | Promise<void>
+type WechatyEventListenerContactDescription = (contact: ContactInterface, newDescription: string, oldDescription: string) => void | Promise<void>
 
 /**
  * @desc       Wechaty Class Event Type
@@ -202,23 +220,31 @@ type WechatyEventListenerStartStop  = ()
  * })
  */
 interface WechatyEventListeners {
-  'room-invite' : WechatyEventListenerRoomInvite
-  'room-join'   : WechatyEventListenerRoomJoin
-  'room-leave'  : WechatyEventListenerRoomLeave
-  'room-topic'  : WechatyEventListenerRoomTopic
-  dong          : WechatyEventListenerDong
-  error         : WechatyEventListenerError
-  friendship    : WechatyEventListenerFriendship
-  heartbeat     : WechatyEventListenerHeartbeat
-  login         : WechatyEventListenerLogin
-  logout        : WechatyEventListenerLogout
-  message       : WechatyEventListenerMessage
-  post          : WechatyEventListenerPost
-  puppet        : WechatyEventListenerPuppet
-  ready         : WechatyEventListenerReady
-  scan          : WechatyEventListenerScan
-  start         : WechatyEventListenerStartStop
-  stop          : WechatyEventListenerStartStop
+  'room-invite'        : WechatyEventListenerRoomInvite
+  'room-join'          : WechatyEventListenerRoomJoin
+  'room-leave'         : WechatyEventListenerRoomLeave
+  'room-topic'         : WechatyEventListenerRoomTopic
+  dong                 : WechatyEventListenerDong
+  error                : WechatyEventListenerError
+  friendship           : WechatyEventListenerFriendship
+  heartbeat            : WechatyEventListenerHeartbeat
+  login                : WechatyEventListenerLogin
+  logout               : WechatyEventListenerLogout
+  message              : WechatyEventListenerMessage
+  post                 : WechatyEventListenerPost
+  puppet               : WechatyEventListenerPuppet
+  ready                : WechatyEventListenerReady
+  scan                 : WechatyEventListenerScan
+  start                : WechatyEventListenerStartStop
+  stop                 : WechatyEventListenerStartStop
+  update               : WechatyEventListenerUpdate
+  'contact-tag-add'    : WechatyEventListenerContactTagAdd
+  'contact-tag-remove' : WechatyEventListenerContactTagRemove
+  'contact-name'       : WechatyEventListenerContactName
+  'contact-alias'      : WechatyEventListenerContactAlias
+  'contact-phone'      : WechatyEventListenerContactPhone
+  'contact-description': WechatyEventListenerContactDescription
+  'room-owner'         : WechatyEventListenerRoomOwner
 }
 
 const WechatyEventEmitter = EventEmitter as any as new () => TypedEventEmitter<
@@ -243,8 +269,16 @@ export type {
   WechatyEventListenerRoomJoin,
   WechatyEventListenerRoomLeave,
   WechatyEventListenerRoomTopic,
+  WechatyEventListenerRoomOwner,
   WechatyEventListenerScan,
   WechatyEventListenerStartStop,
+  WechatyEventListenerUpdate,
+  WechatyEventListenerContactTagAdd,
+  WechatyEventListenerContactTagRemove,
+  WechatyEventListenerContactName,
+  WechatyEventListenerContactAlias,
+  WechatyEventListenerContactPhone,
+  WechatyEventListenerContactDescription,
 }
 export {
   WechatyEventEmitter,

package/src/user-modules/contact.ts

@@ -207,28 +207,6 @@ class ContactMixin extends MixinBase implements SayableSayer {
     log.verbose('Contact', 'static delete(%s)', contact.id)
   }
 
-  /**
-   * Get tags for all contact
-   *
-   * @static
-   * @returns {Promise<TagInterface[]>}
-   * @example
-   * const tags = await wechaty.Contact.tags()
-   */
-  static async tags (): Promise<TagInterface[]> {
-    log.verbose('Contact', 'static tags() for %s', this)
-
-    try {
-      const tagIdList = await this.wechaty.puppet.tagTagList()
-      const tagList = tagIdList.map(id => this.wechaty.Tag.create(id))
-      return tagList
-    } catch (e) {
-      this.wechaty.emitError(e)
-      log.error('Contact', 'static tags() exception: %s', (e as Error).message)
-      return []
-    }
-  }
-
   /**
    *
    * Instance properties
@@ -674,8 +652,13 @@ class ContactMixin extends MixinBase implements SayableSayer {
 
     try {
       const tagPayloadList = await this.wechaty.puppet.tagContactTagList(this.id)
-      const tagList = tagPayloadList.map(tag => this.wechaty.Tag.create(tag))
-      return tagList
+
+      let tagList = tagPayloadList.map(tag => this.wechaty.Tag.load(tag))
+      if (tagList.some(tag => typeof tag === 'undefined')) {
+        await this.wechaty.Tag.sync()
+        tagList = tagPayloadList.map(tag => this.wechaty.Tag.load(tag))
+      }
+      return tagList.filter(tag => !!tag) as TagInterface[]
     } catch (e) {
       this.wechaty.emitError(e)
       log.error('Contact', 'tags() exception: %s', (e as Error).message)
@@ -687,10 +670,20 @@ class ContactMixin extends MixinBase implements SayableSayer {
    * Add a Tag
    */
 
-  async tag (tag: TagInterface): Promise<void> {
-    log.verbose('Contact', 'tag(%s) for %s', tag, this)
+  async tag (tags: TagInterface | TagInterface[]): Promise<void> {
+    log.verbose('Contact', 'tag(%s) for %s', JSON.stringify(tags), this)
 
-    await this.wechaty.puppet.tagContactTagAdd(tag.groupId(), tag.id(), this.id)
+    if (!Array.isArray(tags)) {
+      tags = [tags]
+    }
+
+    const tagIdentifiers = tags.map(tag => {
+      return {
+        id: tag.id(),
+        groupId: tag.groupId(),
+      }
+    })
+    await this.wechaty.puppet.tagContactTagAdd(tagIdentifiers, [this.id])
 
   }
 
@@ -698,10 +691,21 @@ class ContactMixin extends MixinBase implements SayableSayer {
    * Remove a Tag
    */
 
-  async tagRemove (tag: TagInterface): Promise<void> {
-    log.verbose('Contact', 'tagRemove(%s) for %s', tag, this)
+  async tagRemove (tags: TagInterface | TagInterface[]): Promise<void> {
+    log.verbose('Contact', 'tagRemove(%s) for %s', JSON.stringify(tags), this)
+
+    if (!Array.isArray(tags)) {
+      tags = [tags]
+    }
+
+    const tagIdentifiers = tags.map(tag => {
+      return {
+        id: tag.id(),
+        groupId: tag.groupId(),
+      }
+    })
 
-    await this.wechaty.puppet.tagContactTagRemove(tag.groupId(), tag.id(), this.id)
+    await this.wechaty.puppet.tagContactTagRemove(tagIdentifiers, [this.id])
 
   }
 

package/src/user-modules/room.ts

@@ -728,9 +728,16 @@ class RoomMixin extends MixinBase implements SayableSayer {
    *   }
    * }
    */
-  async remove (contact: ContactInterface): Promise<void> {
-    log.verbose('Room', 'del(%s)', contact)
-    await this.wechaty.puppet.roomDel(this.id, contact.id)
+  async remove (contacts: ContactInterface | ContactInterface[]): Promise<void> {
+    log.verbose('Room', 'del(%s)', contacts)
+
+    let contactIds: string[]
+    if (Array.isArray(contacts)) {
+      contactIds = contacts.map(c => c.id)
+    } else {
+      contactIds = [contacts.id]
+    }
+    await this.wechaty.puppet.roomDel(this.id, contactIds)
     // this.delLocal(contact)
   }
 
@@ -738,7 +745,7 @@ class RoomMixin extends MixinBase implements SayableSayer {
    * Huan(202106): will be removed after Dec 31, 2023
    * @deprecated use remove(contact) instead.
    */
-  async del (contact: ContactImpl): Promise<void> {
+  async del (contact: ContactImpl | ContactImpl[]): Promise<void> {
     log.warn('Room', 'del() is DEPRECATED, use remove() instead.\n%s', new Error().stack)
     return this.remove(contact)
   }

package/src/user-modules/tag-group.ts

@@ -26,6 +26,7 @@ import { validationMixin } from '../user-mixins/validation.js'
 import {
   wechatifyMixinBase,
 } from '../user-mixins/wechatify.js'
+import type { TagInterface } from './tag.js'
 
 class TagGroupMixin extends wechatifyMixinBase() {
 
@@ -58,13 +59,52 @@ class TagGroupMixin extends wechatifyMixinBase() {
     return this.payload.name
   }
 
+  private static pool: TagGroupInterface[] = []
+
+  static async list (forceSync = false): Promise<TagGroupInterface[]> {
+    log.verbose('TagGroup', 'list(%s)', forceSync)
+
+    if (this.pool.length > 0 && !forceSync) {
+      return this.pool
+    }
+
+    try {
+      const payloads = await this.wechaty.puppet.tagGroupList()
+      this.pool = payloads.map(payload => new this(payload))
+      return this.pool
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.error('TagGroup', 'list() exception: %s', (e as Error).message)
+      return []
+    }
+  }
+
+  static async sync (): Promise<void> {
+    log.verbose('TagGroup', 'sync()')
+
+    await this.list(true)
+  }
+
+  static load (tagGroupId: string): TagGroupInterface | undefined {
+    log.verbose('TagGroup', 'load(%s)', tagGroupId)
+
+    for (const item of this.pool) {
+      if (item.id() === tagGroupId) {
+        return item
+      }
+    }
+    return undefined
+  }
+
   static async createTagGroup (name: string): Promise<TagGroupInterface | void> {
     log.verbose('TagGroup', 'createTagGroup(%s, %s)', name)
 
     try {
       const payload = await this.wechaty.puppet.tagGroupAdd(name)
       if (payload) {
-        return new this(payload)
+        const newTagGroup = new this(payload)
+        this.pool.push(newTagGroup)
+        return newTagGroup
       }
     } catch (e) {
       this.wechaty.emitError(e)
@@ -77,23 +117,19 @@ class TagGroupMixin extends wechatifyMixinBase() {
 
     try {
       await this.wechaty.puppet.tagGroupDelete(tagGroup.id())
+      this.pool.splice(this.pool.indexOf(tagGroup), 1)
     } catch (e) {
       this.wechaty.emitError(e)
-      log.error('Contact', 'createTag() exception: %s', (e as Error).message)
+      log.error('TagGroup', 'deleteTagGroup() exception: %s', (e as Error).message)
     }
   }
 
-  static async list (): Promise<TagGroupInterface[]> {
-    log.verbose('TagGroup', 'list()')
+  async tags (): Promise<TagInterface[]> {
+    return (await this.wechaty.Tag.list()).filter(tag => tag.groupId() === this.id())
+  }
 
-    try {
-      const payloads = await this.wechaty.puppet.tagGroupList()
-      return payloads.map(payload => new this(payload))
-    } catch (e) {
-      this.wechaty.emitError(e)
-      log.error('TagGroup', 'list() exception: %s', (e as Error).message)
-      return []
-    }
+  override toString () {
+    return `<TagGroup#${this.name() || this.id()}>`
   }
 
 }

package/src/user-modules/tag.ts

@@ -18,6 +18,7 @@
  *
  */
 import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { TagIdentifier } from '@juzi/wechaty-puppet/filters'
 
 import type { Constructor } from 'clone-class'
 import { log } from '../config.js'
@@ -27,6 +28,7 @@ import {
   wechatifyMixinBase,
 }                     from '../user-mixins/wechatify.js'
 import type { ContactInterface } from './contact.js'
+import type { TagGroupInterface } from './tag-group.js'
 
 class TagMixin extends wechatifyMixinBase() {
 
@@ -67,12 +69,23 @@ class TagMixin extends wechatifyMixinBase() {
     return this.payload.name
   }
 
-  static async list (): Promise<TagInterface[]> {
-    log.verbose('Tag', 'list()')
+  group (): TagGroupInterface | undefined {
+    return this.wechaty.TagGroup.load(this.groupId())
+  }
+
+  private static pool: TagInterface[] = []
+
+  static async list (forceSync = false): Promise<TagInterface[]> {
+    log.verbose('Tag', 'list(%s)', forceSync)
+
+    if (this.pool.length > 0 && !forceSync) {
+      return this.pool
+    }
 
     try {
       const payloads = await this.wechaty.puppet.tagTagList()
-      return payloads.map(payload => new this(payload))
+      this.pool = payloads.map(payload => new this(payload))
+      return this.pool
     } catch (e) {
       this.wechaty.emitError(e)
       log.error('Tag', 'list() exception: %s', (e as Error).message)
@@ -80,28 +93,54 @@ class TagMixin extends wechatifyMixinBase() {
     }
   }
 
+  static async sync (): Promise<void> {
+    log.verbose('Tag', 'sync()')
+
+    await this.list(true)
+  }
+
+  static load (tag: TagIdentifier): TagInterface | undefined {
+    log.verbose('TagGroup', 'load(%s)', tag)
+
+    for (const item of this.pool) {
+      if (item.id() === tag.id && (item.groupId() === tag.groupId || (!item.groupId() && !tag.groupId))) {
+        return item
+      }
+    }
+    return undefined
+  }
+
   async contactList (): Promise<ContactInterface[]> {
-    log.verbose('Tag', 'contactList() for tag id: %s', this.id())
+    log.verbose('Tag', 'contactList() for tag : %s', this)
 
-    const contactIds = await this.wechaty.puppet.tagTagContactList(this.groupId(), this.id())
+    const tag = { id: this.id(), groupId: this.groupId() } as TagIdentifier
+    const contactIds = await this.wechaty.puppet.tagTagContactList(tag)
     const contactPromises = contactIds.map(id => this.wechaty.Contact.find({ id })) as Promise<ContactInterface>[]
     return Promise.all(contactPromises)
   }
 
-  async tag (contact: ContactInterface): Promise<void> {
-    log.verbose('Tag', 'tag(%s) for tag id: %s', contact, this.id())
+  async tag (contacts: ContactInterface | ContactInterface[]): Promise<void> {
+    log.verbose('Tag', 'tag(%s) for tag : %s', contacts, this)
 
-    const contactId = contact.id
-    await this.wechaty.puppet.tagContactTagAdd(this.groupId(), this.id(), contactId)
+    const tag = { id: this.id(), groupId: this.groupId() } as TagIdentifier
+    let contactIds: string[]
+    if (Array.isArray(contacts)) {
+      contactIds = contacts.map(c => c.id)
+    } else {
+      contactIds = [contacts.id]
+    }
+    await this.wechaty.puppet.tagContactTagAdd([tag], contactIds)
   }
 
-  static async createTag (tagGroupId: string | undefined, name: string): Promise<TagInterface | void> {
-    log.verbose('Tag', 'createTag(%s, %s)', tagGroupId, name)
+  static async createTag (name: string, tagGroup?: TagGroupInterface): Promise<TagInterface | void> {
+    log.verbose('Tag', 'createTag(%s, %s)', tagGroup, name)
 
     try {
-      const payload = await this.wechaty.puppet.tagTagAdd(tagGroupId, name)
+      const payload = await this.wechaty.puppet.tagTagAdd(name, tagGroup?.name())
       if (payload) {
-        return new this(payload)
+        const newTag = new this(payload)
+        this.pool.push(newTag)
+        return newTag
       }
     } catch (e) {
       this.wechaty.emitError(e)
@@ -109,17 +148,24 @@ class TagMixin extends wechatifyMixinBase() {
     }
   }
 
-  static async deleteTag (tag: TagInterface): Promise<void> {
-    log.verbose('Tag', 'deleteTag(%s, %s)', tag)
+  static async deleteTag (tagInstance: TagInterface): Promise<void> {
+    log.verbose('Tag', 'deleteTag(%s, %s)', tagInstance)
+
+    const tag = { id: tagInstance.id(), groupId: tagInstance.groupId() } as TagIdentifier
 
     try {
-      await this.wechaty.puppet.tagTagDelete(tag.groupId(), tag.id())
+      await this.wechaty.puppet.tagTagDelete(tag)
+      this.pool.splice(this.pool.indexOf(tagInstance), 1)
     } catch (e) {
       this.wechaty.emitError(e)
-      log.error('Contact', 'deleteTag() exception: %s', (e as Error).message)
+      log.error('Tag', 'deleteTag() exception: %s', (e as Error).message)
     }
   }
 
+  override toString () {
+    return `<Tag#${this.name() || this.id()}>`
+  }
+
 }
 
 class TagImpl extends validationMixin(TagMixin)<TagInterface>() {}

package/src/wechaty-mixins/puppet-mixin.ts

@@ -11,7 +11,7 @@ import type {
   StateSwitchInterface,
 }                       from 'state-switch'
 
-import { config }               from '../config.js'
+import { config, FOUR_PER_EM_SPACE }               from '../config.js'
 import { timestampToDate }      from '../pure-functions/timestamp-to-date.js'
 import type {
   ContactImpl,
@@ -25,6 +25,8 @@ import type {
 
 import type { GErrorMixin } from './gerror-mixin.js'
 import type { IoMixin }     from './io-mixin.js'
+import { ContactImportantFields, ContactUpdatableValuePair, InfoUpdateInterface, RoomImportantFields, RoomUpdatableValuePair } from '../schemas/update.js'
+import { diffPayload } from '../pure-functions/update.js'
 
 const PUPPET_MEMORY_NAME = 'puppet'
 
@@ -278,7 +280,7 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                   return
                 }
 
-                this.emit('message', msg)
+                this.emit('message', 'msg')
 
                 const room     = msg.room()
                 const listener = msg.listener()
@@ -438,12 +440,94 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                 switch (payloadType) {
                   case PUPPET.types.Payload.Contact: {
                     const contact = await this.Contact.find({ id: payloadId }) as unknown as undefined | ContactImpl
+                    const oldPayload = JSON.parse(JSON.stringify(contact?.payload || {}))
                     await contact?.ready(true)
+                    const newPayload = JSON.parse(JSON.stringify(contact?.payload || {}))
+
+                    const differences = diffPayload<PUPPET.payloads.Contact>(oldPayload, newPayload)
+                    const importangDifferences = differences.filter(ele => ele && ContactImportantFields.some(key => key === ele.key))
+                    const regularDifferences = differences.filter(ele => ele && !ContactImportantFields.some(key => key === ele.key)) as ContactUpdatableValuePair[]
+                    if (regularDifferences.length > 0) {
+                      const updateEvent: InfoUpdateInterface = {
+                        type: payloadType,
+                        id: payloadId,
+                        updates: regularDifferences,
+                      }
+                      this.emit('update', updateEvent)
+                      contact?.emit('update', updateEvent)
+                    }
+                    for (const difference of importangDifferences) {
+                      switch (difference?.key) {
+                        case 'tags': {
+                          const oldTagsSet = new Set(difference.oldValue?.map(ele => ele.groupId + FOUR_PER_EM_SPACE + ele.id))
+                          const newTagsSet = new Set(difference.newValue?.map(ele => ele.groupId + FOUR_PER_EM_SPACE + ele.id))
+                          const addedTags = difference.newValue?.filter(ele => !oldTagsSet.has(ele.groupId + FOUR_PER_EM_SPACE + ele.id)).map(ele => this.Tag.load(ele)) || []
+                          const removedTags = difference.oldValue?.filter(ele => !newTagsSet.has(ele.groupId + FOUR_PER_EM_SPACE + ele.id)).map(ele => this.Tag.load(ele)) || []
+                          if (addedTags.length > 0) {
+                            this.emit('contact-tag-add', contact, addedTags)
+                          }
+                          if (removedTags.length > 0) {
+                            this.emit('contact-tag-removed', contact, removedTags)
+                          }
+                          break
+                        }
+                        case 'name': {
+                          this.emit('contact-name', contact, difference.newValue || '', difference.oldValue || '')
+                          contact?.emit('name', difference.newValue || '', difference.oldValue || '')
+                          break
+                        }
+                        case 'alias': {
+                          this.emit('contact-alias', contact, difference.newValue || '', difference.oldValue || '')
+                          contact?.emit('alias', difference.newValue || '', difference.oldValue || '')
+                          break
+                        }
+                        case 'phone': {
+                          this.emit('contact-phone', contact, difference.newValue || [], difference.oldValue || [])
+                          contact?.emit('phone', difference.newValue || [], difference.oldValue || [])
+                          break
+                        }
+                        case 'description': {
+                          this.emit('contact-description', contact, difference.newValue || '', difference.oldValue || '')
+                          contact?.emit('description', difference.newValue || '', difference.oldValue || '')
+                          break
+                        }
+                        default:
+                          log.warn('WechatyPuppetMixin', 'puppet dirty unsupported difference type: %s', JSON.stringify(difference))
+                      }
+                    }
                     break
                   }
                   case PUPPET.types.Payload.Room: {
                     const room = await this.Room.find({ id: payloadId })  as unknown as undefined | RoomImpl
+                    const oldPayload = JSON.parse(JSON.stringify(room?.payload || {}))
                     await room?.ready(true)
+                    const newPayload = JSON.parse(JSON.stringify(room?.payload || {}))
+
+                    const differences = diffPayload<PUPPET.payloads.Room>(oldPayload, newPayload)
+                    const importangDifferences = differences.filter(ele => ele && RoomImportantFields.some(key => key === ele.key))
+                    const regularDifferences = differences.filter(ele => ele && !RoomImportantFields.some(key => key === ele.key)) as RoomUpdatableValuePair[]
+                    if (regularDifferences.length > 0) {
+                      const updateEvent: InfoUpdateInterface = {
+                        type: payloadType,
+                        id: payloadId,
+                        updates: regularDifferences,
+                      }
+                      this.emit('update', updateEvent)
+                      room?.emit('update', updateEvent)
+                    }
+                    for (const difference of importangDifferences) {
+                      switch (difference?.key) {
+                        case 'ownerId': {
+                          const oldOwner = (await this.Contact.find({ id: difference.oldValue }))!
+                          const newOwner = (await this.Contact.find({ id: difference.newValue }))!
+                          this.emit('room-owner', room, newOwner, oldOwner)
+                          room?.emit('owner', newOwner, oldOwner)
+                          break
+                        }
+                        default:
+                          log.warn('WechatyPuppetMixin', 'puppet dirty unsupported difference type: %s', JSON.stringify(difference))
+                      }
+                    }
                     break
                   }
                   case PUPPET.types.Payload.RoomMember: {