@juzi/wechaty 1.0.21 → 1.0.24

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

@@ -18,60 +18,69 @@
  *
  */
 import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { TagIdentifier } from '@juzi/wechaty-puppet/filters'
 
 import type { Constructor } from 'clone-class'
+import { concurrencyExecuter } from 'rx-queue'
 import { 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 { TagInterface } from './tag.js'
 
-class TagGroupMixin extends wechatifyMixinBase() {
+const MixinBase = wechatifyMixin(
+  poolifyMixin(
+    Object,
+  )<TagGroupImplInterface>(),
+)
+
+class TagGroupMixin extends MixinBase {
 
   /**
    *
-   * Create
+   * Instance properties
+   * @ignore
    *
    */
-  static create (payload: PUPPET.payloads.TagGroup): TagGroupInterface {
-    log.verbose('TagGroup', 'create()')
-
-    return new this(payload)
-  }
+  payload?: PUPPET.payloads.TagGroup
 
   /**
    * @hideconstructor
    */
   constructor (
-    public readonly payload: PUPPET.payloads.TagGroup,
+    public readonly id: string,
   ) {
     super()
     log.silly('TagGroup', 'constructor()')
   }
 
-  id (): string {
-    return this.payload.id
-  }
-
   name (): string {
-    return this.payload.name
+    return (this.payload && this.payload.name) || ''
   }
 
-  private static pool: TagGroupInterface[] = []
+  static async list (): Promise<TagGroupInterface[]> {
+    log.verbose('TagGroup', 'list()')
 
-  static async list (forceSync = false): Promise<TagGroupInterface[]> {
-    log.verbose('TagGroup', 'list(%s)', forceSync)
+    try {
+      const tagGroupIds = await this.wechaty.puppet.tagGroupList()
 
-    if (this.pool.length > 0 && !forceSync) {
-      return this.pool
-    }
+      const idToTagGroup = async (id: string) => this.find(id).catch(e => this.wechaty.emitError(e))
+
+      const CONCURRENCY = 17
+      const tagGroupIterator = concurrencyExecuter(CONCURRENCY)(idToTagGroup)(tagGroupIds)
+
+      const tagGroupList: TagGroupInterface[] = []
+      for await (const tagGroup of tagGroupIterator) {
+        if (tagGroup) {
+          tagGroupList.push(tagGroup)
+        }
+      }
+
+      return tagGroupList
 
-    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)
@@ -79,31 +88,13 @@ class TagGroupMixin extends wechatifyMixinBase() {
     }
   }
 
-  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) {
-        const newTagGroup = new this(payload)
-        this.pool.push(newTagGroup)
+      const groupId = await this.wechaty.puppet.tagGroupAdd(name)
+      if (groupId) {
+        const newTagGroup = await this.find(groupId)
         return newTagGroup
       }
     } catch (e) {
@@ -116,8 +107,7 @@ class TagGroupMixin extends wechatifyMixinBase() {
     log.verbose('TagGroup', 'deleteTagGroup(%s)', tagGroup)
 
     try {
-      await this.wechaty.puppet.tagGroupDelete(tagGroup.id())
-      this.pool.splice(this.pool.indexOf(tagGroup), 1)
+      await this.wechaty.puppet.tagGroupDelete(tagGroup.id)
     } catch (e) {
       this.wechaty.emitError(e)
       log.error('TagGroup', 'deleteTagGroup() exception: %s', (e as Error).message)
@@ -125,25 +115,117 @@ class TagGroupMixin extends wechatifyMixinBase() {
   }
 
   async tags (): Promise<TagInterface[]> {
-    return (await this.wechaty.Tag.list()).filter(tag => tag.groupId() === this.id())
+    log.verbose('TagGroup', 'tags(%s)', this)
+    try {
+      const tagIdentifierList = await this.wechaty.puppet.tagGroupTagList(this.id)
+
+      const identifierToTag = async (tag: TagIdentifier) => this.wechaty.Tag.find(tag).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('TagGroup', 'list() exception: %s', (e as Error).message)
+      return []
+    }
+
+  }
+
+  static async find (id: string): Promise<TagGroupInterface | undefined> {
+    log.silly('TagGroup', 'find(%s)', id)
+
+    const tagGroup = (this.wechaty.TagGroup as any as typeof TagGroupImpl).load(id)
+
+    try {
+      await tagGroup.ready()
+    } catch (e) {
+      this.wechaty.emitError(e)
+      return undefined
+    }
+    return tagGroup
+  }
+
+  /**
+   * Force reload data for TagGroup, Sync data from low-level API again.
+   *
+   * @returns {Promise<this>}
+   * @example
+   * await tagGroup.sync()
+   */
+  async sync (): Promise<void> {
+    await this.wechaty.puppet.tagGroupPayloadDirty(this.id)
+    await this.ready(true)
+  }
+
+  /**
+   * @ignore
+   */
+  isReady (): boolean {
+    return !!(this.payload)
+  }
+
+  /**
+   * `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('TagGroup', 'ready() @ %s with TagGroup="%s"', this.wechaty.puppet, this.id)
+
+    if (!forceSync && this.isReady()) { // already ready
+      log.silly('TagGroup', 'ready() isReady() true')
+      return
+    }
+
+    try {
+      this.payload = await this.wechaty.puppet.tagGroupPayload(this.id)
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.verbose('TagGroup', 'ready() this.wechaty.puppet.tagGroupPayload(%s) exception: %s',
+        this.id,
+        (e as Error).message,
+      )
+      throw e
+    }
   }
 
   override toString () {
-    return `<TagGroup#${this.name() || this.id()}>`
+    return `<TagGroup#${this.name() || this.id}>`
   }
 
 }
 
-class TagGroupImpl extends validationMixin(TagGroupMixin)<TagGroupInterface>() { }
-interface TagGroupInterface extends TagGroupImpl { }
+class TagGroupImplBase extends validationMixin(TagGroupMixin)<TagGroupImplInterface>() { }
+interface TagGroupImplInterface extends TagGroupImplBase { }
+
+type TagGroupProtectedProperty =
+  | 'ready'
+
+type TagGroupInterface = Omit<TagGroupImplInterface, TagGroupProtectedProperty>
+class TagGroupImpl extends validationMixin(TagGroupImplBase)<TagGroupInterface>() { }
 
 type TagGroupConstructor = Constructor<
-  TagGroupInterface,
-  typeof TagGroupImpl
+  TagGroupImplInterface,
+  Omit<typeof TagGroupImpl, 'load'>
 >
 
 export type {
   TagGroupConstructor,
+  TagGroupProtectedProperty,
   TagGroupInterface,
 }
 export {

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 {