@juzi/wechaty-puppet-whatsapp 1.0.0

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@juzi/wechaty-puppet-whatsapp",
+  "version": "1.0.0",
+  "description": "Wechaty Puppet for WhatsApp",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/src/mod.js",
+      "require": "./dist/cjs/src/mod.js"
+    }
+  },
+  "typings": "./dist/esm/src/mod.d.ts",
+  "engines": {
+    "node": ">=16",
+    "npm": ">=7"
+  },
+  "scripts": {
+    "clean": "shx rm -fr dist/*",
+    "dist": "npm-run-all clean build fixup",
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "fixup": "shx echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+    "start": "cross-env NODE_OPTIONS='--no-warnings --loader=ts-node/esm' node examples/ding-dong-bot.ts",
+    "lint": "npm-run-all lint:es lint:ts lint:md",
+    "lint:md": "markdownlint README.md",
+    "lint:ts": "tsc --isolatedModules --noEmit",
+    "lint:es": "eslint \"src/**/*.ts\" \"tests/**/*.spec.ts\" --ignore-pattern tests/fixtures/",
+    "test": "npm-run-all lint test:unit",
+    "test:pack": "bash -x scripts/npm-pack-testing.sh",
+    "test:unit": "tap --node-arg=--loader=ts-node/esm --node-arg=--no-warnings 'src/**/*.spec.ts' 'tests/**/*.spec.ts'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/juzibot/puppet-whatsapp.git"
+  },
+  "keywords": [
+    "chatie",
+    "wechaty",
+    "chatbot",
+    "bot",
+    "wechat",
+    "sdk",
+    "puppet",
+    "mock"
+  ],
+  "author": "Huan LI <zixia@zixia.net>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/juzibot/puppet-whatsapp/issues"
+  },
+  "homepage": "https://github.com/juzibot/puppet-whatsapp#readme",
+  "devDependencies": {
+    "@chatie/eslint-config": "^1.0.4",
+    "@chatie/semver": "^0.4.7",
+    "@chatie/tsconfig": "^4.6.3",
+    "@types/cuid": "^2.0.1",
+    "@types/fs-extra": "^9.0.13",
+    "@types/mime": "^2.0.3",
+    "@types/node-schedule": "^1.3.2",
+    "@types/qrcode-terminal": "^0.12.0",
+    "qrcode-terminal": "^0.12.0",
+    "tstest": "^1.2.8"
+  },
+  "peerDependencies": {
+    "@juzi/wechaty-puppet": "1.0.0"
+  },
+  "dependencies": {
+    "@juzi/whatsapp-web.js": "^1.16.10",
+    "ee-ts": "^1.0.2",
+    "flash-store": "^1.0.6",
+    "fs-extra": "^10.0.1",
+    "gerror": "^1.0.16",
+    "mime": "^3.0.0",
+    "node-schedule": "^2.1.0",
+    "rxjs": "^7.5.5",
+    "type-fest": "^2.12.2"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "src/"
+  ],
+  "tap": {
+    "check-coverage": false
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  }
+}

package/src/config.ts

