@juzi/wechaty-puppet-service 1.0.129 → 1.0.131

package/src/server/puppet-implementation.ts

@@ -20,6 +20,7 @@
 /* eslint-disable sort-keys */
 /* eslint-disable @typescript-eslint/no-misused-promises */
 import type { Writable }    from 'stream'
+import { inspect } from 'util'
 import {
   chunkDecoder,
   chunkEncoder,
@@ -43,12 +44,33 @@ import {
 import { log } from '../config.js'
 import { grpcError }          from './grpc-error.js'
 import { EventStreamManager } from './event-stream-manager.js'
-import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPayloadToPb, channelPayloadToPb, channelPbToPayload, chatHistoryPayloadToPb, postPbToPayload, urlLinkPayloadToPb, channelCardPayloadToPb } from '../utils/pb-payload-helper.js'
+import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPayloadToPb, channelPayloadToPb, channelPbToPayload, chatHistoryPayloadToPb, postPbToPayload, urlLinkPayloadToPb, channelCardPayloadToPb, roomPayloadToPb, roomMemberLoadStateToPb, roomMemberSnapshotToPb, validateRoomMemberLoadState, validateRoomMemberSnapshot, validateRoomMemberRevision } from '../utils/pb-payload-helper.js'
 import { grpcCallTypeToPuppetMedia, puppetCallMediaTypeToGrpc } from '../utils/call-media-mapping.js'
 import { TextContentType } from '@juzi/wechaty-puppet/types'
 
 type MessageBatchSendResponse = Awaited<ReturnType<PUPPET.impls.PuppetInterface['messageBatchSendText']>>
 
+function roomMemberRpcError<Response> (
+  method: string, error: unknown, callback: grpc.sendUnaryData<Response>,
+): void {
+  log.error('PuppetServiceImpl', 'roomMemberRpcError() %s() rejection: %s', method, inspect(error))
+  if (typeof error === 'object' && error !== null && 'code' in error) {
+    const status = error as Record<string, unknown>
+    const code = status['code']
+    if (typeof code === 'number' && Number.isInteger(code) && code > 0 && code <= 16) {
+      const details = typeof status['details'] === 'string' ? status['details']
+        : error instanceof Error ? error.message : 'Room member RPC failed'
+      callback({ code, details }, null)
+      return
+    }
+  }
+  if (error instanceof Error && /unsupported/i.test(error.message)) {
+    callback({ code: grpc.status.UNIMPLEMENTED, details: error.message }, null)
+    return
+  }
+  grpcError(method, error, callback)
+}
+
 type GrpcBatchResult = {
   setConversationId(value: string): void,
   setError(value: string): void,
@@ -1996,6 +2018,75 @@ function puppetImplementation (
       }
     },
 
