Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

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.ts
index 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.ts
index 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);
+ }
}