@@ -0,0 +1,70 @@
+/// <reference path="./typings.d.ts" />
+import {
+  MessageTypes as WhatsAppMessageType,
+} from './schema/whatsapp-interface.js'
+import { packageJson } from './package-json.js'
+export { log } from '@juzi/wechaty-puppet'
+export {
+  FileBox,
+  FileBoxType,
+} from 'file-box'
+
+const VERSION = packageJson.version || '0.0.0'
+
+const MEMORY_SLOT = 'PUPPET_WHATSAPP_CLIENT_ID'
+const PRE = 'PuppetWhatsApp'
+
+export const SPECIAL_BOT_PUSHNAME = '-' // FIXME: pushname is '-', see: https://github.com/wechaty/puppet-whatsapp/issues/233
+
+export const MIN_BATTERY_VALUE_FOR_LOGOUT = Number(process.env['MIN_BATTERY_VALUE_FOR_LOGOUT']) || 1
+
+export const MessageMediaTypeList = [
+  // WhatsAppMessageType.CONTACT_CARD_MULTI,
+  WhatsAppMessageType.AUDIO,
+  WhatsAppMessageType.VOICE,
+  WhatsAppMessageType.IMAGE,
+  WhatsAppMessageType.VIDEO,
+  WhatsAppMessageType.DOCUMENT,
+  WhatsAppMessageType.STICKER,
+]
+
+export {
+  MEMORY_SLOT,
+  VERSION,
+  PRE,
+}
+
+export const STRINGS = {
+  en_US: {
+    DEFAULT_HELLO_MESSAGE: 'Hello, I\'m your new WhatsApp friend!',
+    LOGOUT_REASON: {
+      BATTERY_LOWER_IN_PHONE: 'Low battery on your phone, please plug into power source',
+      DEFAULT: 'Logged out',
+      LOGIN_CONFLICT: 'Logged in on other device',
+      NETWORK_TIMEOUT_IN_PHONE: 'WhatsApp connect to your phone',
+    },
+  },
+  zh_CN: {
+    DEFAULT_HELLO_MESSAGE: '你好，我是你的新WhatsApp好友！',
+    LOGOUT_REASON: {
+      BATTERY_LOWER_IN_PHONE: '手机电量过低，即将无法继续使用WhatsApp',
+      DEFAULT: '已退出登录',
+      LOGIN_CONFLICT: '已在其他设备上登录',
+      NETWORK_TIMEOUT_IN_PHONE: '手机端网络连接异常',
+    },
+  },
+}
+
+type LangCodes = keyof typeof STRINGS
+
+export const LANGUAGE: LangCodes = process.env['LANGUAGE'] as LangCodes | undefined || 'zh_CN'
+
+export const DEFAULT_TIMEOUT = {
+  MESSAGE_SEND: 20 * 1000, // should allow long waiting time since connection breaks a log (maybe even no timeout limit?)
+  MESSAGE_SEND_FILE: 15 * 60 * 1000,
+  MESSAGE_SEND_TEXT: 20 * 1000,
+  TIMEOUT_WAIT_CONNECTED: 3 * 1000,
+}
+
+export const HISTORY_MESSAGES_DAYS = Number(process.env['HISTORY_MESSAGES_DAYS'] || '3')
+export const MAX_HEARTBEAT_MISSED = Number(process.env['MAX_HEARTBEAT_MISSED'] || '3')

package/src/data/cache-manager.spec.ts

@@ -0,0 +1,33 @@
+import { CacheManager } from './cache-manager.js'
+import { test } from 'tstest'
+
+test('cacheManager start and stop test', async t => {
+  try {
+    await CacheManager.init('test')
+    t.ok(CacheManager.Instance instanceof CacheManager)
+
+    await CacheManager.release()
+    t.ok('cacheManager release success')
+    t.pass('cacheManager start and stop test pass')
+  } catch (e) {
+    t.fail(e as any)
+  }
+})
+
+test('cacheManager set and get test', async t => {
+  try {
+    const testTimestamp = Date.now()
+    await CacheManager.init('test')
+
+    const cacheManager = CacheManager.Instance
+    await cacheManager.setLatestMessageTimestampForChat('test', testTimestamp)
+    const timeStamp = await (cacheManager.getLatestMessageTimestampForChat('test'))
+
+    t.ok(timeStamp === testTimestamp)
+
+    await CacheManager.release()
+    t.pass('cacheManager set and get test')
+  } catch (e) {
+    t.fail(e as any)
+  }
+})

package/src/data/cache-manager.ts

