@juzi/wechaty 1.0.155 → 1.0.157

package/src/user-modules/room.ts

@@ -268,6 +268,69 @@ class RoomMixin extends MixinBase implements SayableSayer {
     return undefined
   }
 
+  /**
+   * Async iterator variant of {@link findAll} that yields rooms in batches.
+   *
+   * Each batch is materialised with a single `puppet.batchRoomPayload` RPC,
+   * so iterating N rooms costs roughly `ceil(N / batch)` round trips instead
+   * of N. Uses `puppet.batchRoomPayload` directly (required on the puppet
+   * abstract), so callers do not need a per-id fallback path. Callers may
+   * `break` between batches to short-circuit.
+   *
+   * @static
+   * @param {PUPPET.filters.Room} [query]
+   * @param {{ batch?: number }} [opts] batch size, default 100
+   * @returns {AsyncIterable<RoomInterface[]>}
+   * @example
+   * for await (const chunk of bot.Room.findAllIter()) {
+   *   for (const room of chunk) {
+   *     console.log(await room.topic())
+   *   }
+   * }
+   */
+  static async * findAllIter (
+    query? : PUPPET.filters.Room,
+    opts?  : { batch?: number },
+  ): AsyncIterable<RoomInterface[]> {
+    const batch = opts?.batch ?? 100
+    log.verbose('Room', 'findAllIter(%s, batch=%d)', JSON.stringify(query, stringifyFilter) || '', batch)
+
+    if (batch <= 0) {
+      throw new Error(`Room.findAllIter() batch must be positive, got ${batch}`)
+    }
+
+    const roomIdList: string[] = await this.wechaty.puppet.roomSearch(query)
+
+    if (!this.wechaty.isLoggedIn) {
+      throw new Error('Room.findAllIter() requires logged in')
+    }
+
+    for (let i = 0; i < roomIdList.length; i += batch) {
+      const idChunk = roomIdList.slice(i, i + batch)
+
+      const payloadMap = await this.wechaty.puppet.batchRoomPayload(idChunk)
+
+      const roomChunk: RoomInterface[] = []
+      for (const id of idChunk) {
+        const payload = payloadMap.get(id)
+        if (!payload) {
+          log.silly('Room', 'findAllIter() payload missing for id=%s, skip', id)
+          continue
+        }
+
+        const room = (this.wechaty.Room as any as typeof RoomImpl).load(id)
+        room.payload = payload
+        roomChunk.push(room)
+      }
+
+      if (roomChunk.length > 0) {
+        yield roomChunk
+      } else {
+        log.warn('Room', 'findAllIter() batch all missing from payloadMap, idChunk=%j', idChunk)
+      }
+    }
+  }
+
   static async batchLoadRooms (roomIdList: string[]) {
     let continuousErrorCount = 0
     let totalErrorCount = 0

package/src/wechaty-mixins/puppet-mixin-dirty-call.spec.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import { test }        from 'tstest'
+import * as PUPPET     from '@juzi/wechaty-puppet'
+import { PuppetMock }  from '@juzi/wechaty-puppet-mock'
+
+import { WechatyBuilder } from '../wechaty-builder.js'
+
+/**
+ * Regression: the dirty event listener for `Payload.Call` in `puppet-mixin`
+ * used to do `await this.puppet.callPayloadDirty(payloadId)` inside the
+ * handler itself.
+ *
+ * Under wechaty-puppet-service, `callPayloadDirty` fires a gRPC
+ * `DirtyPayload` to the server, which then re-emits `dirty` back to the
+ * client through the event stream. That re-emit triggers the handler
+ * again, forming an infinite client⇄server feedback loop.
+ *
+ * All other dirty branches (Contact / Room / Message / Wxxd*) only call
+ * `find(...).ready(true)`; the Call branch was the outlier.
+ *
+ * The fix removes the in-handler `callPayloadDirty` call so the branch
+ * matches the rest of the template. This test pins that contract:
+ * emitting a Call-typed dirty event must NOT cause the handler to call
+ * `puppet.callPayloadDirty` again.
+ */
+test('dirty(Call) handler must NOT call callPayloadDirty (would form a gRPC loop)', async t => {
+  const puppet = new PuppetMock() as any
+  const wechaty = WechatyBuilder.build({ puppet })
+
+  await wechaty.start()
+
+  let dirtyCallCount = 0
+  const originalCallPayloadDirty = puppet.callPayloadDirty.bind(puppet)
+  puppet.callPayloadDirty = async (id: string) => {
+    dirtyCallCount++
+    return originalCallPayloadDirty(id)
+  }
+
+  puppet.emit('dirty', {
+    payloadType: PUPPET.types.Payload.Call,
+    payloadId:   'call-id-x',
+  })
+
+  // Allow the async handler to run.
+  await new Promise(resolve => setTimeout(resolve, 50))
+
+  t.equal(
+    dirtyCallCount,
+    0,
+    `dirty(Call) handler must not re-invoke callPayloadDirty; got ${dirtyCallCount} call(s)`,
+  )
+
+  await wechaty.stop()
+})

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

@@ -753,16 +753,21 @@ const puppetMixin = <MixinBase extends WechatifyUserModuleMixin & GErrorMixin &
                   }
                   case PUPPET.types.Payload.Call: {
                     /**
-                     * Invalidate the puppet-side cache so the next callPayload()
-                     * pull reflects the latest server state, then refresh the
-                     * user-layer Call payload so getters (media / participants /
-                     * endTime) reflect the new view immediately. Whether the
-                     * call is still alive is still decided by the call-event
-                     * handler via __finalizeIfEnded; we do not touch the pool
-                     * here, and we do not emit a synthetic user event — the
-                     * UI is expected to read getters when it needs the value.
+                     * Refresh the user-layer Call payload so getters (media /
+                     * participants / endTime) reflect the new view. Whether
+                     * the call is still alive is still decided by the
+                     * call-event handler via __finalizeIfEnded; we do not
+                     * touch the pool here, and we do not emit a synthetic
+                     * user event — the UI is expected to read getters when
+                     * it needs the value.
+                     *
+                     * IMPORTANT: do NOT call puppet.callPayloadDirty here.
+                     * Under puppet-service that fires a gRPC DirtyPayload
+                     * which the server bounces back as another `dirty`
+                     * event, forming an infinite client⇄server feedback
+                     * loop. Cache invalidation is already handled by the
+                     * cache-mixin onDirty listener registered alongside.
                      */
-                    await this.puppet.callPayloadDirty(payloadId)
                     const call = this.__callPool.get(payloadId)
                     if (call) {
                       try {