Init Mixins (#154)

* create PayloadCache class

* init mixins

* add mixin docs

* code clean

* change protected to jsdoc (#155)

* add CacheMixin & WatchdogMin with PuppetSkelton

* add CacheMixin & WatchdogMin with PuppetSkelton

* clean

* follow mixin design (#156)

* Create PuppetError classes (#159)

* split all code into mixins

* fix memory

* fix

* fix memory

* 0.49.4

* clean

* 0.49.5

* rename PuppetError -> GError

* rename PuppetError -> GError

* 0.49.6

* clean code

* 0.49.7

Author: huan

README.md

@@ -112,11 +112,17 @@ Set the max size for wechaty entities in LRU Cache.
 * [What Are Pure Functions And Why Use Them?](https://medium.com/@jamesjefferyuk/javascript-what-are-pure-functions-4d4d5392d49c)
 * [Master the JavaScript Interview: What is a Pure Function?](https://medium.com/javascript-scene/master-the-javascript-interview-what-is-a-pure-function-d1c076bec976)
 
+### Mixin
+
+* [The mixin pattern in TypeScript – all you need to know](https://www.bryntum.com/blog/the-mixin-pattern-in-typescript-all-you-need-to-know/)
+* [Mixin Classes in TypeScript](https://mariusschulz.com/blog/mixin-classes-in-typescript)
+
 ## History
 
-### master v0.47
+### master v0.49
 
 1. Add `Error` interface to `EventErrorPayload`, and make `.data` optional
+2. Using [Mixin](https://en.wikipedia.org/wiki/Mixin) to extend `Puppet`
 
 ### v0.43 (Aug 28, 2021)
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "wechaty-puppet",
-  "version": "0.49.3",
+  "version": "0.49.7",
   "description": "Abstract Puppet for Wechaty",
   "type": "module",
   "exports": {

src/payload-cache.spec.ts renamed to src/agents/cache-agent.spec.ts

@@ -2,10 +2,10 @@
 
 import { test }  from 'tstest'
 
-import { PayloadCache } from './payload-cache.js'
+import { CacheAgent } from './cache-agent.js'
 
-test('PayloadCache roomMemberId() restart', async t => {
-  const payloadCache = new PayloadCache()
+test('CacheAgent roomMemberId() restart', async t => {
+  const payloadCache = new CacheAgent()
   const roomMemberId = payloadCache.roomMemberId('roomId', 'userId')
   t.equal(roomMemberId, 'roomId-userId', 'should get right id')
 })

src/payload-cache.ts renamed to src/agents/cache-agent.ts

@@ -6,34 +6,28 @@ import QuickLru                 from '@alloc/quick-lru'
 import {
   envVars,
   log,
-}                         from './config.js'
+}                         from '../config.js'
 import type {
   ContactPayload,
-}                         from './schemas/contact.js'
+}                         from '../schemas/contact.js'
 import type {
   FriendshipPayload,
-}                         from './schemas/friendship.js'
+}                         from '../schemas/friendship.js'
 import type {
   MessagePayload,
-}                         from './schemas/message.js'
+}                         from '../schemas/message.js'
 import type {
   RoomMemberPayload,
   RoomPayload,
-}                         from './schemas/room.js'
+}                         from '../schemas/room.js'
 import type {
   RoomInvitationPayload,
-}                         from './schemas/room-invitation.js'
+}                         from '../schemas/room-invitation.js'
+import type { PuppetOptions } from '../schemas/puppet.js'
 
-interface PayloadCacheOptions {
-  contact?        : number
-  friendship?     : number
-  message?        : number
-  room?           : number
-  roomInvitation? : number
-  roomMember?     : number
-}
+type PayloadCacheOptions = Required<PuppetOptions>['cache']
 
-class PayloadCache {
+class CacheAgent {
 
   readonly contact        : QuickLru<string, ContactPayload>
   readonly friendship     : QuickLru<string, FriendshipPayload>
@@ -45,7 +39,7 @@ class PayloadCache {
   constructor (
     protected options: PayloadCacheOptions = {},
   ) {
-    log.verbose('PayloadCache', 'constructor(%s)', JSON.stringify(options))
+    log.verbose('CacheAgent', 'constructor("%s")', JSON.stringify(options))
 
     /**
      * Setup LRU Caches
@@ -77,12 +71,12 @@ class PayloadCache {
   }
 
   start (): void {
-    log.verbose('PayloadCache', 'start()')
+    log.verbose('CacheAgent', 'start()')
     this.clear()
   }
 
   stop (): void {
-    log.verbose('PayloadCache', 'stop()')
+    log.verbose('CacheAgent', 'stop()')
     this.clear()
   }
 
@@ -97,7 +91,7 @@ class PayloadCache {
    *  Huan(2021-08-28): clear the cache when stop
    */
   clear (): void {
-    log.verbose('PayloadCache', 'clear()')
+    log.verbose('CacheAgent', 'clear()')
 
     this.contact.clear()
     this.friendship.clear()
@@ -119,4 +113,5 @@ class PayloadCache {
 
 }
 
-export { PayloadCache }
+export type { PayloadCacheOptions }
+export { CacheAgent }

src/agents/mod.ts

@@ -0,0 +1,7 @@
+import { CacheAgent } from './cache-agent.js'
+import { WatchdogAgent } from './watchdog-agent.js'
+
+export {
+  CacheAgent,
+  WatchdogAgent,
+}

src/agents/watchdog-agent.ts

@@ -0,0 +1,92 @@
+import {
+  Watchdog,
+  WatchdogFood,
+}                       from 'watchdog'
+
+import type { PuppetSkelton } from '../puppet/skelton.js'
+import {
+  log,
+}           from '../config.js'
+
+const DEFAULT_WATCHDOG_TIMEOUT_SECONDS  = 60
+
+class WatchdogAgent {
+
+  protected readonly watchdog : Watchdog
+
+  private cleanCallbackList: Function[]
+
+  /**
+   * Throttle Reset Events
+   *
+   * @private
+   */
+  // protected readonly resetThrottleQueue: ThrottleQueue<string>
+
+  constructor (
+    protected readonly puppet: PuppetSkelton,
+  ) {
+    log.verbose('WatchdogAgent', 'constructor(%s)', puppet)
+
+    this.cleanCallbackList = []
+
+    /**
+     * 1. Setup Watchdog
+     *  puppet implementation class only need to do one thing:
+     *  feed the watchdog by `this.emit('heartbeat', ...)`
+     */
+    const timeoutSeconds = puppet.options.timeoutSeconds || DEFAULT_WATCHDOG_TIMEOUT_SECONDS
+    log.verbose('WatchdogAgent', 'constructor() watchdog timeout set to %d seconds', timeoutSeconds)
+    this.watchdog = new Watchdog(1000 * timeoutSeconds, 'Puppet')
+
+    // /**
+    //   * 2. Setup `reset` Event via a 1 second Throttle Queue:
+    //   */
+    // this.resetThrottleQueue = new ThrottleQueue<string>(1000)
+    // this.resetThrottleQueue.subscribe(reason => {
+    //   log.silly('WatchdogAgent', 'constructor() resetThrottleQueue.subscribe() reason: "%s"', reason)
+    //   puppet.reset(reason)
+    // })
+  }
+
+  /**
+   * @private
+   *
+   * For used by Wechaty internal ONLY.
+   */
+  start (): void {
+    /**
+     * puppet event `heartbeat` to feed() watchdog
+     */
+    const feed = (food: WatchdogFood) => { this.watchdog.feed(food) }
+    this.puppet.on('heartbeat', feed)
+    this.cleanCallbackList.push(() => this.puppet.off('heartbeat', feed))
+
+    /**
+     * watchdog event `reset` to reset() puppet
+     */
+    const reset = (lastFood: WatchdogFood) => {
+      log.warn('WatchdogAgent', 'start() reset() reason: %s', JSON.stringify(lastFood))
+      this.puppet
+        .reset(`WatchdogAgent reset: lastFood: "${JSON.stringify(lastFood)}"`)
+        .catch(e => log.error('WatchdogAgent', 'start() reset() rejection: %s', e.message))
+    }
+    this.watchdog.on('reset', reset)
+    this.cleanCallbackList.push(() => this.puppet.off('reset', reset))
+
+    // this.puppet.on('reset', this.throttleReset)
+  }
+
+  stop (): void {
+    while (this.cleanCallbackList.length) {
+      const callback = this.cleanCallbackList.shift()
+      if (callback) {
+        callback()
+      }
+    }
+    this.watchdog.sleep()
+  }
+
+}
+
+export { WatchdogAgent }

src/events.ts

@@ -53,6 +53,13 @@ interface PuppetEvents {
   scan          : PuppetScanListener
 }
 
-export const PuppetEventEmitter = EventEmitter as new () => TypedEventEmitter<
+const PuppetEventEmitter = EventEmitter as new () => TypedEventEmitter<
   PuppetEvents
 >
+
+export type {
+  PuppetEvents,
+}
+export {
+  PuppetEventEmitter,
+}

src/gerror/ecma.ts

@@ -0,0 +1,17 @@
+/**
+ * JavaScript Error Interface:
+ *
+ * interface Error {
+ *   name: string;
+ *   message: string;
+ *   stack?: string;
+ * }
+ */
+interface EcmaError extends Error {}
+
+const isEcmaError = (payload: any): payload is EcmaError => payload instanceof Object
+  && typeof payload.name    === 'string'
+  && typeof payload.message === 'string'
+
+export type { EcmaError }
+export { isEcmaError }

src/gerror/gerror.spec.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import { test } from 'tstest'
+
+import { GError } from './gerror.js'
+import { Code } from './grpc.js'
+
+test('GError class smoke testing', async t => {
+  const MESSAGE = 'test'
+
+  const gerror = GError.fromJSON(new Error(MESSAGE))
+  const obj    = gerror.toJSON()
+
+  t.equal(obj.code, Code.UNKNOWN, 'should be default code UNKNOWN')
+  t.equal(obj.message, MESSAGE, 'should set message')
+})

src/gerror/gerror.ts

@@ -0,0 +1,120 @@
+/**
+ * [RFC] We need a better error system #159
+ *  https://github.com/wechaty/puppet/issues/159
+ */
+import { log } from '../config.js'
+
+import type { EcmaError }   from './ecma.js'
+import { isEcmaError }      from './ecma.js'
+import type { GrpcStatus }  from './grpc.js'
+import {
+  isGrpcStatus,
+  Code,
+}                           from './grpc.js'
+
+const isGError = (payload: any): payload is GError => payload instanceof Object
+  && isEcmaError(payload)
+  && isGrpcStatus(payload)
+
+class GError extends Error implements GrpcStatus, EcmaError {
+
+  code     : number
+  details? : any[]
+
+  /**
+   * From a gRPC standard error
+   *  Protobuf
+   */
+  public static fromJSON (payload: string | GrpcStatus | EcmaError) {
+    log.verbose('PuppetError', 'from("%s")', JSON.stringify(payload))
+
+    if (typeof payload === 'string') {
+      payload = JSON.parse(payload)
+    }
+
+    if (!isEcmaError(payload) && !isGrpcStatus(payload)) {
+      throw new Error('payload is neither EcmaError nor GrpcStatus')
+    }
+
+    const e = new this(payload)
+    return e
+  }
+
+  protected constructor (
+    payload: GrpcStatus | EcmaError,
+  ) {
+    super()
+    log.verbose('PuppetError', 'constructor("%s")', JSON.stringify(payload))
+
+    /**
+     * Common properties
+     */
+    this.message = payload.message
+
+    if (isGError(payload)) {
+      this.code    = payload.code
+      this.details = payload.details
+      this.name    = payload.name
+      this.stack   = payload.stack
+
+    } else if (isGrpcStatus(payload)) {
+      this.code    = payload.code
+      this.details = payload.details
+      /**
+       * Convert gRPC error to EcmaError
+       */
+      this.name = Array.isArray(payload.details) && payload.details.length > 0
+        ? payload.details[0]
+        : Code[this.code] || String(this.code)
+
+    } else if (isEcmaError(payload)) {
+      this.name  = payload.name
+      this.stack = payload.stack
+      /**
+       * Convert EcmaError to gRPC error
+       */
+      this.code  = Code.UNKNOWN
+      this.details = [
+        payload.name,
+        ...payload.stack?.split('\n') ?? [],
+      ]
+
+    } else {
+      throw new Error('payload is neither EcmaError nor GrpcStatus')
+    }
+  }
+
+  public toJSON (): GrpcStatus & EcmaError {
+    return {
+      code    : this.code,
+      details : this.details,
+      message : this.message,
+      name    : this.name,
+      stack   : this.stack,
+    }
+  }
+
+  public toGrpcStatus (): GrpcStatus {
+    return {
+      code    : this.code,
+      details : this.details,
+      message : this.message,
+    }
+  }
+
+  public toEcmaError (): EcmaError {
+    return {
+      message : this.message,
+      name    : this.name,
+      stack   : this.stack,
+    }
+  }
+
+}
+
+export {
+  GError,
+  isGError,
+  isGrpcStatus,
+  isEcmaError,
+}