@juzi/wechaty 1.0.0

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

@@ -0,0 +1,117 @@
+import { log }        from 'wechaty-puppet'
+import { Io } from '../io.js'
+import type { WechatyOptions } from '../wechaty-builder.js'
+
+import type { WechatySkeleton }      from '../wechaty/mod.js'
+import type { GErrorMixin } from './gerror-mixin.js'
+
+/**
+ * Huan(202111): we should not include the IO logic internally
+ *
+ * TODO: remove all IO related logics from Wechaty internal
+ */
+const ioMixin = <MixinBase extends typeof WechatySkeleton & GErrorMixin> (mixinBase: MixinBase) => {
+  log.verbose('WechatyIoMixin', 'ioMixin(%s)', mixinBase.name)
+
+  abstract class IoMixin extends mixinBase {
+
+    __io?: Io
+    get io (): Io {
+      if (!this.__io) {
+        throw new Error('NO IO')
+      }
+      return this.__io
+    }
+
+    __ioToken?: string
+
+    constructor (...args: any[]) {
+      log.verbose('WechatyIoMixin', 'constructor()')
+      super(...args)
+
+      const options = args[0] || {} as WechatyOptions
+      if (options.ioToken) {
+        this.__ioToken = options.ioToken
+      }
+    }
+
+    override async start (): Promise<void> {
+      log.verbose('WechatyIoMixin', 'start()')
+
+      await super.start()
+
+      if (!this.__ioToken) {
+        return
+      }
+
+      /**
+       * Clean the memory leak-ed io (?)
+       */
+      if (this.__io) {
+        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.__io = undefined
+      }
+
+      /**
+       * Initialize IO instance
+       */
+      this.__io = new Io({
+        token   : this.__ioToken,
+        wechaty : this as any,  // <- FIXME: remove any, Huan(202111)
+      })
+
+      log.verbose('WechatyIoMixin', 'start() starting io ...')
+      await this.__io.start()
+      log.verbose('WechatyIoMixin', 'start() starting io ... done')
+    }
+
+    override async stop (): Promise<void> {
+      log.verbose('WechatyIoMixin', 'stop()')
+
+      try {
+        if (!this.__io) {
+          return
+        }
+
+        const io = this.__io
+        this.__io = undefined
+
+        try {
+          log.verbose('WechatyIoMixin', 'stop() starting io ...')
+          await io.stop()
+          log.verbose('WechatyIoMixin', 'stop() starting io ... done')
+        } catch (e) {
+          this.emitError(e)
+        }
+
+      } finally {
+        await super.stop()
+      }
+
+    }
+
+  }
+
+  return IoMixin
+}
+
+type IoMixin = ReturnType<typeof ioMixin>
+
+type ProtectedPropertyIoMixin =
+  | '__io'
+  | '__ioToken'
+  | 'io'
+
+export type {
+  IoMixin,
+  ProtectedPropertyIoMixin,
+}
+export {
+  ioMixin,
+}

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

@@ -0,0 +1,15 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+import { test } from 'tstest'
+
+import type {
+  LoginMixin,
+  ProtectedPropertyLoginMixin,
+}                                             from './login-mixin.js'
+
+test('ProtectedPropertyLoginMixin', async t => {
+  type NotExistInMixin = Exclude<ProtectedPropertyLoginMixin, keyof InstanceType<LoginMixin>>
+  type NotExistTest = NotExistInMixin extends never ? true : false
+
+  const noOneLeft: NotExistTest = true
+  t.ok(noOneLeft, 'should match Mixin properties for every protected property')
+})

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

