Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(session): drop the pending reconnect of a retired session

Yudhi Armyndharis1df6167146a7
diff --git a/src/modules/session/session-engine-lifecycle.service.ts b/src/modules/session/session-engine-lifecycle.service.ts
index 14d4403f6..1517b1958 100644
--- a/src/modules/session/session-engine-lifecycle.service.ts
+++ b/src/modules/session/session-engine-lifecycle.service.ts
@@ -1451,6 +1451,11 @@ export class SessionEngineLifecycle {
await this.fences.destroyWithEscalation(id, mine);
this.engines.deleteIfLive(id, mine);
}
+ // Nothing will re-register an engine for this episode now. A state left pending would keep the
+ // session counted as active: its lease renewed with no engine behind it, and its cap slot held.
+ if (!this.engines.has(id) && this.reconnectStates.get(id) === state && state.started === attempt) {
+ this.cancelReconnect(id);
+ }
// Same start/delete window as start()'s post-init guard: this re-init re-created auth dirs
// delete() had already purged — purge again so no credentials outlive the row.
await this.purgeAuthDirsIfDeleted(id);
diff --git a/src/modules/session/session-reconnect-retired.spec.ts b/src/modules/session/session-reconnect-retired.spec.ts
new file mode 100644
index 000000000..f874cfc32
--- /dev/null
+++ b/src/modules/session/session-reconnect-retired.spec.ts
@@ -0,0 +1,74 @@
+import { SessionEngineLifecycle, type ReconnectState } from './session-engine-lifecycle.service';
+import { EngineRegistry } from '../../engine/engine-registry.service';
+import { Session } from './entities/session.entity';
+
+const ID = '11111111-1111-4111-8111-111111111111';
+
+function fixture(row: Partial<Session>) {
+ const stored = { id: ID, name: 'retired-reconnect', phone: '628111', config: {}, ...row } as Session;
+ const repository = {
+ findOne: jest.fn(() => Promise.resolve({ ...stored })),
+ exists: jest.fn().mockResolvedValue(false),
+ update: jest.fn().mockResolvedValue({ affected: 1 }),
+ };
+ const state = { attachTo: <T>(value: T): T => value, clear: jest.fn(), set: jest.fn(), get: jest.fn() };
+ const engine = {
+ initialize: jest.fn().mockResolvedValue(undefined),
+ disconnect: jest.fn().mockResolvedValue(undefined),
+ destroy: jest.fn().mockResolvedValue(undefined),
+ forceDestroy: jest.fn().mockResolvedValue(undefined),
+ };
+ const factory = { create: jest.fn(() => engine), purgeSessionData: jest.fn().mockResolvedValue(undefined) };
+ const registry = new EngineRegistry();
+ const lifecycle = new SessionEngineLifecycle(
+ repository as never,
+ {} as never,
+ factory as never,
+ registry,
+ {} as never,
+ {} as never,
+ state as never,
+ state as never,
+ state as never,
+ { emitSessionStatus: jest.fn() } as never,
+ { dispatch: jest.fn().mockResolvedValue(undefined) } as never,
+ { execute: jest.fn().mockResolvedValue({ continue: true }) } as never,
+ {} as never,
+ );
+ const reconnect = (reconnectState: ReconnectState): Promise<void> =>
+ (
+ lifecycle as unknown as {
+ executeReconnect(id: string, session: Session, state: ReconnectState): Promise<void>;
+ }
+ ).executeReconnect(ID, { ...stored }, reconnectState);
+ const states = (): Map<string, ReconnectState> =>
+ (lifecycle as unknown as { reconnectStates: Map<string, ReconnectState> }).reconnectStates;
+ return { lifecycle, registry, engine, reconnect, states };
+}
+
+describe('a reconnect that finishes initializing for a stopped session', () => {
+ it('leaves nothing pending once the engine it built is retired', async () => {
+ const f = fixture({ desiredState: 'stopped' });
+ const state: ReconnectState = { attempts: 1, timer: null, maxAttempts: 5, baseDelay: 5000 };
+ f.states().set(ID, state);
+
+ await f.reconnect(state);
+
+ expect(f.engine.destroy).toHaveBeenCalled();
+ expect(f.registry.has(ID)).toBe(false);
+ expect(f.lifecycle.isEngineActive(ID)).toBe(false);
+ expect(f.lifecycle.startSlotHolders().has(ID)).toBe(false);
+ });
+
+ it('keeps the engine and the pending attempt of a session that is still wanted', async () => {
+ const f = fixture({ desiredState: null });
+ const state: ReconnectState = { attempts: 1, timer: null, maxAttempts: 5, baseDelay: 5000 };
+ f.states().set(ID, state);
+
+ await f.reconnect(state);
+
+ expect(f.engine.destroy).not.toHaveBeenCalled();
+ expect(f.registry.has(ID)).toBe(true);
+ expect(f.lifecycle.isEngineActive(ID)).toBe(true);
+ });
+});