Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(messages): retain mutations on duplicate echoes

Yudhi Armyndharis4a01cc95a178
diff --git a/src/modules/session/message-projector.service.ts b/src/modules/session/message-projector.service.ts
index 6cba5820b..94fbb99a3 100644
--- a/src/modules/session/message-projector.service.ts
+++ b/src/modules/session/message-projector.service.ts
@@ -733,8 +733,8 @@ export class MessageProjector {
// one transient retry) fails open, so a real send is never dropped on a DB fault.
const outcome = await this.insertWithRetry(id, engine, dbMessage, 'outgoing');
if (outcome.landed === 'stale') return;
- // The first attempt may have committed before its error: that row still takes what arrived.
- if (outcome.landed === 'dup' && outcome.retried) this.applyChangesMadeInFlight(id, outgoing.id);
+ // The REST writer may have won either attempt; its row still takes the echo's pending changes.
+ if (outcome.landed === 'dup') this.applyChangesMadeInFlight(id, outgoing.id);
if (outcome.landed === 'yes') {
this.applyChangesMadeInFlight(id, outgoing.id);
// Fire-and-forget, mirroring onMessage: plugin providers (search etc.) see phone-
diff --git a/src/modules/session/own-send-mutations.spec.ts b/src/modules/session/own-send-mutations.spec.ts
new file mode 100644
index 000000000..8fd31aeed
--- /dev/null
+++ b/src/modules/session/own-send-mutations.spec.ts
@@ -0,0 +1,108 @@
+import { DataSource } from 'typeorm';
+import { EngineRegistry } from '../../engine/engine-registry.service';
+import type { IncomingMessage, IWhatsAppEngine } from '../../engine/interfaces/whatsapp-engine.interface';
+import { Message, MessageStatus } from '../message/entities/message.entity';
+import { MessageSendService } from '../message/message-send.service';
+import { ACK_RECONCILE_DELAY_MS, MessageProjector } from './message-projector.service';
+
+const settle = (): Promise<void> => new Promise(resolve => setImmediate(resolve));
+
+describe('an own-send echo losing its first insert to the REST writer', () => {
+ it.each(['revoke', 'edit', 'reaction', 'ack'] as const)('preserves an in-flight %s', async change => {
+ jest.useFakeTimers({ doNotFake: ['setImmediate'] });
+ const ds = await new DataSource({
+ type: 'better-sqlite3',
+ database: ':memory:',
+ entities: [Message],
+ synchronize: true,
+ }).initialize();
+ const repo = ds.getRepository(Message);
+ const engines = new EngineRegistry();
+ let releaseEcho!: (value: unknown) => void;
+ const held = new Promise(resolve => (releaseEcho = resolve));
+ const hooks = {
+ execute: jest.fn((event: string, data: unknown) =>
+ event === 'message:sent' ? held : Promise.resolve({ continue: true, data }),
+ ),
+ };
+ const events = {
+ emitMessageSent: jest.fn(),
+ emitMessageRevoked: jest.fn(),
+ emitMessageEdited: jest.fn(),
+ emitMessageReaction: jest.fn(),
+ emitMessageAck: jest.fn(),
+ };
+ const engine = {} as IWhatsAppEngine;
+ engines.set('s1', engine);
+ const projector = new MessageProjector(
+ repo,
+ { update: jest.fn().mockResolvedValue(undefined) } as never,
+ engines,
+ events as never,
+ { dispatch: jest.fn().mockResolvedValue(undefined) } as never,
+ hooks as never,
+ {} as never,
+ {} as never,
+ );
+ const echo: IncomingMessage = {
+ id: 'WA1',
+ chatId: '[email protected]',
+ from: 'me',
+ body: 'Question',
+ type: 'poll',
+ timestamp: 1,
+ fromMe: true,
+ isGroup: false,
+ kind: 'individual',
+ poll: { name: 'Question', options: ['A', 'B'], allowMultipleAnswers: false },
+ };
+ Object.assign(engine, {
+ sendPollMessage: async () => {
+ projector.handleOwnSendEcho('s1', engine, echo);
+ if (change === 'revoke') projector.handleMessageRevoked('s1', engine, { ...echo, type: 'revoked', body: '' });
+ if (change === 'edit') projector.applyMessageEditQueued('s1', { messageId: 'WA1', body: 'fixed' } as never);
+ if (change === 'reaction')
+ projector.applyReactionQueued('s1', { messageId: 'WA1', senderId: 'peer', reaction: 'ok' } as never);
+ if (change === 'ack') {
+ projector.handleMessageAck('s1', engine, 'WA1', 'read');
+ projector.handleMessageAck('s1', engine, 'WA1', 'delivered');
+ }
+ await settle();
+ return { id: 'WA1', timestamp: 1 };
+ },
+ });
+ const sender = new MessageSendService(
+ repo,
+ { findOne: () => Promise.resolve({ phone: 'me' }) } as never,
+ engines,
+ hooks as never,
+ {} as never,
+ { assertSendAllowed: () => Promise.resolve(), recordSendSuccess: () => undefined } as never,
+ );
+ try {
+ await sender.sendPoll('s1', { chatId: '[email protected]', name: 'Question', options: ['A', 'B'] });
+ const persistedBeforeEcho = hooks.execute.mock.calls.filter(([event]) => event === 'message:persisted').length;
+ releaseEcho({ continue: true, data: echo });
+ for (let i = 0; i < 8; i++) await settle();
+ const row = await repo.findOneByOrFail({ sessionId: 's1', waMessageId: 'WA1' });
+ if (change === 'revoke') {
+ expect(row).toMatchObject({ type: 'revoked', body: '', metadata: null });
+ expect(events.emitMessageSent).not.toHaveBeenCalled();
+ }
+ if (change === 'edit') expect(row.body).toBe('fixed');
+ if (change === 'reaction') expect(row.metadata?.reactions).toEqual({ peer: 'ok' });
+ if (change === 'ack') expect(row.status).toBe(MessageStatus.READ);
+ expect(await repo.count()).toBe(1);
+ // Only the revoke updates the persisted projection; losing the insert does not publish a second copy.
+ expect(hooks.execute.mock.calls.filter(([event]) => event === 'message:persisted')).toHaveLength(
+ persistedBeforeEcho + (change === 'revoke' ? 1 : 0),
+ );
+ } finally {
+ await jest.advanceTimersByTimeAsync(ACK_RECONCILE_DELAY_MS);
+ jest.useRealTimers();
+ engines.delete('s1');
+ await ds.destroy();
+ }
+ });
+});