@@ -0,0 +1,124 @@
+import { log }      from 'wechaty-puppet'
+
+import type {
+  ContactSelfImpl,
+  ContactSelfInterface,
+}                               from '../user-modules/mod.js'
+import type { WechatySkeleton } from '../wechaty/mod.js'
+
+import type { GErrorMixin }     from './gerror-mixin.js'
+import type { PuppetMixin }     from './puppet-mixin.js'
+
+const loginMixin = <MixinBase extends typeof WechatySkeleton & PuppetMixin & GErrorMixin> (mixinBase: MixinBase) => {
+  log.verbose('WechatyLoginMixin', 'loginMixin(%s)', mixinBase.name)
+
+  abstract class LoginMixin extends mixinBase {
+
+    get authQrCode (): undefined | string {
+      return this.puppet.authQrCode
+    }
+
+    /**
+     * The current user
+     *
+     * @returns {ContactSelfInterface}
+     * @example
+     * const contact = bot.currentUser
+     * console.log(`Bot is ${contact.name()}`)
+     */
+    get currentUser (): ContactSelfInterface {
+      return (this.ContactSelf as typeof ContactSelfImpl)
+        .load(this.puppet.currentUserId)
+    }
+
+    /**
+     * Get the logon / logoff state
+     *
+     * @returns {boolean}
+     * @example
+     * if (bot.isLoggedin) {
+     *   console.log('Bot logged in')
+     * } else {
+     *   console.log('Bot not logged in')
+     * }
+     */
+    get isLoggedIn (): boolean {
+      try {
+        // the `this.puppet` might not be initialized yet
+        return this.puppet.isLoggedIn
+      } catch (e) {
+        this.emit('error', e)
+
+        log.warn('WechatyLoginMixin', 'get isLoggedIn puppet instance is not ready yet')
+        // https://github.com/wechaty/wechaty/issues/1878
+        return false
+      }
+    }
+
+    __loginMixinInited = false
+
+    constructor (...args: any[]) {
+      log.verbose('WechatyLoginMixin', 'constructor()')
+      super(...args)
+    }
+
+    override async init (): Promise<void> {
+      log.verbose('WechatyLoginMixin', 'init()')
+      await super.init()
+
+      if (this.__loginMixinInited) {
+        return
+      }
+      this.__loginMixinInited = true
+    }
+
+    /**
+     * Logout the bot
+     *
+     * @returns {Promise<void>}
+     * @example
+     * await bot.logout()
+     */
+    async logout (): Promise<void>  {
+      log.verbose('WechatyLoginMixin', 'logout()')
+      await this.puppet.logout()
+    }
+
+    /**
+     * @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)
+      return this.isLoggedIn
+    }
+
+    /**
+     * Will be removed after Dec 31, 2022
+     * @deprecated use {@link Wechaty#currentUser} instead
+     */
+    userSelf () {
+      log.warn('WechatyLoginMixin', 'userSelf() deprecated: use currentUser instead.\n%s',
+        new Error().stack,
+      )
+      return this.currentUser
+    }
+
+  }
+
+  return LoginMixin
+}
+
+type LoginMixin = ReturnType<typeof loginMixin>
+
+type ProtectedPropertyLoginMixin =
+  | 'userSelf'  // deprecated: use `currentUser` instead. (will be removed after Dec 31, 2022)
+  | 'logonoff'  // deprecated: use `isLoggedIn` instead. ((will be removed after Dec 31, 2022)
+  | '__loginMixinInited'
+
+export type {
+  LoginMixin,
+  ProtectedPropertyLoginMixin,
+}
+export {
+  loginMixin,
+}

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

@@ -0,0 +1,93 @@
+import { log }  from 'wechaty-puppet'
+
+import { VERSION }  from '../config.js'
+
+import type { WechatySkeleton }   from '../wechaty/mod.js'
+
+import type { GErrorMixin }       from './gerror-mixin.js'
+import type { PuppetMixin }       from './puppet-mixin.js'
+
+const miscMixin = <MixinBase extends typeof WechatySkeleton & PuppetMixin & GErrorMixin> (mixinBase: MixinBase) => {
+  log.verbose('WechatyMiscMixin', 'miscMixin(%s)', mixinBase.name)
+
+  abstract class MiscMixin extends mixinBase {
+
+    constructor (...args: any[]) {
+      super(...args)
+    }
+
+    /**
+     * @ignore
+     */
+    override toString () {
+      if (Object.keys(this.__options).length <= 0) {
+        return this.constructor.name
+      }
+
+      return [
+        'Wechaty#',
+        this.id,
+        `<${(this.__options.puppet) || ''}>`,
+        `(${(this.__memory && this.__memory.name) || ''})`,
+      ].join('')
+    }
+
+    /**
+     * Wechaty bot name set by `options.name`
+     * default: `wechaty`
+     */
+    name () {
+      return this.__options.name || 'wechaty'
+    }
+
+    /**
+     * @ignore
+     * Return version of Wechaty
+     *
+     * @returns {string}                  - the version number
+     * @example
+     * console.log(Wechaty.instance().version())       // return '#git[af39df]'
+     * console.log(Wechaty.instance().version(true))   // return '0.7.9'
+     */
+    version (): string {
+      return VERSION
+    }
+
+    /**
+     * @ignore
+     */
+    async sleep (milliseconds: number): Promise<void> {
+      await new Promise<void>(resolve =>
+        setTimeout(resolve, milliseconds),
+      )
+    }
+
+    /**
+     * @private
+     */
+    ding (data?: string): void {
+      log.silly('WechatyMiscMixin', 'ding(%s)', data || '')
+
+      try {
+        this.puppet.ding(data)
+      } catch (e) {
+        this.emitError(e)
+      }
+    }
+
+  }
+
+  return MiscMixin
+}
+
+type MiscMixin = ReturnType<typeof miscMixin>
+
+type ProtectedPropertyMiscMixin = never
+
+export type {
+  MiscMixin,
+  ProtectedPropertyMiscMixin,
+}
+export {
+  miscMixin,
+}

