diff --git a/apps/mobile/src/features/pull-requests/usePullRequestList.ts b/apps/mobile/src/features/pull-requests/usePullRequestList.ts index d4fe1ab3461bd..8ba0721fd7fb5 100644 --- a/apps/mobile/src/features/pull-requests/usePullRequestList.ts +++ b/apps/mobile/src/features/pull-requests/usePullRequestList.ts @@ -1,3 +1,8 @@ +import { + editHeldPullRequestListEntries, + pullRequestHostAnswer, + pullRequestPendingEditsFor, +} from "@t3tools/client-runtime/state/pull-requests"; import { RegistryContext, useAtomMount, useAtomSubscribe, useAtomValue } from "@effect/atom-react"; import { executeAtomQuery, squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime"; import type { EnvironmentId, PullRequestDiffStat, PullRequestListInput } from "@t3tools/contracts"; @@ -31,7 +36,10 @@ type Read = (atom: Atom.Atom) => A; /** The head the list query holds now, cached or answered. */ function currentHead(read: Read, target: ListTarget) { - return AsyncResult.getOrElse(read(composerPullRequests.list(target)), () => null); + return AsyncResult.getOrElse( + read(pullRequestHostAnswer(composerPullRequests.list(target))), + () => null, + ); } function currentPages(read: Read, target: ListTarget): PullRequestListPages | null { @@ -44,12 +52,23 @@ function currentPages(read: Read, target: ListTarget): PullRequestListPages | nu const sourcesFamily = Atom.family((key: string) => { const targets: readonly ListTarget[] = JSON.parse(key); return Atom.make((get) => - targets.map((target) => ({ - target, - result: get(composerPullRequests.list(target)), - pages: currentPages(get, target), - stats: get(pullRequestListStatsFamily(target.environmentId)), - })), + targets.map((target) => { + const pages = currentPages(get, target); + return { + target, + result: get(composerPullRequests.list(target)), + pages: + pages === null + ? null + : { + ...pages, + entries: editHeldPullRequestListEntries(target.input, pages.entries, (entry) => + get(pullRequestPendingEditsFor(target.environmentId, entry)), + ), + }, + stats: get(pullRequestListStatsFamily(target.environmentId)), + }; + }), ); }); @@ -71,7 +90,7 @@ async function loadNextPages( continuations(registry, targets).map(async ({ target, pages, input }) => { const response = await executeAtomQuery( registry, - composerPullRequests.list({ ...target, input }), + pullRequestHostAnswer(composerPullRequests.list({ ...target, input })), { signal, refresh: retry, @@ -113,11 +132,15 @@ async function refreshHeads( input: {}, }); if (signal.aborted) return; - const response = await executeAtomQuery(registry, composerPullRequests.list(target), { - refresh: true, - signal, - reportFailure: false, - }); + const response = await executeAtomQuery( + registry, + pullRequestHostAnswer(composerPullRequests.list(target)), + { + refresh: true, + signal, + reportFailure: false, + }, + ); if (signal.aborted) return; if (response._tag === "Failure") throw squashAtomCommandFailure(response); registry.set( diff --git a/apps/mobile/src/state/pull-requests.ts b/apps/mobile/src/state/pull-requests.ts index 8ca65760e5913..cb8606b96b5f9 100644 --- a/apps/mobile/src/state/pull-requests.ts +++ b/apps/mobile/src/state/pull-requests.ts @@ -1,7 +1,9 @@ import { createPullRequestEnvironmentAtoms, + editHeldPullRequestListEntries, createPullRequestStackAtomFamily, patchPullRequestListEntries, + pullRequestPendingEditsAtom, } from "@t3tools/client-runtime/state/pull-requests"; import type { EnvironmentId, PullRequestListInput, PullRequestRef } from "@t3tools/contracts"; import * as Effect from "effect/Effect"; @@ -66,11 +68,30 @@ export const composerPullRequests = createPullRequestEnvironmentAtoms(connection pages.entries, target.input, reply, + registry.get(pullRequestPendingEditsAtom(target.environmentId)), ); return entries === "refresh" || entries === pages.entries ? pages : { ...pages, entries }; }); } }), + acceptedEdit: (target, edit, registry) => + Effect.sync(() => { + for (const atom of registry.getNodes().keys()) { + const listing = + typeof atom === "string" ? undefined : pullRequestListPagesTargets.get(atom); + if (listing === undefined || listing[0] !== target.environmentId) continue; + registry.update(atom as Atom.Writable, (pages) => { + if (pages === null) return pages; + const entries = editHeldPullRequestListEntries( + listing[1], + pages.entries, + () => [edit], + registry.get(pullRequestPendingEditsAtom(target.environmentId)), + ); + return entries === pages.entries ? pages : { ...pages, entries }; + }); + } + }), // A new head can change which files GitHub still counts as viewed, so the viewed-files read is // refreshed where the new head lands. The detail atom still holds the previous answer here. detail: (target, value, registry) => diff --git a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx index 6e4a2bb6fb6a0..47606eee7436b 100644 --- a/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx +++ b/apps/web/src/components/pullRequest/PullRequestDetailPanel.tsx @@ -1650,7 +1650,6 @@ export function PullRequestDetailPanel({ pullRequestKey={pullRequestKey} detail={detail} canWriteSourceControl={canWriteSourceControl} - onSaved={refreshDetail} /> } author={ diff --git a/apps/web/src/components/pullRequest/PullRequestLabelPicker.tsx b/apps/web/src/components/pullRequest/PullRequestLabelPicker.tsx index e32ef26053bd2..24b4d1eedd7b5 100644 --- a/apps/web/src/components/pullRequest/PullRequestLabelPicker.tsx +++ b/apps/web/src/components/pullRequest/PullRequestLabelPicker.tsx @@ -32,7 +32,6 @@ export function PullRequestLabelPicker({ }) { const [open, setOpen] = useState(false); const [query, setQuery] = useState(""); - const [pending, setPending] = useState(null); const candidatesQuery = useEnvironmentQuery( open ? pullRequestEnvironment.labelCandidates({ environmentId, input: reference }) : null, @@ -45,14 +44,12 @@ export function PullRequestLabelPicker({ matches(entry, query), ); + // Each change shows at once and queues behind the one before it on the host. const toggle = async (candidate: PullRequestLabelCandidate) => { - if (pending !== null) return; - setPending(candidate.name); const result = await setLabels({ environmentId, input: { ...reference, labels: [candidate.name], applied: !candidate.isApplied }, }); - setPending(null); if (result._tag === "Failure") { toastManager.add({ type: "error", @@ -88,7 +85,7 @@ export function PullRequestLabelPicker({ truncated={candidatesQuery.data?.truncated === true} truncatedLabel="This repository has more labels than are listed here. Apply the rest on the host." candidateKey={(candidate) => candidate.name} - disabled={pending !== null} + disabled={false} onSelect={(candidate) => void toggle(candidate)} > {(candidate) => { diff --git a/apps/web/src/components/pullRequest/PullRequestTitleEditor.tsx b/apps/web/src/components/pullRequest/PullRequestTitleEditor.tsx index ce6e8a801074d..992e785f018b8 100644 --- a/apps/web/src/components/pullRequest/PullRequestTitleEditor.tsx +++ b/apps/web/src/components/pullRequest/PullRequestTitleEditor.tsx @@ -24,14 +24,12 @@ export function PullRequestTitleEditor({ pullRequestKey, detail, canWriteSourceControl, - onSaved, }: { environmentId: EnvironmentId; reference: PullRequestRef; pullRequestKey: string; detail: PullRequestDetail; canWriteSourceControl: boolean; - onSaved: () => void; }) { const update = useAtomCommand(pullRequestEnvironment.update, { reportFailure: false }); const [titleScope, setTitleScope] = useState<{ @@ -49,9 +47,12 @@ export function PullRequestTitleEditor({ return; } setTitleSaving(true); + // The new title shows while the host takes it, so the editor closes at once. + setTitleScope(null); const result = await update({ environmentId, input: { ...reference, title } }); setTitleSaving(false); if (result._tag === "Failure") { + setTitleScope({ pullRequestKey, text: title }); toastManager.add({ type: "error", title: "The title could not be saved", @@ -60,10 +61,7 @@ export function PullRequestTitleEditor({ "The host refused the new title.", ), }); - return; } - setTitleScope(null); - onSaved(); }; if (titleDraft === null) { diff --git a/apps/web/src/components/pullRequest/PullRequestsPage.tsx b/apps/web/src/components/pullRequest/PullRequestsPage.tsx index 4fb9969218c22..a6959de237766 100644 --- a/apps/web/src/components/pullRequest/PullRequestsPage.tsx +++ b/apps/web/src/components/pullRequest/PullRequestsPage.tsx @@ -1,3 +1,5 @@ +import { heldPullRequestListEntriesAtom } from "@t3tools/client-runtime/state/pull-requests"; +import { AsyncResult, Atom } from "effect/reactivity"; import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients"; import { applyPullRequestDraftFilterChange } from "@t3tools/client-runtime/pull-request-query"; import { Spinner } from "~/components/ui/spinner"; @@ -104,7 +106,7 @@ import { import { useSidebarProjectGroups } from "~/hooks/useSidebarProjectGroups"; import { pullRequestEnvironment, - usePullRequestList, + usePullRequestHostList, usePullRequestListStats, restoredPullRequestList, usePullRequestTurnRefreshes, @@ -147,6 +149,35 @@ const EMPTY_PREVIEW_SESSIONS = {}; const EMPTY_PREVIEW_DESKTOP_STATE = {}; const EMPTY_TERMINAL_LABELS = new Map(); const EMPTY_PENDING_SURFACES = new Set(); +const heldRowReaders = new WeakMap< + EnvironmentPullRequestEntry, + Map>> +>(); + +function usePendingListEntries( + input: PullRequestListInput, + entries: ReadonlyArray | undefined, +) { + const key = JSON.stringify(input); + return useAtomValue( + Atom.make((get) => + (entries ?? []).flatMap((entry) => { + let readers = heldRowReaders.get(entry); + if (readers === undefined) { + readers = new Map(); + heldRowReaders.set(entry, readers); + } + let reader = readers.get(key); + if (reader === undefined) { + reader = heldPullRequestListEntriesAtom(entry.environmentId, input, [entry]); + readers.set(key, reader); + } + return AsyncResult.getOrElse(get(reader), () => []); + }), + ), + ); +} + export function PullRequestsPage() { const search = useSearch({ from: "/_chat/pull-requests" }); const sort = search.sort ?? "ready"; @@ -341,7 +372,7 @@ export function PullRequestsPage() { ]; }); const listTargets = listTargetsFor(environmentQueries); - const listQuery = usePullRequestList(listTargets); + const listQuery = usePullRequestHostList(listTargets); /** * Kept as its own read rather than remembered from an earlier answer because an answer cannot @@ -362,7 +393,7 @@ export function PullRequestsPage() { } satisfies PullRequestListInput, })); const baselineTargets = baselineTargetsFor(environmentQueries); - const baselineQuery = usePullRequestList(baselineTargets); + const baselineQuery = usePullRequestHostList(baselineTargets); const observedHosts = rememberPullRequestHosts( rememberPullRequestHosts(hostReads, baselineQuery.observations), listQuery.observations, @@ -387,7 +418,7 @@ export function PullRequestsPage() { } satisfies PullRequestListInput, })); })(); - const facetQuery = usePullRequestList(facetTargets); + const facetQuery = usePullRequestHostList(facetTargets); const filterOptionScope = environmentQueries.map(({ environmentId, projectIds }) => ({ environmentId, input: { @@ -423,8 +454,8 @@ export function PullRequestsPage() { })); return { authored: targetsFor("authored"), reviewing: targetsFor("reviewing") }; })(); - const authoredQuery = usePullRequestList(partitionTargets.authored); - const reviewingQuery = usePullRequestList(partitionTargets.reviewing); + const authoredQuery = usePullRequestHostList(partitionTargets.authored); + const reviewingQuery = usePullRequestHostList(partitionTargets.reviewing); const invalidate = useAtomCommand(pullRequestEnvironment.invalidate, { reportFailure: false }); const [detailRefreshToken, setDetailRefreshToken] = useState(0); const [invalidating, setInvalidating] = useState(false); @@ -703,6 +734,23 @@ export function PullRequestsPage() { search.state, ); + const heldEntries = ordered?.key === filterKey ? ordered.entries : (listData?.entries ?? []); + const overlayInput = { state: search.state, filters }; + const shownEntries = usePendingListEntries(overlayInput, heldEntries); + const shownBaseline = usePendingListEntries( + overlayInput, + typedParsed.filters.checks === undefined ? baselineQuery.data?.entries : undefined, + ); + const shownAuthored = usePendingListEntries( + overlayInput, + partitionsWanted ? authoredQuery.data?.entries : undefined, + ); + const shownReviewing = usePendingListEntries( + overlayInput, + partitionsWanted ? reviewingQuery.data?.entries : undefined, + ); + const shownHeldAuthored = usePendingListEntries(overlayInput, heldPartitions?.authored); + const shownHeldReviewing = usePendingListEntries(overlayInput, heldPartitions?.reviewing); const scrollRef = useRef(null); const { entries, @@ -711,9 +759,12 @@ export function PullRequestsPage() { entriesByStatsKey, heldPullRequestsBySurface, } = pullRequestGroups({ - known: ordered?.key === filterKey ? ordered.entries : (listData?.entries ?? []), + known: shownEntries, // The baseline was read without typed qualifiers, and rows cannot be checked for `checks:`. - baseline: typedParsed.filters.checks === undefined ? baselineQuery.data?.entries : undefined, + baseline: + typedParsed.filters.checks === undefined && baselineQuery.data !== null + ? shownBaseline + : undefined, providers: baselineQuery.data?.providers ?? listData?.providers ?? [], viewers, involvement: search.involvement, @@ -723,11 +774,14 @@ export function PullRequestsPage() { answeredLocally: querySettled && !showingCarried, baselineEmpty, held: - loaded !== null && loaded.environmentKey === environmentKey && loaded.scope === scopeKey - ? loaded.partitions - : undefined, - authored: partitionsWanted ? authoredQuery.data?.entries : undefined, - reviewing: partitionsWanted ? reviewingQuery.data?.entries : undefined, + heldPartitions === undefined + ? undefined + : { + authored: shownHeldAuthored, + reviewing: shownHeldReviewing, + }, + authored: partitionsWanted && authoredQuery.data !== null ? shownAuthored : undefined, + reviewing: partitionsWanted && reviewingQuery.data !== null ? shownReviewing : undefined, partitionsWanted, }); diff --git a/apps/web/src/components/pullRequest/usePullRequestDetail.ts b/apps/web/src/components/pullRequest/usePullRequestDetail.ts index fb7515c646009..a7b28a21b2337 100644 --- a/apps/web/src/components/pullRequest/usePullRequestDetail.ts +++ b/apps/web/src/components/pullRequest/usePullRequestDetail.ts @@ -1,4 +1,6 @@ +import { useAtomValue } from "@effect/atom-react"; import { resolvePullRequestDetailChecks } from "@t3tools/client-runtime/pull-request-checks"; +import { pullRequestPendingEditsFor } from "@t3tools/client-runtime/state/pull-requests"; import { AuthSourceControlWriteScope, type EnvironmentId, @@ -13,6 +15,7 @@ import { useServerConfigs } from "~/state/entities"; import { useEnvironmentQuery } from "~/state/query"; import { useEnvironmentScope } from "~/state/session"; import { + newestDisplayedPullRequestSummary, newestPullRequestSummary, pullRequestEnvironment, pullRequestListEntryToSummary, @@ -105,6 +108,7 @@ export function usePullRequestDetail( setCachedDetail(detailQuery.data); } const observedSummary = useSharedPullRequestSummary(environmentId, reference); + const pendingEdits = useAtomValue(pullRequestPendingEditsFor(environmentId, reference)); const activity = activityQuery.data; const resolvedCoreDetail = resolveDisplayedPullRequestDetail({ live: liveDetail, @@ -115,9 +119,12 @@ export function usePullRequestDetail( // `detail` would cost it its cache scope. const listSummary = listEntry === null ? null : pullRequestListEntryToSummary(listEntry); // The row can come from the page's stored snapshot, which no answer has published yet. - const sharedSummary = newestPullRequestSummary( + const sharedSummary = newestDisplayedPullRequestSummary( resolvedCoreDetail, - newestPullRequestSummary(observedSummary, listSummary), + liveDetail === null, + newestPullRequestSummary(listSummary, observedSummary), + reference, + pendingEdits, ); const coreDetail = resolvedCoreDetail === null || sharedSummary === null || sharedSummary === resolvedCoreDetail diff --git a/apps/web/src/state/pullRequests.test.ts b/apps/web/src/state/pullRequests.test.ts index fafec751a6c0f..5c47ff8666185 100644 --- a/apps/web/src/state/pullRequests.test.ts +++ b/apps/web/src/state/pullRequests.test.ts @@ -44,6 +44,7 @@ import { observePullRequestChecks, observePullRequestMetadata, newestPullRequestSummary, + newestDisplayedPullRequestSummary, rememberPullRequestListAnswer, restorePullRequestList, restoredPullRequestList, @@ -154,6 +155,15 @@ describe("pull request summary cache", () => { const older = summary({ updatedAt: "2026-09-11T00:00:00Z", observedAt: 999 }); expect(newestPullRequestSummary(older, reopened)).toBe(reopened); expect(newestPullRequestSummary(reopened, older)).toBe(reopened); + const edited = summary({ title: "Accepted title" }); + expect(newestPullRequestSummary(summary(), edited)).toBe(edited); + const loaded = summary(); + expect(newestDisplayedPullRequestSummary(loaded, false, edited, loaded, [])).toBe(loaded); + expect(newestDisplayedPullRequestSummary(summary(), true, edited, loaded, [])).toBe(edited); + const titleEdit = { reference: loaded, title: "Pending title" }; + expect(newestDisplayedPullRequestSummary(loaded, true, null, loaded, [titleEdit])?.title).toBe( + "Pending title", + ); }); it("reuses saved thread state while detail is stale and lets newer detail replace it", () => { diff --git a/apps/web/src/state/pullRequests.ts b/apps/web/src/state/pullRequests.ts index 5e75d32cad75d..06abb20717212 100644 --- a/apps/web/src/state/pullRequests.ts +++ b/apps/web/src/state/pullRequests.ts @@ -1,9 +1,13 @@ import { useAtomValue } from "@effect/atom-react"; import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients"; import { + applyPullRequestSummaryEdits, createLinkedPullRequestSummaryAtomFamily, createPullRequestEnvironmentAtoms, createPullRequestStackAtomFamily, + pullRequestPendingEditsFor, + pullRequestHostAnswer, + type PullRequestPendingEdit, } from "@t3tools/client-runtime/state/pull-requests"; import { PullRequestListResult, @@ -69,6 +73,24 @@ export function newestPullRequestSummary( return compareSummaries(current, observed) >= 0 ? observed : current; } +/** A stored snapshot carries no edit, so a shared summary dated the same wins over it. */ +export function newestDisplayedPullRequestSummary( + detail: PullRequestSummary | null, + fromSnapshot: boolean, + shared: PullRequestSummary | null, + reference: PullRequestRef, + edits: ReadonlyArray, +): PullRequestSummary | null { + // With no shared summary the snapshot is all there is, and no answer applied its edits yet. + return applyPullRequestSummaryEdits( + reference, + fromSnapshot + ? newestPullRequestSummary(detail, shared) + : newestPullRequestSummary(shared, detail), + edits, + ); +} + export function pullRequestListEntryToSummary(entry: PullRequestListEntry): PullRequestSummary { return { provider: entry.provider, @@ -403,6 +425,20 @@ export function subscribePullRequestFilesViewedAnswers( // Answers are stamped on arrival: older servers leave no other ordering for same-dated reads. export const pullRequestEnvironment = createPullRequestEnvironmentAtoms(connectionAtomRuntime, { + acceptedEdit: ({ environmentId, input }, edit, registry) => + Effect.map(Clock.currentTimeMillis, (observedAt) => { + const saved = registry.get( + savedPullRequestSummaryAtom(savedPullRequestKey(environmentId, input)), + ); + recordObservation(registry, pullRequestSummaryKey(environmentId, input), (current) => { + const summary = applyPullRequestSummaryEdits( + input, + newestPullRequestSummary(saved, observedPullRequestSummary(current)), + [edit], + ); + return summary === null ? current : { ...current, metadata: { summary, observedAt } }; + }); + }), filesViewed: (target, answer) => Effect.sync(() => { for (const listener of filesViewedAnswerListeners.get(filesViewedAnswerKey(target)) ?? []) @@ -543,6 +579,7 @@ export function useSharedPullRequestSummary( ? "none" : pullRequestSummaryKey(environmentId, reference); const observations = useAtomValue(pullRequestObservationsAtom(key)); + const edits = useAtomValue(pullRequestPendingEditsFor(environmentId, reference)); const saved = useAtomValue( savedPullRequestSummaryAtom( environmentId === null || reference === null @@ -550,7 +587,11 @@ export function useSharedPullRequestSummary( : savedPullRequestKey(environmentId, reference), ), ); - return newestPullRequestSummary(observedPullRequestSummary(observations), saved); + return applyPullRequestSummaryEdits( + reference, + newestPullRequestSummary(saved, observedPullRequestSummary(observations)), + edits, + ); } export const pullRequestStackAtom = createPullRequestStackAtomFamily( connectionAtomRuntime, @@ -664,6 +705,13 @@ function createMergedEnvironmentQuery( }; } +const usePullRequestHostListsQuery = createMergedEnvironmentQuery( + "web-pull-requests:host-list", + (target: EnvironmentQueryTarget) => + pullRequestHostAnswer(pullRequestEnvironment.list(target)), + observeFailedPullRequestList, +); + const usePullRequestListsQuery = createMergedEnvironmentQuery( "web-pull-requests:list", pullRequestEnvironment.list, @@ -707,6 +755,8 @@ export interface MergedPullRequestListView { readonly refresh: (targets?: ReadonlyArray>) => void; } +// Merge inside each hook: the React Compiler memoizes it on `query.values` only there, and +// PullRequestsPage sets state when the merged list's identity changes. export function usePullRequestList( targets: ReadonlyArray>, ): MergedPullRequestListView { @@ -721,6 +771,20 @@ export function usePullRequestList( }; } +export function usePullRequestHostList( + targets: ReadonlyArray>, +): MergedPullRequestListView { + const query = usePullRequestHostListsQuery(targets); + const data = mergePullRequestLists(query.values); + return { + data, + error: query.error, + isPending: query.isPending, + observations: query.observations, + refresh: query.refresh, + }; +} + export function usePullRequestListStats( targets: ReadonlyArray>, ): { diff --git a/packages/client-runtime/src/state/pullRequests.test.ts b/packages/client-runtime/src/state/pullRequests.test.ts index a70179c7974c3..4788e56f8b849 100644 --- a/packages/client-runtime/src/state/pullRequests.test.ts +++ b/packages/client-runtime/src/state/pullRequests.test.ts @@ -7,9 +7,11 @@ import { AuthOrchestrationOperateScope, ProjectId, PullRequestOperationError, + SourceControlProviderKind, WS_METHODS, type AuthSessionState, type PullRequestListInput, + type PullRequestListEntry, } from "@t3tools/contracts"; import { expect, it } from "@effect/vitest"; import * as Schema from "effect/Schema"; @@ -40,8 +42,14 @@ import * as EnvironmentSupervisor from "../connection/supervisor.ts"; import type { WsRpcProtocolClient } from "../rpc/protocol.ts"; import type { RpcSession } from "../rpc/session.ts"; import { + applyPullRequestSummaryEdits, createLinkedPullRequestSummaryAtomFamily, createPullRequestEnvironmentAtoms, + editHeldPullRequestListEntries, + heldPullRequestListEntriesAtom, + pullRequestHostAnswer, + pullRequestPendingEditsAtom, + pullRequestPendingEditsFor, } from "./pullRequests.ts"; import * as PullRequestDiffLoader from "./pullRequestDiffHttp.ts"; import { executeAtomQuery, queryPersistenceKey } from "./runtime.ts"; @@ -1095,6 +1103,20 @@ const actionReply = { observedAt: 200, }; +const actionListEntry: PullRequestListEntry = { + ...actionReply, + provider: SourceControlProviderKind.make("github"), + projectTitle: "Web", + state: "open", + author: null, + mergeability: "unknown", + additions: 0, + deletions: 0, + createdAt: actionReply.updatedAt, + viewerReviewRequested: false, + labels: [], +}; + function actionReplyClient(overrides: Record = {}) { return { [WS_METHODS.pullRequestsSubscribeRefreshes]: () => Stream.never, @@ -2262,3 +2284,649 @@ it.effect("publishes the accepted guide run before the follow-up read finishes", expect(AsyncResult.getOrElse(registry.get(query), () => null)).toEqual(accepted); }), ); + +const listResult = (entries: ReadonlyArray) => ({ + entries, + viewers: {}, + providers: [], + errors: [], + truncated: false, + nextCursors: {}, +}); + +it.effect.each([ + ["close", { state: "closed" }, "open"], + ["reopen", { state: "open" }, "closed"], + ["ready", { isDraft: false }, "open"], + ["draft", { isDraft: true }, "open"], + ["enable-auto-merge", { autoMergeEnabled: true }, "open"], + ["disable-auto-merge", { autoMergeEnabled: false }, "open"], +] as const)("shows %s in loaded readers before the host replies", ([action, shown, from]) => + Effect.scoped( + Effect.gen(function* () { + let reads = 0; + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const before = { + ...actionReference, + provider: "github", + title: "Ship it", + url: actionReply.url, + author: null, + headBranch: "feature", + baseBranch: "main", + state: from, + isDraft: action === "ready", + autoMergeEnabled: action === "disable-auto-merge", + createdAt: "2026-10-27T08:00:00Z", + updatedAt: "2026-10-27T09:00:00Z", + observedAt: 100, + }; + const read = () => + Effect.sync(() => { + reads++; + return before; + }); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: read, + [WS_METHODS.pullRequestsPreview]: read, + [WS_METHODS.pullRequestsSummary]: read, + [WS_METHODS.pullRequestsList]: () => + Effect.sync(() => { + reads++; + return listResult([before]); + }), + [WS_METHODS.pullRequestsRunAction]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + return { ...before, ...shown, updatedAt: "2026-10-27T10:00:00Z", observedAt: 200 }; + }), + }); + const { atoms, registry, runtime } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const readers: ReadonlyArray>> = [ + atoms.detail(target), + atoms.preview(target), + createLinkedPullRequestSummaryAtomFamily(runtime, atoms.refreshes)(target), + ]; + const list = atoms.list({ environmentId: target.environmentId, input: { state: from } }); + for (const atom of [...readers, list]) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } + reads = 0; + + const acting = yield* Effect.promise(() => + atoms.runAction.run(registry, { ...target, input: { ...actionReference, action } }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + + for (const atom of readers.slice(0, action.includes("auto-merge") ? 1 : readers.length)) { + expect(Option.getOrThrow(AsyncResult.value(registry.get(atom)))).toMatchObject(shown); + } + const rows = Option.getOrThrow(AsyncResult.value(registry.get(list))).entries; + if ("state" in shown) expect(rows).toEqual([]); + else if ("isDraft" in shown) expect(rows).toMatchObject([shown]); + else expect(rows).toHaveLength(1); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(acting); + expect(Option.getOrThrow(AsyncResult.value(registry.get(readers[0]!)))).toMatchObject({ + ...shown, + updatedAt: "2026-10-27T10:00:00Z", + }); + // Only a reopen re-reads, for the branch data and permissions its reply lacks. + expect(reads).toBe(action === "reopen" ? 1 : 0); + }), + ), +); + +it.effect("puts readers back when the host refuses an action, and saves nothing it guessed", () => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const open = { ...actionReference, state: "open", isDraft: false, observedAt: 100 }; + const saved = new Map(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => Effect.succeed(open), + [WS_METHODS.pullRequestsList]: () => Effect.succeed(listResult([open])), + [WS_METHODS.pullRequestsRunAction]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + return yield* new PullRequestOperationError({ + operation: "runAction", + detail: "You cannot close this pull request.", + }); + }), + }); + const { atoms, registry } = yield* makeTestRuntime( + client, + undefined, + false, + {}, + { + load: (_environmentId, key) => Effect.sync(() => Option.fromUndefinedOr(saved.get(key))), + save: (_environmentId, key, payload) => Effect.sync(() => void saved.set(key, payload)), + }, + ); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const detail = atoms.detail(target); + const list = atoms.list({ environmentId: target.environmentId, input: { state: "open" } }); + const loaded: ReadonlyArray>> = [ + detail, + list, + ]; + for (const atom of loaded) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } + + const acting = yield* Effect.promise(() => + atoms.runAction.run(registry, { + ...target, + input: { ...actionReference, action: "close" }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("closed"); + const held = Option.getOrThrow( + AsyncResult.value(registry.get(pullRequestHostAnswer(list))), + ).entries; + const shownHeld = () => + editHeldPullRequestListEntries({ state: "open" }, held, () => + registry.get(pullRequestPendingEditsFor(target.environmentId, actionReference)), + ); + expect(shownHeld()).toEqual([]); + yield* Deferred.succeed(release, undefined); + expect((yield* Fiber.join(acting))._tag).toBe("Failure"); + + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("open"); + expect(Option.getOrThrow(AsyncResult.value(registry.get(list))).entries).toMatchObject([ + { state: "open" }, + ]); + expect(shownHeld()).toMatchObject([{ state: "open" }]); + expect([...saved.values()].some((payload) => payload.includes('"closed"'))).toBe(false); + }), + ), +); + +it.effect( + "keeps an accepted change on screen until the re-read when the reply has no summary", + () => + Effect.scoped( + Effect.gen(function* () { + let state = "open"; + let reads = 0; + const rereadStarted = yield* Deferred.make(); + const releaseReread = yield* Deferred.make(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => + Effect.gen(function* () { + reads++; + const answer = { ...actionReference, state, observedAt: reads }; + if (reads === 2) { + yield* Deferred.succeed(rereadStarted, undefined); + yield* Deferred.await(releaseReread); + } + return answer; + }), + [WS_METHODS.pullRequestsRunAction]: () => + Effect.sync(() => { + state = "closed"; + return undefined; + }), + }); + let held = [actionListEntry] as ReadonlyArray; + const { atoms, registry } = yield* makeTestRuntime(client, undefined, false, { + acceptedEdit: (_target, edit) => + Effect.sync(() => { + held = editHeldPullRequestListEntries({ state: "all" }, held, () => [edit]); + }), + }); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const retained = heldPullRequestListEntriesAtom( + target.environmentId, + { state: "all" }, + held, + ); + registry.mount(retained); + const detail = atoms.detail(target); + registry.mount(detail); + yield* Effect.promise(() => executeAtomQuery(registry, detail)); + + yield* Effect.promise(() => + atoms.runAction.run(registry, { + ...target, + input: { ...actionReference, action: "close" }, + }), + ); + yield* Deferred.await(rereadStarted); + + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("closed"); + expect(held[0]?.state).toBe("closed"); + expect(Option.getOrThrow(AsyncResult.value(registry.get(retained)))[0]?.state).toBe( + "closed", + ); + yield* Deferred.succeed(releaseReread, undefined); + expect( + (yield* AtomRegistry.getResult(registry, detail, { suspendOnWaiting: true })).observedAt, + ).toBe(2); + }), + ), +); + +it.effect.each([ + ["with", { ...actionReply, state: "closed" as const }], + ["without", undefined], +] as const)("shows a queued close before the action ahead of it answers, %s a reply", ([, reply]) => + Effect.scoped( + Effect.gen(function* () { + const firstSent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const releaseReopen = yield* Deferred.make(); + const rows = [1, 2].map((number) => ({ + ...actionReference, + number, + state: "open", + isDraft: false, + updatedAt: `2026-10-27T0${number}:00:00Z`, + })); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsList]: () => Effect.succeed(listResult(rows)), + [WS_METHODS.pullRequestsRunAction]: (input: { + readonly number: number; + readonly action: string; + }) => + Effect.gen(function* () { + if (input.action === "reopen") { + yield* Deferred.await(releaseReopen); + return yield* new PullRequestOperationError({ + operation: "runAction", + detail: "reopen refused", + }); + } + if (input.number === 1) { + yield* Deferred.succeed(firstSent, undefined); + yield* Deferred.await(release); + return reply; + } + return undefined; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const list = atoms.list({ environmentId: TARGET.environmentId, input: { state: "open" } }); + registry.mount(list); + yield* Effect.promise(() => executeAtomQuery(registry, list)); + + const closes = [1, 2].map((number) => + atoms.runAction.run(registry, { + environmentId: TARGET.environmentId, + input: { ...actionReference, number, action: "close" }, + }), + ); + yield* Deferred.await(firstSent); + + expect(Option.getOrThrow(AsyncResult.value(registry.get(list))).entries).toEqual([]); + + const reopen = atoms.runAction.run(registry, { + environmentId: TARGET.environmentId, + input: { ...actionReference, number: 1, action: "reopen" }, + }); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(list))).entries.map((row) => row.number), + ).toEqual([1]); + yield* Deferred.succeed(release, undefined); + yield* Effect.promise(() => Promise.all(closes)); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(list))).entries.map((row) => row.number), + ).toEqual([1]); + yield* Deferred.succeed(releaseReopen, undefined); + expect((yield* Effect.promise(() => reopen))._tag).toBe("Failure"); + expect(Option.getOrThrow(AsyncResult.value(registry.get(list))).entries).toEqual([]); + }), + ), +); + +it.effect("leaves a merge as it is until the host says what it did", () => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => + Effect.succeed({ ...actionReference, state: "open", observedAt: 100 }), + [WS_METHODS.pullRequestsRunAction]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + // A merge queue takes the merge and merges later. + return { ...actionReply, state: "open", autoMergeEnabled: true }; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const detail = atoms.detail(target); + registry.mount(detail); + yield* Effect.promise(() => executeAtomQuery(registry, detail)); + + const acting = yield* Effect.promise(() => + atoms.runAction.run(registry, { + ...target, + input: { ...actionReference, action: "merge" }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).state).toBe("open"); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(acting); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail)))).toMatchObject({ + state: "open", + autoMergeEnabled: true, + }); + }), + ), +); + +it.effect.each(["accepted", "refused"] as const)( + "shows a title edit at once and keeps it only when the host takes it (%s)", + (outcome) => + Effect.scoped( + Effect.gen(function* () { + let title = "Original"; + let reads = 0; + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const read = () => + Effect.sync(() => { + reads++; + return { ...actionReference, state: "open", title, observedAt: reads }; + }); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: read, + [WS_METHODS.pullRequestsPreview]: read, + [WS_METHODS.pullRequestsList]: () => + Effect.sync(() => { + reads++; + return listResult([ + { ...actionReference, state: "open", title, updatedAt: actionReply.updatedAt }, + ]); + }), + [WS_METHODS.pullRequestsUpdate]: (input: { readonly title: string }) => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + if (outcome === "refused") return yield* new MutationRefused(); + title = input.title; + }), + }); + let held: ReadonlyArray = []; + let observedTitle = "Original"; + const handlers = { + detail: (_target: unknown, detail: { readonly title: string }) => + Effect.sync(() => { + observedTitle = detail.title; + }), + acceptedEdit: ( + _target: unknown, + edit: Parameters[2][number], + ) => + Effect.sync(() => { + observedTitle = edit.title ?? observedTitle; + held = editHeldPullRequestListEntries({ state: "open" }, held, () => [edit]); + }), + }; + const { atoms, registry } = yield* makeTestRuntime(client, undefined, false, handlers); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const detail = atoms.detail(target); + const preview = atoms.preview(target); + const list = atoms.list({ environmentId: target.environmentId, input: { state: "open" } }); + const loaded: ReadonlyArray>> = [ + detail, + preview, + list, + ]; + for (const atom of loaded) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } + held = Option.getOrThrow( + AsyncResult.value(registry.get(pullRequestHostAnswer(list))), + ).entries; + const retained = heldPullRequestListEntriesAtom( + target.environmentId, + { state: "open" }, + held, + ); + registry.mount(retained); + const titles = () => [ + Option.getOrThrow(AsyncResult.value(registry.get(detail))).title, + Option.getOrThrow(AsyncResult.value(registry.get(preview))).title, + Option.getOrThrow(AsyncResult.value(registry.get(list))).entries[0]?.title, + applyPullRequestSummaryEdits( + actionReference, + { + ...actionReply, + provider: SourceControlProviderKind.make("github"), + title: observedTitle, + }, + registry.get(pullRequestPendingEditsAtom(target.environmentId)), + )?.title, + ]; + + const editing = yield* Effect.promise(() => + atoms.update.run(registry, { ...target, input: { ...actionReference, title: "Edited" } }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(titles()).toEqual(["Edited", "Edited", "Edited", "Edited"]); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(editing); + + expect(titles()).toEqual( + outcome === "refused" + ? ["Original", "Original", "Original", "Original"] + : ["Edited", "Edited", "Edited", "Edited"], + ); + expect(observedTitle).toBe(outcome === "refused" ? "Original" : "Edited"); + expect(held[0]?.title).toBe(outcome === "refused" ? "Original" : "Edited"); + expect(Option.getOrThrow(AsyncResult.value(registry.get(retained)))[0]?.title).toBe( + outcome === "refused" ? "Original" : "Edited", + ); + // The edit is known, so no reader asks the host again. + expect(reads).toBe(3); + }), + ), +); + +it.effect.each(["accepted", "refused"] as const)( + "keeps a label change on retained rows only when the host takes it (%s)", + (outcome) => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + const existing = { name: "existing", color: "111111" }; + const added = { name: "new", color: "abcdef" }; + const client = actionReplyClient({ + [WS_METHODS.pullRequestsDetail]: () => + Effect.succeed({ ...actionReference, state: "open", labels: [existing] }), + [WS_METHODS.pullRequestsLabelCandidates]: () => + Effect.succeed({ + candidates: [ + { ...existing, description: null, isApplied: true }, + { ...added, description: null, isApplied: false }, + ], + truncated: false, + }), + [WS_METHODS.pullRequestsSetLabels]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + if (outcome === "refused") return yield* new MutationRefused(); + }), + }); + let held: ReadonlyArray = [ + { ...actionListEntry, labels: [existing] }, + ]; + const { atoms, registry } = yield* makeTestRuntime(client, undefined, false, { + acceptedEdit: (_target, edit) => + Effect.sync(() => { + held = editHeldPullRequestListEntries({ state: "open" }, held, () => [edit]); + }), + }); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const retained = heldPullRequestListEntriesAtom( + target.environmentId, + { state: "open" }, + held, + ); + registry.mount(retained); + const detail = atoms.detail(target); + const candidates = atoms.labelCandidates(target); + const loaded: ReadonlyArray>> = [ + detail, + candidates, + ]; + for (const atom of loaded) { + registry.mount(atom); + yield* Effect.promise(() => executeAtomQuery(registry, atom)); + } + + const labelling = yield* Effect.promise(() => + atoms.setLabels.run(registry, { + ...target, + input: { ...actionReference, labels: ["new"], applied: true }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).labels).toEqual([ + existing, + added, + ]); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(candidates))).candidates.map( + (candidate) => candidate.isApplied, + ), + ).toEqual([true, true]); + yield* Deferred.succeed(release, undefined); + expect((yield* Fiber.join(labelling))._tag).toBe( + outcome === "refused" ? "Failure" : "Success", + ); + expect(held[0]?.labels).toEqual(outcome === "refused" ? [existing] : [existing, added]); + expect(Option.getOrThrow(AsyncResult.value(registry.get(retained)))[0]?.labels).toEqual( + outcome === "refused" ? [existing] : [existing, added], + ); + + expect(Option.getOrThrow(AsyncResult.value(registry.get(detail))).labels).toEqual( + outcome === "refused" ? [existing] : [existing, added], + ); + expect( + Option.getOrThrow(AsyncResult.value(registry.get(candidates))).candidates.map( + (candidate) => candidate.isApplied, + ), + ).toEqual(outcome === "refused" ? [true, false] : [true, true]); + }), + ), +); + +it.effect.each(["loaded", "loading"] as const)( + "keeps an accepted label change when a candidates read sent before it answers late (%s)", + (shown) => + Effect.scoped( + Effect.gen(function* () { + let applied = false; + let reads = 0; + const readStarted = yield* Deferred.make(); + const releaseRead = yield* Deferred.make(); + const client = actionReplyClient({ + [WS_METHODS.pullRequestsLabelCandidates]: () => + Effect.gen(function* () { + reads++; + const answer = { + candidates: [{ name: "new", color: null, description: null, isApplied: applied }], + truncated: false, + }; + if (reads === (shown === "loaded" ? 2 : 1)) { + yield* Deferred.succeed(readStarted, undefined); + yield* Deferred.await(releaseRead); + } + return answer; + }), + [WS_METHODS.pullRequestsSetLabels]: () => + Effect.sync(() => { + applied = true; + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const candidates = atoms.labelCandidates(target); + registry.mount(candidates); + if (shown === "loaded") { + yield* Effect.promise(() => executeAtomQuery(registry, candidates)); + registry.refresh(candidates); + } + yield* Deferred.await(readStarted); + + yield* Effect.promise(() => + atoms.setLabels.run(registry, { + ...target, + input: { ...actionReference, labels: ["new"], applied: true }, + }), + ); + yield* Deferred.succeed(releaseRead, undefined); + + expect( + (yield* AtomRegistry.getResult(registry, candidates, { suspendOnWaiting: true })) + .candidates[0]?.isApplied, + ).toBe(true); + }), + ), +); + +it.effect.each(["accepted", "refused"] as const)( + "shows a close in the checks read the panel takes its state from (%s)", + (outcome) => + Effect.scoped( + Effect.gen(function* () { + const sent = yield* Deferred.make(); + const release = yield* Deferred.make(); + let reads = 0; + const client = actionReplyClient({ + [WS_METHODS.pullRequestsChecks]: () => + reads++ === 0 + ? Effect.succeed({ state: "open", checks: [], observedAt: 100 }) + : Effect.never, + [WS_METHODS.pullRequestsRunAction]: () => + Effect.gen(function* () { + yield* Deferred.succeed(sent, undefined); + yield* Deferred.await(release); + if (outcome === "accepted") return { ...actionReply, state: "closed" as const }; + return yield* new PullRequestOperationError({ + operation: "runAction", + detail: "You cannot close this pull request.", + }); + }), + }); + const { atoms, registry } = yield* makeTestRuntime(client); + const target = { environmentId: TARGET.environmentId, input: actionReference }; + const checks = atoms.checks(target); + registry.mount(checks); + yield* Effect.promise(() => executeAtomQuery(registry, checks)); + const state = () => Option.getOrThrow(AsyncResult.value(registry.get(checks)))?.state; + + const acting = yield* Effect.promise(() => + atoms.runAction.run(registry, { + ...target, + input: { ...actionReference, action: "close" }, + }), + ).pipe(Effect.forkScoped); + yield* Deferred.await(sent); + expect(state()).toBe("closed"); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(acting); + // An accepted close stays while the next checks read is still out. + expect(state()).toBe(outcome === "accepted" ? "closed" : "open"); + }), + ), +); diff --git a/packages/client-runtime/src/state/pullRequests.ts b/packages/client-runtime/src/state/pullRequests.ts index e930bd2c17b36..623ced4fc4f5b 100644 --- a/packages/client-runtime/src/state/pullRequests.ts +++ b/packages/client-runtime/src/state/pullRequests.ts @@ -16,11 +16,15 @@ import { type PullRequestListInput, type PullRequestListStatsInput, type PullRequestListStatsResult, + type PullRequestUpdateInput, type PullRequestDetail, type PullRequestDiffInput, type PullRequestListEntry, type PullRequestRef, type PullRequestMergeMethod, + type PullRequestLabel, + type PullRequestLabelCandidateList, + type PullRequestState, PullRequestOperationError, PullRequestSummary, type VcsStatusResult, @@ -34,6 +38,7 @@ import * as SubscriptionRef from "effect/SubscriptionRef"; import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity"; import { + type AtomCommand, createAtomCommandScheduler, createEnvironmentRpcCommand, createEnvironmentRpcQueryAtomFamily, @@ -120,10 +125,11 @@ function writableQueryFamily( /** Restart pre-mutation reads before patching so they cannot restore stale values. */ function updateCached( registry: AtomRegistry.AtomRegistry, - atom: Atom.Writable>, + shown: Atom.Writable>, update: (value: A) => A, refresh = false, ) { + const atom = (uneditedReaders.get(shown) ?? shown) as typeof shown; if (refresh || registry.get(atom).waiting) registry.refresh(atom); registry.update(atom, AsyncResult.map(update)); } @@ -143,6 +149,253 @@ interface ActionReplyPatch { // Module-wide so readers built by separate factories, such as linked summaries, are patched too. const actionReplyPatches = new WeakMap(); +/** What a write in flight will change, shown by every reader until the host answers. */ +export interface PullRequestPendingEdit { + readonly reference: PullRequestRef; + readonly state?: PullRequestState; + readonly isDraft?: boolean; + readonly autoMergeEnabled?: boolean; + readonly title?: string; + readonly body?: string; + readonly labels?: { + readonly applied: boolean; + readonly labels: ReadonlyArray; + }; +} + +type EditedField = "state" | "isDraft" | "autoMergeEnabled" | "title" | "body"; + +interface EditableReader { + readonly environmentId: EnvironmentId; + readonly concerns: (reference: PullRequestRef) => boolean; + readonly edit: ( + value: never, + edits: ReadonlyArray, + pending?: ReadonlyArray, + ) => unknown; +} + +// Module-wide like the reply patches, so separately built readers see the same writes. +export const pullRequestPendingEditsAtom = Atom.family((_environmentId: EnvironmentId | null) => + Atom.make>([]).pipe(Atom.keepAlive), +); +const editableReaders = new WeakMap(); +const editedReaders = new WeakMap(); +const uneditedReaders = new WeakMap(); + +const pendingEditsByPullRequest = Atom.family((key: string) => { + const [environmentId, reference] = JSON.parse(key) as [EnvironmentId, PullRequestRef]; + return Atom.make((get) => + get(pullRequestPendingEditsAtom(environmentId)).filter((edit) => + samePullRequest(reference, edit.reference), + ), + ).pipe( + Atom.withEquality( + (previous: ReadonlyArray, next) => + previous.length === next.length && previous.every((edit, index) => edit === next[index]), + ), + ); +}); +const noPendingEdits = Atom.make>([]); + +export function pullRequestPendingEditsFor( + environmentId: EnvironmentId | null, + reference: PullRequestRef | null, +): Atom.Atom> { + return environmentId === null || reference === null + ? noPendingEdits + : pendingEditsByPullRequest(JSON.stringify([environmentId, pullRequestReference(reference)])); +} + +export function pullRequestHostAnswer(reader: Atom.Atom): Atom.Atom { + return (uneditedReaders.get(reader) ?? reader) as Atom.Atom; +} + +function loadedValue(registry: AtomRegistry.AtomRegistry, atom: Atom.Atom) { + return Option.flatMap(registry.getNodes().get(atom)?.valueOption() ?? Option.none(), (result) => + AsyncResult.value(result as AsyncResult.AsyncResult), + ); +} + +function withEdit( + value: T, + edit: PullRequestPendingEdit, + fields: ReadonlyArray, +): T { + const held = value as Record; + const changed = fields.filter( + (field) => edit[field] !== undefined && held[field] !== edit[field], + ); + let next = + changed.length === 0 + ? held + : { ...held, ...Object.fromEntries(changed.map((field) => [field, edit[field]])) }; + if (edit.autoMergeEnabled === false && next.autoMergeMethod !== undefined) { + const { autoMergeMethod: _disarmed, ...withoutAutoMerge } = next; + next = withoutAutoMerge; + } + return next as T; +} + +function withLabelEdit }>( + value: T, + edit: PullRequestPendingEdit, +): T { + if (edit.labels === undefined) return value; + const { applied, labels: changed } = edit.labels; + const names = new Set(changed.map((label) => label.name)); + const labels = applied + ? [ + ...value.labels, + ...changed.filter((label) => !value.labels.some((held) => held.name === label.name)), + ] + : value.labels.filter((label) => !names.has(label.name)); + return labels.length === value.labels.length ? value : { ...value, labels }; +} + +function withLabelCandidateEdit( + value: PullRequestLabelCandidateList, + edit: PullRequestPendingEdit, +): PullRequestLabelCandidateList { + if (edit.labels === undefined) return value; + const { applied, labels } = edit.labels; + let changed = false; + const candidates = value.candidates.map((candidate) => { + if (candidate.isApplied === applied || !labels.some((label) => label.name === candidate.name)) + return candidate; + changed = true; + return { ...candidate, isApplied: applied }; + }); + return changed ? { ...value, candidates } : value; +} + +/** + * The reader with every write in flight for its pull request applied. Writes go to the reader + * underneath, so a refused edit never stays behind in what the host said. + */ +function editedQuery( + inner: Atom.Writable>, + reader: Omit & { + readonly edit: ( + value: A, + edits: ReadonlyArray, + pending?: ReadonlyArray, + ) => A; + }, + idleTtlMs = 5 * 60_000, +): Atom.Writable> { + const existing = editedReaders.get(inner); + if (existing !== undefined) return existing as Atom.Writable>; + const shown = Atom.writable( + (get) => { + const result = get(inner); + const edits = get(pullRequestPendingEditsAtom(reader.environmentId)).filter((edit) => + reader.concerns(edit.reference), + ); + const value = AsyncResult.value(result); + if (Option.isNone(value)) return result; + const next = reader.edit(value.value, edits); + return next === value.value ? result : AsyncResult.map(result, () => next); + }, + (context, value: AsyncResult.AsyncResult) => context.set(inner, value), + (refresh) => refresh(inner), + ).pipe(Atom.setIdleTTL(idleTtlMs)); + editableReaders.set(inner, reader as EditableReader); + editedReaders.set(inner, shown); + uneditedReaders.set(shown, inner); + return shown; +} + +/** Shows the command's edit from the click until it settles, queued behind others or not. */ +function showWhileInFlight( + command: C & AtomCommand, + editOf: (registry: AtomRegistry.AtomRegistry, target: Target) => PullRequestPendingEdit | null, +): C { + return { + ...command, + run: async (registry, target) => { + const edit = editOf(registry, target); + if (edit === null) return command.run(registry, target); + const edits = pullRequestPendingEditsAtom(target.environmentId); + registry.update(edits, (current) => [...current, edit]); + try { + return await command.run(registry, target); + } finally { + registry.update(edits, (current) => current.filter((entry) => entry !== edit)); + } + }, + } satisfies AtomCommand; +} + +/** Keeps an accepted edit in loaded readers once it stops being in flight. */ +function settleEdit( + registry: AtomRegistry.AtomRegistry, + environmentId: EnvironmentId, + edit: PullRequestPendingEdit | null, + readsAfterWrite = false, +) { + if (edit === null) return; + const pending = registry.get(pullRequestPendingEditsAtom(environmentId)); + for (const atom of registry.getNodes().keys()) { + const reader = typeof atom === "string" ? undefined : editableReaders.get(atom); + if (reader?.environmentId !== environmentId || !reader.concerns(edit.reference)) continue; + const shown = loadedValue(registry, atom as Atom.Atom); + const writable = atom as Atom.Writable>; + const unchanged = + Option.isSome(shown) && reader.edit(shown.value, [edit], pending) === shown.value; + if (unchanged) continue; + // A read still waiting may predate the write, unless the caller started it after the commit. + if (!readsAfterWrite && registry.get(writable).waiting) registry.refresh(writable); + if (Option.isNone(shown)) continue; + registry.update( + writable, + AsyncResult.map((value) => reader.edit(value, [edit], pending) as never), + ); + } +} + +function pullRequestReference(input: PullRequestRef): PullRequestRef { + const { projectId, host, repository, number, expectedAccountId } = input; + return { + projectId, + ...(host === undefined ? {} : { host }), + repository, + number, + ...(expectedAccountId === undefined ? {} : { expectedAccountId }), + }; +} + +/** What an action changes, left out where only the host knows, as when a queue takes a merge. */ +function actionEdit(input: PullRequestActionInput): PullRequestPendingEdit | null { + if (input.stackNumber !== undefined) return null; + const reference = pullRequestReference(input); + switch (input.action) { + case "close": + return { reference, state: "closed" }; + case "reopen": + return { reference, state: "open" }; + case "ready": + return { reference, isDraft: false }; + case "draft": + return { reference, isDraft: true }; + case "enable-auto-merge": + return { reference, autoMergeEnabled: true }; + case "disable-auto-merge": + return { reference, autoMergeEnabled: false }; + default: + return null; + } +} + +function updateEdit(input: PullRequestUpdateInput): PullRequestPendingEdit | null { + if (input.title === undefined && input.body === undefined) return null; + return { + reference: pullRequestReference(input), + ...(input.title === undefined ? {} : { title: input.title }), + ...(input.body === undefined ? {} : { body: input.body }), + }; +} + function samePullRequest(reader: PullRequestRef, acted: PullRequestRef) { return ( reader.projectId === acted.projectId && @@ -154,6 +407,21 @@ function samePullRequest(reader: PullRequestRef, acted: PullRequestRef) { ); } +export function applyPullRequestSummaryEdits( + reference: PullRequestRef | null, + summary: PullRequestSummary | null, + edits: ReadonlyArray, +): PullRequestSummary | null { + if (reference === null || summary === null) return summary; + return edits.reduce( + (current, edit) => + samePullRequest(reference, edit.reference) + ? withEdit(current, edit, ["state", "isDraft", "autoMergeEnabled", "title"]) + : current, + summary, + ); +} + function pickDefined( source: T, keys: ReadonlyArray, @@ -172,6 +440,22 @@ function listAccepts(input: PullRequestListInput, state: string, isDraft: boolea ); } +function listKeeps( + input: PullRequestListInput, + entry: PullRequestListEntry, + pending: ReadonlyArray, +) { + if (listAccepts(input, entry.state, entry.isDraft)) return true; + const edited = pending.reduce( + (current, edit) => + samePullRequest(entry, edit.reference) + ? withEdit(current, edit, ["state", "isDraft"]) + : current, + entry, + ); + return edited !== entry && listAccepts(input, edited.state, edited.isDraft); +} + /** * Listing rows with an action's reply applied, the same array when it changes none, and `refresh` * when the reply adds the pull request to a listing, which only a read can place. @@ -181,6 +465,7 @@ export function patchPullRequestListEntries( entries: ReadonlyArray, reference: PullRequestRef, reply: PullRequestSummary, + pending: ReadonlyArray = [], ): ReadonlyArray | "refresh" { let found = false; let changed = false; @@ -203,7 +488,7 @@ export function patchPullRequestListEntries( "updatedAt", ]), }; - return listAccepts(input, next.state, next.isDraft) ? [next] : []; + return listKeeps(input, next, pending) ? [next] : []; }); if (!found) { return input.cursors === undefined && listAccepts(input, reply.state, reply.isDraft) @@ -215,13 +500,66 @@ export function patchPullRequestListEntries( : entries; } +function editPullRequestListEntries( + input: PullRequestListInput, + entries: ReadonlyArray, + edits: ReadonlyArray, + pending = edits, +): ReadonlyArray { + let changed = false; + const edited = entries.flatMap((entry): Entry[] => { + const next = edits.reduce( + (current, edit) => + samePullRequest(entry, edit.reference) + ? withLabelEdit(withEdit(current, edit, ["state", "isDraft", "title"]), edit) + : current, + entry, + ); + if (next === entry && listAccepts(input, next.state, next.isDraft)) return [entry]; + changed = true; + return listKeeps(input, next, pending) ? [next] : []; + }); + return changed ? edited : entries; +} + +export function editHeldPullRequestListEntries( + input: PullRequestListInput, + entries: ReadonlyArray, + editsOf: (entry: Entry) => ReadonlyArray, + pending?: ReadonlyArray, +): ReadonlyArray { + let changed = false; + const shown = entries.flatMap((entry) => { + const edits = editsOf(entry); + const next = editPullRequestListEntries(input, [entry], edits, pending); + if (next[0] !== entry) changed = true; + return next; + }); + return changed ? shown : entries; +} + +export function heldPullRequestListEntriesAtom( + environmentId: EnvironmentId, + input: PullRequestListInput, + entries: ReadonlyArray, +) { + return actionPatchedQuery(() => Atom.make(AsyncResult.success(entries)), { + label: "pull-requests:held-list-entries", + concerns: (_input: PullRequestListInput, reference) => + entries.some((entry) => samePullRequest(entry, reference)), + edit: editPullRequestListEntries, + patch: patchPullRequestListEntries, + })({ environmentId, input }); +} + function patchListWithReply( input: PullRequestListInput, value: PullRequestListResult, reference: PullRequestRef, reply: PullRequestSummary, + pending: ReadonlyArray, ): PullRequestListResult | "refresh" { - const entries = patchPullRequestListEntries(input, value.entries, reference, reply); + const entries = patchPullRequestListEntries(input, value.entries, reference, reply, pending); if (entries === "refresh") return entries; return entries === value.entries ? value : { ...value, entries }; } @@ -246,6 +584,7 @@ function actionPatchedQuery( value: A, reference: PullRequestRef, reply: PullRequestSummary, + pending: ReadonlyArray, ) => A | "refresh"; /** Fields the reply lacks also changed, so the patched value shows while a read fetches them. */ readonly rereads?: (value: A, reply: PullRequestSummary) => boolean; @@ -253,6 +592,13 @@ function actionPatchedQuery( readonly rereadWithoutReply?: boolean; /** False for reads the refresh stream does not restart; defaults to true. */ readonly refreshedByServer?: (input: Input) => boolean; + /** Shows a write in flight; absent where the reader holds nothing such a write changes. */ + readonly edit?: ( + input: Input, + value: A, + edits: ReadonlyArray, + pending?: ReadonlyArray, + ) => A; }, ) { const writable = Atom.family((atom: Atom.Atom>) => @@ -261,7 +607,20 @@ function actionPatchedQuery( return (target: { readonly environmentId: EnvironmentId; readonly input: Input }) => { const query = source(target); const atom = writable(query); - if (actionReplyPatches.has(atom)) return atom; + const edit = options.edit; + const reader = + edit === undefined + ? atom + : editedQuery( + atom, + { + environmentId: target.environmentId, + concerns: (reference) => options.concerns(target.input, reference), + edit: (value, edits, pending) => edit(target.input, value, edits, pending), + }, + options.idleTtlMs, + ); + if (actionReplyPatches.has(atom)) return reader; const pendingRead = (registry: AtomRegistry.AtomRegistry) => { const result = Option.getOrUndefined( registry.getNodes().get(query)?.valueOption() ?? Option.none(), @@ -290,14 +649,22 @@ function actionPatchedQuery( (current: AsyncResult.AsyncResult) => AsyncResult.value(current), ); if (Option.isNone(shown)) return reread(); - const patched = options.patch(target.input, shown.value, reference, reply); + const patched = options.patch( + target.input, + shown.value, + reference, + reply, + registry.get(pullRequestPendingEditsAtom(environmentId)), + ); if (patched === "refresh") return reread(); const lacking = options.rereads?.(shown.value, reply) === true; const next = reuseUnchanged(shown.value, patched); if (next === shown.value) return lacking || (unrefreshed && pending !== undefined) ? reread() : undefined; yield* options.onAnswer?.(target, next, registry) ?? Effect.void; - const mounted = (registry.getNodes().get(atom)?.listeners.size ?? 0) > 0; + const mounted = [atom, reader].some( + (shownBy) => (registry.getNodes().get(shownBy)?.listeners.size ?? 0) > 0, + ); if (!freshRead && (pending !== undefined || lacking || (unrefreshed && mounted))) registry.refresh(atom); registry.update( @@ -314,7 +681,7 @@ function actionPatchedQuery( }, ), }); - return atom; + return reader; }; } @@ -381,6 +748,12 @@ export function createLinkedPullRequestSummaryAtomFamily( number: value.number, ...(value.observedAt === undefined ? {} : { observedAt: value.observedAt }), }, + edit: (_input, value, edits) => + edits.reduce( + (current, edit) => + withEdit(current, edit, ["state", "isDraft", "autoMergeEnabled", "title"]), + value, + ), }, ); } @@ -395,6 +768,7 @@ export interface PullRequestAnswerHandlers { readonly reviewGuide?: QueryAnswerHandler; /** Once per action reply, after the loaded readers show it; unscoped references only. */ readonly actionReply?: QueryAnswerHandler; + readonly acceptedEdit?: QueryAnswerHandler; } export function createPullRequestStackAtomFamily( @@ -536,6 +910,15 @@ export function createPullRequestEnvironmentAtoms( const { autoMergeMethod: _disarmed, ...withoutAutoMerge } = patched; return withoutAutoMerge; }, + edit: (_input, value, edits) => + edits.reduce( + (current, edit) => + withLabelEdit( + withEdit(current, edit, ["state", "isDraft", "autoMergeEnabled", "title", "body"]), + edit, + ), + value, + ), }, ), ); @@ -598,6 +981,11 @@ export function createPullRequestEnvironmentAtoms( "observedAt", ]), }, + edit: (_input, value, edits) => + edits.reduce( + (current, edit) => withEdit(current, edit, ["state", "isDraft", "title"]), + value, + ), }, ), ); @@ -605,7 +993,7 @@ export function createPullRequestEnvironmentAtoms( // Hover cards read their own atoms, so a pending or failed hover read never decides where a // click on the same link goes. const previewCard = previewQuery("environment-data:pull-requests:preview-card"); - const labelCandidates = writableQueryFamily( + const labelCandidateQueries = writableQueryFamily( createEnvironmentRpcQueryAtomFamily(runtime, { label: "environment-data:pull-requests:label-candidates", tag: WS_METHODS.pullRequestsLabelCandidates, @@ -613,6 +1001,37 @@ export function createPullRequestEnvironmentAtoms( staleTimeMs: 60_000, }), ); + const labelCandidates = normalizePullRequestQuery((target) => + editedQuery(labelCandidateQueries(target), { + environmentId: target.environmentId, + concerns: (reference) => samePullRequest(target.input, reference), + edit: (value, edits) => edits.reduce(withLabelCandidateEdit, value), + }), + ); + const labelEdit = ( + registry: AtomRegistry.AtomRegistry, + target: { + readonly environmentId: EnvironmentId; + readonly input: PullRequestRef & { + readonly labels: ReadonlyArray; + readonly applied: boolean; + }; + }, + ): PullRequestPendingEdit => { + const candidates = Option.getOrUndefined( + loadedValue(registry, labelCandidates(target)), + )?.candidates; + return { + reference: pullRequestReference(target.input), + labels: { + applied: target.input.applied, + labels: target.input.labels.map((name) => ({ + name, + color: candidates?.find((candidate) => candidate.name === name)?.color ?? null, + })), + }, + }; + }; const reviewGuide = writableQueryFamily( createEnvironmentRpcQueryAtomFamily(runtime, { label: "environment-data:pull-requests:review-guide", @@ -720,6 +1139,52 @@ export function createPullRequestEnvironmentAtoms( ); } }); + const checksLabel = "environment-data:pull-requests:checks"; + const checksPersistence = persistQuery(Schema.NullOr(PullRequestChecks)); + // Panels take the state from the newest of detail and checks, so checks show writes too. + const checks = normalizePullRequestQuery( + actionPatchedQuery( + createEnvironmentRpcQueryAtomFamily(runtime, { + label: checksLabel, + persistence: checksPersistence, + tag: WS_METHODS.pullRequestsChecks, + execute: (input) => routedRequest(WS_METHODS.pullRequestsChecks, input), + staleTimeMs: 45_000, + refreshTrigger: ({ environmentId }) => refreshes({ environmentId, input: {} }), + ...(onAnswer.checks === undefined ? {} : { onAnswer: onAnswer.checks }), + }), + { + label: checksLabel, + persistence: checksPersistence, + onAnswer: onAnswer.checks, + concerns: samePullRequest, + patch: (_input, value, _reference, reply) => + value === null || value.state === reply.state || isStalePullRequestReply(value, reply) + ? value + : { ...value, state: reply.state }, + edit: (_input, value, edits) => { + const state = edits.findLast((edit) => edit.state !== undefined)?.state; + return value === null || state === undefined || value.state === state + ? value + : { ...value, state }; + }, + }, + ), + ); + const acceptEdit = ( + registry: AtomRegistry.AtomRegistry, + environmentId: EnvironmentId, + edit: PullRequestPendingEdit | null, + readsAfterWrite = false, + ) => + Effect.sync(() => settleEdit(registry, environmentId, edit, readsAfterWrite)).pipe( + Effect.andThen(() => + edit === null + ? Effect.void + : (onAnswer.acceptedEdit?.({ environmentId, input: edit.reference }, edit, registry) ?? + Effect.void), + ), + ); const listLabel = "environment-data:pull-requests:list"; const listPersistence = persistQuery(PullRequestListResult); @@ -764,6 +1229,10 @@ export function createPullRequestEnvironmentAtoms( input.host.toLowerCase() === reference.host.toLowerCase()), refreshedByServer: (input) => input.cursors === undefined, patch: patchListWithReply, + edit: (input, value, edits, pending) => { + const entries = editPullRequestListEntries(input, value.entries, edits, pending); + return entries === value.entries ? value : { ...value, entries }; + }, }, ), /** @@ -788,17 +1257,7 @@ export function createPullRequestEnvironmentAtoms( detailReadVersion, preview, previewCard, - checks: normalizePullRequestQuery( - createEnvironmentRpcQueryAtomFamily(runtime, { - label: "environment-data:pull-requests:checks", - persistence: persistQuery(Schema.NullOr(PullRequestChecks)), - tag: WS_METHODS.pullRequestsChecks, - execute: (input) => routedRequest(WS_METHODS.pullRequestsChecks, input), - staleTimeMs: 45_000, - refreshTrigger: ({ environmentId }) => refreshes({ environmentId, input: {} }), - ...(onAnswer.checks === undefined ? {} : { onAnswer: onAnswer.checks }), - }), - ), + checks, activity, threadComments: createEnvironmentRpcCommand(runtime, { label: "environment-data:pull-requests:thread-comments", @@ -869,41 +1328,47 @@ export function createPullRequestEnvironmentAtoms( JSON.stringify([environmentId, input.projectId, input.repository, input.number]), }, }), - runAction: createEnvironmentRpcCommand(runtime, { - tag: WS_METHODS.pullRequestsRunAction, - label: "environment-data:pull-requests:run-action", - // Preparation belongs to the write's lane. Refreshable queries would restart it after - // every preceding action, and preparing outside the lane could reorder the clicks. - execute: runAction, - onStart: (_target, registry) => readsInFlight(registry), - // Loaded readers show the reply, or re-read when the host's reply lacked the pull request. - onSuccess: ({ environmentId, input }, registry, reply, readsBeforeSend) => { - const { projectId, host, repository, number, expectedAccountId } = input; - return applyActionReply( - registry, - environmentId, - { - projectId, - ...(host === undefined ? {} : { host }), - repository, - number, - ...(expectedAccountId === undefined ? {} : { expectedAccountId }), - }, - reply, - readsBeforeSend ?? new Set(), - ); - }, - scheduler: commandScheduler, - concurrency: serialPerEnvironment, - }), - update: createEnvironmentRpcCommand(runtime, { - label: "environment-data:pull-requests:update", - tag: WS_METHODS.pullRequestsUpdate, - execute: (input) => routedRequest(WS_METHODS.pullRequestsUpdate, input), - onSuccess: (target, registry) => Effect.sync(() => registry.refresh(preview(target))), - scheduler: commandScheduler, - concurrency: serialPerEnvironment, - }), + runAction: showWhileInFlight( + createEnvironmentRpcCommand(runtime, { + tag: WS_METHODS.pullRequestsRunAction, + label: "environment-data:pull-requests:run-action", + // Preparation belongs to the write's lane. Refreshable queries would restart it after + // every preceding action, and preparing outside the lane could reorder the clicks. + execute: runAction, + onStart: (_target, registry) => readsInFlight(registry), + // Loaded readers show the reply, or re-read when the host's reply lacked the pull request. + onSuccess: ({ environmentId, input }, registry, reply, readsBeforeSend) => + applyActionReply( + registry, + environmentId, + pullRequestReference(input), + reply, + readsBeforeSend ?? new Set(), + ).pipe( + // The re-read a bare reply starts would otherwise show the old state until it answers. + Effect.andThen( + reply === undefined + ? acceptEdit(registry, environmentId, actionEdit(input), true) + : Effect.void, + ), + ), + scheduler: commandScheduler, + concurrency: serialPerEnvironment, + }), + (_registry, { input }) => actionEdit(input), + ), + update: showWhileInFlight( + createEnvironmentRpcCommand(runtime, { + label: "environment-data:pull-requests:update", + tag: WS_METHODS.pullRequestsUpdate, + execute: (input) => routedRequest(WS_METHODS.pullRequestsUpdate, input), + onSuccess: (target, registry) => + acceptEdit(registry, target.environmentId, updateEdit(target.input)), + scheduler: commandScheduler, + concurrency: serialPerEnvironment, + }), + (_registry, { input }) => updateEdit(input), + ), comment: createEnvironmentRpcCommand(runtime, { label: "environment-data:pull-requests:comment", tag: WS_METHODS.pullRequestsComment, @@ -1039,44 +1504,18 @@ export function createPullRequestEnvironmentAtoms( }), }), labelCandidates, - setLabels: createEnvironmentRpcCommand(runtime, { - label: "environment-data:pull-requests:set-labels", - tag: WS_METHODS.pullRequestsSetLabels, - execute: (input) => routedRequest(WS_METHODS.pullRequestsSetLabels, input), - scheduler: commandScheduler, - concurrency: serialPerEnvironment, - onSuccess: (target, registry) => - Effect.sync(() => { - const { labels, applied } = target.input; - const candidatesAtom = labelCandidates(target); - const candidates = AsyncResult.getOrElse(registry.get(candidatesAtom), () => null); - const names = new Set(labels); - updateCached(registry, candidatesAtom, (value) => ({ - ...value, - candidates: value.candidates.map((candidate) => - names.has(candidate.name) ? { ...candidate, isApplied: applied } : candidate, - ), - })); - for (const atom of loadedDetails(registry, target)) { - updateCached(registry, atom, (value) => ({ - ...value, - labels: applied - ? [ - ...value.labels, - ...labels - .filter((name) => !value.labels.some((label) => label.name === name)) - .map((name) => ({ - name, - color: - candidates?.candidates.find((candidate) => candidate.name === name) - ?.color ?? null, - })), - ] - : value.labels.filter((label) => !names.has(label.name)), - })); - } - }), - }), + setLabels: showWhileInFlight( + createEnvironmentRpcCommand(runtime, { + label: "environment-data:pull-requests:set-labels", + tag: WS_METHODS.pullRequestsSetLabels, + execute: (input) => routedRequest(WS_METHODS.pullRequestsSetLabels, input), + scheduler: commandScheduler, + concurrency: serialPerEnvironment, + onSuccess: (target, registry) => + acceptEdit(registry, target.environmentId, labelEdit(registry, target)), + }), + labelEdit, + ), setThreadResolution: createEnvironmentRpcCommand(runtime, { label: "environment-data:pull-requests:set-thread-resolution", tag: WS_METHODS.pullRequestsSetThreadResolution,