@juzi/wechaty 1.0.24 → 1.0.25

package/src/user-modules/tag.ts

@@ -18,12 +18,11 @@
  *
  */
 import * as PUPPET from '@juzi/wechaty-puppet'
-import type { TagIdentifier } from '@juzi/wechaty-puppet/filters'
-import { getTagKey } from '@juzi/wechaty-puppet/helpers'
+import type { TagQueryFilter } from '@juzi/wechaty-puppet/dist/esm/src/schemas/tag.js'
 
 import type { Constructor } from 'clone-class'
 import { concurrencyExecuter } from 'rx-queue'
-import { FOUR_PER_EM_SPACE, log } from '../config.js'
+import { log } from '../config.js'
 import { poolifyMixin } from '../user-mixins/poolify.js'
 
 import { validationMixin } from '../user-mixins/validation.js'
@@ -48,43 +47,43 @@ class TagMixin extends MixinBase {
    *
    */
   payload?: PUPPET.payloads.Tag
-  public readonly id: string
-  public readonly groupId?: string
 
   /**
    * @hideconstructor
    */
   constructor (
-    public readonly key: string,
+    public readonly id: string,
   ) {
     super()
-    this.groupId = this.key.split(FOUR_PER_EM_SPACE)[0]
-    this.id = this.key.split(FOUR_PER_EM_SPACE)[1]!
     log.silly('Tag', 'constructor()')
   }
 
   type (): PUPPET.types.Tag {
-    return (this.payload && this.payload.type) || PUPPET.types.Tag.Personal
+    return (this.payload && this.payload.type) || PUPPET.types.Tag.Unspecific
   }
 
   name (): string {
     return (this.payload && this.payload.name) || ''
   }
 
+  groupId (): string {
+    return (this.payload && this.payload.groupId) || ''
+  }
+
   async group (): Promise<TagGroupInterface | undefined> {
-    return this.groupId ? this.wechaty.TagGroup.find(this.groupId) : undefined
+    return this.payload?.groupId ? this.wechaty.TagGroup.find({ id: this.payload.groupId }) : undefined
   }
 
-  static async list (forceSync = false): Promise<TagInterface[]> {
-    log.verbose('Tag', 'list(%s)', forceSync)
+  static async list (): Promise<TagInterface[]> {
+    log.verbose('Tag', 'list()')
 
     try {
-      const tagIdentifierList = await this.wechaty.puppet.tagTagList()
+      const tagIdList = await this.wechaty.puppet.tagTagList()
 
-      const identifierToTag = async (identifier: TagIdentifier) => this.find(identifier).catch(e => this.wechaty.emitError(e))
+      const idToTag = async (id: string) => this.find({ id }).catch(e => this.wechaty.emitError(e))
 
       const CONCURRENCY = 17
-      const tagIterator = concurrencyExecuter(CONCURRENCY)(identifierToTag)(tagIdentifierList)
+      const tagIterator = concurrencyExecuter(CONCURRENCY)(idToTag)(tagIdList)
 
       const tagList: TagInterface[] = []
       for await (const tag of tagIterator) {
@@ -102,18 +101,30 @@ class TagMixin extends MixinBase {
     }
   }
 
-  static async find (identifier: TagIdentifier): Promise<TagInterface | undefined> {
-    log.silly('Tag', 'find(%s)', JSON.stringify(identifier))
+  static async find (filter: TagQueryFilter): Promise<TagInterface | undefined> {
+    log.silly('Tag', 'find(%s)', JSON.stringify(filter))
 
-    const tag = (this.wechaty.Tag as any as typeof TagImpl).load(getTagKey(identifier))
+    if (filter.id) {
+      const tag = (this.wechaty.Tag as any as typeof TagImpl).load(filter.id)
 
-    try {
-      await tag.ready()
-    } catch (e) {
-      this.wechaty.emitError(e)
-      return undefined
+      try {
+        await tag.ready()
+      } catch (e) {
+        this.wechaty.emitError(e)
+        return undefined
+      }
+      return tag
     }
-    return tag
+
+    if (filter.name) {
+      const tags = (await this.wechaty.Tag.list()).filter(t => t.name() === filter.name)
+      if (tags.length > 0) {
+        return tags[0]
+      }
+    }
+
+    return undefined
+    // TODO: use a puppet method to find tag, like how contact and room do it
   }
 
   /**
@@ -124,10 +135,7 @@ class TagMixin extends MixinBase {
    * await tag.sync()
    */
   async sync (): Promise<void> {
-    await this.wechaty.puppet.tagPayloadDirty(getTagKey({
-      id: this.id,
-      groupId: this.groupId,
-    }))
+    await this.wechaty.puppet.tagPayloadDirty(this.id)
     await this.ready(true)
   }
 
@@ -149,7 +157,7 @@ class TagMixin extends MixinBase {
   async ready (
     forceSync = false,
   ): Promise<void> {
-    log.silly('Tag', 'ready() @ %s with Tag key="%s"', this.wechaty.puppet, this.key)
+    log.silly('Tag', 'ready() @ %s with Tag key="%s"', this.wechaty.puppet, this.id)
 
     if (!forceSync && this.isReady()) { // already ready
       log.silly('Tag', 'ready() isReady() true')
@@ -157,10 +165,7 @@ class TagMixin extends MixinBase {
     }
 
     try {
-      this.payload = await this.wechaty.puppet.tagPayload({
-        id: this.id,
-        groupId: this.groupId,
-      })
+      this.payload = await this.wechaty.puppet.tagPayload(this.id)
 
     } catch (e) {
       this.wechaty.emitError(e)
@@ -175,8 +180,7 @@ class TagMixin extends MixinBase {
   async contactList (): Promise<ContactInterface[]> {
     log.verbose('Tag', 'contactList() for tag : %s', this)
 
-    const tag = { id: this.id, groupId: this.groupId } as TagIdentifier
-    const contactIds = await this.wechaty.puppet.tagTagContactList(tag)
+    const contactIds = await this.wechaty.puppet.tagTagContactList(this.id)
     const contactPromises = contactIds.map(id => this.wechaty.Contact.find({ id })) as Promise<ContactInterface>[]
     return Promise.all(contactPromises)
   }
@@ -184,23 +188,22 @@ class TagMixin extends MixinBase {
   async tag (contacts: ContactInterface | ContactInterface[]): Promise<void> {
     log.verbose('Tag', 'tag(%s) for tag : %s', contacts, this)
 
-    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)
+    await this.wechaty.puppet.tagContactTagAdd([this.id], contactIds)
   }
 
   static async createTag (name: string, tagGroup?: TagGroupInterface): Promise<TagInterface | void> {
     log.verbose('Tag', 'createTag(%s, %s)', tagGroup, name)
 
     try {
-      const tagIdentifier = await this.wechaty.puppet.tagTagAdd(name, tagGroup?.name())
-      if (tagIdentifier) {
-        const newTag = await this.find(tagIdentifier)
+      const tagId = await this.wechaty.puppet.tagTagAdd(name, tagGroup?.name())
+      if (tagId) {
+        const newTag = await this.find({ id: tagId })
         return newTag
       }
     } catch (e) {
@@ -212,10 +215,8 @@ class TagMixin extends MixinBase {
   static async deleteTag (tagInstance: TagInterface): Promise<void> {
     log.verbose('Tag', 'deleteTag(%s, %s)', tagInstance)
 
-    const tagIdentifier = { id: tagInstance.id, groupId: tagInstance.groupId } as TagIdentifier
-
     try {
-      await this.wechaty.puppet.tagTagDelete(tagIdentifier)
+      await this.wechaty.puppet.tagTagDelete(tagInstance.id)
     } catch (e) {
       this.wechaty.emitError(e)
       log.error('Tag', 'deleteTag() exception: %s', (e as Error).message)

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

@@ -29,7 +29,6 @@ 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 { checkUntilChanged, diffPayload } from '../pure-functions/update.js'
-import { getTagKey } from '@juzi/wechaty-puppet/helpers'
 
 const PUPPET_MEMORY_NAME = 'puppet'
 
@@ -432,37 +431,22 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
 
           case 'tag':
             puppet.on('tag', async payload => {
-              switch (payload.tagEventType) {
+              switch (payload.type) {
                 case PUPPET.types.TagEvent.TagCreate: {
-                  const newTagPromises = payload.tagEventPayload.map(tag =>
-                    this.Tag.find({
-                      id: tag.tagId,
-                      groupId: tag.tagGroupId,
-                    }),
-                  )
+                  const newTagPromises = payload.idList.map(id => this.Tag.find({ id }))
                   const newTags = await Promise.all(newTagPromises)
-                  this.emit('tag', payload.tagEventType, newTags)
+                  this.emit('tag', payload.type, newTags)
                   break
                 }
                 case PUPPET.types.TagEvent.TagDelete: {
-                  const deletedTagPromises = payload.tagEventPayload.map(tag =>
-                    this.Tag.find({
-                      id: tag.tagId,
-                      groupId: tag.tagGroupId,
-                    }),
-                  )
+                  const deletedTagPromises = payload.idList.map(id => this.Tag.find({ id }))
                   const deletedTags = await Promise.all(deletedTagPromises)
-                  this.emit('tag', payload.tagEventType, deletedTags)
+                  this.emit('tag', payload.type, deletedTags)
                   // TODO: bind tag-delete to tag instance
                   break
                 }
                 case PUPPET.types.TagEvent.TagRename: {
-                  const renamedTagPromises = payload.tagEventPayload.map(tag =>
-                    this.Tag.find({
-                      id: tag.tagId,
-                      groupId: tag.tagGroupId,
-                    }),
-                  )
+                  const renamedTagPromises = payload.idList.map(id => this.Tag.find({ id }))
                   const renamedTags = (await Promise.all(renamedTagPromises)) as TagInterface[]
                   await Promise.all(renamedTags.map(async tag => {
                     const oldName = tag.name()
@@ -471,33 +455,43 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                       return tag.name() === oldName
                     })
                     if (!result) {
-                      log.warn('WechatyPuppetMixin', 'tagRenameEvent still get old name after %s retries for tag %s', PUPPET_PAYLOAD_SYNC_MAX_RETRY, tag.key)
+                      log.warn('WechatyPuppetMixin', 'tagRenameEvent still get old name after %s retries for tag %s', PUPPET_PAYLOAD_SYNC_MAX_RETRY, tag.id)
                     }
                   }))
-                  this.emit('tag', payload.tagEventType, renamedTags)
+                  this.emit('tag', payload.type, renamedTags)
                   // TODO: bind tag-rename to tag instance
                   break
                 }
-                case PUPPET.types.TagEvent.TagGroupCreate: {
-                  const newTagGroupPromises = payload.tagEventPayload.map(tagGroup =>
-                    this.TagGroup.find(tagGroup.tagGroupId),
+                default:
+                  throw new Error('tagEventType ' + payload.type + ' unsupported!')
+              }
+            })
+            break
+
+          case 'tag-group':
+            puppet.on('tag-group', async payload => {
+              switch (payload.type) {
+
+                case PUPPET.types.TagGroupEvent.TagGroupCreate: {
+                  const newTagGroupPromises = payload.idList.map(id =>
+                    this.TagGroup.find({ id }),
                   )
                   const newTagGroups = await Promise.all(newTagGroupPromises)
-                  this.emit('tag', payload.tagEventType, newTagGroups)
+                  this.emit('tag-group', payload.type, newTagGroups)
                   break
                 }
-                case PUPPET.types.TagEvent.TagGroupDelete: {
-                  const deletedTagGroupPromises = payload.tagEventPayload.map(tagGroup =>
-                    this.TagGroup.find(tagGroup.tagGroupId),
+                case PUPPET.types.TagGroupEvent.TagGroupDelete: {
+                  const deletedTagGroupPromises = payload.idList.map(id =>
+                    this.TagGroup.find({ id }),
                   )
                   const deletedTagGroups = await Promise.all(deletedTagGroupPromises)
-                  this.emit('tag', payload.tagEventType, deletedTagGroups)
+                  this.emit('tag-group', payload.type, deletedTagGroups)
                   break
                   // TODO: bind tagGroup-delete to tagGroup instance
                 }
-                case PUPPET.types.TagEvent.TagGroupRename: {
-                  const renamedTagGroupPromises = payload.tagEventPayload.map(tagGroup =>
-                    this.TagGroup.find(tagGroup.tagGroupId),
+                case PUPPET.types.TagGroupEvent.TagGroupRename: {
+                  const renamedTagGroupPromises = payload.idList.map(id =>
+                    this.TagGroup.find({ id }),
                   )
                   const renamedTagGroups = (await Promise.all(renamedTagGroupPromises)) as TagGroupInterface[]
                   await Promise.all(renamedTagGroups.map(async tagGroup => {
@@ -510,10 +504,12 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                       log.warn('WechatyPuppetMixin', 'tagGroupRenameEvent still get old name after %s retries for tagGroup %s', PUPPET_PAYLOAD_SYNC_MAX_RETRY, tagGroup.id)
                     }
                   }))
-                  this.emit('tag', payload.tagEventType, renamedTagGroups)
+                  this.emit('tag-group', payload.type, renamedTagGroups)
                   // TODO: bind tagGroup-rename to tagGroup instance
                   break
                 }
+                default:
+                  throw new Error('tagGroupEventType ' + payload.type + ' unsupported!')
               }
 
             })
@@ -551,10 +547,10 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                     for (const difference of importantDifferences) {
                       switch (difference?.key) {
                         case 'tags': {
-                          const oldTagsSet = new Set(difference.oldValue?.map(ele => getTagKey(ele)))
-                          const newTagsSet = new Set(difference.newValue?.map(ele => getTagKey(ele)))
-                          const addedTags = difference.newValue?.filter(ele => !oldTagsSet.has(getTagKey(ele))).map(ele => this.Tag.find(ele)) || []
-                          const removedTags = difference.oldValue?.filter(ele => !newTagsSet.has(getTagKey(ele))).map(ele => this.Tag.find(ele)) || []
+                          const oldTagsSet = new Set(difference.oldValue)
+                          const newTagsSet = new Set(difference.newValue)
+                          const addedTags = difference.newValue?.filter(ele => !oldTagsSet.has(ele)).map(ele => this.Tag.find({ id: ele })) || []
+                          const removedTags = difference.oldValue?.filter(ele => !newTagsSet.has(ele)).map(ele => this.Tag.find({ id: ele })) || []
                           if (addedTags.length > 0) {
                             this.emit('contact-tag-add', contact, addedTags)
                           }