@juzi/wechaty 1.0.158 → 1.0.160

package/src/wechaty/wechaty-skeleton.ts

@@ -20,19 +20,31 @@
 import { MemoryCard }     from 'memory-card'
 import { log }            from '@juzi/wechaty-puppet'
 import * as UUID          from 'uuid'
-import type { Loggable }  from 'brolog'
 
 import {
   WechatyEventEmitter,
   WechatyEventName,
 }                               from '../schemas/mod.js'
 
+import type { LoggerLike }      from '../schemas/logger.js'
 import type { WechatyOptions }  from '../schemas/wechaty-options.js'
 
 abstract class WechatySkeleton extends WechatyEventEmitter {
 
-  static readonly log: Loggable = log
-  readonly log: Loggable = log
+  static readonly log: LoggerLike = log
+
+  /**
+   * Effective logger for this Wechaty instance.
+   *
+   * Populated in the following order (see puppet-mixin):
+   *   1. `puppet.log`     — the logger the puppet ended up using
+   *      (which, when {@link WechatyOptions.logger} is supplied, is
+   *      the caller's logger).
+   *   2. the built-in brolog `log` — hard fallback for the pre-init
+   *      window and for puppets that have not adopted `puppet.log`.
+   */
+  __log: LoggerLike = log
+  get log (): LoggerLike { return this.__log }
 
   /**
    * the UUID of the Wechaty
@@ -77,20 +89,20 @@ abstract class WechatySkeleton extends WechatyEventEmitter {
    *    by skipping the second time initialization.
    */
   async init (): Promise<void> {
-    log.verbose('WechatySkeleton', 'init()')
+    this.log.verbose('WechatySkeleton', 'init()')
 
     if (!this.__memory) {
       this.__memory = new MemoryCard(this.__options.name)
       try {
         await this.__memory.load()
       } catch (_) {
-        log.silly('WechatySkeleton', 'onStart() memory.load() had already loaded')
+        this.log.silly('WechatySkeleton', 'onStart() memory.load() had already loaded')
       }
     }
   }
 
   async start (): Promise<void> {
-    log.verbose('WechatySkeleton', 'start()')
+    this.log.verbose('WechatySkeleton', 'start()')
     // no super.start()
 
     /**
@@ -100,12 +112,12 @@ abstract class WechatySkeleton extends WechatyEventEmitter {
   }
 
   async stop  (): Promise<void> {
-    log.verbose('WechatySkeleton', 'stop()')
+    this.log.verbose('WechatySkeleton', 'stop()')
     // no super.stop()
   }
 
   override on (event: WechatyEventName, listener: (...args: any[]) => any): this {
-    log.verbose('WechatySkeleton', 'on(%s, listener) registering... listenerCount: %s',
+    this.log.verbose('WechatySkeleton', 'on(%s, listener) registering... listenerCount: %s',
       event,
       this.listenerCount(event),
     )
@@ -117,6 +129,7 @@ abstract class WechatySkeleton extends WechatyEventEmitter {
 
 type WechatySkeletonProtectedProperty =
   | '__events'
+  | '__log'
   | '__memory'
   | '__options'
   | 'memory'

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

@@ -36,7 +36,7 @@ const ioMixin = <MixinBase extends typeof WechatySkeleton & GErrorMixin> (mixinB
     }
 
     override async start (): Promise<void> {
-      log.verbose('WechatyIoMixin', 'start()')
+      this.log.verbose('WechatyIoMixin', 'start()')
 
       await super.start()
 
@@ -48,13 +48,13 @@ const ioMixin = <MixinBase extends typeof WechatySkeleton & GErrorMixin> (mixinB
        * Clean the memory leak-ed io (?)
        */
       if (this.__io) {
-        log.error('WechatyIoMixin', 'start() found existing io instance: stopping...')
+        this.log.error('WechatyIoMixin', 'start() found existing io instance: stopping...')
         try {
           await this.__io.stop()
         } catch (e) {
           this.emitError(e)
         }
-        log.error('WechatyIoMixin', 'start() found existing io instance: stopping... done')
+        this.log.error('WechatyIoMixin', 'start() found existing io instance: stopping... done')
         this.__io = undefined
       }
 
@@ -66,13 +66,13 @@ const ioMixin = <MixinBase extends typeof WechatySkeleton & GErrorMixin> (mixinB
         wechaty : this as any,  // <- FIXME: remove any, Huan(202111)
       })
 
-      log.verbose('WechatyIoMixin', 'start() starting io ...')
+      this.log.verbose('WechatyIoMixin', 'start() starting io ...')
       await this.__io.start()
-      log.verbose('WechatyIoMixin', 'start() starting io ... done')
+      this.log.verbose('WechatyIoMixin', 'start() starting io ... done')
     }
 
     override async stop (): Promise<void> {
-      log.verbose('WechatyIoMixin', 'stop()')
+      this.log.verbose('WechatyIoMixin', 'stop()')
 
       try {
         if (!this.__io) {
@@ -83,9 +83,9 @@ const ioMixin = <MixinBase extends typeof WechatySkeleton & GErrorMixin> (mixinB
         this.__io = undefined
 
         try {
-          log.verbose('WechatyIoMixin', 'stop() starting io ...')
+          this.log.verbose('WechatyIoMixin', 'stop() starting io ...')
           await io.stop()
-          log.verbose('WechatyIoMixin', 'stop() starting io ... done')
+          this.log.verbose('WechatyIoMixin', 'stop() starting io ... done')
         } catch (e) {
           this.emitError(e)
         }

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

@@ -49,7 +49,7 @@ const loginMixin = <MixinBase extends typeof WechatySkeleton & PuppetMixin & GEr
       } catch (e) {
         this.emit('error', e)
 
-        log.warn('WechatyLoginMixin', 'get isLoggedIn puppet instance is not ready yet')
+        this.log.warn('WechatyLoginMixin', 'get isLoggedIn puppet instance is not ready yet')
         // https://github.com/wechaty/wechaty/issues/1878
         return false
       }
@@ -63,7 +63,7 @@ const loginMixin = <MixinBase extends typeof WechatySkeleton & PuppetMixin & GEr
     }
 
     override async init (): Promise<void> {
-      log.verbose('WechatyLoginMixin', 'init()')
+      this.log.verbose('WechatyLoginMixin', 'init()')
       await super.init()
 
       if (this.__loginMixinInited) {
@@ -80,7 +80,7 @@ const loginMixin = <MixinBase extends typeof WechatySkeleton & PuppetMixin & GEr
      * await bot.logout()
      */
     async logout (reason?: string): Promise<void>  {
-      log.verbose('WechatyLoginMixin', 'logout()')
+      this.log.verbose('WechatyLoginMixin', 'logout()')
       await this.puppet.logout(reason)
     }
 
@@ -88,7 +88,7 @@ const loginMixin = <MixinBase extends typeof WechatySkeleton & PuppetMixin & GEr
      * @deprecated: use `isLoggedIn` property instead. will be removed after Dec 31, 2022
      */
     logonoff (): boolean {
-      log.warn('WechatyLoginMixin', 'logonoff() is deprecated: use `isLoggedIn` property instead.\n%s', new Error().stack)
+      this.log.warn('WechatyLoginMixin', 'logonoff() is deprecated: use `isLoggedIn` property instead.\n%s', new Error().stack)
       return this.isLoggedIn
     }
 
@@ -97,7 +97,7 @@ const loginMixin = <MixinBase extends typeof WechatySkeleton & PuppetMixin & GEr
      * @deprecated use {@link Wechaty#currentUser} instead
      */
     userSelf () {
-      log.warn('WechatyLoginMixin', 'userSelf() deprecated: use currentUser instead.\n%s',
+      this.log.warn('WechatyLoginMixin', 'userSelf() deprecated: use currentUser instead.\n%s',
         new Error().stack,
       )
       return this.currentUser

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

@@ -66,7 +66,7 @@ const miscMixin = <MixinBase extends typeof WechatySkeleton & PuppetMixin & GErr
      * @private
      */
     ding (data?: string): void {
-      log.silly('WechatyMiscMixin', 'ding(%s)', data || '')
+      this.log.silly('WechatyMiscMixin', 'ding(%s)', data || '')
 
       try {
         this.puppet.ding(data)

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

@@ -58,16 +58,16 @@ const pluginMixin = <MixinBase extends typeof WechatySkeleton & GErrorMixin & Mi
       )[]
     ): WechatyPluginUninstaller {
       const pluginList = plugins.flat()
-      log.verbose('WechatyPluginMixin', 'use() total %d plugins', pluginList.length)
+      this.log.verbose('WechatyPluginMixin', 'use() total %d plugins', pluginList.length)
 
       const uninstallerList: WechatyPluginUninstaller[] = []
 
       for (const plugin of pluginList) {
-        log.verbose('WechatyPluginMixin', 'use() installing Plugin %s on Wechaty %s ...', plugin.name, this.name())
+        this.log.verbose('WechatyPluginMixin', 'use() installing Plugin %s on Wechaty %s ...', plugin.name, this.name())
 
         const uninstaller = plugin(this as any) // <- Huan(202110): TODO: remove any
         if (isWechatyPluginUninstaller(uninstaller)) {
-          log.verbose('WechatyPluginMixin', 'use() saving uninstaller for Plugin %s on Wechaty %s ...', plugin.name, this.name())
+          this.log.verbose('WechatyPluginMixin', 'use() saving uninstaller for Plugin %s on Wechaty %s ...', plugin.name, this.name())
           uninstallerList.push(uninstaller)
         }
       }
@@ -76,9 +76,9 @@ const pluginMixin = <MixinBase extends typeof WechatySkeleton & GErrorMixin & Mi
        * Return the function to uninstall all plugins
        */
       return () => uninstallerList.forEach(uninstaller => {
-        log.verbose('WechatyPluginMixin', 'use() uninstalling Plugin %s on Wechaty %s ...', uninstaller.name, this.name())
+        this.log.verbose('WechatyPluginMixin', 'use() uninstalling Plugin %s on Wechaty %s ...', uninstaller.name, this.name())
         uninstaller()
-        log.verbose('WechatyPluginMixin', 'use() uninstalling Plugin %s on Wechaty %s ... done', uninstaller.name, this.name())
+        this.log.verbose('WechatyPluginMixin', 'use() uninstalling Plugin %s on Wechaty %s ... done', uninstaller.name, this.name())
       })
     }
 

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

@@ -0,0 +1,144 @@
+#!/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 handler for pooled user-modules
+ * (Contact / Room / WxxdProduct / WxxdOrder) used to call
+ * `this.Xxx.find({ id }).ready(true)`. `find({ id })` on a pool miss
+ * constructs a fresh instance and calls `ready()` — a puppet-side gRPC
+ * round-trip — turning a passive "invalidate if cached" signal into an
+ * active fetch for ids no business code has touched.
+ *
+ * The fix looks the id up in the pool directly and only calls
+ * `.ready(true)` when the instance is already pooled.
+ */
+
+async function delay (ms: number): Promise<void> {
+  await new Promise<void>(resolve => setTimeout(resolve, ms))
+}
+
+test('dirty handler does not fetch payload for un-pooled ids, but still refreshes pooled ones', async t => {
+  const puppet = new PuppetMock() as any
+  const wechaty = WechatyBuilder.build({ puppet })
+
+  const botContact = puppet.mocker.createContact({ name: 'test-bot' })
+
+  await wechaty.start()
+  await puppet.mocker.login(botContact)
+
+  // --- Case 1: un-pooled Contact id must not trigger contactRawPayload ---
+
+  let contactRawPayloadCalls = 0
+  const originalContactRawPayload = puppet.contactRawPayload.bind(puppet)
+  puppet.contactRawPayload = async (id: string) => {
+    contactRawPayloadCalls++
+    return originalContactRawPayload(id)
+  }
+
+  puppet.emit('dirty', {
+    payloadType: PUPPET.types.Payload.Contact,
+    payloadId:   'never-loaded-contact-id',
+  })
+  await delay(50)
+
+  t.equal(
+    contactRawPayloadCalls,
+    0,
+    `dirty(Contact) for un-pooled id must not trigger contactRawPayload; got ${contactRawPayloadCalls} call(s)`,
+  )
+
+  // --- Case 2: un-pooled Room id must not trigger roomRawPayload ---
+
+  let roomRawPayloadCalls = 0
+  const originalRoomRawPayload = puppet.roomRawPayload.bind(puppet)
+  puppet.roomRawPayload = async (id: string) => {
+    roomRawPayloadCalls++
+    return originalRoomRawPayload(id)
+  }
+
+  puppet.emit('dirty', {
+    payloadType: PUPPET.types.Payload.Room,
+    payloadId:   'never-loaded-room-id',
+  })
+  await delay(50)
+
+  t.equal(
+    roomRawPayloadCalls,
+    0,
+    `dirty(Room) for un-pooled id must not trigger roomRawPayload; got ${roomRawPayloadCalls} call(s)`,
+  )
+
+  // --- Case 3: Message dirty must not trigger messageRawPayload (Message has no user-layer pool) ---
+
+  let messageRawPayloadCalls = 0
+  const originalMessageRawPayload = puppet.messageRawPayload.bind(puppet)
+  puppet.messageRawPayload = async (id: string) => {
+    messageRawPayloadCalls++
+    return originalMessageRawPayload(id)
+  }
+
+  puppet.emit('dirty', {
+    payloadType: PUPPET.types.Payload.Message,
+    payloadId:   'some-message-id',
+  })
+  await delay(50)
+
+  t.equal(
+    messageRawPayloadCalls,
+    0,
+    `dirty(Message) must not trigger messageRawPayload at the user layer; got ${messageRawPayloadCalls} call(s)`,
+  )
+
+  // --- Case 4: un-pooled Contact still emits the user-facing dirty event ---
+
+  let wechatyDirtyEmits = 0
+  wechaty.on('dirty', () => {
+    wechatyDirtyEmits++
+  })
+
+  puppet.emit('dirty', {
+    payloadType: PUPPET.types.Payload.Contact,
+    payloadId:   'yet-another-un-pooled-id',
+  })
+  await delay(50)
+
+  t.equal(
+    wechatyDirtyEmits,
+    1,
+    `wechaty.emit('dirty', ...) must fire once even when the id is not pooled; got ${wechatyDirtyEmits}`,
+  )
+
+  // --- Case 5: pooled Contact MUST re-fetch on dirty ---
+
+  const pooledContact = puppet.mocker.createContact({ name: 'pooled-contact' })
+
+  // Force the contact into the wechatified pool via find(). Payload gets
+  // loaded once as part of find()'s ready() call — subsequent counts we
+  // measure from AFTER this seed.
+  await wechaty.Contact.find({ id: pooledContact.id })
+
+  let contactPayloadCalls = 0
+  const originalContactPayload = puppet.contactPayload.bind(puppet)
+  puppet.contactPayload = async (id: string) => {
+    contactPayloadCalls++
+    return originalContactPayload(id)
+  }
+
+  puppet.emit('dirty', {
+    payloadType: PUPPET.types.Payload.Contact,
+    payloadId:   pooledContact.id,
+  })
+  await delay(50)
+
+  t.ok(
+    contactPayloadCalls >= 1,
+    `dirty(Contact) for pooled id must trigger contactPayload via ready(true); got ${contactPayloadCalls} call(s)`,
+  )
+
+  await wechaty.stop()
+})