@@ -0,0 +1,331 @@
+import * as path from 'path'
+import * as fs from 'fs-extra'
+import * as os from 'os'
+import { FlashStore } from 'flash-store'
+
+import { log } from '../config.js'
+import { WA_ERROR_TYPE } from '../exception/error-type.js'
+import WAError from '../exception/whatsapp-error.js'
+
+import type {
+  WhatsAppContactPayload,
+  InviteV4Data,
+  WhatsAppMessagePayload,
+} from '../schema/whatsapp-type.js'
+
+const PRE = 'CacheManager'
+
+export class CacheManager {
+
+  /**
+   * ************************************************************************
+   *                Static Methods
+   * ************************************************************************
+   */
+  private static _instance?: CacheManager
+
+  public static get Instance () {
+    if (!this._instance) {
+      throw WAError(WA_ERROR_TYPE.ERR_NO_CACHE, 'no instance')
+    }
+    return this._instance
+  }
+
+  public static async init (userId: string) {
+    if (this._instance) {
+      return
+    }
+    this._instance = new CacheManager()
+    await this._instance.initCache(userId)
+  }
+
+  public static async release () {
+    if (!this._instance) {
+      return
+    }
+    await this._instance.releaseCache()
+    this._instance = undefined
+  }
+
+  /**
+   * ************************************************************************
+   *                Instance Methods
+   * ************************************************************************
+   */
+  // Static cache, won't change over time
+  private cacheMessageRawPayload?: FlashStore<string, WhatsAppMessagePayload>
+  private cacheContactOrRoomRawPayload?: FlashStore<string, WhatsAppContactPayload>
+  private cacheRoomMemberIdList?: FlashStore<string, string[]>
+  private cacheRoomInvitationRawPayload?: FlashStore<string, Partial<InviteV4Data>>
+  private cacheLatestMessageTimestampForChat?: FlashStore<string, number>
+
+  /**
+   * -------------------------------
+   * Message Cache Section
+   * --------------------------------
+   */
+  public async getMessageRawPayload (id: string) {
+    const cache = this.getMessageCache()
+    return cache.get(id)
+  }
+
+  public async setMessageRawPayload (id: string, payload: WhatsAppMessagePayload): Promise<void> {
+    const cache = this.getMessageCache()
+    // @ts-ignore client is in implementation but not in interface
+    const { client, ...rest } = payload
+    await cache.set(id, rest)
+  }
+
+  public deleteMessage (id: string) {
+    const cache = this.getMessageCache()
+    return cache.delete(id)
+  }
+
+  private getMessageCache () {
+    if (!this.cacheMessageRawPayload) {
+      throw WAError(WA_ERROR_TYPE.ERR_NO_CACHE, 'getMessageCache() has no cache')
+    }
+    return this.cacheMessageRawPayload
+  }
+
+  /**
+   * -------------------------------
+   * Contact And Room Cache Section
+   * --------------------------------
+   */
+  public async getContactOrRoomRawPayload (id: string) {
+    const cache = this.getContactOrRoomCache()
+    return cache.get(id)
+  }
+
+  public async setContactOrRoomRawPayload (id: string, payload: WhatsAppContactPayload): Promise<void> {
+    const cache = this.getContactOrRoomCache()
+    // @ts-ignore client is in implementation but not in interface
+    const { client, ...rest } = payload
+    await cache.set(id, rest)
+  }
+
+  public deleteContactOrRoom (id: string) {
+    const cache = this.getContactOrRoomCache()
+    return cache.delete(id)
+  }
+
+  private getContactOrRoomCache () {
+    if (!this.cacheContactOrRoomRawPayload) {
+      throw WAError(WA_ERROR_TYPE.ERR_NO_CACHE, 'getContactOrRoomCache() has no cache')
+    }
+    return this.cacheContactOrRoomRawPayload
+  }
+
+  public async getContactIdList () {
+    const cache = this.getContactOrRoomCache()
+    const list = []
+    for await (const key of cache.keys()) {
+      const value = await cache.get(key)
+      if (!value) {
+        continue
+      }
+      if (!value.isGroup && value.id._serialized) {
+        list.push(value.id._serialized)
+      }
+    }
+    return list
+  }
+
+  public async getRoomIdList () {
+    const cache = this.getContactOrRoomCache()
+    const list = []
+    for await (const key of cache.keys()) {
+      const value = await cache.get(key)
+      if (!value) {
+        continue
+      }
+      if (value.isGroup && value.id._serialized) {
+        list.push(value.id._serialized)
+      }
+    }
+    return list
+  }
+
+  /**
+   * -------------------------------
+   * Room Member Cache Section
+   * --------------------------------
+   */
+  public async getRoomMemberIdList (roomId: string) {
+    const cache = this.getRoomMemberCache()
+    const memberIdList = await cache.get(roomId)
+    return memberIdList || []
+  }
+
+  public async setRoomMemberIdList (roomId: string, list: string[]): Promise<void> {
+    const cache = this.getRoomMemberCache()
+    await cache.set(roomId, list)
+  }
+
+  public async addRoomMemberToList (roomId: string, memberIds: string | string[]): Promise<void> {
+    const memberIdListInCache = await this.getRoomMemberIdList(roomId)
+    if (Array.isArray(memberIds)) {
+      memberIds.forEach(memberId => !memberIdListInCache.includes(memberId) && memberIdListInCache.push(memberId))
+      await this.setRoomMemberIdList(roomId, memberIdListInCache)
+    } else {
+      !memberIdListInCache.includes(memberIds) && memberIdListInCache.push(memberIds)
+      await this.setRoomMemberIdList(roomId, memberIdListInCache)
+    }
+  }
+
+  public async removeRoomMemberFromList (roomId: string, memberIds: string | string[]): Promise<void> {
+    const memberIdListInCache = await this.getRoomMemberIdList(roomId)
+    if (Array.isArray(memberIds)) {
+      const memberIdList = memberIdListInCache.filter(id => !memberIds.includes(id))
+      await this.setRoomMemberIdList(roomId, memberIdList)
+    } else {
+      if (memberIdListInCache.includes(memberIds)) {
+        const memberIdList = memberIdListInCache.filter(id => id !== memberIds)
+        await this.setRoomMemberIdList(roomId, memberIdList)
+      }
+    }
+  }
+
+  public async deleteRoomMemberIdList (roomId: string) {
+    const cache = this.getRoomMemberCache()
+    await cache.delete(roomId)
+  }
+
+  private getRoomMemberCache () {
+    if (!this.cacheRoomMemberIdList) {
+      throw WAError(WA_ERROR_TYPE.ERR_NO_CACHE, 'getRoomMemberCache() has no cache')
+    }
+    return this.cacheRoomMemberIdList
+  }
+
+  /**
+   * -------------------------------
+   * Room Invitation Cache Section
+   * --------------------------------
+   */
+  public async getRoomInvitationRawPayload (id: string) {
+    const cache = this.getRoomInvitationCache()
+    return cache.get(id)
+  }
+
+  public async setRoomInvitationRawPayload (id: string, payload: Partial<InviteV4Data>): Promise<void> {
+    const cache = this.getRoomInvitationCache()
+    await cache.set(id, payload)
+  }
+
+  public deleteRoomInvitation (id: string) {
+    const cache = this.getRoomInvitationCache()
+    return cache.delete(id)
+  }
+
+  private getRoomInvitationCache () {
+    if (!this.cacheRoomInvitationRawPayload) {
+      throw WAError(WA_ERROR_TYPE.ERR_NO_CACHE, 'getRoomInvitationCache() has no cache')
+    }
+    return this.cacheRoomInvitationRawPayload
+  }
+
+  /**
+   * -------------------------------
+   * Message Cache Section
+   * --------------------------------
+   */
+
+  /**
+   * get timestamp of the latest message for contact or room, if timestamp is not in cache, return Number.MAX_SAFE_INTEGER
+   * @param {string} id message id
+   * @returns {number} timestamp or Number.MAX_SAFE_INTEGER
+   */
+  public async getLatestMessageTimestampForChat (id: string): Promise<number> {
+    const cache = this.getLatestMessageTimestampForChatCache()
+    const timestamp = await cache.get(id)
+    if (!timestamp) {
+      return Number.MAX_SAFE_INTEGER
+    }
+    return timestamp
+  }
+
+  public async setLatestMessageTimestampForChat (id: string, num: number): Promise<void> {
+    const cache = this.getLatestMessageTimestampForChatCache()
+    await cache.set(id, num)
+  }
+
+  private getLatestMessageTimestampForChatCache () {
+    if (!this.cacheLatestMessageTimestampForChat) {
+      throw WAError(WA_ERROR_TYPE.ERR_NO_CACHE, 'getLatestMessageTimestampForChatCache() has no cache')
+    }
+    return this.cacheLatestMessageTimestampForChat
+  }
+
+  /**
+   * -------------------------------
+   * Private Method Section
+   * --------------------------------
+   */
+
+  private async initCache (
+    userId: string,
+  ): Promise<void> {
+
+    if (this.cacheMessageRawPayload) {
+      throw WAError(WA_ERROR_TYPE.ERR_INIT, 'cacheMessageRawPayload does not exist.')
+    }
+
+    const baseDir = path.join(
+      os.homedir(),
+      '.wechaty',
+      'puppet-whatsapp',
+      'flash-store-v0.12',
+      userId,
+    )
+
+    const baseDirExist = await fs.pathExists(baseDir)
+
+    if (!baseDirExist) {
+      await fs.mkdirp(baseDir)
+    }
+
+    this.cacheMessageRawPayload = new FlashStore(path.join(baseDir, 'message'))
+    this.cacheContactOrRoomRawPayload = new FlashStore(path.join(baseDir, 'contact-or-room'))
+    this.cacheRoomInvitationRawPayload = new FlashStore(path.join(baseDir, 'room-invitation'))
+    this.cacheRoomMemberIdList = new FlashStore(path.join(baseDir, 'room-member'))
+    this.cacheLatestMessageTimestampForChat = new FlashStore(path.join(baseDir, 'latest-message-timestamp-for-chat'))
+
+    const messageTotal = await this.cacheMessageRawPayload.size
+
+    log.verbose(PRE, `initCache() inited Messages: ${messageTotal} cacheDir="${baseDir}"`)
+  }
+
+  private async releaseCache () {
+    log.verbose(PRE, 'releaseCache()')
+
+    if (this.cacheMessageRawPayload
+        && this.cacheContactOrRoomRawPayload
+        && this.cacheRoomInvitationRawPayload
+        && this.cacheRoomMemberIdList
+        && this.cacheLatestMessageTimestampForChat
+    ) {
+      log.silly(PRE, 'releaseCache() closing caches ...')
+
+      await Promise.all([
+        this.cacheMessageRawPayload.close(),
+        this.cacheContactOrRoomRawPayload.close(),
+        this.cacheRoomInvitationRawPayload.close(),
+        this.cacheRoomMemberIdList.close(),
+        this.cacheLatestMessageTimestampForChat.close(),
+      ])
+
+      this.cacheMessageRawPayload = undefined
+      this.cacheContactOrRoomRawPayload = undefined
+      this.cacheRoomInvitationRawPayload = undefined
+      this.cacheRoomMemberIdList = undefined
+      this.cacheLatestMessageTimestampForChat = undefined
+
+      log.silly(PRE, 'releaseCache() cache closed.')
+    } else {
+      log.verbose(PRE, 'releaseCache() cache not exist.')
+    }
+  }
+
+}

