@juzi/wechaty 1.0.19 → 1.0.23

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,7 +25,7 @@ import type {
 
 import type { GErrorMixin } from './gerror-mixin.js'
 import type { IoMixin }     from './io-mixin.js'
-import type { InfoUpdateInterface } from '../schemas/update.js'
+import { ContactImportantFields, ContactUpdatableValuePair, InfoUpdateInterface, RoomImportantFields, RoomUpdatableValuePair } from '../schemas/update.js'
 import { diffPayload } from '../pure-functions/update.js'
 
 const PUPPET_MEMORY_NAME = 'puppet'
@@ -443,15 +443,58 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                     const oldPayload = JSON.parse(JSON.stringify(contact?.payload || {}))
                     await contact?.ready(true)
                     const newPayload = JSON.parse(JSON.stringify(contact?.payload || {}))
-                    const updateEvent: InfoUpdateInterface = {
-                      type: payloadType,
-                      id: payloadId,
-                      updates: diffPayload(oldPayload, newPayload),
-                    }
-                    if (updateEvent.updates.length > 0) {
+
+                    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-remove', 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: {
@@ -459,15 +502,32 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                     const oldPayload = JSON.parse(JSON.stringify(room?.payload || {}))
                     await room?.ready(true)
                     const newPayload = JSON.parse(JSON.stringify(room?.payload || {}))
-                    const updateEvent: InfoUpdateInterface = {
-                      type: payloadType,
-                      id: payloadId,
-                      updates: diffPayload(oldPayload, newPayload),
-                    }
-                    if (updateEvent.updates.length > 0) {
+
+                    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: {