@juzi/wechaty-puppet-service 1.0.23 → 1.0.26

package/src/client/puppet-service.ts

@@ -68,6 +68,7 @@ import { packageJson }  from '../package-json.js'
 
 import { GrpcManager }  from './grpc-manager.js'
 import { PayloadStore } from './payload-store.js'
+import { channelPayloadToPb, channelPbToPayload, urlLinkPayloadToPb, urlLinkPbToPayload } from '../utils/pb-payload-helper.js'
 
 export type PuppetServiceOptions = PUPPET.PuppetOptions & {
   authority?  : string
@@ -2195,6 +2196,241 @@ class PuppetService extends PUPPET.Puppet {
     return payload
   }
 
+  /**
+   *
+   * Post & Moment Section
+   *
+   */
+
+  override async postPublish (payload: PUPPET.payloads.Post): Promise<void | string> {
+    log.verbose('PuppetService', 'postPublish(%s)', JSON.stringify(payload))
+
+    if (!PUPPET.payloads.isPostClient(payload)) {
+      throw new Error('can only publish client post now')
+    }
+    const request = new grpcPuppet.MomentPublishRequest()
+    const post = new grpcPuppet.PostPayloadClient()
+    post.setType(grpcPuppet.PostType.POST_TYPE_MOMENT)
+    for (const item of payload.sayableList) {
+      const sayable = new grpcPuppet.PostSayable()
+      switch (item.type) {
+        case PUPPET.types.Sayable.Text:
+          sayable.setType(grpcPuppet.SayableType.SAYABLE_TYPE_TEXT)
+          sayable.setText(item.payload.text)
+          sayable.setMentionIdListList(item.payload.mentions)
+          break
+        case PUPPET.types.Sayable.Attachment: {
+          sayable.setType(grpcPuppet.SayableType.SAYABLE_TYPE_FILE)
+          const serializedFileBox = typeof item.payload.filebox === 'string' ? item.payload.filebox : await this.serializeFileBox(item.payload.filebox)
+          sayable.setFileBox(serializedFileBox)
+          break
+        }
+        case PUPPET.types.Sayable.Url: {
+          sayable.setType(grpcPuppet.SayableType.SAYABLE_TYPE_URL)
+          const urlLinkPayload = item.payload
+          const pbUrlLinkPayload = urlLinkPayloadToPb(grpcPuppet, urlLinkPayload)
+          sayable.setUrlLink(pbUrlLinkPayload)
+          break
+        }
+        case PUPPET.types.Sayable.Channel: {
+          sayable.setType(grpcPuppet.SayableType.SAYABLE_TYPE_CHANNEL)
+          const channelPayload = item.payload
+          const pbChannelPayload = channelPayloadToPb(grpcPuppet, channelPayload)
+          sayable.setChannel(pbChannelPayload)
+          break
+        }
+        default:
+          throw new Error(`postPublish unsupported type ${item.type}`)
+      }
+      post.addSayableList(sayable)
+    }
+    request.setPost(post)
+
+    const result = await util.promisify(
+      this.grpcManager.client.momentPublish
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const momentId = result.getMomentId()
+
+    return momentId
+  }
+
+  override async momentSignature (text?: string): Promise<void | string> {
+    log.verbose('PuppetService', 'momentSignature(%s)', text)
+
+    const request = new grpcPuppet.MomentSignatureRequest()
+    if (text) {
+      request.setText(text)
+    }
+
+    const response = await util.promisify(
+      this.grpcManager.client.momentSignature
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const signature = response.getText()
+
+    return signature
+  }
+
+  override async momentCoverage (cover?: FileBoxInterface | undefined): Promise<void | FileBoxInterface> {
+    log.verbose('PuppetService', 'momentCoverage(%s)', JSON.stringify(cover))
+
+    const request = new grpcPuppet.MomentCoverageRequest()
+    if (cover) {
+      const serializedFileBox = await this.serializeFileBox(cover)
+      request.setFileBox(serializedFileBox)
+    }
+
+    const response = await util.promisify(
+      this.grpcManager.client.momentCoverage
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const jsonText = response.getFileBox()
+    if (jsonText) {
+      return this.FileBoxUuid.fromJSON(jsonText)
+    }
+  }
+
+  override async postPayloadSayable (postId: string, sayableId: string): Promise<PUPPET.payloads.Sayable> {
+    log.verbose('PuppetService', 'postPayloadSayable(%s, %s)', postId, sayableId)
+
+    const request = new grpcPuppet.PostPayloadSayableRequest()
+    request.setPostId(postId)
+    request.setSayableId(sayableId)
+
+    const response = await util.promisify(
+      this.grpcManager.client.postPayloadSayable
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const sayable = response.getSayable()
+    let sayablePayload: PUPPET.payloads.Sayable | undefined
+
+    if (sayable) {
+      switch (sayable.getType()) {
+        case grpcPuppet.SayableType.SAYABLE_TYPE_TEXT:
+          sayablePayload = PUPPET.payloads.sayable.text(sayable.getText() || '', sayable.getMentionIdListList())
+          break
+        case grpcPuppet.SayableType.SAYABLE_TYPE_FILE: {
+          const fileJsonStr = sayable.getFileBox()
+          if (!fileJsonStr) {
+            break
+          }
+          const file = this.FileBoxUuid.fromJSON(fileJsonStr)
+          sayablePayload = PUPPET.payloads.sayable.attachment(file)
+          break
+        }
+        case grpcPuppet.SayableType.SAYABLE_TYPE_URL: {
+          const urlLinkPayloadPb = sayable.getUrlLink()
+          if (!urlLinkPayloadPb) {
+            break
+          }
+          const urlLinkPayload = urlLinkPbToPayload(urlLinkPayloadPb)
+          sayablePayload = PUPPET.payloads.sayable.url(urlLinkPayload)
+          break
+        }
+        case grpcPuppet.SayableType.SAYABLE_TYPE_CHANNEL: {
+          const channelPayloadPb = sayable.getChannel()
+          if (!channelPayloadPb) {
+            break
+          }
+          const channelPayload = channelPbToPayload(channelPayloadPb!)
+          sayablePayload = PUPPET.payloads.sayable.channel(channelPayload)
+          break
+        }
+        default:
+          throw new Error(`unsupported postSayableType type ${sayable.getType()}`)
+      }
+    }
+    if (!sayablePayload) {
+      throw new Error(`cannot get sayable ${sayableId} from post ${postId}`)
+    } else {
+      return sayablePayload
+    }
+  }
+
+  override async postRawPayload (id: string): Promise<PUPPET.payloads.Post> {
+    log.verbose('PuppetService', 'postRawPayload(%s)', id)
+
+    const request = new grpcPuppet.PostPayloadRequest()
+    request.setPostId(id)
+
+    const response = await util.promisify(
+      this.grpcManager.client.postPayload
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const postPb = response.getPost()
+    if (!postPb) {
+      throw new Error(`failed to get post for id ${id}`)
+    }
+    const timestamp = postPb.getTimestamp()
+    const payload: PUPPET.payloads.PostServer = {
+      id,
+      parentId: postPb.getParentId(),
+      rootId: postPb.getRootId(),
+      type: postPb.getType() || PUPPET.types.Post.Unspecified,
+      sayableList: [],
+      contactId: postPb.getContactId(),
+      timestamp: timestamp ? millisecondsFromTimestamp(timestamp) : Date.now(),
+      counter: {
+        children: postPb.getChildren(),
+        descendant: postPb.getDescendant(),
+        taps: {
+          [PUPPET.types.Tap.Like]: postPb.getLike(),
+        },
+      },
+    }
+    const sayablePbList = postPb.getSayableListList()
+    for (const sayablePb of sayablePbList) {
+      payload.sayableList.push(sayablePb.getId())
+    }
+    return payload
+  }
+
+  override async postRawPayloadParser (payload: PUPPET.payloads.Post): Promise<PUPPET.payloads.Post> {
+    // log.silly('PuppetService', 'postRawPayloadParser({id:%s})', payload.id)
+    // passthrough
+    return payload
+  }
+
+  override async postComment (postId: string, text: string, mentionIdList?: string[] | undefined): Promise<string | void> {
+    log.verbose('PuppetService', 'postComment(%s, %s, %s)', postId, text, JSON.stringify(mentionIdList))
+
+    const request = new grpcPuppet.PostCommentRequest()
+    request.setPostId(postId)
+    request.setText(text)
+    request.setMentionIdListList(mentionIdList || [])
+
+    const response = await util.promisify(
+      this.grpcManager.client.postComment
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const commentId = response.getCommentId()
+
+    return commentId
+  }
+
+  override async postLike (postId: string): Promise<string | void> {
+    log.verbose('PuppetService', 'postLike(%s)', postId)
+
+    const request = new grpcPuppet.PostLikeRequest()
+    request.setPostId(postId)
+
+    const response = await util.promisify(
+      this.grpcManager.client.postLike
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const tapId = response.getTapId()
+
+    return tapId
+  }
+
   /**
    * @deprecated Will be removed in v2.0
    */

package/src/package-json.ts

@@ -4,7 +4,7 @@
 import type { PackageJson } from 'type-fest'
 export const packageJson: PackageJson = {
   "name": "@juzi/wechaty-puppet-service",
-  "version": "1.0.23",
+  "version": "1.0.26",
   "description": "Puppet Service for Wechaty",
   "type": "module",
   "exports": {
@@ -69,10 +69,10 @@ export const packageJson: PackageJson = {
     "why-is-node-running": "^2.2.1"
   },
   "peerDependencies": {
-    "@juzi/wechaty-puppet": "^1.0.30"
+    "@juzi/wechaty-puppet": "^1.0.33"
   },
   "dependencies": {
-    "@juzi/wechaty-grpc": "^1.0.17",
+    "@juzi/wechaty-grpc": "^1.0.24",
     "@juzi/wechaty-redux": "^1.0.1",
     "clone-class": "^1.1.1",
     "ducks": "^1.0.2",

package/src/server/puppet-implementation.ts

@@ -47,6 +47,7 @@ import {
 import { log } from '../config.js'
 import { grpcError }          from './grpc-error.js'
 import { EventStreamManager } from './event-stream-manager.js'
+import { channelPayloadToPb, channelPbToPayload, urlLinkPayloadToPb, urlLinkPbToPayload } from '../utils/pb-payload-helper.js'
 
 function puppetImplementation (
   puppet      : PUPPET.impls.PuppetInterface,
@@ -1746,6 +1747,249 @@ function puppetImplementation (
       }
     },
 
+    /**
+     *
+     * Post & Moment
+     *
+     */
+
+    momentPublish: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'momentPublish()')
+
+      try {
+        const post = call.request.getPost()
+        if (!post) {
+          throw new Error('no post found')
+        }
+        const type = post.getType()
+        if (type !== grpcPuppet.PostType.POST_TYPE_MOMENT) {
+          throw new Error('cannot publish non-moment post')
+        }
+        const payload: PUPPET.payloads.PostClient = {
+          type: PUPPET.types.Post.Moment,
+          sayableList: [],
+        }
+        const sayableList = post.getSayableListList()
+        for (const sayable of sayableList) {
+          let sayablePayload: PUPPET.payloads.Sayable | undefined
+          switch (sayable.getType()) {
+            case grpcPuppet.SayableType.SAYABLE_TYPE_TEXT:
+              sayablePayload = PUPPET.payloads.sayable.text(sayable.getText() || '', sayable.getMentionIdListList())
+              break
+            case grpcPuppet.SayableType.SAYABLE_TYPE_FILE: {
+              const fileJsonStr = sayable.getFileBox()
+              if (!fileJsonStr) {
+                break
+              }
+              const file = FileBoxUuid.fromJSON(fileJsonStr)
+              sayablePayload = PUPPET.payloads.sayable.attachment(file)
+              break
+            }
+            case grpcPuppet.SayableType.SAYABLE_TYPE_URL: {
+              const urlLinkPayloadPb = sayable.getUrlLink()
+              if (!urlLinkPayloadPb) {
+                break
+              }
+              const urlLinkPayload = urlLinkPbToPayload(urlLinkPayloadPb)
+              sayablePayload = PUPPET.payloads.sayable.url(urlLinkPayload)
+              break
+            }
+            case grpcPuppet.SayableType.SAYABLE_TYPE_CHANNEL: {
+              const channelPayloadPb = sayable.getChannel()
+              if (!channelPayloadPb) {
+                break
+              }
+              const channelPayload = channelPbToPayload(channelPayloadPb!)
+              sayablePayload = PUPPET.payloads.sayable.channel(channelPayload)
+              break
+            }
+            default:
+              throw new Error(`unsupported postSayableType type ${sayable.getType()}`)
+          }
+          if (sayablePayload) {
+            payload.sayableList.push(sayablePayload)
+          } else {
+            throw new Error(`unable to fetch sayable from ${JSON.stringify(sayable.toObject())}`)
+          }
+        }
+
+        const momentId = await puppet.postPublish(payload)
+        const response = new grpcPuppet.MomentPublishResponse()
+        if (momentId) {
+          response.setMomentId(momentId)
+        }
+
+        return callback(null, response)
+
+      } catch (e) {
+        return grpcError('momentPublish', e, callback)
+      }
+
+    },
+
+    postComment: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'postComment()')
+
+      try {
+        const postId = call.request.getPostId()
+        const mentionIdList = call.request.getMentionIdListList()
+        const text = call.request.getText()
+
+        const result = await puppet.postComment(postId, text, mentionIdList)
+        const response = new grpcPuppet.PostCommentResponse()
+        if (result) { response.setCommentId(result) }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('postComment', e, callback)
+      }
+    },
+
+    postLike: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'postLike()')
+
+      try {
+        const postId = call.request.getPostId()
+
+        const tapId = await puppet.postLike(postId)
+        const response = new grpcPuppet.PostLikeResponse()
+        if (tapId) { response.setTapId(tapId) }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('postLike', e, callback)
+      }
+    },
+
+    momentSignature: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'momentSignature()')
+
+      try {
+        const signature = call.request.getText()
+        const result = await puppet.momentSignature(signature || undefined)
+
+        const response = new grpcPuppet.MomentSignatureResponse()
+        if (result) {
+          response.setText(result)
+        }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('momentSignature', e, callback)
+      }
+    },
+
+    momentCoverage: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'momentCoverage()')
+
+      try {
+        const fileJsonStr = call.request.getFileBox()
+
+        const response = new grpcPuppet.MomentCoverageResponse()
+
+        if (fileJsonStr) {
+          const file = FileBoxUuid.fromJSON(fileJsonStr)
+          await puppet.momentCoverage(file)
+        } else {
+          const file = await puppet.momentCoverage()
+          if (file) {
+            response.setFileBox(await serializeFileBox(file))
+          } else {
+            throw new Error('fail to get moment coverage')
+          }
+        }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('momentCoverage', e, callback)
+      }
+    },
+
+    postPayload: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'postPayloadSayable()')
+
+      try {
+        const postId = call.request.getPostId()
+        const postPayload = await puppet.postPayload(postId) as PUPPET.payloads.PostServer
+
+        const response = new grpcPuppet.PostPayloadResponse()
+        const postPayloadPb = new grpcPuppet.PostPayloadServer()
+        if (postPayload.parentId) { postPayloadPb.setParentId(postPayload.parentId) }
+        if (postPayload.rootId) { postPayloadPb.setRootId(postPayload.rootId) }
+        if (postPayload.type) {
+          postPayloadPb.setType(postPayload.type)
+        } else {
+          postPayloadPb.setType(grpcPuppet.PostType.POST_TYPE_UNSPECIFIED)
+        }
+        if (postPayload.contactId) { postPayloadPb.setContactId(postPayload.contactId) }
+        postPayloadPb.setTimestamp(timestampFromMilliseconds(postPayload.timestamp))
+        if (postPayload.counter.children) { postPayloadPb.setChildren(postPayload.counter.children) }
+        if (postPayload.counter.descendant) { postPayloadPb.setDescendant(postPayload.counter.descendant) }
+        if (postPayload.counter.taps && postPayload.counter.taps[PUPPET.types.Tap.Like]) {
+          postPayloadPb.setLike(postPayload.counter.taps[PUPPET.types.Tap.Like]!)
+        }
+        const sayablePbList = []
+        for (const sayable of postPayload.sayableList) {
+          const sayablePb = new grpcPuppet.PostSayable()
+          sayablePb.setId(sayable)
+          sayablePbList.push(sayablePb)
+        }
+        postPayloadPb.setSayableListList(sayablePbList)
+        response.setPost(postPayloadPb)
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('postPayloadSayable', e, callback)
+      }
+
+    },
+
+    postPayloadSayable: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'postPayloadSayable()')
+
+      try {
+        const postId = call.request.getPostId()
+        const sayableId = call.request.getSayableId()
+
+        const result = await puppet.postPayloadSayable(postId, sayableId)
+        const response = new grpcPuppet.PostPayloadSayableResponse()
+        const sayablePb = new grpcPuppet.PostSayable()
+        switch (result.type) {
+          case PUPPET.types.Sayable.Text:
+            sayablePb.setType(grpcPuppet.SayableType.SAYABLE_TYPE_TEXT)
+            sayablePb.setText(result.payload.text)
+            sayablePb.setMentionIdListList(result.payload.mentions)
+            break
+          case PUPPET.types.Sayable.Attachment: {
+            sayablePb.setType(grpcPuppet.SayableType.SAYABLE_TYPE_FILE)
+            const serializedFileBox = typeof result.payload.filebox === 'string' ? result.payload.filebox : await serializeFileBox(result.payload.filebox)
+            sayablePb.setFileBox(serializedFileBox)
+            break
+          }
+          case PUPPET.types.Sayable.Url: {
+            sayablePb.setType(grpcPuppet.SayableType.SAYABLE_TYPE_URL)
+            const urlLinkPayload = result.payload
+            const pbUrlLinkPayload = urlLinkPayloadToPb(grpcPuppet, urlLinkPayload)
+            sayablePb.setUrlLink(pbUrlLinkPayload)
+            break
+          }
+          case PUPPET.types.Sayable.Channel: {
+            sayablePb.setType(grpcPuppet.SayableType.SAYABLE_TYPE_CHANNEL)
+            const channelPayload = result.payload
+            const pbChannelPayload = channelPayloadToPb(grpcPuppet, channelPayload)
+            sayablePb.setChannel(pbChannelPayload)
+            break
+          }
+          default:
+            throw new Error(`postPayloadSayable unsupported type ${result.type}`)
+        }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('postPayloadSayable', e, callback)
+      }
+    },
+
     download: async (call) => {
       log.verbose('PuppetServiceImpl', 'download()')
 

package/src/utils/pb-payload-helper.ts

@@ -0,0 +1,60 @@
+import type {
+  puppet,
+} from '@juzi/wechaty-grpc'
+
+import type * as PUPPET from '@juzi/wechaty-puppet'
+
+type grpcPuppet = typeof puppet
+
+export const miniProgramPayloadToPb = (grpcPuppet: grpcPuppet, miniProgramPayload: PUPPET.payloads.MiniProgram) => {
+  const pbMiniProgramPayload = new grpcPuppet.MiniProgramPayload()
+  if (miniProgramPayload.appid) { pbMiniProgramPayload.setAppid(miniProgramPayload.appid) }
+  if (miniProgramPayload.description) { pbMiniProgramPayload.setDescription(miniProgramPayload.description) }
+  if (miniProgramPayload.iconUrl) { pbMiniProgramPayload.setIconUrl(miniProgramPayload.iconUrl) }
+  if (miniProgramPayload.pagePath) { pbMiniProgramPayload.setPagePath(miniProgramPayload.pagePath) }
+  if (miniProgramPayload.shareId) { pbMiniProgramPayload.setShareId(miniProgramPayload.shareId) }
+  if (miniProgramPayload.thumbKey) { pbMiniProgramPayload.setThumbKey(miniProgramPayload.thumbKey) }
+  if (miniProgramPayload.thumbUrl) { pbMiniProgramPayload.setThumbUrl(miniProgramPayload.thumbUrl) }
+  if (miniProgramPayload.title) { pbMiniProgramPayload.setTitle(miniProgramPayload.title) }
+  if (miniProgramPayload.username) { pbMiniProgramPayload.setUsername(miniProgramPayload.username) }
+
+  return pbMiniProgramPayload
+}
+
+export const urlLinkPayloadToPb = (grpcPuppet: grpcPuppet, urlLinkPayload: PUPPET.payloads.UrlLink) => {
+  const pbUrlLinkPayload = new grpcPuppet.UrlLinkPayload()
+  pbUrlLinkPayload.setUrl(urlLinkPayload.url)
+  pbUrlLinkPayload.setTitle(urlLinkPayload.title)
+  if (urlLinkPayload.description) { pbUrlLinkPayload.setDescription(urlLinkPayload.description) }
+  if (urlLinkPayload.thumbnailUrl) { pbUrlLinkPayload.setThumbnailUrl(urlLinkPayload.thumbnailUrl) }
+  return pbUrlLinkPayload
+}
+
+export const urlLinkPbToPayload = (urlLinkPayloadPb: puppet.UrlLinkPayload) => {
+  const _urlLinkPayloadPb = urlLinkPayloadPb.toObject()
+  const urlLinkPayload: PUPPET.payloads.UrlLink = {
+    ..._urlLinkPayloadPb,
+  }
+  return urlLinkPayload
+}
+
+export const channelPayloadToPb = (grpcPuppet: grpcPuppet, channelPayload: PUPPET.payloads.Channel) => {
+  const pbChannelPayload = new grpcPuppet.ChannelPayload()
+  if (channelPayload.avatar) { pbChannelPayload.setAvatar(channelPayload.avatar) }
+  if (channelPayload.coverUrl) { pbChannelPayload.setCoverUrl(channelPayload.coverUrl) }
+  if (channelPayload.desc) { pbChannelPayload.setDesc(channelPayload.desc) }
+  if (channelPayload.extras) { pbChannelPayload.setExtras(channelPayload.extras) }
+  if (channelPayload.feedType) { pbChannelPayload.setFeedType(channelPayload.feedType) }
+  if (channelPayload.nickname) { pbChannelPayload.setNickname(channelPayload.nickname) }
+  if (channelPayload.thumbUrl) { pbChannelPayload.setThumbUrl(channelPayload.thumbUrl) }
+  if (channelPayload.url) { pbChannelPayload.setUrl(channelPayload.url) }
+  return pbChannelPayload
+}
+
+export const channelPbToPayload = (channelPayloadPb: puppet.ChannelPayload) => {
+  const _channelPayloadPb = channelPayloadPb.toObject()
+  const channelPayload: PUPPET.payloads.Channel = {
+    ..._channelPayloadPb,
+  }
+  return channelPayload
+}