Skip to content

Commit f84deb6

Browse files
perf(web): provider update rows compile with the React Compiler
Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent cf7e41e commit f84deb6

2 files changed

Lines changed: 114 additions & 123 deletions

File tree

‎apps/web/reactCompiledFiles.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -56,4 +56,5 @@ export const REACT_COMPILED_FILES = [
5656
"apps/web/src/components/ServerUpdateAction.tsx",
5757
"apps/web/src/components/files/AttachmentFilePreview.tsx",
5858
"apps/web/src/components/usage/UsagePage.tsx",
59+
"apps/web/src/components/ProviderUpdateEnvironmentRows.tsx",
5960
] as const;

‎apps/web/src/components/ProviderUpdateEnvironmentRows.tsx‎

Lines changed: 113 additions & 123 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,13 @@
11
import { CheckIcon } from "lucide-react";
2-
import { type ReactNode, useCallback, useMemo, useRef, useState } from "react";
2+
import { type ReactNode, useRef, useState } from "react";
33
import {
44
AuthProvidersManageScope,
55
type EnvironmentId,
66
type ServerProvider,
77
} from "@t3tools/contracts";
88
import {
99
isAtomCommandInterrupted,
10+
settlePromise,
1011
squashAtomCommandFailure,
1112
type AtomCommandResult,
1213
} from "@t3tools/client-runtime/state/runtime";
@@ -160,12 +161,9 @@ export function ProviderUpdateEnvironmentRows({
160161
const updateProvider = useAtomCommand(serverEnvironment.updateProvider, {
161162
reportFailure: false,
162163
});
163-
const groupByEnvironment = useMemo(
164-
() => new Map(groups.map((group) => [group.environmentId, group] as const)),
165-
[groups],
166-
);
164+
const groupByEnvironment = new Map(groups.map((group) => [group.environmentId, group] as const));
167165

168-
const visibleAfterIsoRef = useRef<string>(new Date().toISOString());
166+
const [visibleAfterIso] = useState(() => new Date().toISOString());
169167

170168
// setPendingEnvironments is an async state update, and PENDING_EXPIRY_MS can
171169
// clear the spinner while a request is still in flight, so a rapid
@@ -191,7 +189,7 @@ export function ProviderUpdateEnvironmentRows({
191189
ReadonlyMap<EnvironmentId, ProviderUpdateToastView>
192190
>(() => new Map());
193191

194-
const clearPending = useCallback((environmentId: EnvironmentId) => {
192+
const clearPending = (environmentId: EnvironmentId) => {
195193
setPendingEnvironments((previous) => {
196194
if (!previous.has(environmentId)) {
197195
return previous;
@@ -200,31 +198,81 @@ export function ProviderUpdateEnvironmentRows({
200198
next.delete(environmentId);
201199
return next;
202200
});
203-
}, []);
201+
};
202+
203+
const handleUpdate = async (environmentId: EnvironmentId) => {
204+
if (!readEnvironmentScope(environmentId, AuthProvidersManageScope)) return;
205+
const group = groupByEnvironment.get(environmentId);
206+
if (!group || group.candidates.length === 0) {
207+
return;
208+
}
209+
if (inFlightEnvironmentsRef.current.has(environmentId)) {
210+
return;
211+
}
212+
inFlightEnvironmentsRef.current.add(environmentId);
213+
const requestVersion = (requestVersionRef.current.get(environmentId) ?? 0) + 1;
214+
requestVersionRef.current.set(environmentId, requestVersion);
215+
const isCurrentRequest = () => requestVersionRef.current.get(environmentId) === requestVersion;
216+
onInteract?.();
217+
const providerCount = group.candidates.length;
218+
const targets = group.candidates.map((candidate) => ({
219+
driver: candidate.driver,
220+
instanceId: candidate.instanceId,
221+
}));
222+
223+
setPendingEnvironments((previous) => new Set(previous).add(environmentId));
224+
setErrorByEnvironment((previous) => {
225+
if (!previous.has(environmentId)) {
226+
return previous;
227+
}
228+
const next = new Map(previous);
229+
next.delete(environmentId);
230+
return next;
231+
});
232+
setResultByEnvironment((previous) => {
233+
if (!previous.has(environmentId)) {
234+
return previous;
235+
}
236+
const next = new Map(previous);
237+
next.delete(environmentId);
238+
return next;
239+
});
204240

205-
const handleUpdate = useCallback(
206-
async (environmentId: EnvironmentId) => {
207-
if (!readEnvironmentScope(environmentId, AuthProvidersManageScope)) return;
208-
const group = groupByEnvironment.get(environmentId);
209-
if (!group || group.candidates.length === 0) {
241+
const expiry = setTimeout(() => {
242+
if (!isCurrentRequest()) {
210243
return;
211244
}
212-
if (inFlightEnvironmentsRef.current.has(environmentId)) {
245+
inFlightEnvironmentsRef.current.delete(environmentId);
246+
clearPending(environmentId);
247+
setErrorByEnvironment((previous) =>
248+
new Map(previous).set(environmentId, "Update timed out — try again."),
249+
);
250+
}, PENDING_EXPIRY_MS);
251+
const settled = await settlePromise(async () => {
252+
const results = await Promise.all(
253+
targets.map(async (target): Promise<PromiseSettledResult<LocalProviderUpdateOutcome>> => {
254+
try {
255+
const result = await updateProvider({
256+
environmentId,
257+
input: { provider: target.driver, instanceId: target.instanceId },
258+
});
259+
return toProviderUpdateOutcome({
260+
environmentId,
261+
isPrimary: group.isPrimary,
262+
target,
263+
result,
264+
});
265+
} catch (error) {
266+
return {
267+
status: "rejected",
268+
reason: error instanceof Error ? error : new Error("Provider update failed."),
269+
};
270+
}
271+
}),
272+
);
273+
if (!isCurrentRequest()) {
213274
return;
214275
}
215-
inFlightEnvironmentsRef.current.add(environmentId);
216-
const requestVersion = (requestVersionRef.current.get(environmentId) ?? 0) + 1;
217-
requestVersionRef.current.set(environmentId, requestVersion);
218-
const isCurrentRequest = () =>
219-
requestVersionRef.current.get(environmentId) === requestVersion;
220-
onInteract?.();
221-
const providerCount = group.candidates.length;
222-
const targets = group.candidates.map((candidate) => ({
223-
driver: candidate.driver,
224-
instanceId: candidate.instanceId,
225-
}));
226-
227-
setPendingEnvironments((previous) => new Set(previous).add(environmentId));
228276
setErrorByEnvironment((previous) => {
229277
if (!previous.has(environmentId)) {
230278
return previous;
@@ -233,104 +281,46 @@ export function ProviderUpdateEnvironmentRows({
233281
next.delete(environmentId);
234282
return next;
235283
});
236-
setResultByEnvironment((previous) => {
237-
if (!previous.has(environmentId)) {
238-
return previous;
239-
}
240-
const next = new Map(previous);
241-
next.delete(environmentId);
242-
return next;
243-
});
244-
245-
const expiry = setTimeout(() => {
246-
if (!isCurrentRequest()) {
247-
return;
248-
}
249-
inFlightEnvironmentsRef.current.delete(environmentId);
250-
clearPending(environmentId);
284+
if (results.length === 0) {
251285
setErrorByEnvironment((previous) =>
252-
new Map(previous).set(environmentId, "Update timed out — try again."),
253-
);
254-
}, PENDING_EXPIRY_MS);
255-
try {
256-
const results = await Promise.all(
257-
targets.map(async (target): Promise<PromiseSettledResult<LocalProviderUpdateOutcome>> => {
258-
try {
259-
const result = await updateProvider({
260-
environmentId,
261-
input: { provider: target.driver, instanceId: target.instanceId },
262-
});
263-
return toProviderUpdateOutcome({
264-
environmentId,
265-
isPrimary: group.isPrimary,
266-
target,
267-
result,
268-
});
269-
} catch (error) {
270-
return {
271-
status: "rejected",
272-
reason: error instanceof Error ? error : new Error("Provider update failed."),
273-
};
274-
}
275-
}),
286+
new Map(previous).set(
287+
environmentId,
288+
"This environment isn’t connected — try again once it reconnects.",
289+
),
276290
);
277-
if (!isCurrentRequest()) {
278-
return;
279-
}
280-
setErrorByEnvironment((previous) => {
281-
if (!previous.has(environmentId)) {
282-
return previous;
283-
}
284-
const next = new Map(previous);
285-
next.delete(environmentId);
286-
return next;
287-
});
288-
if (results.length === 0) {
289-
setErrorByEnvironment((previous) =>
290-
new Map(previous).set(
291-
environmentId,
292-
"This environment isn’t connected — try again once it reconnects.",
293-
),
294-
);
295-
return;
296-
}
297-
const rejectedMessage = firstRejectedProviderUpdateMessage(results);
298-
if (rejectedMessage) {
299-
setErrorByEnvironment((previous) =>
300-
new Map(previous).set(environmentId, rejectedMessage),
301-
);
302-
return;
303-
}
304-
const view = getProviderUpdateProgressToastView({
305-
providers: collectProviderUpdateOutcomeSnapshots(results),
306-
providerCount,
307-
});
308-
// A stored view never re-polls, so persisting it would pin the row's
309-
// spinner forever once the pending flag expires. Drop it and let the
310-
// live per-environment provider state (pill) plus the pending expiry
311-
// drive the row, so it self-heals to whatever the backend actually did.
312-
if (isTerminalProviderUpdatePhase(view.phase)) {
313-
setResultByEnvironment((previous) => new Map(previous).set(environmentId, view));
314-
}
315-
} catch (error) {
316-
if (isCurrentRequest()) {
317-
setErrorByEnvironment((previous) =>
318-
new Map(previous).set(
319-
environmentId,
320-
error instanceof Error ? error.message : "Provider update failed.",
321-
),
322-
);
323-
}
324-
} finally {
325-
clearTimeout(expiry);
326-
if (isCurrentRequest()) {
327-
clearPending(environmentId);
328-
inFlightEnvironmentsRef.current.delete(environmentId);
329-
}
291+
return;
330292
}
331-
},
332-
[clearPending, groupByEnvironment, onInteract, updateProvider],
333-
);
293+
const rejectedMessage = firstRejectedProviderUpdateMessage(results);
294+
if (rejectedMessage) {
295+
setErrorByEnvironment((previous) => new Map(previous).set(environmentId, rejectedMessage));
296+
return;
297+
}
298+
const view = getProviderUpdateProgressToastView({
299+
providers: collectProviderUpdateOutcomeSnapshots(results),
300+
providerCount,
301+
});
302+
// A stored view never re-polls, so persisting it would pin the row's
303+
// spinner forever once the pending flag expires. Drop it and let the
304+
// live per-environment provider state (pill) plus the pending expiry
305+
// drive the row, so it self-heals to whatever the backend actually did.
306+
if (isTerminalProviderUpdatePhase(view.phase)) {
307+
setResultByEnvironment((previous) => new Map(previous).set(environmentId, view));
308+
}
309+
});
310+
clearTimeout(expiry);
311+
if (!isCurrentRequest()) return;
312+
if (settled._tag === "Failure") {
313+
const error = squashAtomCommandFailure(settled);
314+
setErrorByEnvironment((previous) =>
315+
new Map(previous).set(
316+
environmentId,
317+
error instanceof Error ? error.message : "Provider update failed.",
318+
),
319+
);
320+
}
321+
clearPending(environmentId);
322+
inFlightEnvironmentsRef.current.delete(environmentId);
323+
};
334324

335325
const rows = groups
336326
.map((group) => ({
@@ -340,7 +330,7 @@ export function ProviderUpdateEnvironmentRows({
340330
error: errorByEnvironment.get(group.environmentId),
341331
result: resultByEnvironment.get(group.environmentId),
342332
pill: getProviderUpdateSidebarPillView(group.candidates, {
343-
visibleAfterIso: visibleAfterIsoRef.current,
333+
visibleAfterIso,
344334
}),
345335
isPending: pendingEnvironments.has(group.environmentId),
346336
}),

0 commit comments

Comments
 (0)