package/src/exception/error-type.ts

@@ -0,0 +1,59 @@
+enum BASE_ERROR_TYPE {
+  ERR_REQUEST_TIMEOUT = 1101,  // 请求超时
+  ERR_START = 1102,  // 启动异常
+  ERR_STOP = 1103,  // 停止异常
+}
+
+enum INIT_ERROR_TYPE {
+  ERR_INIT = 1001,  // 未初始化
+  ERR_NOT_LOGIN = 1002,  // 未登录
+  ERR_CACHE_EXISTED = 1003,  // 缓存已存在
+  ERR_NO_CACHE = 1004,  // 缓存无效
+}
+
+enum MESSAGE_ERROR_TYPE {
+  ERR_SEND_MSG = 2001,  // 发送消息失败
+  ERR_SEND_MSG_TIMEOUT = 2002,  // 发送消息超时
+  ERR_UNKNOWN_SEND_STATUS = 2003,  // 未知消息发送结果
+  ERR_MSG_NOT_FOUND = 2004,  // 未查到消息内容
+  ERR_MSG_NOT_MATCH = 2005,  // 消息类型不匹配
+  ERR_MSG_CONTACT = 2006,  // 提取卡片消息异常
+  ERR_MSG_IMAGE = 2007,  // 提取图片消息异常
+  ERR_MSG_FILE = 2008,  // 提取文件消息异常
+  ERR_MSG_URL_LINK = 2009,  // 提取链接消息异常
+  ERR_MSG_FORWARD = 2010,  // 转发消息异常
+  ERR_MSG_IMAGE_WITHOUT_BODY = 2011,  // 图片消息中不包含缩率图信息
+}
+
+enum ROOM_ERROR_TYPE {
+  ERR_ROOM_NOT_FOUND = 3001,  // 群聊不存在
+  ERR_CREATE_ROOM = 3002,  // 创建群聊失败
+  ERR_MODIFY_ROOM_NAME = 3003,  // 修改群名称失败
+  ERR_ADD_ROOM = 3004,  // 拉人进群失败
+  ERR_REMOVE_ROOM = 3005,  // 踢人出群失败
+  ERR_ACCEPT_ROOM_INVITATION = 3006, // 自动通过群邀请失败
+  ERR_ANNOUNCE_NO_PERMISSION = 3007,  // 无发送群公告权限
+  ERR_ROOM_AVATAR_NOT_FOUND = 3008,  // 群头像不存在
+}
+
+enum CONTACT_ERROR_TYPE {
+  ERR_CONTACT_NOT_FOUND = 4001,  // 联系人不存在
+  ERR_INVALID_CONTACT_ID = 4002,  // 联系人ID无效
+  ERR_CONTACT_CARD_ID = 4003,  // 名片id异常
+}
+
+enum OTHER_ERROR_TYPE {
+  ERR_RATE_FUNCTION_NOT_FOUND = 5001, // 队列中对象不存在
+  ERR_GROUP_OR_CONTACT_ID = 5002, // ID错误
+}
+
+export const WA_ERROR_TYPE = {
+  ...BASE_ERROR_TYPE,  // 基础错误类型
+  ...INIT_ERROR_TYPE,  // 初始化错误类型
+  ...MESSAGE_ERROR_TYPE,  // 消息相关错误类型
+  ...ROOM_ERROR_TYPE,  // 群相关错误类型
+  ...CONTACT_ERROR_TYPE,  // 联系人相关错误类型
+  ...OTHER_ERROR_TYPE, // 其他错误类型
+}
+
+export type WAErrorType = BASE_ERROR_TYPE | INIT_ERROR_TYPE | MESSAGE_ERROR_TYPE | ROOM_ERROR_TYPE | CONTACT_ERROR_TYPE | OTHER_ERROR_TYPE

