Skip to content

Commit 7ca3c8c

Browse files
committed
fix(desktop): preserve channel history failures on refresh
Keep failed cold-history queries in their error state and prevent retry transitions from being mistaken for settled empty timelines. Signed-off-by: Thomas Petersen <[email protected]>
1 parent 339f4ba commit 7ca3c8c

5 files changed

Lines changed: 186 additions & 7 deletions

File tree

‎desktop/src/features/channels/ui/ChannelScreen.tsx‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -636,7 +636,7 @@ export function ChannelScreen({
636636
resolveTimelineLoadingLatch(
637637
settledChannelIdRef.current,
638638
activeChannelId,
639-
timelineLoadingNow,
639+
timelineLoadingNow, !messagesQuery.isError,
640640
);
641641
settledChannelIdRef.current = settledChannelId;
642642
const { welcomeKickoffStage, welcomeKickoffSettingUp } =

‎desktop/src/features/messages/lib/projectChannelWindow.test.mjs‎

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -416,3 +416,74 @@ test("test_concurrent_refreshes_after_seeded_snapshot_share_one_authoritative_fe
416416
unsubscribe();
417417
}
418418
});
419+
420+
test("test_subscription_refresh_preserves_cold_history_error", async () => {
421+
const client = new QueryClient({
422+
defaultOptions: { queries: { retry: false } },
423+
});
424+
const channelId = "cold-failure";
425+
const queryKey = channelMessagesKey(channelId);
426+
const observer = new QueryObserver(client, {
427+
queryKey,
428+
queryFn: async () => {
429+
throw new Error("history unavailable");
430+
},
431+
});
432+
const unsubscribe = observer.subscribe(() => {});
433+
434+
try {
435+
await observer.refetch();
436+
assert.equal(observer.getCurrentResult().status, "error");
437+
assert.equal(observer.getCurrentResult().data, undefined);
438+
439+
await assert.rejects(
440+
refreshChannelWindowMessages(client, channelId),
441+
/history unavailable/,
442+
);
443+
assert.equal(observer.getCurrentResult().status, "error");
444+
assert.equal(observer.getCurrentResult().data, undefined);
445+
} finally {
446+
unsubscribe();
447+
}
448+
});
449+
450+
test("test_refresh_failure_retains_cached_rows_and_success_clears_error", async () => {
451+
const harness = createHarness();
452+
let shouldFail = true;
453+
const refreshed = event("refreshed", 110);
454+
const observer = new QueryObserver(harness.client, {
455+
queryKey: harness.messagesKey,
456+
queryFn: async ({ signal }) => {
457+
if (shouldFail) {
458+
throw new Error("history unavailable");
459+
}
460+
const previousMessages =
461+
harness.client.getQueryData(harness.messagesKey) ?? [];
462+
return reconcileFetchedChannelWindow(
463+
harness.client,
464+
harness.channelId,
465+
wirePage([refreshed, event("initial", 100)]),
466+
previousMessages,
467+
signal,
468+
);
469+
},
470+
staleTime: Number.POSITIVE_INFINITY,
471+
});
472+
const unsubscribe = observer.subscribe(() => {});
473+
474+
try {
475+
await assert.rejects(
476+
refreshChannelWindowMessages(harness.client, harness.channelId),
477+
/history unavailable/,
478+
);
479+
assert.equal(observer.getCurrentResult().status, "error");
480+
assert.deepEqual(contents(harness), ["initial"]);
481+
482+
shouldFail = false;
483+
await refreshChannelWindowMessages(harness.client, harness.channelId);
484+
assert.equal(observer.getCurrentResult().status, "success");
485+
assert.deepEqual(contents(harness), ["initial", "refreshed"]);
486+
} finally {
487+
unsubscribe();
488+
}
489+
});

‎desktop/src/features/messages/lib/projectChannelWindow.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ export async function refreshChannelWindowMessages(
4747
}
4848
await queryClient.invalidateQueries(
4949
{ queryKey, exact: true, refetchType: "active" },
50-
{ cancelRefetch: !seeded },
50+
{ cancelRefetch: !seeded, throwOnError: true },
5151
);
5252
projectChannelWindowMessages(queryClient, channelId);
5353
}

‎desktop/src/features/messages/lib/timelineLoadingState.test.mjs‎

Lines changed: 110 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,11 @@
11
import assert from "node:assert/strict";
22
import test from "node:test";
3+
import { QueryClient, QueryObserver } from "@tanstack/react-query";
34

4-
import { selectTimelineLoadingState } from "./timelineLoadingState.ts";
5+
import {
6+
resolveTimelineLoadingLatch,
7+
selectTimelineLoadingState,
8+
} from "./timelineLoadingState.ts";
59

610
const settled = {
711
isPending: false,
@@ -10,6 +14,34 @@ const settled = {
1014
dataLength: null,
1115
};
1216

17+
function deferred() {
18+
let resolve;
19+
let reject;
20+
const promise = new Promise((resolvePromise, rejectPromise) => {
21+
resolve = resolvePromise;
22+
reject = rejectPromise;
23+
});
24+
return { promise, reject, resolve };
25+
}
26+
27+
function resolveQueryLoading(result, settledChannelId = null) {
28+
const loadingNow = selectTimelineLoadingState(
29+
{
30+
isPending: result.isPending,
31+
isFetching: result.isFetching,
32+
isPlaceholderData: result.isPlaceholderData,
33+
dataLength: result.data?.length ?? null,
34+
},
35+
settledChannelId === "chan-a",
36+
);
37+
return resolveTimelineLoadingLatch(
38+
settledChannelId,
39+
"chan-a",
40+
loadingNow,
41+
!result.isError,
42+
);
43+
}
44+
1345
test("pending first fetch with no cache is loading", () => {
1446
assert.equal(
1547
selectTimelineLoadingState({ ...settled, isPending: true }),
@@ -120,8 +152,6 @@ test("settled channel with rows mid-refetch is not loading", () => {
120152
);
121153
});
122154

123-
import { resolveTimelineLoadingLatch } from "./timelineLoadingState.ts";
124-
125155
test("latch: loading on first entry to a channel", () => {
126156
const r = resolveTimelineLoadingLatch(null, "chan-a", true);
127157
assert.equal(r.isLoading, true);
@@ -158,3 +188,80 @@ test("latch: no active channel passes loadingNow through untouched", () => {
158188
false,
159189
);
160190
});
191+
192+
test("query wiring: cold error retry stays loading until successful empty result", async () => {
193+
const client = new QueryClient({
194+
defaultOptions: { queries: { retry: false } },
195+
});
196+
const first = deferred();
197+
const retry = deferred();
198+
let attempt = 0;
199+
const observer = new QueryObserver(client, {
200+
queryKey: ["messages", "chan-a"],
201+
queryFn: () => [first.promise, retry.promise][attempt++],
202+
});
203+
const unsubscribe = observer.subscribe(() => {});
204+
205+
try {
206+
first.reject(new Error("history unavailable"));
207+
await new Promise((resolve) => setImmediate(resolve));
208+
let loading = resolveQueryLoading(observer.getCurrentResult());
209+
assert.equal(observer.getCurrentResult().status, "error");
210+
assert.deepEqual(loading, { settledChannelId: null, isLoading: false });
211+
212+
const retryResult = observer.refetch();
213+
loading = resolveQueryLoading(observer.getCurrentResult());
214+
assert.equal(observer.getCurrentResult().status, "pending");
215+
assert.deepEqual(loading, { settledChannelId: null, isLoading: true });
216+
217+
retry.resolve([]);
218+
await retryResult;
219+
loading = resolveQueryLoading(observer.getCurrentResult());
220+
assert.equal(observer.getCurrentResult().status, "success");
221+
assert.deepEqual(loading, {
222+
settledChannelId: "chan-a",
223+
isLoading: false,
224+
});
225+
} finally {
226+
unsubscribe();
227+
}
228+
});
229+
230+
test("query wiring: repeated cold retry failure never settles as empty", async () => {
231+
const client = new QueryClient({
232+
defaultOptions: { queries: { retry: false } },
233+
});
234+
const first = deferred();
235+
const retry = deferred();
236+
let attempt = 0;
237+
const observer = new QueryObserver(client, {
238+
queryKey: ["messages", "chan-a"],
239+
queryFn: () => [first.promise, retry.promise][attempt++],
240+
});
241+
const unsubscribe = observer.subscribe(() => {});
242+
243+
try {
244+
first.reject(new Error("history unavailable"));
245+
await new Promise((resolve) => setImmediate(resolve));
246+
assert.deepEqual(resolveQueryLoading(observer.getCurrentResult()), {
247+
settledChannelId: null,
248+
isLoading: false,
249+
});
250+
251+
const retryResult = observer.refetch();
252+
assert.deepEqual(resolveQueryLoading(observer.getCurrentResult()), {
253+
settledChannelId: null,
254+
isLoading: true,
255+
});
256+
257+
retry.reject(new Error("still unavailable"));
258+
await retryResult;
259+
assert.equal(observer.getCurrentResult().status, "error");
260+
assert.deepEqual(resolveQueryLoading(observer.getCurrentResult()), {
261+
settledChannelId: null,
262+
isLoading: false,
263+
});
264+
} finally {
265+
unsubscribe();
266+
}
267+
});

‎desktop/src/features/messages/lib/timelineLoadingState.ts‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -50,6 +50,7 @@ export function resolveTimelineLoadingLatch(
5050
settledChannelId: string | null,
5151
activeChannelId: string | null,
5252
loadingNow: boolean,
53+
canSettle = true,
5354
): { settledChannelId: string | null; isLoading: boolean } {
5455
if (activeChannelId === null) {
5556
return { settledChannelId, isLoading: loadingNow };
@@ -58,9 +59,9 @@ export function resolveTimelineLoadingLatch(
5859
// Already settled for this channel — stay loaded through refetch blips.
5960
return { settledChannelId, isLoading: false };
6061
}
61-
if (!loadingNow) {
62+
if (!loadingNow && canSettle) {
6263
// First settle for this channel; latch it.
6364
return { settledChannelId: activeChannelId, isLoading: false };
6465
}
65-
return { settledChannelId, isLoading: true };
66+
return { settledChannelId, isLoading: loadingNow };
6667
}

0 commit comments

Comments
 (0)