Free, Open Source, Self-Hosted WhatsApp API Gateway
TypeScript apibotgatewayself-hostedwhatsappwhatsapp-apiwhatsapp-automationwhatsapp-botwhatsapp-gatewaywhatsapp-gateway-apiwhatsapp-webwhatsapp-web-api
import { DataSource } from 'typeorm';
import { IngressEvent } from './entities/ingress-event.entity';
import { IngressEventService } from './ingress-event.service';
import { AddIntegrationFabric1781900000000 } from '../../database/migrations/1781900000000-AddIntegrationFabric';
import { WidenIngressDedupKey1782100000000 } from '../../database/migrations/1782100000000-WidenIngressDedupKey';
import { AddIngressEventDispatchState1785112230000 } from '../../database/migrations/1785112230000-AddIngressEventDispatchState';
import { SlimIngressEventPayload1785600000000 } from '../../database/migrations/1785600000000-SlimIngressEventPayload';
describe('IngressEventService.recordOrSkip', () => {
let ds: DataSource;
let service: IngressEventService;
beforeEach(async () => {
ds = new DataSource({ type: 'better-sqlite3', database: ':memory:', entities: [IngressEvent], migrations: [] });
await ds.initialize();
const runner = ds.createQueryRunner();
await new AddIntegrationFabric1781900000000().up(runner);
await new WidenIngressDedupKey1782100000000().up(runner);
await new AddIngressEventDispatchState1785112230000().up(runner);
await new SlimIngressEventPayload1785600000000().up(runner);
await runner.release();
service = new IngressEventService(ds.getRepository(IngressEvent));
});
afterEach(async () => {
if (ds.isInitialized) await ds.destroy();
});
const row = () => ({
instanceId: 'inst',
pluginId: 'plug',
providerDeliveryId: 'd1',
route: 'chatwoot',
payload: { headers: {}, query: {}, body: '{}', rawBody: '{}' },
payloadHash: 'hash-of-{}',
sessionId: null,
});
const key = { pluginId: 'plug', instanceId: 'inst', providerDeliveryId: 'd1' };
const stored = () => ds.getRepository(IngressEvent).findOneByOrFail(key);
it('returns true for a first delivery and false for a replay of the same delivery id', async () => {
expect(await service.recordOrSkip(row())).toBe(true);
expect(await service.recordOrSkip(row())).toBe(false);
});
it('treats the same delivery id under a different instance as new', async () => {
expect(await service.recordOrSkip(row())).toBe(true);
expect(await service.recordOrSkip({ ...row(), instanceId: 'inst2' })).toBe(true);
});
it('treats the same instance+delivery id under a different plugin as new (dedup key includes pluginId)', async () => {
// instanceId is only unique within a plugin; two plugins sharing the string must not collide.
expect(await service.recordOrSkip(row())).toBe(true);
expect(await service.recordOrSkip({ ...row(), pluginId: 'other-plug' })).toBe(true);
});
it('writes new events as dispatchState pending with zero attempts (watched by the reconciler)', async () => {
await service.recordOrSkip(row());
const event = await stored();
expect(event.dispatchState).toBe('pending');
expect(event.dispatchAttempts).toBe(0);
expect(event.lastDispatchAt).toBeNull();
});
it('keeps the full payload (the reconciler replay source) plus its hash while pending', async () => {
await service.recordOrSkip(row());
const event = await stored();
expect(event.payload).toEqual({ headers: {}, query: {}, body: '{}', rawBody: '{}' });
expect(event.payloadHash).toBe('hash-of-{}');
});
it.each(['queued', 'dispatched'] as const)(
'marks outcome %s as dispatched with a dispatch timestamp',
async outcome => {
await service.recordOrSkip(row());
await service.markDispatchOutcome(key, outcome);
const event = await stored();
expect(event.dispatchState).toBe('dispatched');
expect(event.lastDispatchAt).toBeInstanceOf(Date);
expect(event.dispatchAttempts).toBe(0);
},
);
it.each(['queued', 'dispatched'] as const)(
'retires the full payload on outcome %s but keeps the hash and the dedup oracle',
async outcome => {
await service.recordOrSkip(row());
await service.markDispatchOutcome(key, outcome);
const event = await stored();
// The dispatch tier owns the payload now — the dedup row slims to its marker + fingerprint.
expect(event.payload).toBeNull();
expect(event.payloadHash).toBe('hash-of-{}');
// Dedup is keyed on (pluginId, instanceId, providerDeliveryId), never on the payload.
expect(await service.recordOrSkip(row())).toBe(false);
},
);
it('marks outcome failed as still-pending with the attempt counted AND the payload kept (reconciler replays from it)', async () => {
await service.recordOrSkip(row());
await service.markDispatchOutcome(key, 'failed');
const event = await stored();
expect(event.dispatchState).toBe('pending');
expect(event.dispatchAttempts).toBe(1);
expect(event.lastDispatchAt).toBeInstanceOf(Date);
expect(event.payload).not.toBeNull();
// Repeated failures accumulate against the reconciler's replay budget.
await service.markDispatchOutcome(key, 'failed');
expect((await stored()).dispatchAttempts).toBe(2);
expect((await stored()).dispatchState).toBe('pending');
});
});