Add lightweight delivery recovery

Author: Rodrigo

__tests__/routes/groups.ts

@@ -216,7 +216,6 @@ describe('groups routes', () => {
           name: 'Maria',
           user_id: '123456789012345@lid',
           username: '@maria.vendas',
-          picture: 'https://cdn.exemplo.com/profile/maria.jpg',
           lid: '123456789012345@lid',
           is_admin: true,
           role: 'admin',
@@ -233,6 +232,23 @@ describe('groups routes', () => {
     }))
   })
 
+  test('details does not include participants by default', async () => {
+    const phone = '556600000000'
+    const groupJid = '120363040468224422@g.us'
+    const { app, redis } = await loadApp(true)
+    redis.getGroup.mockResolvedValue(cachedGroup)
+
+    const res = await request(app.server).get(`/v15.0/${phone}/groups/${groupJid}`)
+
+    expect(res.status).toEqual(200)
+    expect(res.body.id).toEqual(groupJid)
+    expect(res.body.subject).toEqual(cachedGroup.subject)
+    expect(res.body.total_participant_count).toEqual(2)
+    expect(res.body.participants).toBeUndefined()
+    expect(redis.getContactName).not.toHaveBeenCalled()
+    expect(redis.getContactInfo).not.toHaveBeenCalled()
+  })
+
   test('participants route returns Meta-like participant payload when flag is enabled', async () => {
     const phone = '556600000000'
     const groupJid = '120363040468224422@g.us'
@@ -377,7 +393,7 @@ describe('groups routes', () => {
 
     expect(res.status).toEqual(200)
     expect(incoming.groupMetadata).toHaveBeenCalledWith(phone, groupJid)
-    expect(redis.redisDelKey).toHaveBeenCalledWith(`unoapi-group:${phone}:${groupJid}`)
+    expect(redis.redisDelKey).not.toHaveBeenCalled()
     expect(redis.setGroup).toHaveBeenCalledWith(phone, groupJid, freshGroup)
     expect(res.body.total_participant_count).toEqual(2)
     expect(res.body.participants[1]).toEqual(expect.objectContaining({
@@ -529,6 +545,31 @@ describe('groups routes', () => {
     }))
   })
 
+  test('add participants accepts object payloads and emits participants webhook', async () => {
+    const phone = '556600000000'
+    const groupJid = '120363040468224422@g.us'
+    const { app, incoming, outgoing, redis } = await loadApp(true)
+    incoming.groupParticipantsUpdate = jest.fn().mockResolvedValue([{ status: '200', jid: '556699999999@s.whatsapp.net' }])
+    redis.getLidForPn.mockResolvedValue('123456789012345@lid')
+    outgoing.send.mockResolvedValue(undefined)
+
+    const res = await request(app.server)
+      .post(`/v15.0/${phone}/groups/${groupJid}/participants`)
+      .send({ participants: [{ wa_id: '556699999999', user_id: '123456789012345@lid' }] })
+
+    expect(res.status).toEqual(200)
+    expect(incoming.groupParticipantsUpdate).toHaveBeenCalledWith(phone, groupJid, ['556699999999@s.whatsapp.net'], 'add')
+    expect(res.body).toEqual({ group_id: groupJid, added: ['556699999999'], failed: [] })
+    expect(outgoing.send).toHaveBeenCalledWith(phone, expect.objectContaining({
+      entry: [expect.objectContaining({
+        changes: [expect.objectContaining({
+          field: 'group_participants_update',
+          value: expect.objectContaining({ group_id: groupJid, action: 'add', participants: [{ wa_id: '556699999999', user_id: '123456789012345@lid' }] }),
+        })],
+      })],
+    }))
+  })
+
   test('invite link get and reset use Baileys invite APIs', async () => {
     const phone = '556600000000'
     const groupJid = '120363040468224422@g.us'
@@ -545,6 +586,30 @@ describe('groups routes', () => {
     expect(postRes.body).toEqual({ group_id: groupJid, invite_link: 'https://chat.whatsapp.com/new456', reset: true })
   })
 
+  test('invite link hyphen alias and patch update are accepted', async () => {
+    const phone = '556600000000'
+    const groupJid = '120363040468224422@g.us'
+    const { app, incoming, outgoing } = await loadApp(true)
+    incoming.groupInviteCode = jest.fn().mockResolvedValue('old123')
+    incoming.groupRevokeInvite = jest.fn().mockResolvedValue('new456')
+    incoming.groupUpdateDescription = jest.fn().mockResolvedValue(undefined)
+    outgoing.send.mockResolvedValue(undefined)
+
+    const getRes = await request(app.server).get(`/v15.0/${phone}/groups/${groupJid}/invite-link`)
+    const postRes = await request(app.server).post(`/v15.0/${phone}/groups/${groupJid}/invite-link`)
+    const patchRes = await request(app.server)
+      .patch(`/v15.0/${phone}/groups/${groupJid}`)
+      .send({ description: 'Descricao via patch' })
+
+    expect(getRes.status).toEqual(200)
+    expect(getRes.body).toEqual({ group_id: groupJid, invite_link: 'https://chat.whatsapp.com/old123' })
+    expect(postRes.status).toEqual(200)
+    expect(postRes.body).toEqual({ group_id: groupJid, invite_link: 'https://chat.whatsapp.com/new456', reset: true })
+    expect(patchRes.status).toEqual(200)
+    expect(incoming.groupUpdateDescription).toHaveBeenCalledWith(phone, groupJid, 'Descricao via patch')
+    expect(patchRes.body).toEqual(expect.objectContaining({ id: groupJid, description: 'Descricao via patch', updated: true }))
+  })
+
   test('join requests list approve and reject map Baileys calls', async () => {
     const phone = '556600000000'
     const groupJid = '120363040468224422@g.us'

__tests__/routes/messages.ts

@@ -130,6 +130,42 @@ describe('messages routes', () => {
     )
   })
 
+  test('delivery recovery route forces session refresh for the original message id', async () => {
+    const recoverSpy = jest.spyOn(incoming, 'recoverDelivery').mockResolvedValue({
+      ok: {
+        messaging_product: 'whatsapp',
+        messages: [{ id: 'uno-message-1' }],
+        recovery: { attempted: true },
+      },
+    } as any)
+
+    const res = await request(app.server)
+      .post(`/v19.0/${phone}/messages/uno-message-1/recover_delivery`)
+      .send({
+        to: '5566996810064',
+        type: 'text',
+        text: { body: 'reenviar agora' },
+      })
+
+    expect(res.status).toEqual(200)
+    expect(recoverSpy).toHaveBeenCalledWith(
+      phone,
+      expect.objectContaining({
+        message_id: 'uno-message-1',
+        to: '5566996810064',
+        type: 'text',
+        _requestId: expect.any(String),
+      }),
+      expect.objectContaining({
+        endpoint: 'messages',
+        forceDeliveryRecovery: true,
+        forceSessionRefresh: true,
+        forceDeviceList: true,
+        useUserDevicesCache: false,
+      }),
+    )
+  })
+
   test('whatsapp with 400 status', async () => {
     jest.spyOn(incoming, 'send').mockRejectedValue(new Error('cannot login'))
     const res = await request(app.server).post(`/v15.0/${phone}/messages`).send(json)

__tests__/services/client_baileys.ts

@@ -5,9 +5,11 @@ jest.mock('../../src/utils/audio_convert', () => ({
 jest.mock('../../src/defaults', () => {
   const actual = jest.requireActual('../../src/defaults')
   return {
-    __esModule: true,
-    ...actual,
-    SEND_AUDIO_MESSAGE_AS_PTT: true,
+    __esModule: true,
+    ...actual,
+    SEND_AUDIO_MESSAGE_AS_PTT: true,
+    GROUP_METADATA_EVENT_REFRESH_DEBOUNCE_MS: 10,
+    GROUP_METADATA_EVENT_REFRESH_MIN_INTERVAL_MS: 0,
   }
 })
 jest.mock('../../src/services/socket')
@@ -32,11 +34,12 @@ import {
   rejectCall,
   sendCallNode,
   fetchImageUrl,
-  fetchGroupMetadata,
-  exists,
-  close,
-  logout,
-} from '../../src/services/socket'
+  fetchGroupMetadata,
+  groupMetadata,
+  exists,
+  close,
+  logout,
+} from '../../src/services/socket'
 import { mock, mockFn } from 'jest-mock-extended'
 import { proto } from '@whiskeysockets/baileys'
 import { DataStore } from '../../src/services/data_store'
@@ -74,6 +77,7 @@ describe('service client baileys', () => {
   let sendCallNodeMock
   let fetchImageUrl
   let fetchGroupMetadata
+  let groupMetadataMock
   let getConfig: getConfig
   let config: Config
   let close: close
@@ -116,11 +120,12 @@ describe('service client baileys', () => {
     logout = mockFn<logout>()
     fetchImageUrl = mockFn<fetchImageUrl>()
     fetchGroupMetadata = mockFn<fetchGroupMetadata>()
+    groupMetadataMock = mockFn<groupMetadata>()
     const capturedEvent = (name, callback) => {
       eventHandlers[name] = callback
       return event(name, callback)
     }
-    mockConnect.mockResolvedValue({ event: capturedEvent as any, status, send, read, rejectCall, sendCallNode: sendCallNodeMock, fetchImageUrl, fetchGroupMetadata, exists, close, logout })
+    mockConnect.mockResolvedValue({ event: capturedEvent as any, status, send, read, rejectCall, sendCallNode: sendCallNodeMock, fetchImageUrl, fetchGroupMetadata, groupMetadata: groupMetadataMock, exists, close, logout })
   })
 
   test('call send with unknown status', async () => {
@@ -157,6 +162,44 @@ describe('service client baileys', () => {
     expect(response.ok.messages[0].id).toBe(`uno-${id}`)
   })
 
+  test('recovers delivery by refreshing sessions and resending with mapped provider id', async () => {
+    const unoId = 'uno-message-1'
+    const providerId = 'provider-message-1'
+    dataStore.loadProviderId.mockResolvedValue(providerId)
+    dataStore.loadUnoId.mockImplementation(async (id: string) => id === providerId ? unoId : undefined)
+    send.mockResolvedValue({
+      key: { id: providerId, remoteJid: '5566996810064@s.whatsapp.net' },
+      message: { conversation: 'reenviar agora' },
+    })
+
+    await client.connect(0)
+    const response = await client.recoverDelivery!({
+      message_id: unoId,
+      to: '5566996810064',
+      type: 'text',
+      text: { body: 'reenviar agora' },
+    }, {})
+
+    expect(send).toHaveBeenCalledWith(
+      '5566996810064@s.whatsapp.net',
+      expect.objectContaining({ text: 'reenviar agora' }),
+      expect.objectContaining({
+        messageId: providerId,
+        forceDeliveryRecovery: true,
+        forceSessionRefresh: true,
+        forceDeviceList: true,
+        useUserDevicesCache: false,
+      }),
+    )
+    expect(dataStore.setUnoId).toHaveBeenCalledWith(providerId, unoId)
+    expect(response.ok.messages[0].id).toBe(unoId)
+    expect((response.ok as any).recovery).toEqual(expect.objectContaining({
+      attempted: true,
+      message_id: unoId,
+      provider_id: providerId,
+    }))
+  })
+
   test('call send with recipient_type group normalizes destination and response ids', async () => {
     const id = `${new Date().getMilliseconds()}`
     send.mockResolvedValue({ key: { id, remoteJid: '120363040468224422@g.us' } })
@@ -181,8 +224,45 @@ describe('service client baileys', () => {
     expect(response.ok.messages[0].id).toBe(`uno-${id}`)
   })
 
+  test('refreshes group metadata cache after group participants update event', async () => {
+    const groupJid = '120363040468224422@g.us'
+    const metadata = {
+      id: groupJid,
+      subject: 'Grupo atualizado',
+      participants: [
+        { id: '5566996222471@s.whatsapp.net' },
+        { id: '11343495192601@lid' },
+      ],
+    }
+    groupMetadataMock.mockResolvedValue(metadata)
+
+    await client.connect(0)
+    await eventHandlers['group-participants.update']?.({
+      id: groupJid,
+      participants: ['5566996222471@s.whatsapp.net'],
+      action: 'add',
+    })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(groupMetadataMock).toHaveBeenCalledWith(groupJid)
+    expect(dataStore.setGroupMetada).toHaveBeenCalledWith(groupJid, metadata)
+  })
+
+  test('refreshes group metadata cache after groups update event', async () => {
+    const groupJid = '120363040468224422@g.us'
+    const metadata = { id: groupJid, subject: 'Novo nome', participants: [] }
+    groupMetadataMock.mockResolvedValue(metadata)
+
+    await client.connect(0)
+    await eventHandlers['groups.update']?.([{ id: groupJid, subject: 'Novo nome' }])
+    await new Promise((resolve) => setTimeout(resolve, 20))
+
+    expect(groupMetadataMock).toHaveBeenCalledWith(groupJid)
+    expect(dataStore.setGroupMetada).toHaveBeenCalledWith(groupJid, metadata)
+  })
+
   test('call send with message type unknown', async () => {
-    const type = `${new Date().getMilliseconds()}`
+    const type = `${new Date().getMilliseconds()}`
     try {
       await client.connect(0)
       await client.send({ type }, {})
@@ -198,7 +278,7 @@ describe('service client baileys', () => {
     send = async () => {
       throw new SendError(1, '')
     }
-    mockConnect.mockResolvedValue({ event, status, send, read, rejectCall, sendCallNode: sendCallNodeMock, fetchImageUrl, fetchGroupMetadata, exists, close, logout })
+    mockConnect.mockResolvedValue({ event, status, send, read, rejectCall, sendCallNode: sendCallNodeMock, fetchImageUrl, fetchGroupMetadata, groupMetadata: groupMetadataMock, exists, close, logout })
     await client.connect(0)
     const response = await client.send(payload, {})
     expect(response.error.entry.length).toBe(1)
@@ -293,6 +373,23 @@ describe('service client baileys', () => {
     expect(send).toHaveBeenCalledWith('556696923653@s.whatsapp.net', { text: config.rejectCalls }, {})
   })
 
+  test('call offer rejects as incoming call when Baileys sends LID identity', async () => {
+    config.rejectCalls = 'Nao posso atender agora'
+    await client.connect(0)
+
+    await eventHandlers.call?.([
+      {
+        from: '123456789012345@lid',
+        callerPn: '556696923653@s.whatsapp.net',
+        id: 'call-offer-1',
+        status: 'offer',
+      },
+    ])
+
+    expect(rejectCall).toHaveBeenCalledWith('call-offer-1', '123456789012345@lid')
+    expect(send).toHaveBeenCalledWith('556696923653@s.whatsapp.net', { text: config.rejectCalls }, {})
+  })
+
   test('call ringing falls back to from when callerPn is absent', async () => {
     config.rejectCalls = 'Nao posso atender agora'
     await client.connect(0)

__tests__/services/data_store_file.ts

@@ -4,8 +4,16 @@ import { defaultConfig } from '../../src/services/config'
 
 describe('service data store file', () => {
   const phone = `${new Date().getMilliseconds()}`
-  test('return a new instance', async () => {
-    const dataStore: DataStore = await getDataStoreFile(phone, defaultConfig)
-    expect(dataStore).toBe(dataStore)
-  })
-})
+  test('return a new instance', async () => {
+    const dataStore: DataStore = await getDataStoreFile(phone, defaultConfig)
+    expect(dataStore).toBe(dataStore)
+  })
+
+  test('loads status by provider id when status was stored by uno id', async () => {
+    const dataStore: DataStore = await getDataStoreFile(`${phone}-status`, defaultConfig)
+    await dataStore.setUnoId('provider-id-1', 'uno-id-1')
+    await dataStore.setStatus('uno-id-1', 'sent')
+
+    await expect(dataStore.loadStatus('provider-id-1')).resolves.toBe('sent')
+  })
+})