@juzi/wechaty-puppet-service 1.0.113 → 1.0.114

package/src/client/puppet-service.ts

@@ -50,7 +50,7 @@ import { packageJson }  from '../package-json.js'
 
 import { GrpcManager }  from './grpc-manager.js'
 import { PayloadStore } from './payload-store.js'
-import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPbToPayload, channelPayloadToPb, channelPbToPayload, chatHistoryPbToPayload, contactPbToPayload, postPayloadToPb, roomMemberPbToPayload, urlLinkPbToPayload, channelCardPayloadToPb, channelCardPbToPayload } from '../utils/pb-payload-helper.js'
+import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPbToPayload, channelPayloadToPb, channelPbToPayload, chatHistoryPbToPayload, contactPbToPayload, postPayloadToPb, roomMemberPbToPayload, urlLinkPbToPayload, channelCardPayloadToPb, channelCardPbToPayload, miniProgramPayloadToPb, urlLinkPayloadToPb, locationPayloadToPb } from '../utils/pb-payload-helper.js'
 import type { MessageBroadcastTargets } from '@juzi/wechaty-puppet/dist/esm/src/schemas/message.js'
 import { timeoutPromise } from 'gerror'
 import { BooleanIndicator } from 'state-switch'
@@ -72,6 +72,34 @@ export type PuppetServiceOptions = PUPPET.PuppetOptions & {
 const ResetLoginTimeout = 30 * 1000
 const ResetReadyTimeout = 20 * 1000 // normally ready comes 15 seconds after login
 
+type MessageBatchSendResponse = Awaited<ReturnType<PUPPET.impls.PuppetInterface['messageBatchSendText']>>
+
+type GrpcUnaryMethod<Request, Response> = {
+  (request: Request, callback: (error: Error | null, response: Response) => void): unknown,
+}
+
+type GrpcBatchResult = {
+  getConversationId(): string,
+  getError(): string,
+  getId(): string,
+}
+
+type GrpcBatchResponse<Result extends GrpcBatchResult> = {
+  getResultsList(): Result[],
+}
+
+function grpcBatchResultsToPayload<Result extends GrpcBatchResult> (
+  response: GrpcBatchResponse<Result>,
+): MessageBatchSendResponse {
+  return {
+    results: response.getResultsList().map(result => ({
+      conversationId : result.getConversationId(),
+      error          : result.getError() || undefined,
+      id             : result.getId() || undefined,
+    })),
+  }
+}
+
 class PuppetService extends PUPPET.Puppet {
 
   static override readonly VERSION = VERSION
@@ -125,6 +153,17 @@ class PuppetService extends PUPPET.Puppet {
     return JSON.stringify(normalizedFileBox)
   }
 
+  private async grpcUnary<Request, Response> (
+    method  : GrpcUnaryMethod<Request, Response>,
+    request : Request,
+  ): Promise<Response> {
+    const promisified = util.promisify(
+      method.bind(this.grpcManager.client),
+    ) as (request: Request) => Promise<Response>
+
+    return promisified(request)
+  }
+
   override name () {
     return packageJson.name || 'wechaty-puppet-service'
   }
@@ -461,7 +500,7 @@ class PuppetService extends PUPPET.Puppet {
   ): Promise<void> {
     log.verbose('PuppetService', 'fastDirty(%s<%s>, %s)', PUPPET.types.Dirty[payloadType], payloadType, payloadId)
 
-    const dirtyMap = {
+    const dirtyMap: Partial<Record<PUPPET.types.Dirty, (id: string) => Promise<unknown>>> = {
       [PUPPET.types.Dirty.Contact]:      async (id: string) => this._payloadStore.contact?.delete(id),
       [PUPPET.types.Dirty.Friendship]:   async (_: string) => {},
       [PUPPET.types.Dirty.Message]:      async (_: string) => {},
@@ -474,7 +513,7 @@ class PuppetService extends PUPPET.Puppet {
     }
 
     try {
-      await dirtyMap[payloadType](payloadId)
+      await dirtyMap[payloadType]?.(payloadId)
     } catch (error) {
       this.emit('error', error)
     }
@@ -1487,6 +1526,211 @@ class PuppetService extends PUPPET.Puppet {
     }
   }
 
+  override async messageBatchSendText (
+    conversationIds : string[],
+    text            : string,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendText(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendTextRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setText(text)
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendTextRequest, grpcPuppet.MessageBatchSendTextResponse>(
+      this.grpcManager.client.messageBatchSendText,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendFile (
+    conversationIds : string[],
+    fileBox         : FileBoxInterface,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendFile(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendFileRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setFileBox(await this.serializeFileBox(fileBox))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendFileRequest, grpcPuppet.MessageBatchSendFileResponse>(
+      this.grpcManager.client.messageBatchSendFile,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchForward (
+    conversationIds : string[],
+    messageIds      : string | string[],
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchForward(%s, %s)', conversationIds.join(','), messageIds)
+
+    const request = new grpcPuppet.MessageBatchForwardRequest()
+    request.setConversationIdsList(conversationIds)
+    if (Array.isArray(messageIds)) {
+      request.setMessageIdsList(messageIds)
+      if (messageIds.length === 1) {
+        request.setMessageId(messageIds[0] as string)
+      }
+    } else {
+      request.setMessageId(messageIds)
+    }
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchForwardRequest, grpcPuppet.MessageBatchForwardResponse>(
+      this.grpcManager.client.messageBatchForward,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendContact (
+    conversationIds : string[],
+    contactId       : string,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendContact(%s, %s)', conversationIds.join(','), contactId)
+
+    const request = new grpcPuppet.MessageBatchSendContactRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setContactId(contactId)
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendContactRequest, grpcPuppet.MessageBatchSendContactResponse>(
+      this.grpcManager.client.messageBatchSendContact,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendUrl (
+    conversationIds : string[],
+    urlLinkPayload  : PUPPET.payloads.UrlLink,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendUrl(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendUrlRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setUrlLink(urlLinkPayloadToPb(grpcPuppet, urlLinkPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendUrlRequest, grpcPuppet.MessageBatchSendUrlResponse>(
+      this.grpcManager.client.messageBatchSendUrl,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendMiniProgram (
+    conversationIds     : string[],
+    miniProgramPayload  : PUPPET.payloads.MiniProgram,
+    batchTaskId?        : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendMiniProgram(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendMiniProgramRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setMiniProgram(miniProgramPayloadToPb(grpcPuppet, miniProgramPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendMiniProgramRequest, grpcPuppet.MessageBatchSendMiniProgramResponse>(
+      this.grpcManager.client.messageBatchSendMiniProgram,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendLocation (
+    conversationIds  : string[],
+    locationPayload  : PUPPET.payloads.Location,
+    batchTaskId?     : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendLocation(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendLocationRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setLocation(locationPayloadToPb(grpcPuppet, locationPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendLocationRequest, grpcPuppet.MessageBatchSendLocationResponse>(
+      this.grpcManager.client.messageBatchSendLocation,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendChannel (
+    conversationIds : string[],
+    channelPayload  : PUPPET.payloads.Channel,
+    batchTaskId?    : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendChannel(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendChannelRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setChannel(channelPayloadToPb(grpcPuppet, channelPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendChannelRequest, grpcPuppet.MessageBatchSendChannelResponse>(
+      this.grpcManager.client.messageBatchSendChannel,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
+  override async messageBatchSendChannelCard (
+    conversationIds     : string[],
+    channelCardPayload  : PUPPET.payloads.ChannelCard,
+    batchTaskId?        : string,
+  ): Promise<MessageBatchSendResponse> {
+    log.verbose('PuppetService', 'messageBatchSendChannelCard(%s)', conversationIds.join(','))
+
+    const request = new grpcPuppet.MessageBatchSendChannelCardRequest()
+    request.setConversationIdsList(conversationIds)
+    request.setChannelCard(channelCardPayloadToPb(grpcPuppet, channelCardPayload))
+    if (batchTaskId) {
+      request.setBatchTaskId(batchTaskId)
+    }
+
+    const response = await this.grpcUnary<grpcPuppet.MessageBatchSendChannelCardRequest, grpcPuppet.MessageBatchSendChannelCardResponse>(
+      this.grpcManager.client.messageBatchSendChannelCard,
+      request,
+    )
+
+    return grpcBatchResultsToPayload(response)
+  }
+
   override async messageSendFile (
     conversationId : string,
     fileBox        : FileBoxInterface,

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.113",
+  "version": "1.0.114",
   "description": "Puppet Service for Wechaty",
   "type": "module",
   "exports": {
@@ -55,7 +55,7 @@ export const packageJson: PackageJson = {
     "@chatie/eslint-config": "^1.0.4",
     "@chatie/semver": "^0.4.7",
     "@chatie/tsconfig": "^4.6.3",
-    "@juzi/wechaty-puppet": "^1.0.125",
+    "@juzi/wechaty-puppet": "^1.0.137",
     "@juzi/wechaty-puppet-mock": "^1.0.1",
     "@swc/core": "1.3.39",
     "@types/google-protobuf": "^3.15.5",
@@ -74,10 +74,10 @@ export const packageJson: PackageJson = {
     "why-is-node-running": "^2.2.1"
   },
   "peerDependencies": {
-    "@juzi/wechaty-puppet": "^1.0.84"
+    "@juzi/wechaty-puppet": "^1.0.137"
   },
   "dependencies": {
-    "@juzi/wechaty-grpc": "^1.0.100",
+    "@juzi/wechaty-grpc": "^1.0.101",
     "clone-class": "^1.1.1",
     "ducks": "^1.0.2",
     "file-box": "^1.5.5",

package/src/server/puppet-implementation.ts

@@ -46,6 +46,36 @@ import { EventStreamManager } from './event-stream-manager.js'
 import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPayloadToPb, channelPayloadToPb, chatHistoryPayloadToPb, postPbToPayload, urlLinkPayloadToPb, channelCardPayloadToPb } from '../utils/pb-payload-helper.js'
 import { TextContentType } from '@juzi/wechaty-puppet/types'
 
+type MessageBatchSendResponse = Awaited<ReturnType<PUPPET.impls.PuppetInterface['messageBatchSendText']>>
+
+type GrpcBatchResult = {
+  setConversationId(value: string): void,
+  setError(value: string): void,
+  setId(value: string): void,
+}
+
+type GrpcBatchResponse<Result extends GrpcBatchResult> = {
+  setResultsList(value: Result[]): void,
+}
+
+const setGrpcBatchResults = <Result extends GrpcBatchResult> (
+  response      : GrpcBatchResponse<Result>,
+  ResultClass   : new () => Result,
+  payload       : MessageBatchSendResponse,
+): void => {
+  response.setResultsList(payload.results.map(result => {
+    const pbResult = new ResultClass()
+    pbResult.setConversationId(result.conversationId)
+    if (result.id) {
+      pbResult.setId(result.id)
+    }
+    if (result.error) {
+      pbResult.setError(result.error)
+    }
+    return pbResult
+  }))
+}
+
 function puppetImplementation (
   puppet      : PUPPET.impls.PuppetInterface,
   FileBoxUuid : typeof FileBox,
@@ -1251,6 +1281,180 @@ function puppetImplementation (
       }
     },
 
+    messageBatchSendText: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendText()')
+
+      try {
+        const results = await puppet.messageBatchSendText(
+          call.request.getConversationIdsList(),
+          call.request.getText(),
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendTextResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendTextResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendText', e, callback)
+      }
+    },
+
+    messageBatchSendFile: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendFile()')
+
+      try {
+        const results = await puppet.messageBatchSendFile(
+          call.request.getConversationIdsList(),
+          FileBoxUuid.fromJSON(call.request.getFileBox()),
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendFileResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendFileResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendFile', e, callback)
+      }
+    },
+
+    messageBatchForward: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchForward()')
+
+      try {
+        const messageIds = call.request.getMessageIdsList()
+        const results = await puppet.messageBatchForward(
+          call.request.getConversationIdsList(),
+          messageIds.length > 0 ? messageIds : call.request.getMessageId(),
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchForwardResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchForwardResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchForward', e, callback)
+      }
+    },
+
+    messageBatchSendContact: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendContact()')
+
+      try {
+        const results = await puppet.messageBatchSendContact(
+          call.request.getConversationIdsList(),
+          call.request.getContactId(),
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendContactResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendContactResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendContact', e, callback)
+      }
+    },
+
+    messageBatchSendUrl: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendUrl()')
+
+      try {
+        const payload = call.request.getUrlLink()?.toObject()
+        if (!payload) {
+          throw new Error('no url link payload found')
+        }
+        const results = await puppet.messageBatchSendUrl(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendUrlResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendUrlResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendUrl', e, callback)
+      }
+    },
+
+    messageBatchSendMiniProgram: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendMiniProgram()')
+
+      try {
+        const payload = call.request.getMiniProgram()?.toObject()
+        if (!payload) {
+          throw new Error('no mini program payload found')
+        }
+        const results = await puppet.messageBatchSendMiniProgram(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendMiniProgramResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendMiniProgramResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendMiniProgram', e, callback)
+      }
+    },
+
+    messageBatchSendLocation: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendLocation()')
+
+      try {
+        const payload = call.request.getLocation()?.toObject()
+        if (!payload) {
+          throw new Error('no location payload found')
+        }
+        const results = await puppet.messageBatchSendLocation(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendLocationResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendLocationResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendLocation', e, callback)
+      }
+    },
+
+    messageBatchSendChannel: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendChannel()')
+
+      try {
+        const payload = call.request.getChannel()?.toObject()
+        if (!payload) {
+          throw new Error('no channel payload found')
+        }
+        const results = await puppet.messageBatchSendChannel(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendChannelResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendChannelResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendChannel', e, callback)
+      }
+    },
+
+    messageBatchSendChannelCard: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'messageBatchSendChannelCard()')
+
+      try {
+        const payload = call.request.getChannelCard()?.toObject()
+        if (!payload) {
+          throw new Error('no channel card payload found')
+        }
+        const results = await puppet.messageBatchSendChannelCard(
+          call.request.getConversationIdsList(),
+          payload,
+          call.request.getBatchTaskId(),
+        )
+        const response = new grpcPuppet.MessageBatchSendChannelCardResponse()
+        setGrpcBatchResults(response, grpcPuppet.MessageBatchSendChannelCardResponse.Result, results)
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('messageBatchSendChannelCard', e, callback)
+      }
+    },
+
     messageSendUrl: async (call, callback) => {
       log.verbose('PuppetServiceImpl', 'messageSendUrl()')
 
@@ -1494,9 +1698,11 @@ function puppetImplementation (
         const inviteOnly = call.request.getInviteOnly()
         const quoteIds = call.request.getQuoteIdsList()
 
-        const target = contactIds.length > 0 ? contactIds : contactId
-
-        await puppet.roomAdd(roomId, target, inviteOnly, quoteIds)
+        if (contactIds.length > 1) {
+          await puppet.roomAddV2(roomId, contactIds, inviteOnly, quoteIds)
+        } else {
+          await puppet.roomAdd(roomId, contactId || contactIds[0] || '', inviteOnly, quoteIds)
+        }
 
         return callback(null, new grpcPuppet.RoomAddResponse())