Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(dashboard): bind pending sends to the active actor

Yudhi Armyndharis065b26d89e30
diff --git a/dashboard/src/pages/MessageTester.test.ts b/dashboard/src/pages/MessageTester.test.ts
index eaccb2cd4..e90fdc264 100644
--- a/dashboard/src/pages/MessageTester.test.ts
+++ b/dashboard/src/pages/MessageTester.test.ts
@@ -875,3 +875,186 @@ test('Send stays disabled while a batch cancel is in flight, so its answer canno
});
assert.equal(sendButton().disabled, false);
});
+
+for (const mode of ['text', 'forward'] as const) {
+ for (const change of ['replace key', 'sign out', 'unmount', 'sign in again'] as const) {
+ test(`a pending ${mode} lookup cannot dispatch after ${change}`, async () => {
+ let release!: (response: Response) => void;
+ const pending = new Promise<Response>(resolve => {
+ release = resolve;
+ });
+ const writes: { key: string | null; body: unknown }[] = [];
+ let lookups = 0;
+ globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+ const url = String(input);
+ if (url.endsWith('/sessions')) return jsonResponse([{ id: 's1', name: 'Main', status: 'ready' }]);
+ if (url.includes('/contacts/check/')) {
+ lookups++;
+ if (mode === 'text' || lookups === 2) return pending;
+ return jsonResponse({ number: '15550000001', exists: true, whatsappId: 'primary@lid' });
+ }
+ if (url.includes('/messages/')) {
+ writes.push({ key: new Headers(init?.headers).get('X-API-Key'), body: JSON.parse(String(init?.body)) });
+ return jsonResponse({ messageId: 'sent', timestamp: 1 });
+ }
+ return jsonResponse([]);
+ }) as typeof fetch;
+ sessionStorage.setItem('openwa_api_key', 'original-key');
+ sessionStorage.setItem('openwa_user_role', 'operator');
+ const client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 1 } } });
+ const tree = () =>
+ createElement(QueryClientProvider, { client }, createElement(RoleProvider, null, createElement(MessageTester)));
+ const view = rtl.render(tree());
+ await rtl.screen.findByRole('option', { name: /Main/ });
+ type(view.container, '#mt-13', '15550000001');
+ if (mode === 'forward') {
+ rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Forward' }));
+ type(view.container, '#mt-9', '15550000002');
+ type(view.container, '#mt-10', 'original-message');
+ } else type(view.container, '#mt-2', 'hello');
+ await rtl.waitFor(() => assert.equal(sendButton().disabled, false));
+ rtl.fireEvent.click(sendButton());
+ await rtl.waitFor(() => assert.equal(lookups, mode === 'text' ? 1 : 2));
+ if (change === 'replace key') sessionStorage.setItem('openwa_api_key', 'replacement-key');
+ if (change === 'sign out') sessionStorage.removeItem('openwa_api_key');
+ if (change === 'unmount' || change === 'sign in again') view.unmount();
+ if (change === 'sign in again') {
+ sessionStorage.removeItem('openwa_api_key');
+ sessionStorage.setItem('openwa_api_key', 'original-key');
+ client.clear();
+ rtl.render(tree());
+ await rtl.screen.findByRole('option', { name: /Main/ });
+ }
+ await rtl.act(async () => {
+ release(jsonResponse({ number: '15550000002', exists: true, whatsappId: 'destination@lid' }));
+ await new Promise(resolve => setImmediate(resolve));
+ });
+ assert.deepEqual(writes, [], 'the abandoned lookup issued a write');
+ client.clear();
+ sessionStorage.removeItem('openwa_api_key');
+ });
+ }
+}
+
+test('an unchanged actor sends to canonical personal and forward destinations', async () => {
+ const writes: { path: string; key: string | null; body: unknown }[] = [];
+ globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+ const path = String(input);
+ if (path.endsWith('/sessions')) return jsonResponse([{ id: 's1', name: 'Main', status: 'ready' }]);
+ if (path.includes('/contacts/check/'))
+ return jsonResponse({
+ number: '15550000001',
+ exists: true,
+ whatsappId: path.endsWith('2') ? 'destination@lid' : 'primary@lid',
+ });
+ if (path.includes('/messages/')) {
+ writes.push({ path, key: new Headers(init?.headers).get('X-API-Key'), body: JSON.parse(String(init?.body)) });
+ return jsonResponse({ messageId: 'sent', timestamp: 1 });
+ }
+ return jsonResponse([]);
+ }) as typeof fetch;
+ sessionStorage.setItem('openwa_api_key', 'original-key');
+ sessionStorage.setItem('openwa_user_role', 'operator');
+ const client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 1 } } });
+ const view = rtl.render(
+ createElement(QueryClientProvider, { client }, createElement(RoleProvider, null, createElement(MessageTester))),
+ );
+ await rtl.screen.findByRole('option', { name: /Main/ });
+ type(view.container, '#mt-13', '15550000001');
+ type(view.container, '#mt-2', 'hello');
+ rtl.fireEvent.click(sendButton());
+ await rtl.waitFor(() => assert.equal(writes.length, 1));
+ await rtl.waitFor(() => assert.equal(sendButton().disabled, false));
+ rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Forward' }));
+ type(view.container, '#mt-9', '15550000002');
+ type(view.container, '#mt-10', 'original-message');
+ rtl.fireEvent.click(sendButton());
+ await rtl.waitFor(() => assert.equal(writes.length, 2));
+ assert.equal(writes[0].key, 'original-key');
+ assert.deepEqual(writes[0].body, { chatId: 'primary@lid', text: 'hello' });
+ assert.equal(writes[1].key, 'original-key');
+ assert.deepEqual(writes[1].body, {
+ fromChatId: 'primary@lid',
+ toChatId: 'destination@lid',
+ messageId: 'original-message',
+ });
+ client.clear();
+ sessionStorage.removeItem('openwa_api_key');
+});
+
+test('replacing the key stops a sequential group send and releases the composer', async () => {
+ sessionStorage.setItem('openwa_api_key', 'original-key');
+ const gateway = stubGroupGateway([
+ { id: '[email protected]', name: 'Family' },
+ { id: '[email protected]', name: 'Work' },
+ ]);
+ await renderGroupsAsWriter();
+ await sendTextToAllGroups();
+ await rtl.waitFor(() => assert.equal(gateway.textSends.length, 1));
+ sessionStorage.setItem('openwa_api_key', 'replacement-key');
+ await rtl.waitFor(() => assert.equal(sendMessageButton().disabled, false), { timeout: 4000 });
+ assert.deepEqual(gateway.textSends, ['[email protected]']);
+ assert.equal(field(window.document.body, '#mt-2').matches(':disabled'), false);
+ assert.equal(rtl.screen.queryByText('Success'), null);
+ sessionStorage.removeItem('openwa_api_key');
+});
+
+test('an old lookup cannot complete a new operation after signing in with the same key', async () => {
+ const releases: ((response: Response) => void)[] = [];
+ const writes: unknown[] = [];
+ globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+ const url = String(input);
+ if (url.endsWith('/sessions')) return jsonResponse([{ id: 's1', name: 'Main', status: 'ready' }]);
+ if (url.includes('/contacts/check/'))
+ return new Promise<Response>(resolve => {
+ releases.push(resolve);
+ });
+ if (url.endsWith('/messages/send-text')) {
+ writes.push(JSON.parse(String(init?.body)));
+ return jsonResponse({ messageId: 'new-operation', timestamp: 1 });
+ }
+ return jsonResponse([]);
+ }) as typeof fetch;
+ sessionStorage.setItem('openwa_api_key', 'same-key');
+ sessionStorage.setItem('openwa_user_role', 'operator');
+ const client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 1 } } });
+ const render = () =>
+ rtl.render(
+ createElement(QueryClientProvider, { client }, createElement(RoleProvider, null, createElement(MessageTester))),
+ );
+ const start = async (view: ReturnType<typeof render>, content: string) => {
+ await rtl.screen.findByRole('option', { name: /Main/ });
+ type(view.container, '#mt-13', '15550000001');
+ type(view.container, '#mt-2', content);
+ rtl.fireEvent.click(sendButton());
+ };
+ const original = render();
+ await start(original, 'old operation');
+ await rtl.waitFor(() => assert.equal(releases.length, 1));
+ original.unmount();
+ client.clear();
+ sessionStorage.removeItem('openwa_api_key');
+ sessionStorage.setItem('openwa_api_key', 'same-key');
+ const current = render();
+ await start(current, 'new operation');
+ await rtl.waitFor(() => assert.equal(releases.length, 2));
+ const resolved = () => jsonResponse({ number: '15550000001', exists: true, whatsappId: 'canonical@lid' });
+ await rtl.act(async () => {
+ releases[0](resolved());
+ await new Promise(resolve => setImmediate(resolve));
+ });
+ assert.deepEqual(writes, []);
+ assert.equal(
+ (current.container.querySelector('.send-btn') as HTMLButtonElement).disabled,
+ true,
+ 'the old completion unlocked the new operation',
+ );
+ await rtl.act(async () => {
+ releases[1](resolved());
+ await new Promise(resolve => setImmediate(resolve));
+ });
+ assert.deepEqual(writes, [{ chatId: 'canonical@lid', text: 'new operation' }]);
+ assert.ok(rtl.screen.getByText('new-operation'));
+ client.clear();
+ sessionStorage.removeItem('openwa_api_key');
+});
diff --git a/dashboard/src/pages/MessageTester.tsx b/dashboard/src/pages/MessageTester.tsx
index 3f6278ca0..34668f812 100644
--- a/dashboard/src/pages/MessageTester.tsx
+++ b/dashboard/src/pages/MessageTester.tsx
@@ -31,6 +31,7 @@ import { PageHeader } from '../components/PageHeader';
import { GroupPicker } from '../components/GroupPicker';
import { groupLabel, isGatewayRefusal, planGroupSend } from '../utils/groupSelection';
import { sendSequentially } from '../utils/sendSequentially';
+import { keepsSameKey } from '../utils/authLifecycle';
import './MessageTester.css';
interface ApiResponse {
@@ -217,10 +218,12 @@ export function MessageTester() {
// in flight at unmount resolves later, so startBatchPolling must refuse to start once unmounted.
// Reset on every mount: StrictMode runs mount, unmount, mount.
const unmountedRef = useRef(false);
+ const sendGenerationRef = useRef(0);
useEffect(() => {
unmountedRef.current = false;
return () => {
unmountedRef.current = true;
+ sendGenerationRef.current += 1;
stopBatchPolling();
};
}, []);
@@ -426,7 +429,11 @@ export function MessageTester() {
const isGroupSending = groupSendProgress !== null;
- const sendToGroups = async (chatIds: string[], sendTo: (chatId: string) => Promise<MessageResponse>) => {
+ const sendToGroups = async (
+ chatIds: string[],
+ sendTo: (chatId: string) => Promise<MessageResponse>,
+ isCurrent: () => boolean,
+ ) => {
const controller = new AbortController();
groupSendAbort.current = controller;
const labels = new Map(groups.map(group => [group.id, groupLabel(group)]));
@@ -441,9 +448,12 @@ export function MessageTester() {
delayMs: GROUP_SEND_DELAY_MS,
signal: controller.signal,
stopOn: isGatewayRefusal,
- onProgress: (current, total) => setGroupSendProgress({ current, total }),
+ onProgress: (current, total) => {
+ if (isCurrent()) setGroupSendProgress({ current, total });
+ },
},
);
+ if (!isCurrent()) return;
setResponse({
success: outcome.sent === chatIds.length,
timestamp: new Date().toISOString(),
@@ -461,9 +471,13 @@ export function MessageTester() {
},
});
} finally {
- groupSendAbort.current = null;
- setGroupSendProgress(null);
- setGroupSendCancelling(false);
+ if (groupSendAbort.current === controller) {
+ groupSendAbort.current = null;
+ if (!unmountedRef.current) {
+ setGroupSendProgress(null);
+ setGroupSendCancelling(false);
+ }
+ }
}
};
@@ -475,6 +489,15 @@ export function MessageTester() {
const handleSend = async () => {
const targetId = recipientType === 'group' ? (selectedGroups[0] ?? '') : recipient;
if (!session || (messageType !== 'bulk' && !targetId)) return;
+ const generation = ++sendGenerationRef.current;
+ const sameKey = keepsSameKey();
+ const isCurrent = () => !unmountedRef.current && generation === sendGenerationRef.current && sameKey();
+ const assertCurrent = () => {
+ if (!isCurrent()) {
+ groupSendAbort.current?.abort();
+ throw new DOMException('Aborted', 'AbortError');
+ }
+ };
setIsLoading(true);
setResponse(null);
// An earlier batch keeps running server-side, but its polling must not overwrite this response.
@@ -489,6 +512,7 @@ export function MessageTester() {
let chatId = targetId;
if (messageType !== 'bulk' && recipientType !== 'group') {
const resolved = await contactApi.checkNumber(session, targetId.replace(/[^0-9]/g, ''));
+ assertCurrent();
if (!resolved.exists || !resolved.whatsappId) {
setResponse({
success: false,
@@ -506,6 +530,7 @@ export function MessageTester() {
messages: buildBulkMessages(bulkRecipientList, content, bulkAttachment),
...(delayMs !== undefined ? { options: { delayBetweenMessages: delayMs } } : {}),
});
+ assertCurrent();
batchSessionRef.current = session;
setResponse({ success: true, timestamp: new Date().toISOString(), batchId: batch.batchId });
setBatchStatus({
@@ -519,6 +544,7 @@ export function MessageTester() {
}
const sendTo = async (target: string): Promise<MessageResponse> => {
+ assertCurrent();
switch (messageType) {
case 'text':
return messageApi.sendText(session, target, content);
@@ -568,6 +594,7 @@ export function MessageTester() {
let toChatId = forwardTo.trim();
if (!toChatId.includes('@')) {
const resolvedTo = await contactApi.checkNumber(session, toChatId.replace(/[^0-9]/g, ''));
+ assertCurrent();
if (!resolvedTo.exists || !resolvedTo.whatsappId) throw new Error(t('messageTester.notOnWhatsApp'));
toChatId = resolvedTo.whatsappId;
}
@@ -585,11 +612,12 @@ export function MessageTester() {
const plan = recipientType === 'group' ? planGroupSend(selectedGroups, messageType) : null;
if (plan?.mode === 'sequential') {
- await sendToGroups(plan.chatIds, sendTo);
+ await sendToGroups(plan.chatIds, sendTo, isCurrent);
return;
}
const result = await sendTo(chatId);
+ assertCurrent();
setResponse({
success: !!result.messageId,
@@ -597,6 +625,7 @@ export function MessageTester() {
timestamp: result.timestamp ? new Date(result.timestamp * 1000).toISOString() : new Date().toISOString(),
});
} catch (err) {
+ if (!isCurrent()) return;
setResponse({
success: false,
timestamp: new Date().toISOString(),
@@ -604,7 +633,7 @@ export function MessageTester() {
status: err instanceof Error ? (err as Error & { status?: number }).status : undefined,
});
} finally {
- setIsLoading(false);
+ if (!unmountedRef.current && generation === sendGenerationRef.current) setIsLoading(false);
}
};