package/src/wechaty-mixins/mod.ts

@@ -0,0 +1,84 @@
+import type {
+  ProtectedPropertyGErrorMixin,
+  GErrorMixin,
+}                                   from './gerror-mixin.js'
+import {
+  gErrorMixin,
+}                                   from './gerror-mixin.js'
+
+import type {
+  ProtectedPropertyPluginMixin,
+  PluginMixin,
+}                                   from './plugin-mixin.js'
+import {
+  pluginMixin,
+}                                   from './plugin-mixin.js'
+
+import type {
+  ProtectedPropertyPuppetMixin,
+  PuppetMixin,
+}                                   from './puppet-mixin.js'
+import {
+  puppetMixin,
+}                                   from './puppet-mixin.js'
+
+import type {
+  ProtectedPropertyWechatifyUserModuleMixin,
+  WechatifyUserModuleMixin,
+}                                   from './wechatify-user-module-mixin.js'
+import {
+  wechatifyUserModuleMixin,
+}                                   from './wechatify-user-module-mixin.js'
+
+import type {
+  ProtectedPropertyIoMixin,
+  IoMixin,
+}                                   from './io-mixin.js'
+import {
+  ioMixin,
+}                                   from './io-mixin.js'
+
+import type {
+  ProtectedPropertyMiscMixin,
+  MiscMixin,
+}                                   from './misc-mixin.js'
+import {
+  miscMixin,
+}                                   from './misc-mixin.js'
+
+import type {
+  ProtectedPropertyLoginMixin,
+  LoginMixin,
+}                                   from './login-mixin.js'
+import {
+  loginMixin,
+}                                   from './login-mixin.js'
+
+type WechatyMixinProtectedProperty =
+  | ProtectedPropertyGErrorMixin
+  | ProtectedPropertyIoMixin
+  | ProtectedPropertyLoginMixin
+  | ProtectedPropertyMiscMixin
+  | ProtectedPropertyPluginMixin
+  | ProtectedPropertyPuppetMixin
+  | ProtectedPropertyWechatifyUserModuleMixin
+
+export type {
+  GErrorMixin,
+  IoMixin,
+  LoginMixin,
+  MiscMixin,
+  PluginMixin,
+  PuppetMixin,
+  WechatifyUserModuleMixin,
+  WechatyMixinProtectedProperty,
+}
+export {
+  gErrorMixin,
+  ioMixin,
+  loginMixin,
+  miscMixin,
+  pluginMixin,
+  puppetMixin,
+  wechatifyUserModuleMixin,
+}

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

@@ -0,0 +1,98 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+import {
+  test,
+  sinon,
+}             from 'tstest'
+
+import { function as FP } from 'fp-ts'
+
+/**
+ * Huan(202201): must import `./wechaty-impl.js` first
+ *
+ * Or will throw error:
+ *
+ * ReferenceError: Cannot access 'wechatifyUserModuleMixin' before initialization
+ *   at file:///home/huan/git/wechaty/wechaty/src/wechaty/wechaty-base.ts:58:3 *
+ *
+ * TODO: find out why
+ */
+import '../wechaty/wechaty-impl.js'
+
+import {
+  gErrorMixin,
+}                             from '../wechaty-mixins/mod.js'
+
+import {
+  WechatySkeleton,
+}                             from '../wechaty/wechaty-skeleton.js'
+
+import {
+  pluginMixin,
+  PluginMixin,
+  ProtectedPropertyPluginMixin,
+}                                             from './plugin-mixin.js'
+import { miscMixin } from './misc-mixin.js'
+import { puppetMixin } from './puppet-mixin.js'
+import { ioMixin } from './io-mixin.js'
+import { wechatifyUserModuleMixin } from './wechatify-user-module-mixin.js'
+
+test('ProtectedPropertyPluginMixin', async t => {
+  type NotExistInMixin = Exclude<ProtectedPropertyPluginMixin, keyof InstanceType<PluginMixin>>
+  type NotExistTest = NotExistInMixin extends never ? true : false
+
+  const noOneLeft: NotExistTest = true
+  t.ok(noOneLeft, 'should match Mixin properties for every protected property')
+})
+
+test('PluginMixin smoke testing', async t => {
+  const sandbox = sinon.createSandbox({
+    useFakeTimers: true,
+  })
+
+  const mixinBase = FP.pipe(
+    WechatySkeleton,
+    gErrorMixin,
+    ioMixin,
+    wechatifyUserModuleMixin,
+    puppetMixin,
+    miscMixin,
+    pluginMixin,
+  )
+
+  class PluginMixinTest extends mixinBase {
+
+    counter = 0
+
+  }
+
+  const Plugin = (wechaty: any) => {
+    wechaty.counter++
+    return () => wechaty.counter--
+  }
+
+  const pluginMixinTest = new PluginMixinTest({ puppet: 'wechaty-puppet-mock' })
+  let future
+
+  const unuse = pluginMixinTest.use(Plugin)
+
+  t.equal(pluginMixinTest.counter, 1, 'should call plugin function right after use before start')
+  future = pluginMixinTest.start()
+  t.equal(pluginMixinTest.counter, 1, 'should call plugin function right after start')
+
+  /**
+   * finish initializing the system
+   */
+  await sandbox.clock.runAllAsync()
+  await future
+  // t.equal(pluginMixinTest.counter, 1, 'should call plugin function after start')
+
+  future = pluginMixinTest.stop()
+  await sandbox.clock.runAllAsync()
+  await future
+  t.equal(pluginMixinTest.counter, 1, 'should not clean plugin context after stop')
+
+  unuse()
+  t.equal(pluginMixinTest.counter, 0, 'should clean plugin context after call unuse()')
+
+  sandbox.restore()
+})

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

