Free, Open Source, Self-Hosted WhatsApp API Gateway
TypeScript apibotgatewayself-hostedwhatsappwhatsapp-apiwhatsapp-automationwhatsapp-botwhatsapp-gatewaywhatsapp-gateway-apiwhatsapp-webwhatsapp-web-api
fix(session): look a cached lid negative up again after five minutes
Yudhi Armyndharise9db7aca227e
diff --git a/src/modules/session/session-lid-resolver.service.spec.ts b/src/modules/session/session-lid-resolver.service.spec.tsindex 13af13350..5223d4392 100644--- a/src/modules/session/session-lid-resolver.service.spec.ts+++ b/src/modules/session/session-lid-resolver.service.spec.ts@@ -236,6 +236,49 @@ describe('SessionLidResolver', () => {});});+ describe('a cached negative', () => {+ it('is looked up again five minutes on, whatever the wall clock does, and reported again', async () => {+ resolveContactPhone.mockResolvedValue(null);+ const wall = Date.parse('2026-10-01T00:00:00Z');+ const wallClock = jest.spyOn(Date, 'now').mockReturnValue(wall);+ try {+ await expect(resolver.resolveSenderPhone('s1', '404@lid')).resolves.toBeNull();+ wallClock.mockReturnValue(wall + 3_600_000); // set forward an hour+ clock += 299_999;+ for (let i = 0; i < 100; i++) await resolver.resolveSenderPhone('s1', '404@lid');+ expect(resolveContactPhone).toHaveBeenCalledTimes(1);++ clock += 1;+ await expect(resolver.resolveSenderPhone('s1', '404@lid')).resolves.toBeNull();+ await resolver.resolveSenderPhone('s1', '404@lid');++ expect(resolveContactPhone).toHaveBeenCalledTimes(2);+ expect(remember).toHaveBeenCalledTimes(2);+ expect(remember).toHaveBeenLastCalledWith('404', null, 's1');+ } finally {+ wallClock.mockRestore();+ }+ });++ it('is the only answer looked up again: a cached phone stays', async () => {+ await resolver.resolveSenderPhone('s1', '111@lid');+ clock += 3_600_000;+ await resolver.resolveSenderPhone('s1', '111@lid');++ expect(resolveContactPhone).toHaveBeenCalledTimes(1);+ });++ it('forgets when to look it up again along with its cached answer', async () => {+ resolveContactPhone.mockResolvedValue(null);+ remember.mockResolvedValueOnce(false);+ await resolver.resolveSenderPhone('s1', '0@lid'); // dropped: its write failed+ await settle();+ for (let i = 1; i <= 5001; i++) await resolver.resolveSenderPhone('s1', `${i}@lid`);++ expect((resolver as unknown as { recheckAt: Map<string, number> }).recheckAt.size).toBe(5000);+ });+ });+it('never rejects when the mapping store write fails (fire-and-forget)', async () => {remember.mockRejectedValue(new Error('db down'));@@ -283,6 +326,8 @@ describe('SessionLidResolver over the shared lid table', () => {let resolver: SessionLidResolver;let warn: jest.SpyInstance;let wallClock: jest.SpyInstance<number, []>;+ /** The resolver's monotonic clock, in ms. */+ let clock: number;/** What each session's engine answers for the contact's lid. */const answers: Record<string, string | null> = {};const row = () => repo.findOne({ where: { lid: '111' } });@@ -317,6 +362,8 @@ describe('SessionLidResolver over the shared lid table', () => {} as unknown as IWhatsAppEngine);}resolver = new SessionLidResolver(engines, store);+ clock = 0;+ (resolver as unknown as { now: () => number }).now = () => clock;wallClock = jest.spyOn(Date, 'now').mockReturnValue(T);});@@ -356,4 +403,22 @@ describe('SessionLidResolver over the shared lid table', () => {expect(await admitted(Q)).toEqual([true, true]);expect(warn).not.toHaveBeenCalled();});++ it('clears the number five minutes after a negative the owner refused, once that owner has logged out', async () => {+ await message(s1); // s1 resolves the phone and stores it+ answers[s2] = null; // the account of s2 cannot see the number+ await message(s2); // refused: s1 is linked and owns the row+ expect(await row()).toMatchObject({ phone: P, sessionId: s1 });+ await ds.getRepository(Session).update({ id: s1 }, { phone: null }); // s1 logs out++ clock += 299_999;+ await message(s2);+ expect(await admitted(P)).toEqual([true, true]);+ clock += 1;+ await message(s2);++ expect(await row()).toMatchObject({ phone: null, sessionId: s2 });+ expect(await admitted(P)).toEqual([false, false]);+ expect(warn).not.toHaveBeenCalled();+ });});diff --git a/src/modules/session/session-lid-resolver.service.ts b/src/modules/session/session-lid-resolver.service.tsindex 0389d9525..9ce0f1c81 100644--- a/src/modules/session/session-lid-resolver.service.ts+++ b/src/modules/session/session-lid-resolver.service.ts@@ -16,9 +16,9 @@ import { LidNotMappedError } from '../../common/errors/lid-not-mapped.error';@Injectable()export class SessionLidResolver {/**- * Bounded cache keyed `${sessionId}:${lid}`. Caches misses (null) too, so a chatty unmapped sender- * isn't re-queried on every message (which also reduces engine rate-limit pressure). Best-effort- * feature, so staleness is acceptable.+ * Bounded cache keyed `${sessionId}:${lid}`. Caches misses (null) too, for a while ({@link recheckAt}), so+ * a chatty unmapped sender isn't re-queried on every message (which also reduces engine rate-limit+ * pressure). Best-effort feature, so staleness is acceptable.*/private readonly cache = new Map<string, string | null>();private static readonly CACHE_MAX = 5000;@@ -31,6 +31,13 @@ export class SessionLidResolver {private static readonly RETRY_AFTER_MS = 60_000;/** Lookups under way, per key, so messages that arrive together from one sender share a single one. */private readonly inFlight = new Map<string, Promise<string | null>>();+ /**+ * When a cached negative is looked up again, per key, on {@link now}. The lid table refuses a negative while+ * another linked session owns the phone, and a cached answer is otherwise never reported again, so that+ * phone would stay mapped after its owner logged out. At most one lookup and one write per key per interval.+ */+ private readonly recheckAt = new Map<string, number>();+ private static readonly NEGATIVE_RECHECK_MS = 5 * 60_000;/** Monotonic clock in ms, so a wall clock set back does not stretch a wait (a seam for tests). */private readonly now = (): number => performance.now();@@ -50,7 +57,8 @@ export class SessionLidResolver {const key = `${sessionId}:${contactId}`;const cached = this.cache.get(key);if (cached !== undefined) {- return cached;+ if (cached !== null || (this.recheckAt.get(key) ?? Infinity) > this.now()) return cached;+ this.forget(key);}if ((this.retryAfter.get(key) ?? 0) > this.now()) {return null;@@ -99,11 +107,12 @@ export class SessionLidResolver {// Bounded FIFO eviction: Map preserves insertion order, so the first key is the oldest.if (this.cache.size >= SessionLidResolver.CACHE_MAX) {for (const oldest of this.cache.keys()) {- this.cache.delete(oldest);+ this.forget(oldest);break;}}this.cache.set(key, phone);+ if (phone === null) this.recheckAt.set(key, this.now() + SessionLidResolver.NEGATIVE_RECHECK_MS);}// Persist the resolution so the read-path can bridge this contact's `@lid` and `@c.us` rows even// when the operator never sent to them (#583 R3 Phase 2). A definitive null is persisted too, so@@ -125,8 +134,14 @@ export class SessionLidResolver {void this.lidMappingStore?.remember(userPart(contactId), phone, sessionId)?.then(stored => {- if (stored === false) this.cache.delete(key);+ if (stored === false) this.forget(key);}).catch(() => {});}++ /** Drop a cached answer, and when it was due to be looked up again. */+ private forget(key: string): void {+ this.cache.delete(key);+ this.recheckAt.delete(key);+ }}