@juzi/wechaty 1.0.17 → 1.0.21

package/src/schemas/contact-events.ts

@@ -6,13 +6,16 @@ import type {
   FriendshipInterface,
   MessageInterface,
 }                   from '../user-modules/mod.js'
+import type { InfoUpdateInterface } from './update.js'
 
 type ContactEventListenerMessage    = (this: ContactInterface, message: MessageInterface, date?: Date)  => void | Promise<void>
 type ContactEventListenerFriendship = (friendship: FriendshipInterface)                                 => void | Promise<void>
+type ContactEventListenerUpdate = (info: InfoUpdateInterface) => void | Promise<void>
 
 interface ContactEventListeners {
   friendship : ContactEventListenerFriendship,
   message    : ContactEventListenerMessage,
+  update     : ContactEventListenerUpdate,
 }
 
 const ContactEventEmitter = EventEmitter as any as new () => TypedEventEmitter<
@@ -23,6 +26,7 @@ export type {
   ContactEventListeners,
   ContactEventListenerMessage,
   ContactEventListenerFriendship,
+  ContactEventListenerUpdate,
 }
 export {
   ContactEventEmitter,

package/src/schemas/room-events.ts

@@ -7,12 +7,14 @@ import type {
   RoomInterface,
   RoomInvitationInterface,
 }                   from '../user-modules/mod.js'
+import type { InfoUpdateInterface } from './update.js'
 
 export const ROOM_EVENT_DICT = {
   invite  : 'tbw',
   join    : 'tbw',
   leave   : 'tbw',
   message : 'message that received in this room',
+  update  : 'room info update',
   topic   : 'tbw',
 }
 export type RoomEventName = keyof typeof ROOM_EVENT_DICT
@@ -102,6 +104,7 @@ type RoomEventListenerJoin    = (this: RoomInterface, inviteeList: ContactInterf
 type RoomEventListenerLeave   = (this: RoomInterface, leaverList: ContactInterface[], remover?: ContactInterface, date?: Date)  => void | Promise<void>
 type RoomEventListenerMessage = (this: RoomInterface, message: MessageInterface, date?: Date)                                   => void | Promise<void>
 type RoomEventListenerTopic   = (this: RoomInterface, topic: string, oldTopic: string, changer: ContactInterface, date?: Date)  => void | Promise<void>
+type RoomEventListenerUpdate  = (info: InfoUpdateInterface) => void | Promise<void>
 
 interface RoomEventListeners {
   invite  : RoomEventListenerInvite
@@ -109,6 +112,7 @@ interface RoomEventListeners {
   leave   : RoomEventListenerLeave
   message : RoomEventListenerMessage
   topic   : RoomEventListenerTopic
+  update  : RoomEventListenerUpdate
 }
 
 const RoomEventEmitter = EventEmitter as any as new () => TypedEventEmitter<
@@ -122,6 +126,7 @@ export type {
   RoomEventListenerLeave,
   RoomEventListenerMessage,
   RoomEventListenerTopic,
+  RoomEventListenerUpdate,
 }
 export {
   RoomEventEmitter,

package/src/schemas/update.ts

@@ -0,0 +1,14 @@
+/* eslint-disable valid-typeof */
+import type * as PUPPET from '@juzi/wechaty-puppet'
+
+export interface InfoUpdateInterface {
+  type: PUPPET.types.Payload,
+  id: string,
+  updates: InfoUpdateValuePair[],
+}
+
+export interface InfoUpdateValuePair {
+  key: string,
+  oldValue: string,
+  newValue: string
+}

package/src/schemas/wechaty-events.ts

@@ -13,6 +13,7 @@ import type {
   MessageInterface,
   PostInterface,
 }                       from '../user-modules/mod.js'
+import type { InfoUpdateInterface } from './update.js'
 
 const WECHATY_EVENT_DICT = {
   ...PUPPET.types.CHAT_EVENT_DICT,
@@ -23,6 +24,7 @@ const WECHATY_EVENT_DICT = {
   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.',
 } as const
 
 type WechatyEventName  = keyof typeof WECHATY_EVENT_DICT
@@ -46,7 +48,7 @@ type WechatyEventListenerRoomLeave  = (room: RoomInterface, leaverList: ContactI
 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 WechatyEventListenerUpdate     = (info: InfoUpdateInterface) => void | Promise<void>
 /**
  * @desc       Wechaty Class Event Type
  * @typedef    WechatyEventName
@@ -219,6 +221,7 @@ interface WechatyEventListeners {
   scan          : WechatyEventListenerScan
   start         : WechatyEventListenerStartStop
   stop          : WechatyEventListenerStartStop
+  update        : WechatyEventListenerUpdate
 }
 
 const WechatyEventEmitter = EventEmitter as any as new () => TypedEventEmitter<
@@ -245,6 +248,7 @@ export type {
   WechatyEventListenerRoomTopic,
   WechatyEventListenerScan,
   WechatyEventListenerStartStop,
+  WechatyEventListenerUpdate,
 }
 export {
   WechatyEventEmitter,

package/src/user-modules/contact.ts

@@ -207,30 +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)
-
-    // TODO implement new tag methods
-    // try {
-    //   const tagIdList = await this.wechaty.puppet.tagContactList()
-    //   const tagList = tagIdList.map(id => this.wechaty.Tag.load(id))
-    //   return tagList
-    // } catch (e) {
-    //   this.wechaty.emitError(e)
-    //   log.error('Contact', 'static tags() exception: %s', (e as Error).message)
-    //   return []
-    // }
-    return []
-  }
-
   /**
    *
    * Instance properties
@@ -674,17 +650,63 @@ class ContactMixin extends MixinBase implements SayableSayer {
   async tags (): Promise<TagInterface[]> {
     log.verbose('Contact', 'tags() for %s', this)
 
-    // TODO: implement new tag methods
-    // try {
-    //   const tagIdList = await this.wechaty.puppet.tagContactList(this.id)
-    //   const tagList = tagIdList.map(id => this.wechaty.Tag.load(id))
-    //   return tagList
-    // } catch (e) {
-    //   this.wechaty.emitError(e)
-    //   log.error('Contact', 'tags() exception: %s', (e as Error).message)
-    //   return []
-    // }
-    return []
+    try {
+      const tagPayloadList = await this.wechaty.puppet.tagContactTagList(this.id)
+
+      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)
+      return []
+    }
+  }
+
+  /**
+   * Add a Tag
+   */
+
+  async tag (tags: TagInterface | TagInterface[]): Promise<void> {
+    log.verbose('Contact', 'tag(%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.tagContactTagAdd(tagIdentifiers, [this.id])
+
+  }
+
+  /**
+   * Remove a Tag
+   */
+
+  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(tagIdentifiers, [this.id])
+
   }
 
   /**

package/src/user-modules/mod.ts

@@ -87,6 +87,11 @@ import {
   TagInterface,
   TagConstructor,
 }                           from './tag.js'
+import {
+  TagGroupImpl,
+  TagGroupInterface,
+  TagGroupConstructor,
+}                           from './tag-group.js'
 import {
   UrlLinkImpl,
   UrlLinkInterface,
@@ -120,6 +125,7 @@ export type {
   RoomInterface,
   RoomInvitationInterface,
   TagInterface,
+  TagGroupInterface,
   DelayInterface,
   UrlLinkInterface,
   ChannelInterface,
@@ -141,6 +147,7 @@ export type {
   RoomInvitationConstructor,
   DelayConstructor,
   TagConstructor,
+  TagGroupConstructor,
   UrlLinkConstructor,
   ChannelConstructor,
 }
@@ -163,6 +170,7 @@ export {
   RoomInvitationImpl,
   DelayImpl,
   TagImpl,
+  TagGroupImpl,
   UrlLinkImpl,
   ChannelImpl,
 }

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

@@ -0,0 +1,151 @@
+/**
+ *   Wechaty Chatbot SDK - https://github.com/wechaty/wechaty
+ *
+ *   @copyright 2016 Huan LI (李卓桓) <https://github.com/huan>, and
+ *                   Wechaty Contributors <https://github.com/wechaty>.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agGroupreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific languagGroupe governing permissions and
+ *   limitations under the License.
+ *
+ */
+import type * as PUPPET from '@juzi/wechaty-puppet'
+
+import type { Constructor } from 'clone-class'
+import { log } from '../config.js'
+
+import { validationMixin } from '../user-mixins/validation.js'
+import {
+  wechatifyMixinBase,
+} from '../user-mixins/wechatify.js'
+import type { TagInterface } from './tag.js'
+
+class TagGroupMixin extends wechatifyMixinBase() {
+
+  /**
+   *
+   * Create
+   *
+   */
+  static create (payload: PUPPET.payloads.TagGroup): TagGroupInterface {
+    log.verbose('TagGroup', 'create()')
+
+    return new this(payload)
+  }
+
+  /**
+   * @hideconstructor
+   */
+  constructor (
+    public readonly payload: PUPPET.payloads.TagGroup,
+  ) {
+    super()
+    log.silly('TagGroup', 'constructor()')
+  }
+
+  id (): string {
+    return this.payload.id
+  }
+
+  name (): string {
+    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) {
+        const newTagGroup = new this(payload)
+        this.pool.push(newTagGroup)
+        return newTagGroup
+      }
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.error('Contact', 'createTag() exception: %s', (e as Error).message)
+    }
+  }
+
+  static async deleteTagGroup (tagGroup: TagGroupInterface): Promise<TagGroupInterface | void> {
+    log.verbose('TagGroup', 'deleteTagGroup(%s)', tagGroup)
+
+    try {
+      await this.wechaty.puppet.tagGroupDelete(tagGroup.id())
+      this.pool.splice(this.pool.indexOf(tagGroup), 1)
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.error('TagGroup', 'deleteTagGroup() exception: %s', (e as Error).message)
+    }
+  }
+
+  async tags (): Promise<TagInterface[]> {
+    return (await this.wechaty.Tag.list()).filter(tag => tag.groupId() === this.id())
+  }
+
+  override toString () {
+    return `<TagGroup#${this.name() || this.id()}>`
+  }
+
+}
+
+class TagGroupImpl extends validationMixin(TagGroupMixin)<TagGroupInterface>() { }
+interface TagGroupInterface extends TagGroupImpl { }
+
+type TagGroupConstructor = Constructor<
+  TagGroupInterface,
+  typeof TagGroupImpl
+>
+
+export type {
+  TagGroupConstructor,
+  TagGroupInterface,
+}
+export {
+  TagGroupImpl,
+}

package/src/user-modules/tag.ts

@@ -17,37 +17,154 @@
  *   limitations under the License.
  *
  */
-import {
-  log,
-}                     from '@juzi/wechaty-puppet'
+import type * as PUPPET from '@juzi/wechaty-puppet'
+import type { TagIdentifier } from '@juzi/wechaty-puppet/filters'
 
-import type { Constructor }  from 'clone-class'
+import type { Constructor } from 'clone-class'
+import { log } from '../config.js'
 
-import {
-  poolifyMixin,
-}                     from '../user-mixins/poolify.js'
 import { validationMixin } from '../user-mixins/validation.js'
 import {
   wechatifyMixinBase,
 }                     from '../user-mixins/wechatify.js'
+import type { ContactInterface } from './contact.js'
+import type { TagGroupInterface } from './tag-group.js'
+
+class TagMixin extends wechatifyMixinBase() {
 
-const MixinBase = poolifyMixin(
-  wechatifyMixinBase(),
-)<TagInterface>()
+  /**
+   *
+   * Create
+   *
+   */
+  static create (payload: PUPPET.payloads.Tag): TagInterface {
+    log.verbose('Tag', 'create()')
 
-class TagMixin extends MixinBase {
+    return new this(payload)
+  }
 
   /**
    * @hideconstructor
    */
   constructor (
-    public readonly id: string,
+    public readonly payload: PUPPET.payloads.Tag,
   ) {
     super()
-    log.silly('Tag', `constructor(${id})`)
+    log.silly('Tag', 'constructor()')
+  }
+
+  id (): string {
+    return this.payload.id
+  }
+
+  type (): PUPPET.types.Tag {
+    return this.payload.type
+  }
+
+  groupId (): string {
+    return this.payload.groupId || ''
+  }
+
+  name (): string {
+    return this.payload.name
+  }
+
+  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()
+      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)
+      return []
+    }
   }
 
-  // TODO: implement new tag methods
+  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 : %s', this)
+
+    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 (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)
+  }
+
+  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(name, tagGroup?.name())
+      if (payload) {
+        const newTag = new this(payload)
+        this.pool.push(newTag)
+        return newTag
+      }
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.error('Contact', '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
+
+    try {
+      await this.wechaty.puppet.tagTagDelete(tag)
+      this.pool.splice(this.pool.indexOf(tagInstance), 1)
+    } catch (e) {
+      this.wechaty.emitError(e)
+      log.error('Tag', 'deleteTag() exception: %s', (e as Error).message)
+    }
+  }
+
+  override toString () {
+    return `<Tag#${this.name() || this.id()}>`
+  }
 
 }
 

package/src/wechaty/wechaty-impl.spec.ts

@@ -17,6 +17,7 @@ import type {
   RoomConstructor,
   DelayConstructor,
   TagConstructor,
+  TagGroupConstructor,
   UrlLinkConstructor,
   MessageInterface,
   ChannelConstructor,
@@ -45,6 +46,7 @@ test('Wechaty interface', async t => {
     Room           : RoomConstructor
     RoomInvitation : RoomInvitationConstructor
     Tag            : TagConstructor
+    TagGroup       : TagGroupConstructor
     UrlLink        : UrlLinkConstructor
     Channel        : ChannelConstructor
 
@@ -63,6 +65,7 @@ test('Wechaty interface', async t => {
         = this.Room
         = this.RoomInvitation
         = this.Tag
+        = this.TagGroup
         = this.UrlLink
         = this.Channel
         = {} as any

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

@@ -25,6 +25,8 @@ import type {
 
 import type { GErrorMixin } from './gerror-mixin.js'
 import type { IoMixin }     from './io-mixin.js'
+import type { InfoUpdateInterface } from '../schemas/update.js'
+import { diffPayload } from '../pure-functions/update.js'
 
 const PUPPET_MEMORY_NAME = 'puppet'
 
@@ -438,12 +440,34 @@ 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 updateEvent: InfoUpdateInterface = {
+                      type: payloadType,
+                      id: payloadId,
+                      updates: diffPayload(oldPayload, newPayload),
+                    }
+                    if (updateEvent.updates.length > 0) {
+                      this.emit('update', updateEvent)
+                      contact?.emit('update', updateEvent)
+                    }
                     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 updateEvent: InfoUpdateInterface = {
+                      type: payloadType,
+                      id: payloadId,
+                      updates: diffPayload(oldPayload, newPayload),
+                    }
+                    if (updateEvent.updates.length > 0) {
+                      this.emit('update', updateEvent)
+                      room?.emit('update', updateEvent)
+                    }
                     break
                   }
                   case PUPPET.types.Payload.RoomMember: {