@juzi/wechaty 1.0.58 → 1.0.59

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> {