package/src/exception/whatsapp-error.spec.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node --no-warnings --loader ts-node/esm
+
+import { test } from 'tstest'
+import { WA_ERROR_TYPE } from './error-type.js'
+
+import WAError from './whatsapp-error.js'
+
+function throwError () {
+  throw WAError(WA_ERROR_TYPE.ERR_INIT, 'no cache manager')
+}
+test('WAError should throw', async t => {
+  t.throws(throwError, WAError, WAError(WA_ERROR_TYPE.ERR_INIT, 'no cache manager'))
+  t.pass('WAError should throw pass')
+})
+
+test('WAError instanceof error', async t => {
+  const err = WAError(WA_ERROR_TYPE.ERR_INIT, 'no cache manager')
+  t.ok(err instanceof Error)
+  t.pass('WAError instanceof error pass')
+})
+
+test('WAError should has message', async t => {
+  const err = WAError(WA_ERROR_TYPE.ERR_INIT, 'no cache manager')
+  t.ok(err.message === 'no cache manager')
+  t.pass('WAError should has message pass')
+})

package/src/exception/whatsapp-error.ts

@@ -0,0 +1,15 @@
+import { WAErrorType, WA_ERROR_TYPE } from './error-type.js'
+import { GError } from 'gerror'
+
+export default function WAError (
+  type: WAErrorType,
+  message: string,
+  details?: string,
+) {
+  return GError.from({
+    code: +type,
+    details,
+    message,
+    name: WA_ERROR_TYPE[type],
+  })
+}