+    roomMemberSync: async (
+      call: grpc.ServerUnaryCall<grpcPuppet.RoomMemberSyncRequest, grpcPuppet.RoomMemberLoadStateResponse>,
+      callback: grpc.sendUnaryData<grpcPuppet.RoomMemberLoadStateResponse>,
+    ): Promise<void> => {
+      try {
+        const roomId = call.request.getId()
+        if (!roomId) {
+          return callback({ code: grpc.status.INVALID_ARGUMENT, details: 'roomId is required' }, null)
+        }
+        const options = call.request.getForce() ? { force: true } : undefined
+        if (typeof puppet.roomMemberSync !== 'function') { throw new Error('roomMemberSync unsupported by adapter') }
+        const state = await puppet.roomMemberSync(roomId, options)
+        validateRoomMemberLoadState(state, roomId)
+        return callback(null, roomMemberLoadStateToPb(state))
+      } catch (error) {
+        return roomMemberRpcError('roomMemberSync', error, callback)
+      }
+    },
+
+    roomMemberLoadState: async (
+      call: grpc.ServerUnaryCall<grpcPuppet.RoomMemberLoadStateRequest, grpcPuppet.RoomMemberLoadStateResponse>,
+      callback: grpc.sendUnaryData<grpcPuppet.RoomMemberLoadStateResponse>,
+    ): Promise<void> => {
+      try {
+        const roomId = call.request.getId()
+        if (!roomId) {
+          return callback({ code: grpc.status.INVALID_ARGUMENT, details: 'roomId is required' }, null)
+        }
+        if (typeof puppet.roomMemberLoadState !== 'function') { throw new Error('roomMemberLoadState unsupported by adapter') }
+        const state = await puppet.roomMemberLoadState(roomId)
+        validateRoomMemberLoadState(state, roomId)
+        return callback(null, roomMemberLoadStateToPb(state))
+      } catch (error) {
+        return roomMemberRpcError('roomMemberLoadState', error, callback)
+      }
+    },
+
+    roomMemberSnapshot: async (
+      call: grpc.ServerUnaryCall<grpcPuppet.RoomMemberSnapshotRequest, grpcPuppet.RoomMemberSnapshotResponse>,
+      callback: grpc.sendUnaryData<grpcPuppet.RoomMemberSnapshotResponse>,
+    ): Promise<void> => {
+      try {
+        const roomId = call.request.getId()
+        const revision = call.request.getRevision()
+        const pageSize = call.request.getPageSize()
+        try {
+          if (!roomId) { throw new Error('roomId is required') }
+          validateRoomMemberRevision(revision)
+          if (!Number.isInteger(pageSize) || pageSize < 0 || pageSize > 500) {
+            throw new Error('pageSize must be an integer between 0 and 500')
+          }
+        } catch (error) {
+          return callback({ code: grpc.status.INVALID_ARGUMENT, details: (error as Error).message }, null)
+        }
+        if (typeof puppet.roomMemberSnapshot !== 'function') { throw new Error('roomMemberSnapshot unsupported by adapter') }
+        const snapshot = await puppet.roomMemberSnapshot(roomId, revision, {
+          pageToken: call.request.getPageToken(), pageSize,
+        })
+        try {
+          validateRoomMemberSnapshot(snapshot, roomId, revision)
+        } catch (error) {
+          return callback({ code: grpc.status.FAILED_PRECONDITION, details: (error as Error).message }, null)
+        }
+        return callback(null, roomMemberSnapshotToPb(snapshot))
+      } catch (error) {
+        return roomMemberRpcError('roomMemberSnapshot', error, callback)
+      }
+    },
+
     roomMemberList: async (call, callback) => {
       log.verbose('PuppetServiceImpl', 'roomMemberList()')
 
@@ -2085,20 +2176,7 @@ function puppetImplementation (
 
         const payload = await puppet.roomPayload(roomId)
 
-        const response = new grpcPuppet.RoomPayloadResponse()
-        response.setAdminIdsList(payload.adminIdList)
-        response.setAvatar(payload.avatar || '')
-        response.setHandle(payload.handle || '')
-        response.setId(payload.id)
-        response.setMemberIdsList(payload.memberIdList)
-        response.setOwnerId(payload.ownerId || '')
-        response.setTopic(payload.topic)
-        response.setAdditionalInfo(payload.additionalInfo || '')
-        response.setRoomRemark(payload.remark || '')
-        response.setExternal(!!payload.external)
-        if (payload.createTime) {
-          response.setCreateTime(timestampFromMilliseconds(payload.createTime))
-        }
+        const response = roomPayloadToPb(payload)
 
         return callback(null, response)
 
@@ -2119,20 +2197,7 @@ function puppetImplementation (
 
         const payloads: grpcPuppet.RoomPayloadResponse[] = []
         for (const [ _, payload ] of payloadMap.entries()) {
-          const pb = new grpcPuppet.RoomPayloadResponse()
-          pb.setAdminIdsList(payload.adminIdList)
-          pb.setAvatar(payload.avatar || '')
-          pb.setHandle(payload.handle || '')
-          pb.setId(payload.id)
-          pb.setMemberIdsList(payload.memberIdList)
-          pb.setOwnerId(payload.ownerId || '')
-          pb.setTopic(payload.topic)
-          pb.setAdditionalInfo(payload.additionalInfo || '')
-          pb.setRoomRemark(payload.remark || '')
-          pb.setExternal(!!payload.external)
-          if (payload.createTime) {
-            pb.setCreateTime(timestampFromMilliseconds(payload.createTime))
-          }
+          const pb = roomPayloadToPb(payload)
           payloads.push(pb)
         }
 
@@ -3017,6 +3082,56 @@ function puppetImplementation (
       }
     },
 
+    orgBroadcastPayload: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'orgBroadcastPayload()')
+
+      try {
+        const orgBroadcastId = call.request.getId()
+        const payload = await puppet.orgBroadcastPayload(orgBroadcastId)
+
+        const response = new grpcPuppet.OrgBroadcastPayloadResponse()
+        response.setId(payload.id)
+        response.setSendType(payload.sendType)
+        response.setConversationType(payload.conversationType)
+        response.setCreatorId(payload.creatorId ?? '')
+        response.setExecTime(payload.execTime)
+        response.setStatus(payload.status)
+        response.setCanCancel(payload.canCancel)
+        response.setAllowSelect(payload.allowSelect)
+        response.setSent(payload.sent)
+        response.setTotalCount(payload.totalCount)
+        response.setSentCount(payload.sentCount)
+        response.setContentListJson(payload.contentListJson)
+        response.setTargetsList(payload.targets.map(target => {
+          const targetPb = new grpcPuppet.OrgBroadcastTarget()
+          targetPb.setContactId(target.contactId ?? '')
+          targetPb.setRoomId(target.roomId ?? '')
+          targetPb.setStatus(target.status as number as grpcPuppet.OrgBroadcastTargetStatusMap[keyof grpcPuppet.OrgBroadcastTargetStatusMap])
+          return targetPb
+        }))
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('orgBroadcastPayload', e, callback)
+      }
+    },
+
+    orgBroadcastExecute: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'orgBroadcastExecute()')
+
+      try {
+        const orgBroadcastId = call.request.getId()
+        const targetIds = call.request.getTargetIdsList()
+
+        // an empty target_ids on the wire means all targets of the org broadcast
+        await puppet.orgBroadcastExecute(orgBroadcastId, targetIds.length ? targetIds : undefined)
+
+        return callback(null, new grpcPuppet.OrgBroadcastExecuteResponse())
+      } catch (e) {
+        return grpcError('orgBroadcastExecute', e, callback)
+      }
+    },
+
     download: async (call) => {
       log.verbose('PuppetServiceImpl', 'download()')
 

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

@@ -6,8 +6,91 @@ import {
 import * as PUPPET from '@juzi/wechaty-puppet'
 import type { FileBox, FileBoxInterface } from 'file-box'
 
+import { millisecondsFromTimestamp, timestampFromMilliseconds } from '../pure-functions/timestamp.js'
+
 type grpcPuppet = typeof puppet
 
+export function roomPbToPayload (pb: puppet.RoomPayloadResponse): PUPPET.payloads.Room {
+  const createTime = pb.getCreateTime()
+  const loadedAt = pb.getMemberLoadedAt()
+  return {
+    adminIdList: pb.getAdminIdsList(),
+    avatar: pb.getAvatar(),
+    handle: pb.getHandle(),
+    id: pb.getId(),
+    memberIdList: pb.getMemberIdsList(),
+    ownerId: pb.getOwnerId(),
+    topic: pb.getTopic(),
+    additionalInfo: pb.getAdditionalInfo(),
+    remark: pb.getRoomRemark(),
+    external: pb.getExternal(),
+    ...(createTime ? { createTime: millisecondsFromTimestamp(createTime) } : {}),
+    memberCount: pb.getMemberCount(),
+    memberLoadMode: pb.getMemberLoadMode(),
+    memberLoadStatus: pb.getMemberLoadStatus(),
+    memberLoadRevision: pb.getMemberLoadRevision(),
+    ...(loadedAt ? { memberLoadedAt: millisecondsFromTimestamp(loadedAt) } : {}),
+  }
+}
+
+export function roomPayloadToPb (payload: PUPPET.payloads.Room): puppet.RoomPayloadResponse {
+  const pb = new puppet.RoomPayloadResponse()
+  pb.setAdminIdsList(payload.adminIdList)
+  pb.setAvatar(payload.avatar || '')
+  pb.setHandle(payload.handle || '')
+  pb.setId(payload.id)
+  pb.setMemberIdsList(payload.memberIdList)
+  pb.setOwnerId(payload.ownerId || '')
+  pb.setTopic(payload.topic)
+  pb.setAdditionalInfo(payload.additionalInfo || '')
+  pb.setRoomRemark(payload.remark || '')
+  pb.setExternal(!!payload.external)
+  if (payload.createTime !== undefined) { pb.setCreateTime(timestampFromMilliseconds(payload.createTime)) }
+  if (payload.memberCount !== undefined) { pb.setMemberCount(payload.memberCount) }
+  if (payload.memberLoadMode !== undefined) { pb.setMemberLoadMode(payload.memberLoadMode) }
+  if (payload.memberLoadStatus !== undefined) { pb.setMemberLoadStatus(payload.memberLoadStatus) }
+  if (payload.memberLoadRevision !== undefined) { pb.setMemberLoadRevision(payload.memberLoadRevision) }
+  if (payload.memberLoadedAt !== undefined) { pb.setMemberLoadedAt(timestampFromMilliseconds(payload.memberLoadedAt)) }
+  return pb
+}
+
+export function validateRoomMemberRevision (revision: string): void {
+  if (typeof revision !== 'string' || !/^(0|[1-9][0-9]*)$/.test(revision)) {
+    throw new Error('Invalid room member revision')
+  }
+}
+
+export function validateRoomMemberLoadState (state: unknown, roomId?: string): asserts state is PUPPET.payloads.RoomMemberLoadState {
+  if (typeof state !== 'object' || state === null) { throw new Error('Invalid room member load state') }
+  const value = state as Record<string, unknown>
+  if (typeof value['roomId'] !== 'string' || !value['roomId'].trim()
+    || (roomId !== undefined && value['roomId'] !== roomId)) { throw new Error('Invalid room member roomId') }
+  if (typeof value['taskId'] !== 'string') { throw new Error('Invalid room member taskId') }
+  if (typeof value['revision'] !== 'string') { throw new Error('Invalid room member revision') }
+  validateRoomMemberRevision(value['revision'])
+  const status = value['status']
+  if (typeof status !== 'number' || !Number.isInteger(status) || status < 0 || status > 4) {
+    throw new Error('Invalid room member load status')
+  }
+  if (value['loadedAt'] !== undefined && (typeof value['loadedAt'] !== 'number' || !Number.isFinite(value['loadedAt']))) {
+    throw new Error('Invalid room member loadedAt')
+  }
+  if (value['error'] !== undefined && typeof value['error'] !== 'string') { throw new Error('Invalid room member error') }
+}
+
+export function validateRoomMemberSnapshot (
+  snapshot: PUPPET.payloads.RoomMemberSnapshot, roomId: string, revision: string,
+): void {
+  if (!roomId || snapshot.roomId !== roomId) { throw new Error('Room member snapshot roomId mismatch') }
+  validateRoomMemberRevision(snapshot.revision)
+  validateRoomMemberRevision(revision)
+  if (snapshot.revision !== revision) { throw new Error('Room member snapshot revision mismatch') }
+  if (!Array.isArray(snapshot.members)) { throw new Error('Invalid room member snapshot members') }
+  if (snapshot.loadedAt !== undefined && !Number.isFinite(snapshot.loadedAt)) {
+    throw new Error('Invalid room member snapshot loadedAt')
+  }
+}
+
 export const miniProgramPayloadToPb = (grpcPuppet: grpcPuppet, miniProgramPayload: PUPPET.payloads.MiniProgram) => {
   const pbMiniProgramPayload = new grpcPuppet.MiniProgramPayload()
   if (miniProgramPayload.appid) { pbMiniProgramPayload.setAppid(miniProgramPayload.appid) }
@@ -440,6 +523,73 @@ export const roomMemberPbToPayload = (pb: puppet.RoomMemberPayloadResponse) => {
   return payload
 }
 
+export function roomMemberPayloadToPb (payload: PUPPET.payloads.RoomMember): puppet.RoomMemberPayloadResponse {
+  const pb = new puppet.RoomMemberPayloadResponse()
+  pb.setAvatar(payload.avatar)
+  pb.setId(payload.id)
+  pb.setInviterId(payload.inviterId || '')
+  pb.setName(payload.name)
+  pb.setRoomAlias(payload.roomAlias || '')
+  pb.setAdditionalInfo(payload.additionalInfo || '')
+  pb.setJoinScene(payload.joinScene ?? PUPPET.types.RoomMemberJoinScene.Unknown)
+  pb.setJoinTime(payload.joinTime ?? 0)
+  return pb
+}
+
+export function roomMemberLoadStateToPb (state: PUPPET.payloads.RoomMemberLoadState): puppet.RoomMemberLoadStateResponse {
+  validateRoomMemberLoadState(state, state.roomId)
+  const pb = new puppet.RoomMemberLoadStateResponse()
+  pb.setId(state.roomId)
+  pb.setTaskId(state.taskId)
+  pb.setStatus(state.status)
+  pb.setRevision(state.revision)
+  if (state.loadedAt !== undefined) { pb.setLoadedAt(timestampFromMilliseconds(state.loadedAt)) }
+  if (state.error !== undefined) { pb.setError(state.error) }
+  return pb
+}
+
+export function roomMemberLoadStatePbToPayload (
+  pb: puppet.RoomMemberLoadStateResponse, roomId: string,
+): PUPPET.payloads.RoomMemberLoadState {
+  const loadedAt = pb.getLoadedAt()
+  const state: PUPPET.payloads.RoomMemberLoadState = {
+    roomId: pb.getId(),
+    taskId: pb.getTaskId(),
+    status: pb.getStatus(),
+    revision: pb.getRevision(),
+    ...(loadedAt ? { loadedAt: millisecondsFromTimestamp(loadedAt) } : {}),
+    ...(pb.getError() ? { error: pb.getError() } : {}),
+  }
+  validateRoomMemberLoadState(state, roomId)
+  return state
+}
+
+export function roomMemberSnapshotToPb (snapshot: PUPPET.payloads.RoomMemberSnapshot): puppet.RoomMemberSnapshotResponse {
+  validateRoomMemberSnapshot(snapshot, snapshot.roomId, snapshot.revision)
+  const pb = new puppet.RoomMemberSnapshotResponse()
+  pb.setId(snapshot.roomId)
+  pb.setRevision(snapshot.revision)
+  pb.setMembersList(snapshot.members.map(roomMemberPayloadToPb))
+  if (snapshot.loadedAt !== undefined) { pb.setLoadedAt(timestampFromMilliseconds(snapshot.loadedAt)) }
+  if (snapshot.nextPageToken !== undefined) { pb.setNextPageToken(snapshot.nextPageToken) }
+  return pb
+}
+
+export function roomMemberSnapshotPbToPayload (
+  pb: puppet.RoomMemberSnapshotResponse, roomId: string, revision: string,
+): PUPPET.payloads.RoomMemberSnapshot {
+  const loadedAt = pb.getLoadedAt()
+  const snapshot: PUPPET.payloads.RoomMemberSnapshot = {
+    roomId: pb.getId(),
+    revision: pb.getRevision(),
+    members: pb.getMembersList().map(roomMemberPbToPayload),
+    ...(loadedAt ? { loadedAt: millisecondsFromTimestamp(loadedAt) } : {}),
+    ...(pb.getNextPageToken() ? { nextPageToken: pb.getNextPageToken() } : {}),
+  }
+  validateRoomMemberSnapshot(snapshot, roomId, revision)
+  return snapshot
+}
+
 export const contactPbToPayload = (pb: puppet.ContactPayloadResponse) => {
   const payload: PUPPET.payloads.Contact = {
     address     : pb.getAddress(),

package/src/utils/room-member-load.spec.ts

@@ -0,0 +1,67 @@
+import { test } from 'tstest'
+import * as PUPPET from '@juzi/wechaty-puppet'
+import { puppet as grpcPuppet } from '@juzi/wechaty-grpc'
+
+import {
+  roomPayloadToPb,
+  roomPbToPayload,
+  roomMemberLoadStateToPb,
+  roomMemberLoadStatePbToPayload,
+  validateRoomMemberSnapshot,
+} from './pb-payload-helper.js'
+
+test('room payload roundtrip retains lazy fields and timestamp zero', async t => {
+  const payload: PUPPET.payloads.Room = {
+    id: 'room',
+    topic: 'topic',
+    adminIdList: [],
+    memberIdList: [],
+    memberCount: 0,
+    memberLoadMode: PUPPET.types.RoomMemberLoadMode.Lazy,
+    memberLoadStatus: PUPPET.types.RoomMemberLoadStatus.Loaded,
+    memberLoadRevision: '9007199254740993',
+    memberLoadedAt: 0,
+  }
+  const result = roomPbToPayload(roomPayloadToPb(payload))
+  t.equal(result.memberCount, 0)
+  t.equal(result.memberLoadMode, payload.memberLoadMode)
+  t.equal(result.memberLoadStatus, payload.memberLoadStatus)
+  t.equal(result.memberLoadRevision, payload.memberLoadRevision)
+  t.equal(result.memberLoadedAt, 0)
+  const legacy = roomPbToPayload(new grpcPuppet.RoomPayloadResponse())
+  t.equal(legacy.memberLoadMode, PUPPET.types.RoomMemberLoadMode.Unspecified)
+  t.equal(legacy.memberLoadedAt, undefined)
+})
+
+test('load state preserves exact revision and rejects invalid responses', async t => {
+  const state: PUPPET.payloads.RoomMemberLoadState = {
+    roomId: 'room',
+    taskId: 'task',
+    status: PUPPET.types.RoomMemberLoadStatus.Pending,
+    revision: '9007199254740993',
+    loadedAt: 0,
+  }
+  t.same(roomMemberLoadStatePbToPayload(roomMemberLoadStateToPb(state), 'room'), state)
+  t.throws(() => roomMemberLoadStatePbToPayload(roomMemberLoadStateToPb(state), 'other'), /roomId/)
+  t.throws(() => roomMemberLoadStateToPb({ ...state, revision: '01' }), /revision/)
+  t.throws(() => roomMemberLoadStateToPb({ ...state, status: 99 }), /status/)
+  const response = roomMemberLoadStateToPb(state)
+  response.setStatus(99 as Parameters<typeof response.setStatus>[0])
+  t.throws(() => roomMemberLoadStatePbToPayload(response, 'room'), /status/)
+  response.setStatus(state.status)
+  response.setRevision('01')
+  t.throws(() => roomMemberLoadStatePbToPayload(response, 'room'), /revision/)
+  const failed: PUPPET.payloads.RoomMemberLoadState = {
+    ...state, status: PUPPET.types.RoomMemberLoadStatus.Failed, error: 'load failed',
+  }
+  t.same(roomMemberLoadStatePbToPayload(roomMemberLoadStateToPb(failed), 'room'), failed)
+})
+
+test('snapshot must match both room and requested revision', async t => {
+  const snapshot: PUPPET.payloads.RoomMemberSnapshot = {
+    roomId: 'room', revision: '2', members: [], nextPageToken: 'next',
+  }
+  t.doesNotThrow(() => validateRoomMemberSnapshot(snapshot, 'room', '2'))
+  t.throws(() => validateRoomMemberSnapshot(snapshot, 'room', '1'), /revision/)
+  t.throws(() => validateRoomMemberSnapshot(snapshot, 'other', '2'), /roomId/)
+})