@juzi/wechaty 1.0.58 → 1.0.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juzi/wechaty",
-  "version": "1.0.58",
+  "version": "1.0.60",
   "description": "Wechaty is a RPA SDK for Chatbot Makers.",
   "type": "module",
   "exports": {
@@ -109,7 +109,7 @@
   },
   "homepage": "https://github.com/wechaty/",
   "dependencies": {
-    "@juzi/wechaty-puppet-service": "^1.0.61",
+    "@juzi/wechaty-puppet-service": "^1.0.64",
     "clone-class": "^1.1.1",
     "cmd-ts": "^0.10.0",
     "cockatiel": "^2.0.2",
@@ -132,7 +132,7 @@
     "@chatie/eslint-config": "^1.0.4",
     "@chatie/semver": "^0.4.7",
     "@chatie/tsconfig": "^4.6.3",
-    "@juzi/wechaty-puppet": "^1.0.58",
+    "@juzi/wechaty-puppet": "^1.0.59",
     "@juzi/wechaty-puppet-mock": "^1.0.1",
     "@swc/core": "1.3.44",
     "@swc/helpers": "^0.3.6",

package/src/package-json.ts

@@ -4,10 +4,10 @@
  */
 import type { PackageJsonWechaty } from './config'
 
-export const GIT_COMMIT_HASH: string = '7bb15dcc3563fbf710742a0c90443e9bd74da35b'
+export const GIT_COMMIT_HASH: string = '47f0dca4c164f04760e66d514ee0cf668f5e9945'
 export const packageJson: PackageJsonWechaty = {
   "name": "@juzi/wechaty",
-  "version": "1.0.58",
+  "version": "1.0.60",
   "description": "Wechaty is a RPA SDK for Chatbot Makers.",
   "type": "module",
   "exports": {
@@ -116,7 +116,7 @@ export const packageJson: PackageJsonWechaty = {
   },
   "homepage": "https://github.com/wechaty/",
   "dependencies": {
-    "@juzi/wechaty-puppet-service": "^1.0.61",
+    "@juzi/wechaty-puppet-service": "^1.0.64",
     "clone-class": "^1.1.1",
     "cmd-ts": "^0.10.0",
     "cockatiel": "^2.0.2",
@@ -139,7 +139,7 @@ export const packageJson: PackageJsonWechaty = {
     "@chatie/eslint-config": "^1.0.4",
     "@chatie/semver": "^0.4.7",
     "@chatie/tsconfig": "^4.6.3",
-    "@juzi/wechaty-puppet": "^1.0.58",
+    "@juzi/wechaty-puppet": "^1.0.59",
     "@juzi/wechaty-puppet-mock": "^1.0.1",
     "@swc/core": "1.3.44",
     "@swc/helpers": "^0.3.6",

package/src/user-modules/contact-self.ts

@@ -36,6 +36,7 @@ import {
 }                       from './contact.js'
 import { validationMixin } from '../user-mixins/validation.js'
 import { poolifyMixin } from '../user-mixins/poolify.js'
+import type { RoomInterface } from './room.js'
 
 const MixinBase = poolifyMixin(
   ContactImpl,
@@ -199,6 +200,20 @@ class ContactSelfMixin extends MixinBase {
     return this.wechaty.puppet.contactSelfSignature(signature).then(this.sync.bind(this))
   }
 
+  public async roomAlias (room: RoomInterface, alias?: string): Promise<void | string> {
+    log.verbose('ContactSelf', 'roomAlias()')
+
+    if (typeof alias === 'undefined') {
+      return room.alias(this)
+    }
+
+    if (!(await room.has(this))) {
+      throw new Error('cannot edit room alias because you are not in room')
+    }
+
+    return this.wechaty.puppet.contactSelfRoomAlias(room.id, alias)
+  }
+
 }
 
 class ContactSelfImpl extends validationMixin(ContactSelfMixin)<ContactSelfInterface>() {}

package/src/user-modules/contact.ts

@@ -173,48 +173,46 @@ class ContactMixin extends MixinBase implements SayableSayer {
   ): Promise<ContactInterface[]> {
     log.verbose('Contact', 'findAll(%s)', JSON.stringify(query, stringifyFilter) || '')
 
-    try {
-      const contactIdList: string[] = await this.wechaty.puppet.contactSearch(query)
-
-      let continuousErrorCount = 0
-      let totalErrorCount = 0
-      const idToContact = async (id: string) => {
-        const result = await this.wechaty.Contact.find({ id }).catch(e => {
-          this.wechaty.emitError(e)
-          continuousErrorCount++
-          totalErrorCount++
-          if (continuousErrorCount > 5) {
-            throw new Error('5 continuous errors!')
-          }
-          if (totalErrorCount > 100) {
-            throw new Error('100 total errors!')
-          }
-        })
-        continuousErrorCount = 0
-        return result
-      }
-
-      /**
-       * we need to use concurrencyExecuter to reduce the parallel number of the requests
-       */
-      const CONCURRENCY = 17
-      const contactIterator = concurrencyExecuter(CONCURRENCY)(idToContact)(contactIdList)
+    const contactIdList: string[] = await this.wechaty.puppet.contactSearch(query)
 
-      const contactList: ContactInterface[] = []
+    let continuousErrorCount = 0
+    let totalErrorCount = 0
+    const totalErrorThreshold = Math.round(contactIdList.length / 5)
 
-      for await (const contact of contactIterator) {
-        if (contact) {
-          contactList.push(contact)
-        }
+    const idToContact = async (id: string) => {
+      if (!this.wechaty.isLoggedIn) {
+        throw new Error('wechaty not logged in')
       }
+      const result = await this.wechaty.Contact.find({ id }).catch(e => {
+        this.wechaty.emitError(e)
+        continuousErrorCount++
+        totalErrorCount++
+        if (continuousErrorCount > 5) {
+          throw new Error('5 continuous errors!')
+        }
+        if (totalErrorCount > totalErrorThreshold) {
+          throw new Error(`${totalErrorThreshold} total errors!`)
+        }
+      })
+      continuousErrorCount = 0
+      return result
+    }
 
-      return contactList
+    /**
+     * we need to use concurrencyExecuter to reduce the parallel number of the requests
+     */
+    const CONCURRENCY = 17
+    const contactIterator = concurrencyExecuter(CONCURRENCY)(idToContact)(contactIdList)
 
-    } catch (e) {
-      this.wechaty.emitError(e)
-      log.error('Contact', 'this.wechaty.puppet.contactFindAll() rejected: %s', (e as Error).message)
-      return [] // fail safe
+    const contactList: ContactInterface[] = []
+
+    for await (const contact of contactIterator) {
+      if (contact) {
+        contactList.push(contact)
+      }
     }
+
+    return contactList
   }
 
   // TODO

package/src/user-modules/message.ts

@@ -191,9 +191,28 @@ class MessageMixin extends MixinBase implements SayableSayer {
     const { contactIds = [], roomIds = [] } = await this.wechaty.puppet.getMessageBroadcastTarget()
 
     const CONCURRENCY = 17
-    const idToRoom = async (id: string) =>
-      this.wechaty.Room.find({ id })
-        .catch(e => this.wechaty.emitError(e))
+
+    let roomContinuousErrorCount = 0
+    let roomTotalErrorCount = 0
+    const roomTotalErrorThreshold = Math.round(roomIds.length / 5)
+    const idToRoom = async (id: string) => {
+      if (!this.wechaty.isLoggedIn) {
+        throw new Error('wechaty not logged in')
+      }
+      const result = await this.wechaty.Room.find({ id }).catch(e => {
+        this.wechaty.emitError(e)
+        roomContinuousErrorCount++
+        roomTotalErrorCount++
+        if (roomContinuousErrorCount > 5) {
+          throw new Error('5 continuous errors!')
+        }
+        if (roomTotalErrorCount > roomTotalErrorThreshold) {
+          throw new Error(`${roomTotalErrorThreshold} total errors!`)
+        }
+      })
+      roomContinuousErrorCount = 0
+      return result
+    }
 
     const roomIterator = concurrencyExecuter(CONCURRENCY)(idToRoom)(roomIds)
 
@@ -205,9 +224,27 @@ class MessageMixin extends MixinBase implements SayableSayer {
       }
     }
 
-    const idToContact = async (id: string) =>
-      this.wechaty.Contact.find({ id })
-        .catch(e => this.wechaty.emitError(e))
+    let contactContinuousErrorCount = 0
+    let contactTotalErrorCount = 0
+    const contactTotalErrorThreshold = Math.round(roomIds.length / 5)
+    const idToContact = async (id: string) => {
+      if (!this.wechaty.isLoggedIn) {
+        throw new Error('wechaty not logged in')
+      }
+      const result = await this.wechaty.Contact.find({ id }).catch(e => {
+        this.wechaty.emitError(e)
+        contactContinuousErrorCount++
+        contactTotalErrorCount++
+        if (contactContinuousErrorCount > 5) {
+          throw new Error('5 continuous errors!')
+        }
+        if (contactTotalErrorCount > contactTotalErrorThreshold) {
+          throw new Error(`${contactTotalErrorThreshold} total errors!`)
+        }
+      })
+      contactContinuousErrorCount = 0
+      return result
+    }
 
     const contactIterator = concurrencyExecuter(CONCURRENCY)(idToContact)(contactIds)
 

package/src/user-modules/room.spec.ts

@@ -52,6 +52,13 @@ test('findAll()', async t => {
       topic: EXPECTED_ROOM_TOPIC,
     } as PUPPET.payloads.Room
   })
+  const mockContact = puppet.mocker.createContact({ name: 'bot' })
+  await puppet.mocker.login(mockContact)
+
+  const future = new Promise(resolve => {
+    wechaty.on('login', resolve)
+  })
+  await future
 
   const roomList = await wechaty.Room.findAll()
   t.equal(roomList.length, 1, 'should find 1 room')
@@ -60,6 +67,32 @@ test('findAll()', async t => {
   await wechaty.stop()
 })
 
+test('room.findAll() not login test', async t => {
+  const EXPECTED_ROOM_ID      = 'test-id'
+  const EXPECTED_ROOM_TOPIC   = 'test-topic'
+  const EXPECTED_ROOM_ID_LIST = [ EXPECTED_ROOM_ID ]
+
+  const sandbox = sinon.createSandbox()
+
+  const puppet = new PuppetMock() as any
+  const wechaty = WechatyBuilder.build({ puppet })
+
+  await wechaty.start()
+
+  sandbox.stub(puppet, 'roomSearch').resolves(EXPECTED_ROOM_ID_LIST)
+  sandbox.stub(puppet, 'roomMemberList').resolves([])
+  sandbox.stub(puppet, 'roomPayload').callsFake(async () => {
+    await new Promise(resolve => setImmediate(resolve))
+    return {
+      topic: EXPECTED_ROOM_TOPIC,
+    } as PUPPET.payloads.Room
+  })
+
+  await t.rejects(wechaty.Room.findAll())
+
+  await wechaty.stop()
+})
+
 test('room.say() smoke testing', async () => {
 
   const sandbox = sinon.createSandbox()

package/src/user-modules/room.ts

@@ -147,48 +147,45 @@ class RoomMixin extends MixinBase implements SayableSayer {
   ): Promise<RoomInterface[]> {
     log.verbose('Room', 'findAll(%s)', JSON.stringify(query, stringifyFilter) || '')
 
-    try {
-      const roomIdList = await this.wechaty.puppet.roomSearch(query)
-
-      let continuousErrorCount = 0
-      let totalErrorCount = 0
-      const idToRoom = async (id: string) => {
-        const result = await this.wechaty.Room.find({ id }).catch(e => {
-          this.wechaty.emitError(e)
-          continuousErrorCount++
-          totalErrorCount++
-          if (continuousErrorCount > 5) {
-            throw new Error('5 continuous errors!')
-          }
-          if (totalErrorCount > 100) {
-            throw new Error('100 total errors!')
-          }
-        })
-        continuousErrorCount = 0
-        return result
+    const roomIdList = await this.wechaty.puppet.roomSearch(query)
+
+    let continuousErrorCount = 0
+    let totalErrorCount = 0
+    const totalErrorThreshold = Math.round(roomIdList.length / 5)
+    const idToRoom = async (id: string) => {
+      if (!this.wechaty.isLoggedIn) {
+        throw new Error('wechaty not logged in')
       }
+      const result = await this.wechaty.Room.find({ id }).catch(e => {
+        this.wechaty.emitError(e)
+        continuousErrorCount++
+        totalErrorCount++
+        if (continuousErrorCount > 5) {
+          throw new Error('5 continuous errors!')
+        }
+        if (totalErrorCount > totalErrorThreshold) {
+          throw new Error(`${totalErrorThreshold} total errors!`)
+        }
+      })
+      continuousErrorCount = 0
+      return result
+    }
 
-      /**
-       * we need to use concurrencyExecuter to reduce the parallel number of the requests
-       */
-      const CONCURRENCY = 17
-      const roomIterator = concurrencyExecuter(CONCURRENCY)(idToRoom)(roomIdList)
+    /**
+     * we need to use concurrencyExecuter to reduce the parallel number of the requests
+     */
+    const CONCURRENCY = 17
+    const roomIterator = concurrencyExecuter(CONCURRENCY)(idToRoom)(roomIdList)
 
-      const roomList: RoomInterface[] = []
+    const roomList: RoomInterface[] = []
 
-      for await (const room of roomIterator) {
-        if (room) {
-          roomList.push(room)
-        }
+    for await (const room of roomIterator) {
+      if (room) {
+        roomList.push(room)
       }
-
-      return roomList
-
-    } catch (e) {
-      this.wechaty.emitError(e)
-      log.verbose('Room', 'findAll() rejected: %s', (e as Error).message)
-      return [] as RoomInterface[] // fail safe
     }
+
+    return roomList
   }
 
   /**

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

@@ -67,7 +67,27 @@ class TagGroupMixin extends MixinBase {
     try {
       const tagGroupIds = await this.wechaty.puppet.tagGroupList()
 
-      const idToTagGroup = async (id: string) => this.find({ id }).catch(e => this.wechaty.emitError(e))
+      let continuousErrorCount = 0
+      let totalErrorCount = 0
+      const totalErrorThreshold = Math.round(tagGroupIds.length / 5)
+      const idToTagGroup = async (id: string) => {
+        if (!this.wechaty.isLoggedIn) {
+          throw new Error('wechaty not logged in')
+        }
+        const result = this.find({ id }).catch(e => {
+          this.wechaty.emitError(e)
+          continuousErrorCount++
+          totalErrorCount++
+          if (continuousErrorCount > 5) {
+            throw new Error('5 continuous errors!')
+          }
+          if (totalErrorCount > totalErrorThreshold) {
+            throw new Error(`${totalErrorThreshold} total errors!`)
+          }
+        })
+        continuousErrorCount = 0
+        return result
+      }
 
       const CONCURRENCY = 17
       const tagGroupIterator = concurrencyExecuter(CONCURRENCY)(idToTagGroup)(tagGroupIds)

package/src/user-modules/tag.ts

@@ -77,28 +77,41 @@ class TagMixin extends MixinBase {
   static async list (): Promise<TagInterface[]> {
     log.verbose('Tag', 'list()')
 
-    try {
-      const tagIdList = await this.wechaty.puppet.tagTagList()
-
-      const idToTag = async (id: string) => this.find({ id }).catch(e => this.wechaty.emitError(e))
-
-      const CONCURRENCY = 17
-      const tagIterator = concurrencyExecuter(CONCURRENCY)(idToTag)(tagIdList)
-
-      const tagList: TagInterface[] = []
-      for await (const tag of tagIterator) {
-        if (tag) {
-          tagList.push(tag)
-        }
+    const tagIdList = await this.wechaty.puppet.tagTagList()
+
+    let continuousErrorCount = 0
+    let totalErrorCount = 0
+    const totalErrorThreshold = Math.round(tagIdList.length / 5)
+    const idToTag = async (id: string) => {
+      if (!this.wechaty.isLoggedIn) {
+        throw new Error('wechaty not logged in')
       }
+      const result = this.find({ id }).catch(e => {
+        this.wechaty.emitError(e)
+        continuousErrorCount++
+        totalErrorCount++
+        if (continuousErrorCount > 5) {
+          throw new Error('5 continuous errors!')
+        }
+        if (totalErrorCount > totalErrorThreshold) {
+          throw new Error(`${totalErrorThreshold} total errors!`)
+        }
+      })
+      continuousErrorCount = 0
+      return result
+    }
 
-      return tagList
+    const CONCURRENCY = 17
+    const tagIterator = concurrencyExecuter(CONCURRENCY)(idToTag)(tagIdList)
 
-    } catch (e) {
-      this.wechaty.emitError(e)
-      log.error('Tag', 'list() exception: %s', (e as Error).message)
-      return []
+    const tagList: TagInterface[] = []
+    for await (const tag of tagIterator) {
+      if (tag) {
+        tagList.push(tag)
+      }
     }
+
+    return tagList
   }
 
   static async find (filter: TagQueryFilter): Promise<TagInterface | undefined> {