package/src/helper/index.ts

@@ -0,0 +1,3 @@
+export {
+
+}

package/src/helper/miscellaneous.ts

@@ -0,0 +1,45 @@
+import { HISTORY_MESSAGES_DAYS } from '../config.js'
+
+const InviteLinkRegex = /^(https?:\/\/)?chat\.whatsapp\.com\/(?:invite\/)?([a-zA-Z0-9_-]{22})$/
+
+export const sleep = async (milliseconds?: number) => {
+  if (milliseconds) {
+    await new Promise<void>(resolve => setTimeout(resolve, milliseconds))
+  }
+}
+
+export const isRoomId = (id: string) => {
+  return /@g.us$/i.test(id)
+}
+
+export const isContactId = (id: string) => {
+  return /@c.us$/i.test(id)
+}
+
+export const isInviteLink = (link: string) => {
+  return InviteLinkRegex.test(link)
+}
+
+export const getInviteCode = (link: string) => {
+  const matched = link.match(InviteLinkRegex)
+  if (matched) {
+    if (matched.length === 3) {
+      const inviteCode = matched[2]
+      return inviteCode
+    }
+  }
+  return undefined
+}
+
+export const batchProcess = async (batchSize: number, list: any[], func: any) => {
+  let index = 0
+  while (batchSize * index < list.length) {
+    const curList = list.slice(batchSize * index, batchSize * (index + 1))
+    await Promise.all(curList.map(func))
+    index++
+  }
+}
+
+export const getMaxTimestampForLoadHistoryMessages = () => {
+  return Math.floor(Date.now() / 1000) - HISTORY_MESSAGES_DAYS * 24 * 3600
+}