@@ -0,0 +1,99 @@
+import { log }              from 'wechaty-puppet'
+
+import type {
+  WechatyPlugin,
+  WechatyPluginUninstaller,
+}                             from '../plugin.js'
+import {
+  isWechatyPluginUninstaller,
+}                             from '../plugin.js'
+
+import type {
+  WechatySkeleton,
+}                       from '../wechaty/mod.js'
+
+import type { GErrorMixin } from './gerror-mixin.js'
+import type { MiscMixin }   from './misc-mixin.js'
+
+interface Plugable {
+  use (
+    ...plugins: (
+      | WechatyPlugin
+      | WechatyPlugin[]
+    )[]
+  ): WechatyPluginUninstaller
+}
+
+const pluginMixin = <MixinBase extends typeof WechatySkeleton & GErrorMixin & MiscMixin> (mixinBase: MixinBase) => {
+  log.verbose('WechatyPluginMixin', 'pluginMixin(%s)', mixinBase.name)
+
+  abstract class PluginMixin extends mixinBase implements Plugable {
+
+    constructor (...args: any[]) {
+      super(...args)
+    }
+
+    /**
+     * @param   {WechatyPlugin[]} plugins      - The plugins you want to use
+     *
+     * @return  {WechatyInterface}                      - this for chaining,
+     *
+     * @desc
+     * For wechaty ecosystem, allow user to define a 3rd party plugin for the all wechaty instances
+     *
+     * @example
+     * // Report all chat message to my server.
+     *
+     * function WechatyReportPlugin(options: { url: string }) {
+     *   return function (this: Wechaty) {
+     *     this.on('message', message => http.post(options.url, { data: message }))
+     *   }
+     * }
+     *
+     * bot.use(WechatyReportPlugin({ url: 'http://somewhere.to.report.your.data.com' })
+     */
+    use (
+      ...plugins: (
+        WechatyPlugin | WechatyPlugin[]
+      )[]
+    ): WechatyPluginUninstaller {
+      const pluginList = plugins.flat()
+      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())
+
+        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())
+          uninstallerList.push(uninstaller)
+        }
+      }
+
+      /**
+       * 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())
+        uninstaller()
+        log.verbose('WechatyPluginMixin', 'use() uninstalling Plugin %s on Wechaty %s ... done', uninstaller.name, this.name())
+      })
+    }
+
+  }
+
+  return PluginMixin
+}
+
+type PluginMixin = ReturnType<typeof pluginMixin>
+
+type ProtectedPropertyPluginMixin = never
+
+export {
+  type Plugable,
+  type PluginMixin,
+  type ProtectedPropertyPluginMixin,
+  pluginMixin,
+}

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

@@ -0,0 +1,15 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+import { test } from 'tstest'
+
+import type {
+  PuppetMixin,
+  ProtectedPropertyPuppetMixin,
+}                                             from './puppet-mixin.js'
+
+test('ProtectedPropertyPuppetMixin', async t => {
+  type NotExistInMixin = Exclude<ProtectedPropertyPuppetMixin, keyof InstanceType<PuppetMixin>>
+  type NotExistTest = NotExistInMixin extends never ? true : false
+
+  const noOneLeft: NotExistTest = true
+  t.ok(noOneLeft, 'should match Mixin properties for every protected property')
+})