Skip to content

Commit 23557bf

Browse files
fix(usage): preserve refresh results and await active checks
Apply mobile failure results as each environment settles so slower batches cannot overwrite newer checks. Manual refreshes await the current provider request and retain their spinner until it finishes. Model: GPT-6. Harness: Codex.
1 parent 5a58fca commit 23557bf

5 files changed

Lines changed: 114 additions & 33 deletions

File tree

‎apps/mobile/src/features/usage/UsageLimitsSection.test.ts‎

Lines changed: 46 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
import { EnvironmentId } from "@t3tools/contracts";
2-
import { expect, it, vi } from "vite-plus/test";
2+
import { beforeEach, expect, it, vi } from "vite-plus/test";
33

44
const state = vi.hoisted(() => ({
55
values: [] as unknown[],
@@ -41,6 +41,14 @@ vi.mock("../../state/server", () => ({ serverEnvironment: { refreshProviders: nu
4141
vi.mock("../../state/use-atom-command", () => ({ useAtomCommand: () => state.refreshProviders }));
4242

4343
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+
});
4452

4553
it("keeps a newer environment failure when an older refresh finishes", async () => {
4654
const a = EnvironmentId.make("mobile-limits-a");
@@ -70,3 +78,40 @@ it("keeps a newer environment failure when an older refresh finishes", async ()
7078
await first;
7179
expect(read().failedLabels).toEqual(["B"]);
7280
});
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: 12 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -301,28 +301,22 @@ export function useRefreshLimits(
301301
(selectedEnvironmentIds === null || selectedEnvironmentIds.has(environmentId)),
302302
);
303303
try {
304-
const results = await Promise.all(
305-
connected.map(([environmentId]) =>
306-
refreshUsageLimits(
304+
await Promise.all(
305+
connected.map(async ([environmentId, presentation]) => {
306+
const result = await refreshUsageLimits(
307307
environmentId,
308308
() => refreshProviders({ environmentId, input: {} }),
309309
automatic,
310-
),
311-
),
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
);
313-
setFailedEnvironments((previous) => [
314-
...previous.filter(({ environmentId }) => !connected.some(([id]) => id === environmentId)),
315-
...connected
316-
.filter(([environmentId], index) =>
317-
results[index] === undefined
318-
? previous.some((failed) => failed.environmentId === environmentId)
319-
: results[index]?._tag === "Failure",
320-
)
321-
.map(([environmentId, presentation]) => ({
322-
environmentId,
323-
label: presentation.entry.target.label,
324-
})),
325-
]);
326320
} finally {
327321
setNow(Date.now());
328322
}

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

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -243,3 +243,30 @@ it("waits for connection and refreshes new environments during a slow refresh",
243243
expect(state.refreshProviders).toHaveBeenLastCalledWith({ environmentId: nextId, input: {} });
244244
await act(() => finishRefresh());
245245
});
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);
272+
});

‎packages/client-runtime/src/state/usage.test.ts‎

Lines changed: 13 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -184,24 +184,31 @@ describe("manual usage refresh", () => {
184184
});
185185

186186
describe("limits refresh cooldown", () => {
187-
it("coalesces in-flight calls and gates automatic refreshes after success or failure", async () => {
187+
it("joins manual calls and gates automatic refreshes after success or failure", async () => {
188188
const clock = vi.spyOn(Date, "now").mockReturnValue(1_000);
189189
try {
190190
for (const fails of [false, true]) {
191191
const id = EnvironmentId.make(`limits-${fails}`);
192-
const pending = Promise.withResolvers<void>();
192+
const pending = Promise.withResolvers<string>();
193193
const refresh = vi.fn(() => pending.promise);
194194
const first = refreshUsageLimits(id, refresh, true);
195195
await refreshUsageLimits(id, refresh, true);
196-
await refreshUsageLimits(id, refresh);
196+
const manual = refreshUsageLimits(id, refresh);
197+
const settled = vi.fn();
198+
void manual.then(settled, settled);
199+
expect(settled).not.toHaveBeenCalled();
197200
expect(refresh).toHaveBeenCalledTimes(1);
198201
if (fails) {
202+
const firstFailure = expect(first).rejects.toThrow("unavailable");
203+
const manualFailure = expect(manual).rejects.toThrow("unavailable");
199204
pending.reject(new Error("unavailable"));
200-
await expect(first).rejects.toThrow("unavailable");
205+
await Promise.all([firstFailure, manualFailure]);
201206
} else {
202-
pending.resolve();
203-
await first;
207+
pending.resolve("quota");
208+
expect(await first).toBe("quota");
209+
expect(await manual).toBe("quota");
204210
}
211+
expect(settled).toHaveBeenCalledTimes(1);
205212
const next = vi.fn(async () => undefined);
206213
clock.mockReturnValue(300_999);
207214
await refreshUsageLimits(id, next, true);

‎packages/client-runtime/src/state/usage.ts‎

Lines changed: 16 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -10,22 +10,30 @@ import type { createServerEnvironmentAtoms } from "./server.ts";
1010
const isEnvironmentRpcUnavailable = Schema.is(EnvironmentRpcUnavailableError);
1111

1212
const limitsRefreshAfter = new Map<EnvironmentId, number>();
13+
const limitsRefreshes = new Map<EnvironmentId, Promise<unknown>>();
1314

1415
export async function refreshUsageLimits<A>(
1516
environmentId: EnvironmentId,
1617
refresh: () => Promise<A>,
1718
automatic = false,
1819
): Promise<A | undefined> {
20+
const pending = limitsRefreshes.get(environmentId);
21+
if (pending !== undefined) {
22+
// Manual refresh waits for the current check; automatic refresh does not repeat it.
23+
return automatic ? undefined : ((await pending) as A);
24+
}
1925
const refreshAfter = limitsRefreshAfter.get(environmentId) ?? 0;
2026
// @effect-diagnostics-next-line globalDate:off
21-
if (refreshAfter === Infinity || (automatic && Date.now() < refreshAfter)) return;
22-
limitsRefreshAfter.set(environmentId, Infinity);
23-
try {
24-
return await refresh();
25-
} finally {
26-
// @effect-diagnostics-next-line globalDate:off
27-
limitsRefreshAfter.set(environmentId, Date.now() + 5 * 60_000);
28-
}
27+
if (automatic && Date.now() < refreshAfter) return;
28+
const current = Promise.resolve()
29+
.then(refresh)
30+
.finally(() => {
31+
limitsRefreshes.delete(environmentId);
32+
// @effect-diagnostics-next-line globalDate:off
33+
limitsRefreshAfter.set(environmentId, Date.now() + 5 * 60_000);
34+
});
35+
limitsRefreshes.set(environmentId, current);
36+
return await current;
2937
}
3038

3139
/** Refresh pricing, then await each selected environment's rescan while it remains connected. */

0 commit comments

Comments
 (0)