@juzi/wechaty 1.0.23 → 1.0.24

package/src/user-modules/tag.ts

@@ -17,75 +17,84 @@
  *   limitations under the License.
  *
  */
-import type * as PUPPET from '@juzi/wechaty-puppet'
+import * as PUPPET from '@juzi/wechaty-puppet'
 import type { TagIdentifier } from '@juzi/wechaty-puppet/filters'
+import { getTagKey } from '@juzi/wechaty-puppet/helpers'
 
 import type { Constructor } from 'clone-class'
-import { log } from '../config.js'
+import { concurrencyExecuter } from 'rx-queue'
+import { FOUR_PER_EM_SPACE, log } from '../config.js'
+import { poolifyMixin } from '../user-mixins/poolify.js'
 
 import { validationMixin } from '../user-mixins/validation.js'
 import {
-  wechatifyMixinBase,
+  wechatifyMixin,
 }                     from '../user-mixins/wechatify.js'
 import type { ContactInterface } from './contact.js'
 import type { TagGroupInterface } from './tag-group.js'
 
-class TagMixin extends wechatifyMixinBase() {
+const MixinBase = wechatifyMixin(
+  poolifyMixin(
+    Object,
+  )<TagImplInterface>(),
+)
+
+class TagMixin extends MixinBase {
 
   /**
    *
-   * Create
+   * Instance properties
+   * @ignore
    *
    */
-  static create (payload: PUPPET.payloads.Tag): TagInterface {
-    log.verbose('Tag', 'create()')
-
-    return new this(payload)
-  }
+  payload?: PUPPET.payloads.Tag
+  public readonly id: string
+  public readonly groupId?: string
 
   /**
    * @hideconstructor
    */
   constructor (
-    public readonly payload: PUPPET.payloads.Tag,
+    public readonly key: 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()')
   }
 
-  id (): string {
-    return this.payload.id
-  }
-
   type (): PUPPET.types.Tag {
-    return this.payload.type
-  }
-
-  groupId (): string {
-    return this.payload.groupId || ''
+    return (this.payload && this.payload.type) || PUPPET.types.Tag.Personal
   }
 
   name (): string {
-    return this.payload.name
+    return (this.payload && this.payload.name) || ''
   }
 
-  group (): TagGroupInterface | undefined {
-    return this.wechaty.TagGroup.load(this.groupId())
+  async group (): Promise<TagGroupInterface | undefined> {
+    return this.groupId ? this.wechaty.TagGroup.find(this.groupId) : undefined
   }
 
-  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()
-      this.pool = payloads.map(payload => new this(payload))
-      return this.pool
+      const tagIdentifierList = await this.wechaty.puppet.tagTagList()
+
+      const identifierToTag = async (identifier: TagIdentifier) => this.find(identifier).catch(e => this.wechaty.emitError(e))
+
+      const CONCURRENCY = 17
+      const tagIterator = concurrencyExecuter(CONCURRENCY)(identifierToTag)(tagIdentifierList)
+
+      const tagList: TagInterface[] = []
+      for await (const tag of tagIterator) {
+        if (tag) {
+          tagList.push(tag)
+        }
+      }
+
+      return tagList
+
     } catch (e) {
       this.wechaty.emitError(e)
       log.error('Tag', 'list() exception: %s', (e as Error).message)
@@ -93,27 +102,80 @@ class TagMixin extends wechatifyMixinBase() {
     }
   }
 
-  static async sync (): Promise<void> {
-    log.verbose('Tag', 'sync()')
+  static async find (identifier: TagIdentifier): Promise<TagInterface | undefined> {
+    log.silly('Tag', 'find(%s)', JSON.stringify(identifier))
+
+    const tag = (this.wechaty.Tag as any as typeof TagImpl).load(getTagKey(identifier))
 
-    await this.list(true)
+    try {
+      await tag.ready()
+    } catch (e) {
+      this.wechaty.emitError(e)
+      return undefined
+    }
+    return tag
   }
 
-  static load (tag: TagIdentifier): TagInterface | undefined {
-    log.verbose('TagGroup', 'load(%s)', tag)
+  /**
+   * Force reload data for Tag, Sync data from low-level API again.
+   *
+   * @returns {Promise<this>}
+   * @example
+   * await tag.sync()
+   */
+  async sync (): Promise<void> {
+    await this.wechaty.puppet.tagPayloadDirty(getTagKey({
+      id: this.id,
+      groupId: this.groupId,
+    }))
+    await this.ready(true)
+  }
 
-    for (const item of this.pool) {
-      if (item.id() === tag.id && (item.groupId() === tag.groupId || (!item.groupId() && !tag.groupId))) {
-        return item
-      }
+  /**
+   * @ignore
+   */
+  isReady (): boolean {
+    return !!(this.payload && this.payload.name)
+  }
+
+  /**
+   * `ready()` is For FrameWork ONLY!
+   *
+   * Please not to use `ready()` at the user land.
+   * If you want to sync data, use `sync()` instead.
+   *
+   * @ignore
+   */
+  async ready (
+    forceSync = false,
+  ): Promise<void> {
+    log.silly('Tag', 'ready() @ %s with Tag key="%s"', this.wechaty.puppet, this.key)
+
+    if (!forceSync && this.isReady()) { // already ready
+      log.silly('Tag', 'ready() isReady() true')
+      return
+    }
+
+    try {
+      this.payload = await this.wechaty.puppet.tagPayload({
+        id: this.id,
+        groupId: this.groupId,
+      })
+
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.verbose('Tag', 'ready() this.wechaty.puppet.tagPayload(%s) exception: %s',
+        this.id,
+        (e as Error).message,
+      )
+      throw e
     }
-    return undefined
   }
 
   async contactList (): Promise<ContactInterface[]> {
     log.verbose('Tag', 'contactList() for tag : %s', this)
 
-    const tag = { id: this.id(), groupId: this.groupId() } as TagIdentifier
+    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)
@@ -122,7 +184,7 @@ class TagMixin extends wechatifyMixinBase() {
   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
+    const tag = { id: this.id, groupId: this.groupId } as TagIdentifier
     let contactIds: string[]
     if (Array.isArray(contacts)) {
       contactIds = contacts.map(c => c.id)
@@ -136,26 +198,24 @@ class TagMixin extends wechatifyMixinBase() {
     log.verbose('Tag', 'createTag(%s, %s)', tagGroup, name)
 
     try {
-      const payload = await this.wechaty.puppet.tagTagAdd(name, tagGroup?.name())
-      if (payload) {
-        const newTag = new this(payload)
-        this.pool.push(newTag)
+      const tagIdentifier = await this.wechaty.puppet.tagTagAdd(name, tagGroup?.name())
+      if (tagIdentifier) {
+        const newTag = await this.find(tagIdentifier)
         return newTag
       }
     } catch (e) {
       this.wechaty.emitError(e)
-      log.error('Contact', 'createTag() exception: %s', (e as Error).message)
+      log.error('Tag', 'createTag() exception: %s', (e as Error).message)
     }
   }
 
   static async deleteTag (tagInstance: TagInterface): Promise<void> {
     log.verbose('Tag', 'deleteTag(%s, %s)', tagInstance)
 
-    const tag = { id: tagInstance.id(), groupId: tagInstance.groupId() } as TagIdentifier
+    const tagIdentifier = { id: tagInstance.id, groupId: tagInstance.groupId } as TagIdentifier
 
     try {
-      await this.wechaty.puppet.tagTagDelete(tag)
-      this.pool.splice(this.pool.indexOf(tagInstance), 1)
+      await this.wechaty.puppet.tagTagDelete(tagIdentifier)
     } catch (e) {
       this.wechaty.emitError(e)
       log.error('Tag', 'deleteTag() exception: %s', (e as Error).message)
@@ -163,21 +223,28 @@ class TagMixin extends wechatifyMixinBase() {
   }
 
   override toString () {
-    return `<Tag#${this.name() || this.id()}>`
+    return `<Tag#${this.name() || this.id}>`
   }
 
 }
 
-class TagImpl extends validationMixin(TagMixin)<TagInterface>() {}
-interface TagInterface extends TagImpl {}
+class TagImplBase extends validationMixin(TagMixin)<TagImplInterface>() {}
+interface TagImplInterface extends TagImplBase {}
+
+type TagProtectedProperty =
+  | 'ready'
+
+type TagInterface = Omit<TagImplInterface, TagProtectedProperty>
+class TagImpl extends validationMixin(TagImplBase)<TagInterface>() {}
 
 type TagConstructor = Constructor<
-  TagInterface,
-  typeof TagImpl
+  TagImplInterface,
+  Omit<typeof TagImpl, 'load'>
 >
 
 export type {
   TagConstructor,
+  TagProtectedProperty,
   TagInterface,
 }
 export {

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

@@ -11,12 +11,14 @@ import type {
   StateSwitchInterface,
 }                       from 'state-switch'
 
-import { config, FOUR_PER_EM_SPACE }               from '../config.js'
+import { config, PUPPET_PAYLOAD_SYNC_GAP, PUPPET_PAYLOAD_SYNC_MAX_RETRY }               from '../config.js'
 import { timestampToDate }      from '../pure-functions/timestamp-to-date.js'
 import type {
   ContactImpl,
   ContactInterface,
   RoomImpl,
+  TagGroupInterface,
+  TagInterface,
 }                               from '../user-modules/mod.js'
 
 import type {
@@ -26,7 +28,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'
+import { checkUntilChanged, diffPayload } from '../pure-functions/update.js'
+import { getTagKey } from '@juzi/wechaty-puppet/helpers'
 
 const PUPPET_MEMORY_NAME = 'puppet'
 
@@ -427,6 +430,95 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
             })
             break
 
+          case 'tag':
+            puppet.on('tag', async payload => {
+              switch (payload.tagEventType) {
+                case PUPPET.types.TagEvent.TagCreate: {
+                  const newTagPromises = payload.tagEventPayload.map(tag =>
+                    this.Tag.find({
+                      id: tag.tagId,
+                      groupId: tag.tagGroupId,
+                    }),
+                  )
+                  const newTags = await Promise.all(newTagPromises)
+                  this.emit('tag', payload.tagEventType, newTags)
+                  break
+                }
+                case PUPPET.types.TagEvent.TagDelete: {
+                  const deletedTagPromises = payload.tagEventPayload.map(tag =>
+                    this.Tag.find({
+                      id: tag.tagId,
+                      groupId: tag.tagGroupId,
+                    }),
+                  )
+                  const deletedTags = await Promise.all(deletedTagPromises)
+                  this.emit('tag', payload.tagEventType, 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 renamedTags = (await Promise.all(renamedTagPromises)) as TagInterface[]
+                  await Promise.all(renamedTags.map(async tag => {
+                    const oldName = tag.name()
+                    const result = await checkUntilChanged(PUPPET_PAYLOAD_SYNC_GAP, PUPPET_PAYLOAD_SYNC_MAX_RETRY, async () => {
+                      await tag.sync()
+                      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)
+                    }
+                  }))
+                  this.emit('tag', payload.tagEventType, 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),
+                  )
+                  const newTagGroups = await Promise.all(newTagGroupPromises)
+                  this.emit('tag', payload.tagEventType, newTagGroups)
+                  break
+                }
+                case PUPPET.types.TagEvent.TagGroupDelete: {
+                  const deletedTagGroupPromises = payload.tagEventPayload.map(tagGroup =>
+                    this.TagGroup.find(tagGroup.tagGroupId),
+                  )
+                  const deletedTagGroups = await Promise.all(deletedTagGroupPromises)
+                  this.emit('tag', payload.tagEventType, 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),
+                  )
+                  const renamedTagGroups = (await Promise.all(renamedTagGroupPromises)) as TagGroupInterface[]
+                  await Promise.all(renamedTagGroups.map(async tagGroup => {
+                    const oldName = tagGroup.name()
+                    const result = await checkUntilChanged(PUPPET_PAYLOAD_SYNC_GAP, PUPPET_PAYLOAD_SYNC_MAX_RETRY, async () => {
+                      await tagGroup.sync()
+                      return tagGroup.name() === oldName
+                    })
+                    if (!result) {
+                      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)
+                  // TODO: bind tagGroup-rename to tagGroup instance
+                  break
+                }
+              }
+
+            })
+            break
+
           case 'reset':
             // Do not propagation `reset` event from puppet
             break
@@ -445,7 +537,7 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                     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 importantDifferences = 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 = {
@@ -456,13 +548,13 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                       this.emit('update', updateEvent)
                       contact?.emit('update', updateEvent)
                     }
-                    for (const difference of importangDifferences) {
+                    for (const difference of importantDifferences) {
                       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)) || []
+                          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)) || []
                           if (addedTags.length > 0) {
                             this.emit('contact-tag-add', contact, addedTags)
                           }
@@ -504,7 +596,7 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                     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 importantDifferences = 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 = {
@@ -515,7 +607,7 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                       this.emit('update', updateEvent)
                       room?.emit('update', updateEvent)
                     }
-                    for (const difference of importangDifferences) {
+                    for (const difference of importantDifferences) {
                       switch (difference?.key) {
                         case 'ownerId': {
                           const oldOwner = (await this.Contact.find({ id: difference.oldValue }))!
@@ -545,6 +637,10 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                   case PUPPET.types.Payload.Message:
                     // Message does not need to dirty (?)
                     break
+                  case PUPPET.types.Payload.Tag:
+                    break
+                  case PUPPET.types.Payload.TagGroup:
+                    break
 
                   case PUPPET.types.Payload.Unspecified:
                   default: