Skip to content

Commit 87a12b5

Browse files
fix(usage): refresh limits when the tab opens (pingdotgg#11928)
Co-authored-by: Julius Marminge <[email protected]>
1 parent f4600d7 commit 87a12b5

8 files changed

Lines changed: 379 additions & 35 deletions

File tree

Lines changed: 117 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
import { EnvironmentId } from "@t3tools/contracts";
2+
import { beforeEach, expect, it, vi } from "vite-plus/test";
3+
4+
const state = vi.hoisted(() => ({
5+
values: [] as unknown[],
6+
cursor: 0,
7+
presentations: new Map(),
8+
refreshProviders: vi.fn(),
9+
autoRefresh: async () => {},
10+
refreshingRef: { current: false },
11+
}));
12+
vi.mock("react", () => ({
13+
useState: (initial: unknown) => {
14+
const index = state.cursor++;
15+
if (!(index in state.values)) {
16+
state.values[index] = typeof initial === "function" ? initial() : initial;
17+
}
18+
return [
19+
state.values[index],
20+
(next: unknown) => {
21+
state.values[index] = typeof next === "function" ? next(state.values[index]) : next;
22+
},
23+
];
24+
},
25+
useRef: () => state.refreshingRef,
26+
useEffect: () => {},
27+
useEffectEvent: (callback: () => Promise<void>) => {
28+
state.autoRefresh = callback;
29+
return callback;
30+
},
31+
}));
32+
vi.mock("@effect/atom-react", () => ({ useAtomValue: () => state.presentations }));
33+
vi.mock("react-native", () => ({ Alert: {}, Pressable: "button", View: "div" }));
34+
vi.mock("../../components/AppText", () => ({ AppText: "span" }));
35+
vi.mock("../../components/ProviderIcon", () => ({ ProviderIcon: () => null }));
36+
vi.mock("./usageProviders", () => ({ useProviderColors: () => ({}) }));
37+
vi.mock("../../state/presentation", () => ({
38+
environmentPresentations: { presentationsAtom: null },
39+
}));
40+
vi.mock("../../state/server", () => ({ serverEnvironment: { refreshProviders: null } }));
41+
vi.mock("../../state/use-atom-command", () => ({ useAtomCommand: () => state.refreshProviders }));
42+
43+
import { useRefreshLimits } from "./UsageLimitsSection";
44+
import { refreshUsageLimits } from "@t3tools/client-runtime/state/usage";
45+
46+
beforeEach(() => {
47+
state.values = [];
48+
state.cursor = 0;
49+
state.refreshingRef.current = false;
50+
state.refreshProviders.mockReset();
51+
});
52+
53+
it("keeps a newer environment failure when an older refresh finishes", async () => {
54+
const a = EnvironmentId.make("mobile-limits-a");
55+
const b = EnvironmentId.make("mobile-limits-b");
56+
const pending = Promise.withResolvers<{ _tag: string }>();
57+
const read = () => {
58+
state.cursor = 0;
59+
return useRefreshLimits();
60+
};
61+
const presentation = (label: string) => ({
62+
connection: { phase: "connected" },
63+
entry: { target: { label } },
64+
});
65+
state.presentations = new Map([[a, presentation("A")]]);
66+
state.refreshProviders.mockImplementation(({ environmentId }) =>
67+
environmentId === a ? pending.promise : Promise.resolve({ _tag: "Failure" }),
68+
);
69+
const first = read().refresh();
70+
state.presentations = new Map([
71+
[a, presentation("A")],
72+
[b, presentation("B")],
73+
]);
74+
read();
75+
await state.autoRefresh();
76+
expect(read().failedLabels).toEqual(["B"]);
77+
pending.resolve({ _tag: "Success" });
78+
await first;
79+
expect(read().failedLabels).toEqual(["B"]);
80+
});
81+
82+
it("does not let an older multi-environment batch clear a newer failure for the same environment", async () => {
83+
const a = EnvironmentId.make("mobile-limits-race-a");
84+
const b = EnvironmentId.make("mobile-limits-race-b");
85+
const aFirst = Promise.withResolvers<{ _tag: string }>();
86+
const bFirst = Promise.withResolvers<{ _tag: string }>();
87+
const read = (selected: ReadonlySet<EnvironmentId> | null = null) => {
88+
state.cursor = 0;
89+
return useRefreshLimits(selected);
90+
};
91+
const presentation = (label: string) => ({
92+
connection: { phase: "connected" },
93+
entry: { target: { label } },
94+
});
95+
state.presentations = new Map([
96+
[a, presentation("A")],
97+
[b, presentation("B")],
98+
]);
99+
let aCalls = 0;
100+
state.refreshProviders.mockImplementation(({ environmentId }) =>
101+
environmentId === b
102+
? bFirst.promise
103+
: ++aCalls === 1
104+
? aFirst.promise
105+
: Promise.resolve({ _tag: "Failure" }),
106+
);
107+
read();
108+
const older = state.autoRefresh();
109+
aFirst.resolve({ _tag: "Success" });
110+
await refreshUsageLimits(a, () => aFirst.promise);
111+
const selected = new Set([a]);
112+
await read(selected).refresh();
113+
expect(read(selected).failedLabels).toEqual(["A"]);
114+
bFirst.resolve({ _tag: "Success" });
115+
await older;
116+
expect(read(selected).failedLabels).toEqual(["A"]);
117+
});

‎apps/mobile/src/features/usage/UsageLimitsSection.tsx‎

Lines changed: 49 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,8 @@ import {
1616
paceOf,
1717
remainingPercent,
1818
} from "@t3tools/shared/usageLimits";
19-
import { type ReactNode, useState } from "react";
19+
import { type ReactNode, useEffect, useEffectEvent, useRef, useState } from "react";
20+
import { refreshUsageLimits } from "@t3tools/client-runtime/state/usage";
2021
import { Alert, Pressable, View } from "react-native";
2122

2223
import { AppText as Text } from "../../components/AppText";
@@ -279,47 +280,79 @@ export function ResetCredits(props: {
279280
* Environments whose probe failed are named, since their rows keep showing
280281
* the previous quota with nothing else to say so.
281282
*/
282-
export function useRefreshLimits(selectedEnvironmentIds: ReadonlySet<EnvironmentId> | null = null) {
283+
export function useRefreshLimits(
284+
selectedEnvironmentIds: ReadonlySet<EnvironmentId> | null = null,
285+
active = false,
286+
) {
283287
const presentations = useAtomValue(environmentPresentations.presentationsAtom);
284288
const refreshProviders = useAtomCommand(serverEnvironment.refreshProviders, {
285289
reportFailure: false,
286290
});
287291
const [now, setNow] = useState(() => Date.now());
288292
const [refreshing, setRefreshing] = useState(false);
293+
const refreshingRef = useRef(false);
289294
const [failedEnvironments, setFailedEnvironments] = useState<
290295
readonly { environmentId: EnvironmentId; label: string }[]
291296
>([]);
292-
// Always toggles `refreshing`, even with nothing to probe: Android's
293-
// RefreshControl keeps its spinner up until it sees true then false.
294-
const refresh = async () => {
297+
const refresh = async (automatic = false) => {
295298
const connected = [...presentations].filter(
296299
([environmentId, presentation]) =>
297300
presentation.connection.phase === "connected" &&
298301
(selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId)),
299302
);
300-
setRefreshing(true);
301303
try {
302-
const results = await Promise.all(
303-
connected.map(([environmentId]) => refreshProviders({ environmentId, input: {} })),
304-
);
305-
setFailedEnvironments(
306-
connected
307-
.filter((_, index) => results[index]?._tag === "Failure")
308-
.map(([environmentId, presentation]) => ({
304+
await Promise.all(
305+
connected.map(async ([environmentId, presentation]) => {
306+
const result = await refreshUsageLimits(
309307
environmentId,
310-
label: presentation.entry.target.label,
311-
})),
308+
() => refreshProviders({ environmentId, input: {} }),
309+
automatic,
310+
);
311+
if (result === undefined) return;
312+
setFailedEnvironments((previous) => [
313+
...previous.filter((failed) => failed.environmentId !== environmentId),
314+
...(result._tag === "Failure"
315+
? [{ environmentId, label: presentation.entry.target.label }]
316+
: []),
317+
]);
318+
}),
312319
);
313320
} finally {
314321
setNow(Date.now());
322+
}
323+
};
324+
// Always toggles `refreshing`, even with nothing to probe: Android's
325+
// RefreshControl keeps its spinner up until it sees true then false.
326+
const refreshManually = async () => {
327+
if (refreshingRef.current) return;
328+
refreshingRef.current = true;
329+
setRefreshing(true);
330+
try {
331+
await refresh();
332+
} finally {
333+
refreshingRef.current = false;
315334
setRefreshing(false);
316335
}
317336
};
337+
const connectedLimitsEnvironments = [...presentations]
338+
.filter(
339+
([environmentId, presentation]) =>
340+
presentation.connection.phase === "connected" &&
341+
(selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId)),
342+
)
343+
.map(([environmentId]) => environmentId)
344+
.sort()
345+
.join(",");
346+
const autoRefreshLimits = useEffectEvent(() => refresh(true));
347+
useEffect(() => {
348+
if (active && connectedLimitsEnvironments) void autoRefreshLimits();
349+
}, [active, connectedLimitsEnvironments]);
350+
318351
const failedLabels = failedEnvironments
319352
.filter(
320353
({ environmentId }) =>
321354
selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId),
322355
)
323356
.map(({ label }) => label);
324-
return { now, refreshing, failedLabels, refresh };
357+
return { now, refreshing, failedLabels, refresh: refreshManually };
325358
}

‎apps/mobile/src/features/usage/UsageRouteScreen.tsx‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
import { EnvironmentId, USAGE_CONTRACT_VERSION } from "@t3tools/contracts";
2-
import { type RouteProp, useNavigation, useRoute } from "@react-navigation/native";
2+
import { type RouteProp, useIsFocused, useNavigation, useRoute } from "@react-navigation/native";
33
import {
44
isCompatibleUsageContractVersion,
55
isModelCostUnknown,
@@ -95,7 +95,8 @@ export function UsageRouteScreen() {
9595
window,
9696
selectedEnvironmentIds,
9797
);
98-
const limits = useRefreshLimits(selectedEnvironmentIds);
98+
const isFocused = useIsFocused();
99+
const limits = useRefreshLimits(selectedEnvironmentIds, isFocused && tab === "limits");
99100

100101
const days = useMemo(
101102
() => enumerateDays(window.sinceDay, window.untilDay),

‎apps/web/src/components/usage/UsagePage.refresh.test.tsx‎

Lines changed: 97 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,13 @@
11
import { EnvironmentId, ProviderInstanceId, USAGE_CONTRACT_VERSION } from "@t3tools/contracts";
22
import { mergeUsage } from "@t3tools/shared/usageMerge";
3-
import { act } from "react";
3+
import { StrictMode, act } from "react";
44
import { create, type ReactTestRenderer } from "react-test-renderer";
55
import { afterEach, beforeEach, expect, it, vi } from "vite-plus/test";
66

77
const state = vi.hoisted(() => ({
88
presentations: new Map(),
99
refreshProviders: vi.fn(async () => undefined),
10+
metric: "limits",
1011
}));
1112
vi.mock("@effect/atom-react", () => ({ useAtomValue: () => state.presentations }));
1213
vi.mock("../../state/presentation", () => ({
@@ -43,7 +44,7 @@ vi.mock("../../state/usage", () => ({
4344
}),
4445
}));
4546
vi.mock("./usagePagePreferences", () => ({
46-
readUsagePagePreferences: () => ({ metric: "limits", windowDays: 30 }),
47+
readUsagePagePreferences: () => ({ metric: state.metric, windowDays: 30 }),
4748
saveUsagePagePreferences: vi.fn(),
4849
}));
4950
vi.mock("../ui/button", () => ({ Button: "button" }));
@@ -83,13 +84,16 @@ vi.mock("../settings/providerDriverMeta", () => ({ getDriverOption: () => ({ lab
8384
import { UsagePage } from "./UsagePage";
8485

8586
let renderer: ReactTestRenderer;
87+
let environmentNumber = 0;
8688
beforeEach(() => {
8789
vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
8890
vi.spyOn(Date, "now").mockReturnValue(Date.parse("2026-09-11T12:00:00Z"));
91+
environmentNumber += 1;
92+
state.metric = "limits";
8993
state.refreshProviders.mockClear();
9094
state.presentations = new Map([
9195
[
92-
EnvironmentId.make("test"),
96+
EnvironmentId.make(`test-${environmentNumber}`),
9397
{
9498
entry: { target: { label: "Test" } },
9599
connection: { phase: "connected" },
@@ -150,7 +154,10 @@ it.each([0, 1])(
150154
.at(buttonIndex)!
151155
.props.onClick();
152156
});
153-
expect(state.refreshProviders).toHaveBeenCalledWith({ environmentId: "test", input: {} });
157+
expect(state.refreshProviders).toHaveBeenCalledWith({
158+
environmentId: `test-${environmentNumber}`,
159+
input: {},
160+
});
154161
expect(
155162
JSON.stringify(renderer.toJSON(), (key, value) => (key === "props" ? undefined : value)),
156163
).toContain("in 1h 30m");
@@ -175,5 +182,91 @@ it("uses the current time when returning to limits from tokens", async () => {
175182
expect(
176183
JSON.stringify(renderer.toJSON(), (key, value) => (key === "props" ? undefined : value)),
177184
).toContain("in 1h 0m");
185+
expect(state.refreshProviders).toHaveBeenCalledTimes(2);
186+
});
187+
188+
it("refreshes once on opening Limits and suppresses rapid returns and remounts", async () => {
189+
state.metric = "tokens";
190+
await act(() => {
191+
renderer = create(
192+
<StrictMode>
193+
<UsagePage />
194+
</StrictMode>,
195+
);
196+
});
178197
expect(state.refreshProviders).not.toHaveBeenCalled();
198+
const selectMetric = (metric: string) =>
199+
renderer.root
200+
.findAll((node) => node.type === "div" && node.props["aria-label"] === "Usage metric")[0]!
201+
.props.onValueChange([metric]);
202+
await act(() => selectMetric("limits"));
203+
expect(state.refreshProviders).toHaveBeenCalledTimes(1);
204+
await act(() => selectMetric("tokens"));
205+
await act(() => selectMetric("limits"));
206+
await act(() => renderer.unmount());
207+
state.metric = "limits";
208+
await act(() => {
209+
renderer = create(
210+
<StrictMode>
211+
<UsagePage />
212+
</StrictMode>,
213+
);
214+
});
215+
expect(state.refreshProviders).toHaveBeenCalledTimes(1);
216+
await act(() => selectMetric("tokens"));
217+
vi.mocked(Date.now).mockReturnValue(Date.parse("2026-09-11T12:05:00Z"));
218+
await act(() => selectMetric("limits"));
219+
expect(state.refreshProviders).toHaveBeenCalledTimes(2);
220+
});
221+
222+
it("waits for connection and refreshes new environments during a slow refresh", async () => {
223+
const [id, presentation] = [...state.presentations][0]!;
224+
state.presentations = new Map([[id, { ...presentation, connection: { phase: "disconnected" } }]]);
225+
await act(() => {
226+
renderer = create(<UsagePage />);
227+
});
228+
expect(state.refreshProviders).not.toHaveBeenCalled();
229+
let finishRefresh!: () => void;
230+
state.refreshProviders.mockImplementationOnce(
231+
() =>
232+
new Promise<undefined>((resolve) => {
233+
finishRefresh = () => resolve(undefined);
234+
}),
235+
);
236+
state.presentations = new Map([[id, presentation]]);
237+
await act(() => renderer.update(<UsagePage />));
238+
expect(state.refreshProviders).toHaveBeenCalledTimes(1);
239+
const nextId = EnvironmentId.make(`${id}-next`);
240+
state.presentations = new Map([...state.presentations, [nextId, presentation]]);
241+
await act(() => renderer.update(<UsagePage />));
242+
expect(state.refreshProviders).toHaveBeenCalledTimes(2);
243+
expect(state.refreshProviders).toHaveBeenLastCalledWith({ environmentId: nextId, input: {} });
244+
await act(() => finishRefresh());
245+
});
246+
247+
it("keeps manual refresh busy until the already-running automatic check settles", async () => {
248+
let finishRefresh!: () => void;
249+
const pending = new Promise<undefined>((resolve) => {
250+
finishRefresh = () => resolve(undefined);
251+
});
252+
state.refreshProviders.mockImplementationOnce(() => pending);
253+
await act(() => {
254+
renderer = create(<UsagePage />);
255+
});
256+
const button = () =>
257+
renderer.root.findAll(
258+
(node) => node.type === "button" && node.props["aria-label"] === "Refresh limits",
259+
)[0]!;
260+
expect(state.refreshProviders).toHaveBeenCalledTimes(1);
261+
await act(() => button().props.onClick());
262+
try {
263+
expect(button().props["aria-busy"]).toBe(true);
264+
expect(state.refreshProviders).toHaveBeenCalledTimes(1);
265+
} finally {
266+
await act(async () => {
267+
finishRefresh();
268+
await pending;
269+
});
270+
}
271+
expect(button().props["aria-busy"]).toBe(false);
179272
});

0 commit comments

Comments
 (0)