feat(github): re-request dismissed reviews (#1921)
This commit is contained in:
@@ -1,7 +1,74 @@
|
||||
import { describe, it, expect } from "vitest";
|
||||
import { shouldHideApproveButton } from "./pr-detail-panel";
|
||||
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
|
||||
import { createElement, useEffect } from "react";
|
||||
import { TooltipProvider } from "@kandev/ui/tooltip";
|
||||
import { afterEach, describe, it, expect, vi } from "vitest";
|
||||
import {
|
||||
PRDetailContent,
|
||||
shouldHideApproveButton,
|
||||
shouldShowReRequestReviewAction,
|
||||
} from "./pr-detail-panel";
|
||||
import {
|
||||
clearPRReviewRequestRegistryForTests,
|
||||
usePRScopedReviewRequest,
|
||||
} from "./use-pr-scoped-review-request";
|
||||
import type { TaskPR, PRFeedback, GitHubPR, PRReview } from "@/lib/types/github";
|
||||
|
||||
const feedbackMocks = vi.hoisted(() => ({
|
||||
refresh: vi.fn(),
|
||||
value: null as PRFeedback | null,
|
||||
}));
|
||||
const reviewMocks = vi.hoisted(() => ({ requestReviewers: vi.fn(), submitReview: vi.fn() }));
|
||||
const RE_REQUEST_BUTTON = "pr-rerequest-review-octocat";
|
||||
const PENDING_REVIEWER = "pr-pending-reviewer-octocat";
|
||||
const DISMISSED_REVIEWED_AT = "2026-01-01T00:00:00Z";
|
||||
|
||||
vi.mock("@/hooks/domains/github/use-pr-feedback", () => ({
|
||||
usePRFeedback: () => ({
|
||||
feedback: feedbackMocks.value,
|
||||
loading: false,
|
||||
refresh: feedbackMocks.refresh,
|
||||
}),
|
||||
}));
|
||||
vi.mock("@/lib/api/domains/github-review-api", () => ({
|
||||
requestPRReviewers: reviewMocks.requestReviewers,
|
||||
submitPRReview: reviewMocks.submitReview,
|
||||
}));
|
||||
vi.mock("@/components/state-provider", () => ({
|
||||
useAppStore: (selector: (state: { setTaskPR: () => void }) => unknown) =>
|
||||
selector({ setTaskPR: vi.fn() }),
|
||||
}));
|
||||
vi.mock("@/lib/state/slices/comments", () => ({
|
||||
isPRFeedbackComment: () => false,
|
||||
useCommentsStore: (
|
||||
selector: (state: {
|
||||
addComment: () => void;
|
||||
pendingForChat: string[];
|
||||
byId: object;
|
||||
}) => unknown,
|
||||
) => selector({ addComment: vi.fn(), pendingForChat: [], byId: {} }),
|
||||
}));
|
||||
vi.mock("@/components/toast-provider", () => ({ useToast: () => ({ toast: vi.fn() }) }));
|
||||
vi.mock("@/hooks/domains/github/use-github-status", () => ({
|
||||
useGitHubStatus: () => ({ status: null }),
|
||||
}));
|
||||
vi.mock("./pr-merge-button", () => ({ PRMergeButton: () => null }));
|
||||
vi.mock("./pr-mergeability-notice", () => ({
|
||||
PRMergeabilityNotice: () => null,
|
||||
buildConflictResolutionMessage: () => "",
|
||||
}));
|
||||
vi.mock("./pr-checks-section", () => ({ ChecksSection: () => null }));
|
||||
vi.mock("./pr-comments-section", () => ({ CommentsSection: () => null }));
|
||||
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
cleanup();
|
||||
feedbackMocks.refresh.mockReset();
|
||||
feedbackMocks.value = null;
|
||||
reviewMocks.requestReviewers.mockReset();
|
||||
reviewMocks.submitReview.mockReset();
|
||||
clearPRReviewRequestRegistryForTests();
|
||||
});
|
||||
|
||||
function makeTaskPR(overrides: Partial<TaskPR> = {}): TaskPR {
|
||||
return {
|
||||
id: "id",
|
||||
@@ -70,11 +137,51 @@ function makeFeedback(
|
||||
};
|
||||
}
|
||||
|
||||
function ReviewRequestHarness({
|
||||
onReady,
|
||||
requestedReviewers = [],
|
||||
reviews = [],
|
||||
}: {
|
||||
onReady: (reviewRequest: ReturnType<typeof usePRScopedReviewRequest>) => void;
|
||||
requestedReviewers?: { login: string; type: "user" }[];
|
||||
reviews?: PRReview[];
|
||||
}) {
|
||||
const reviewRequest = usePRScopedReviewRequest(
|
||||
makeTaskPR(),
|
||||
requestedReviewers,
|
||||
reviews,
|
||||
vi.fn(),
|
||||
vi.fn(),
|
||||
);
|
||||
useEffect(() => onReady(reviewRequest), [onReady, reviewRequest]);
|
||||
return null;
|
||||
}
|
||||
|
||||
function dismissedReview(id = 1): PRReview {
|
||||
return {
|
||||
id,
|
||||
author: "octocat",
|
||||
author_avatar: "",
|
||||
state: "DISMISSED",
|
||||
body: "",
|
||||
created_at: DISMISSED_REVIEWED_AT,
|
||||
};
|
||||
}
|
||||
|
||||
function renderPRDetail() {
|
||||
return render(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
describe("shouldHideApproveButton", () => {
|
||||
it("hides when PR is closed", () => {
|
||||
expect(shouldHideApproveButton(makeTaskPR({ state: "closed" }), null, "bob")).toBe(true);
|
||||
});
|
||||
|
||||
it("hides when PR is merged", () => {
|
||||
expect(shouldHideApproveButton(makeTaskPR({ state: "merged" }), null, "bob")).toBe(true);
|
||||
});
|
||||
@@ -129,3 +236,395 @@ describe("shouldHideApproveButton", () => {
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("shouldShowReRequestReviewAction", () => {
|
||||
it("only permits dismissed reviews on an open PR", () => {
|
||||
expect(shouldShowReRequestReviewAction("open", "DISMISSED")).toBe(true);
|
||||
expect(shouldShowReRequestReviewAction("open", "APPROVED")).toBe(false);
|
||||
expect(shouldShowReRequestReviewAction("closed", "DISMISSED")).toBe(false);
|
||||
expect(shouldShowReRequestReviewAction("merged", "DISMISSED")).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent deferred re-request", () => {
|
||||
it("keeps a successfully re-requested reviewer pending when feedback refresh is deferred", async () => {
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
|
||||
render(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull();
|
||||
});
|
||||
expect(screen.queryByTestId(RE_REQUEST_BUTTON)).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent remount lifecycle", () => {
|
||||
it("keeps an in-flight request locked across a same-PR remount", () => {
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
reviewMocks.requestReviewers.mockReturnValue(new Promise(() => undefined));
|
||||
|
||||
const firstPanel = render(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
firstPanel.unmount();
|
||||
|
||||
render(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
|
||||
expect(reviewMocks.requestReviewers).toHaveBeenCalledOnce();
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent optimistic review reconciliation", () => {
|
||||
it("reclaims optimism when a newer submitted review bypasses requested-reviewer feedback", async () => {
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
|
||||
const view = renderPRDetail();
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
});
|
||||
feedbackMocks.value = makeFeedback({
|
||||
reviews: [
|
||||
{
|
||||
id: 2,
|
||||
author: "octocat",
|
||||
author_avatar: "",
|
||||
state: "APPROVED",
|
||||
body: "Looks good",
|
||||
created_at: "2026-01-02T00:00:00Z",
|
||||
},
|
||||
],
|
||||
});
|
||||
view.rerender(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
|
||||
await waitFor(() => {
|
||||
expect(screen.queryByTestId(PENDING_REVIEWER)).toBeNull();
|
||||
});
|
||||
expect(screen.getByTestId("pr-submitted-review-octocat")).not.toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent same-timestamp review reconciliation", () => {
|
||||
it("uses the review ID to resolve same-timestamp reviewer state", async () => {
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
const view = renderPRDetail();
|
||||
await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)));
|
||||
|
||||
feedbackMocks.value = makeFeedback({
|
||||
reviews: [
|
||||
dismissedReview(),
|
||||
{
|
||||
id: 2,
|
||||
author: "octocat",
|
||||
author_avatar: "",
|
||||
state: "APPROVED",
|
||||
body: "Looks good",
|
||||
created_at: DISMISSED_REVIEWED_AT,
|
||||
},
|
||||
],
|
||||
});
|
||||
view.rerender(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
|
||||
await waitFor(() => expect(screen.queryByTestId(PENDING_REVIEWER)).toBeNull());
|
||||
expect(screen.getByTestId("pr-submitted-review-octocat")).not.toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent confirmed review request", () => {
|
||||
it("reclaims confirmed pending state from the persistent registry", async () => {
|
||||
feedbackMocks.value = makeFeedback({
|
||||
reviews: [dismissedReview()],
|
||||
});
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
const view = render(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
});
|
||||
|
||||
feedbackMocks.value = makeFeedback({
|
||||
pr: { requested_reviewers: [{ login: "octocat", type: "user" }] },
|
||||
reviews: [
|
||||
{
|
||||
id: 1,
|
||||
author: "octocat",
|
||||
author_avatar: "",
|
||||
state: "DISMISSED",
|
||||
body: "",
|
||||
created_at: DISMISSED_REVIEWED_AT,
|
||||
},
|
||||
],
|
||||
});
|
||||
view.rerender(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull();
|
||||
});
|
||||
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
view.rerender(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId(RE_REQUEST_BUTTON)).not.toBeNull();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent same-tick re-request", () => {
|
||||
it("posts once when invoked twice before React has a chance to re-render", () => {
|
||||
reviewMocks.requestReviewers.mockReturnValue(new Promise(() => undefined));
|
||||
let reRequest: (reviewer: string) => Promise<void> = async () => undefined;
|
||||
|
||||
render(
|
||||
createElement(ReviewRequestHarness, {
|
||||
onReady: (request) => {
|
||||
reRequest = request.reRequest;
|
||||
},
|
||||
}),
|
||||
);
|
||||
act(() => {
|
||||
void reRequest("octocat");
|
||||
void reRequest("octocat");
|
||||
});
|
||||
|
||||
expect(reviewMocks.requestReviewers).toHaveBeenCalledOnce();
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent persistent request expiry", () => {
|
||||
it("keeps an unresolved request locked beyond the optimistic expiry window", () => {
|
||||
vi.useFakeTimers();
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
const deferred = new Promise(() => undefined);
|
||||
reviewMocks.requestReviewers.mockReturnValue(deferred);
|
||||
|
||||
const view = renderPRDetail();
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
act(() => vi.advanceTimersByTime(5 * 60 * 1000));
|
||||
view.rerender(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
|
||||
expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(true);
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it("expires successful optimism and updates the panel without a rerender", async () => {
|
||||
vi.useFakeTimers();
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
renderPRDetail();
|
||||
await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)));
|
||||
expect(vi.getTimerCount()).toBe(1);
|
||||
|
||||
act(() => vi.advanceTimersByTime(5 * 60 * 1000));
|
||||
|
||||
expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(false);
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it("clears the expiry timer when feedback confirms the request", async () => {
|
||||
vi.useFakeTimers();
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
const view = renderPRDetail();
|
||||
await act(async () => fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON)));
|
||||
expect(vi.getTimerCount()).toBe(1);
|
||||
|
||||
feedbackMocks.value = makeFeedback({
|
||||
pr: { requested_reviewers: [{ login: "octocat", type: "user" }] },
|
||||
});
|
||||
view.rerender(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
await act(async () => undefined);
|
||||
|
||||
expect(vi.getTimerCount()).toBe(0);
|
||||
vi.useRealTimers();
|
||||
});
|
||||
|
||||
it("reschedules to the next optimistic expiry after the first expires", async () => {
|
||||
vi.useFakeTimers();
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
let reviewRequest: ReturnType<typeof usePRScopedReviewRequest> | undefined;
|
||||
render(
|
||||
createElement(ReviewRequestHarness, {
|
||||
onReady: (value) => {
|
||||
reviewRequest = value;
|
||||
},
|
||||
}),
|
||||
);
|
||||
|
||||
await act(async () => reviewRequest?.reRequest("octocat"));
|
||||
act(() => vi.advanceTimersByTime(60 * 1000));
|
||||
await act(async () => reviewRequest?.reRequest("hubot"));
|
||||
act(() => vi.advanceTimersByTime(4 * 60 * 1000));
|
||||
|
||||
expect(reviewRequest?.requestedReviewers).toEqual([{ login: "hubot", type: "user" }]);
|
||||
vi.useRealTimers();
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent request operation ownership", () => {
|
||||
it("does not let an old completion change a newer request", async () => {
|
||||
let resolveFirst: () => void = () => undefined;
|
||||
const firstRequest = new Promise<void>((resolve) => {
|
||||
resolveFirst = resolve;
|
||||
});
|
||||
const secondRequest = new Promise(() => undefined);
|
||||
reviewMocks.requestReviewers
|
||||
.mockReturnValueOnce(firstRequest)
|
||||
.mockReturnValueOnce(secondRequest);
|
||||
let reviewRequest: ReturnType<typeof usePRScopedReviewRequest> | undefined;
|
||||
const onReady = (value: ReturnType<typeof usePRScopedReviewRequest>) => {
|
||||
reviewRequest = value;
|
||||
};
|
||||
const view = render(createElement(ReviewRequestHarness, { onReady }));
|
||||
|
||||
act(() => void reviewRequest?.reRequest("octocat"));
|
||||
view.rerender(
|
||||
createElement(ReviewRequestHarness, {
|
||||
onReady,
|
||||
requestedReviewers: [{ login: "octocat", type: "user" }],
|
||||
}),
|
||||
);
|
||||
view.rerender(createElement(ReviewRequestHarness, { onReady }));
|
||||
act(() => void reviewRequest?.reRequest("octocat"));
|
||||
await act(async () => resolveFirst());
|
||||
|
||||
expect(reviewRequest?.requestingReviewers).toEqual(["octocat"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent failed feedback refresh", () => {
|
||||
it("keeps the successful re-request optimistic", async () => {
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
feedbackMocks.refresh.mockImplementation(() => {
|
||||
throw new Error("Feedback refresh failed");
|
||||
});
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
|
||||
renderPRDetail();
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
});
|
||||
|
||||
expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent failed re-request", () => {
|
||||
it("clears failed writes so the dismissed reviewer can be retried", async () => {
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
reviewMocks.requestReviewers.mockRejectedValue(new Error("GitHub denied request"));
|
||||
|
||||
renderPRDetail();
|
||||
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
});
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId(RE_REQUEST_BUTTON).hasAttribute("disabled")).toBe(false);
|
||||
});
|
||||
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
});
|
||||
expect(reviewMocks.requestReviewers).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe("PRDetailContent PR identity changes", () => {
|
||||
it("does not retain optimistic reviewers after the repository PR identity changes", async () => {
|
||||
feedbackMocks.value = makeFeedback({ reviews: [dismissedReview()] });
|
||||
reviewMocks.requestReviewers.mockResolvedValue({ requested: true });
|
||||
|
||||
const view = render(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, { taskPR: makeTaskPR(), sessionId: "session-1" }),
|
||||
),
|
||||
);
|
||||
await act(async () => {
|
||||
fireEvent.click(screen.getByTestId(RE_REQUEST_BUTTON));
|
||||
});
|
||||
await waitFor(() => {
|
||||
expect(screen.getByTestId(PENDING_REVIEWER)).not.toBeNull();
|
||||
});
|
||||
|
||||
view.rerender(
|
||||
createElement(
|
||||
TooltipProvider,
|
||||
undefined,
|
||||
createElement(PRDetailContent, {
|
||||
taskPR: makeTaskPR({ pr_number: 2 }),
|
||||
sessionId: "session-1",
|
||||
}),
|
||||
),
|
||||
);
|
||||
|
||||
expect(screen.getByTestId(RE_REQUEST_BUTTON)).not.toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
@@ -23,7 +23,7 @@ import { useGitHubStatus } from "@/hooks/domains/github/use-github-status";
|
||||
import { useCommentsStore, isPRFeedbackComment } from "@/lib/state/slices/comments";
|
||||
import type { PRFeedbackComment } from "@/lib/state/slices/comments";
|
||||
import { useToast } from "@/components/toast-provider";
|
||||
import { submitPRReview } from "@/lib/api/domains/github-api";
|
||||
import { submitPRReview } from "@/lib/api/domains/github-review-api";
|
||||
import type { TaskPR, PRFeedback } from "@/lib/types/github";
|
||||
import {
|
||||
formatTimeAgo,
|
||||
@@ -38,6 +38,7 @@ import { ReviewStateBadge } from "./pr-reviews-section";
|
||||
import { ChecksSection } from "./pr-checks-section";
|
||||
import { ReviewsSection } from "./pr-reviews-section";
|
||||
import { CommentsSection } from "./pr-comments-section";
|
||||
import { usePRScopedReviewRequest } from "./use-pr-scoped-review-request";
|
||||
|
||||
// --- Dockview panel wrapper ---
|
||||
|
||||
@@ -215,8 +216,6 @@ function derivePanelMetrics(taskPR: TaskPR, feedback: PRFeedback | null): PRPane
|
||||
};
|
||||
}
|
||||
|
||||
// --- Main content ---
|
||||
|
||||
function DescriptionSection({ body }: { body: string }) {
|
||||
if (!body) return null;
|
||||
return (
|
||||
@@ -251,6 +250,10 @@ export function shouldHideApproveButton(
|
||||
);
|
||||
}
|
||||
|
||||
export function shouldShowReRequestReviewAction(prState: string, reviewState: string): boolean {
|
||||
return prState === "open" && reviewState === "DISMISSED";
|
||||
}
|
||||
|
||||
function ApproveButton({
|
||||
taskPR,
|
||||
feedback,
|
||||
@@ -305,6 +308,14 @@ function ApproveButton({
|
||||
export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; sessionId: string }) {
|
||||
const { feedback, loading, refresh } = usePRFeedback(taskPR.owner, taskPR.repo, taskPR.pr_number);
|
||||
const { addAsContext } = useAddPRFeedbackAsContext(sessionId, taskPR.pr_number);
|
||||
const { toast } = useToast();
|
||||
const reviewRequest = usePRScopedReviewRequest(
|
||||
taskPR,
|
||||
feedback?.pr.requested_reviewers ?? [],
|
||||
feedback?.reviews ?? [],
|
||||
refresh,
|
||||
toast,
|
||||
);
|
||||
|
||||
useSyncLivePRState(taskPR, feedback);
|
||||
|
||||
@@ -350,7 +361,7 @@ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; session
|
||||
/>
|
||||
<Separator />
|
||||
<ScrollArea className="flex-1 overflow-hidden">
|
||||
<div className="p-3 space-y-1">
|
||||
<div className="box-border w-0 min-w-full max-w-full overflow-x-hidden p-3 space-y-1">
|
||||
{loading && !feedback && (
|
||||
<div className="flex items-center justify-center py-8">
|
||||
<IconLoader2 className="h-6 w-6 text-blue-500 animate-spin" />
|
||||
@@ -361,11 +372,14 @@ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; session
|
||||
<DescriptionSection body={feedback.pr.body ?? ""} />
|
||||
<ReviewsSection
|
||||
reviews={feedback.reviews ?? []}
|
||||
requestedReviewers={feedback.pr.requested_reviewers ?? []}
|
||||
requestedReviewers={reviewRequest.requestedReviewers}
|
||||
prUrl={taskPR.pr_url}
|
||||
reviewState={metrics.reviewState}
|
||||
pendingReviewCount={metrics.pendingReviewCount}
|
||||
onAddAsContext={(msg) => addAsContext("review", msg)}
|
||||
canReRequest={shouldShowReRequestReviewAction(feedback.pr.state, "DISMISSED")}
|
||||
requestingReviewers={reviewRequest.requestingReviewers}
|
||||
onReRequest={reviewRequest.reRequest}
|
||||
/>
|
||||
<ChecksSection
|
||||
checks={feedback.checks ?? []}
|
||||
@@ -392,8 +406,6 @@ export function PRDetailContent({ taskPR, sessionId }: { taskPR: TaskPR; session
|
||||
);
|
||||
}
|
||||
|
||||
// --- Header ---
|
||||
|
||||
function StateBadge({ state }: { state: string }) {
|
||||
const styles: Record<string, string> = {
|
||||
open: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
import { afterEach, describe, expect, it, vi } from "vitest";
|
||||
import { cleanup, fireEvent, render, screen } from "@testing-library/react";
|
||||
import { TooltipProvider } from "@kandev/ui/tooltip";
|
||||
import { reconcileReviews, ReviewsSection } from "./pr-reviews-section";
|
||||
import type { PRReview, RequestedReviewer } from "@/lib/types/github";
|
||||
|
||||
function review(author: string, state: string, created_at = "2026-07-23T10:00:00Z"): PRReview {
|
||||
return { id: 1, author, author_avatar: "", state, body: "", created_at };
|
||||
}
|
||||
|
||||
function requested(login: string): RequestedReviewer {
|
||||
return { login, type: "user" };
|
||||
}
|
||||
|
||||
function renderReviews(ui: React.ReactElement) {
|
||||
return render(<TooltipProvider>{ui}</TooltipProvider>);
|
||||
}
|
||||
|
||||
afterEach(() => cleanup());
|
||||
|
||||
describe("reconcileReviews", () => {
|
||||
it("keeps only latest review per author and enables its dismissed re-request action", () => {
|
||||
const result = reconcileReviews(
|
||||
[review("octocat", "APPROVED", "2026-07-22T10:00:00Z"), review("octocat", "DISMISSED")],
|
||||
[],
|
||||
);
|
||||
|
||||
expect(result.reviews).toEqual([review("octocat", "DISMISSED")]);
|
||||
expect(result.pendingReviewers).toEqual([]);
|
||||
});
|
||||
|
||||
it("makes current requests win over dismissed history case-insensitively", () => {
|
||||
const result = reconcileReviews([review("OctoCat", "DISMISSED")], [requested("octocat")]);
|
||||
|
||||
expect(result.reviews).toEqual([]);
|
||||
expect(result.pendingReviewers).toEqual([requested("octocat")]);
|
||||
});
|
||||
|
||||
it("deduplicates current requested reviewers case-insensitively", () => {
|
||||
const result = reconcileReviews([], [requested("OctoCat"), requested("octocat")]);
|
||||
|
||||
expect(result.pendingReviewers).toEqual([requested("OctoCat")]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("ReviewsSection re-request action", () => {
|
||||
it("names dismissed reviewer and blocks repeated submission while busy", () => {
|
||||
const onReRequest = vi.fn();
|
||||
renderReviews(
|
||||
<ReviewsSection
|
||||
reviews={[review("octocat", "DISMISSED")]}
|
||||
requestedReviewers={[]}
|
||||
prUrl="https://github.com/acme/site/pull/1"
|
||||
reviewState="pending"
|
||||
pendingReviewCount={0}
|
||||
onAddAsContext={vi.fn()}
|
||||
canReRequest
|
||||
requestingReviewers={["OCTOCAT"]}
|
||||
onReRequest={onReRequest}
|
||||
/>,
|
||||
);
|
||||
|
||||
const action = screen.getByRole("button", { name: "Re-request review from octocat" });
|
||||
expect(action).toHaveProperty("disabled", true);
|
||||
expect(action.className).toContain("min-h-11");
|
||||
fireEvent.click(action);
|
||||
expect(onReRequest).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("wraps a long reviewer row so the 44px action stays on-screen on phones", () => {
|
||||
const longLogin = "reviewer-with-a-near-maximum-practical-github-login";
|
||||
renderReviews(
|
||||
<ReviewsSection
|
||||
reviews={[review(longLogin, "DISMISSED")]}
|
||||
requestedReviewers={[]}
|
||||
prUrl="https://github.com/acme/site/pull/1"
|
||||
reviewState="pending"
|
||||
pendingReviewCount={0}
|
||||
onAddAsContext={vi.fn()}
|
||||
canReRequest
|
||||
onReRequest={vi.fn()}
|
||||
/>,
|
||||
);
|
||||
|
||||
const action = screen.getByRole("button", {
|
||||
name: `Re-request review from ${longLogin}`,
|
||||
});
|
||||
const author = screen.getByRole("link", { name: longLogin });
|
||||
expect(action.className).toContain("min-h-11");
|
||||
expect(action.parentElement?.className).toContain("basis-full");
|
||||
expect(author.className).toContain("inline-block");
|
||||
expect(author.className).toContain("max-w-full");
|
||||
});
|
||||
|
||||
it("does not show action for a closed PR or a currently requested reviewer", () => {
|
||||
const { rerender } = renderReviews(
|
||||
<ReviewsSection
|
||||
reviews={[review("octocat", "DISMISSED")]}
|
||||
requestedReviewers={[]}
|
||||
prUrl="https://github.com/acme/site/pull/1"
|
||||
reviewState="pending"
|
||||
pendingReviewCount={0}
|
||||
onAddAsContext={vi.fn()}
|
||||
/>,
|
||||
);
|
||||
expect(screen.queryByRole("button", { name: "Re-request review from octocat" })).toBeNull();
|
||||
|
||||
rerender(
|
||||
<TooltipProvider>
|
||||
<ReviewsSection
|
||||
reviews={[review("octocat", "DISMISSED")]}
|
||||
requestedReviewers={[requested("OctoCat")]}
|
||||
prUrl="https://github.com/acme/site/pull/1"
|
||||
reviewState="pending"
|
||||
pendingReviewCount={1}
|
||||
onAddAsContext={vi.fn()}
|
||||
canReRequest
|
||||
onReRequest={vi.fn()}
|
||||
/>
|
||||
,
|
||||
</TooltipProvider>,
|
||||
);
|
||||
expect(screen.queryByRole("button", { name: "Re-request review from octocat" })).toBeNull();
|
||||
expect(screen.getByText("OctoCat")).not.toBeNull();
|
||||
});
|
||||
});
|
||||
@@ -1,5 +1,6 @@
|
||||
import { IconCheck, IconX, IconClock } from "@tabler/icons-react";
|
||||
import { Badge } from "@kandev/ui/badge";
|
||||
import { Button } from "@kandev/ui/button";
|
||||
import type { PRReview, RequestedReviewer } from "@/lib/types/github";
|
||||
import { CollapsibleSection, FeedbackItemRow } from "./pr-shared";
|
||||
|
||||
@@ -59,15 +60,30 @@ function buildAllReviewsMessage(reviews: PRReview[], prUrl: string): string {
|
||||
return parts.join("\n");
|
||||
}
|
||||
|
||||
function deduplicateReviews(reviews: PRReview[]): PRReview[] {
|
||||
function normalizeLogin(login: string): string {
|
||||
return login.trim().toLowerCase();
|
||||
}
|
||||
|
||||
export function reconcileReviews(reviews: PRReview[], requestedReviewers: RequestedReviewer[]) {
|
||||
const latestByAuthor = new Map<string, PRReview>();
|
||||
for (const review of reviews) {
|
||||
const current = latestByAuthor.get(review.author);
|
||||
const author = normalizeLogin(review.author);
|
||||
const current = latestByAuthor.get(author);
|
||||
if (!current || new Date(review.created_at) > new Date(current.created_at)) {
|
||||
latestByAuthor.set(review.author, review);
|
||||
latestByAuthor.set(author, review);
|
||||
}
|
||||
}
|
||||
return Array.from(latestByAuthor.values());
|
||||
const requestedByLogin = new Map<string, RequestedReviewer>();
|
||||
for (const reviewer of requestedReviewers) {
|
||||
const login = normalizeLogin(reviewer.login);
|
||||
if (!requestedByLogin.has(login)) requestedByLogin.set(login, reviewer);
|
||||
}
|
||||
return {
|
||||
reviews: Array.from(latestByAuthor.entries())
|
||||
.filter(([author]) => !requestedByLogin.has(author))
|
||||
.map(([, review]) => review),
|
||||
pendingReviewers: Array.from(requestedByLogin.values()),
|
||||
};
|
||||
}
|
||||
|
||||
function formatPendingReviewer(reviewer: RequestedReviewer): string {
|
||||
@@ -114,29 +130,58 @@ function SubmittedReviewRow({
|
||||
review,
|
||||
prUrl,
|
||||
onAddAsContext,
|
||||
canReRequest,
|
||||
isRequesting,
|
||||
onReRequest,
|
||||
}: {
|
||||
review: PRReview;
|
||||
prUrl: string;
|
||||
onAddAsContext: (message: string) => void;
|
||||
canReRequest: boolean;
|
||||
isRequesting: boolean;
|
||||
onReRequest?: (reviewer: string) => void;
|
||||
}) {
|
||||
const hasActionable = review.state === "CHANGES_REQUESTED" || !!review.body;
|
||||
return (
|
||||
<FeedbackItemRow
|
||||
author={review.author}
|
||||
authorAvatar={review.author_avatar}
|
||||
body={review.body || undefined}
|
||||
createdAt={review.created_at}
|
||||
metaBadge={<ReviewMetaBadge state={review.state} />}
|
||||
onAddAsContext={
|
||||
hasActionable ? () => onAddAsContext(buildReviewMessage(review, prUrl)) : undefined
|
||||
}
|
||||
/>
|
||||
<div data-testid={`pr-submitted-review-${normalizeLogin(review.author)}`}>
|
||||
<FeedbackItemRow
|
||||
author={review.author}
|
||||
authorAvatar={review.author_avatar}
|
||||
body={review.body || undefined}
|
||||
createdAt={review.created_at}
|
||||
metaBadge={<ReviewMetaBadge state={review.state} />}
|
||||
trailingAction={
|
||||
canReRequest && review.state === "DISMISSED" && onReRequest ? (
|
||||
<div className="basis-full w-full sm:basis-auto sm:w-auto">
|
||||
<Button
|
||||
type="button"
|
||||
size="sm"
|
||||
variant="outline"
|
||||
className="h-8 min-h-11 w-full max-w-full sm:w-auto sm:min-h-0 shrink-0 cursor-pointer px-2 text-[10px] [@media(pointer:coarse)]:min-h-11"
|
||||
data-testid={`pr-rerequest-review-${normalizeLogin(review.author)}`}
|
||||
aria-label={`Re-request review from ${review.author}`}
|
||||
onClick={() => onReRequest(review.author)}
|
||||
disabled={isRequesting}
|
||||
>
|
||||
{isRequesting ? "Requesting..." : "Re-request review"}
|
||||
</Button>
|
||||
</div>
|
||||
) : undefined
|
||||
}
|
||||
onAddAsContext={
|
||||
hasActionable ? () => onAddAsContext(buildReviewMessage(review, prUrl)) : undefined
|
||||
}
|
||||
/>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
function PendingReviewRow({ reviewer }: { reviewer: RequestedReviewer }) {
|
||||
return (
|
||||
<div className="px-2.5 py-1.5 rounded-md border border-border bg-muted/30">
|
||||
<div
|
||||
className="px-2.5 py-1.5 rounded-md border border-border bg-muted/30"
|
||||
data-testid={`pr-pending-reviewer-${normalizeLogin(reviewer.login)}`}
|
||||
>
|
||||
<div className="flex items-center gap-2">
|
||||
<IconClock className="h-3.5 w-3.5 text-yellow-500 shrink-0" />
|
||||
<span className="text-xs font-medium">{formatPendingReviewer(reviewer)}</span>
|
||||
@@ -153,6 +198,9 @@ export function ReviewsSection({
|
||||
reviewState,
|
||||
pendingReviewCount,
|
||||
onAddAsContext,
|
||||
canReRequest = false,
|
||||
requestingReviewers = [],
|
||||
onReRequest,
|
||||
}: {
|
||||
reviews: PRReview[];
|
||||
requestedReviewers: RequestedReviewer[];
|
||||
@@ -160,16 +208,19 @@ export function ReviewsSection({
|
||||
reviewState: string;
|
||||
pendingReviewCount: number;
|
||||
onAddAsContext: (message: string) => void;
|
||||
canReRequest?: boolean;
|
||||
requestingReviewers?: string[];
|
||||
onReRequest?: (reviewer: string) => void;
|
||||
}) {
|
||||
const dedupedReviews = deduplicateReviews(reviews);
|
||||
const reviewedAuthors = new Set(
|
||||
dedupedReviews.filter((r) => r.state !== "PENDING").map((r) => r.author),
|
||||
const { reviews: reconciledReviews, pendingReviewers } = reconcileReviews(
|
||||
reviews,
|
||||
requestedReviewers,
|
||||
);
|
||||
const pendingOnly = requestedReviewers.filter((r) => !reviewedAuthors.has(r.login));
|
||||
const requestingReviewerLogins = new Set(requestingReviewers.map(normalizeLogin));
|
||||
|
||||
const { pendingCount, summary, totalCount } = computeSectionSummary(
|
||||
dedupedReviews,
|
||||
pendingOnly,
|
||||
reconciledReviews,
|
||||
pendingReviewers,
|
||||
pendingReviewCount,
|
||||
);
|
||||
const pendingText = pendingCount > 0 ? ` (${pendingCount} pending)` : "";
|
||||
@@ -188,24 +239,27 @@ export function ReviewsSection({
|
||||
defaultOpen
|
||||
subtitle={subtitle}
|
||||
onAddAll={
|
||||
dedupedReviews.length > 0
|
||||
? () => onAddAsContext(buildAllReviewsMessage(dedupedReviews, prUrl))
|
||||
reconciledReviews.length > 0
|
||||
? () => onAddAsContext(buildAllReviewsMessage(reconciledReviews, prUrl))
|
||||
: undefined
|
||||
}
|
||||
addAllLabel="Add all reviews to chat context"
|
||||
>
|
||||
{dedupedReviews.length === 0 && pendingCount === 0 && (
|
||||
{reconciledReviews.length === 0 && pendingCount === 0 && (
|
||||
<p className="text-xs text-muted-foreground px-2 py-2">No reviews yet</p>
|
||||
)}
|
||||
{dedupedReviews.map((review) => (
|
||||
{reconciledReviews.map((review) => (
|
||||
<SubmittedReviewRow
|
||||
key={review.id}
|
||||
review={review}
|
||||
prUrl={prUrl}
|
||||
onAddAsContext={onAddAsContext}
|
||||
canReRequest={canReRequest}
|
||||
isRequesting={requestingReviewerLogins.has(normalizeLogin(review.author))}
|
||||
onReRequest={onReRequest}
|
||||
/>
|
||||
))}
|
||||
{pendingOnly.map((reviewer) => (
|
||||
{pendingReviewers.map((reviewer) => (
|
||||
<PendingReviewRow key={`pending-${reviewer.type}-${reviewer.login}`} reviewer={reviewer} />
|
||||
))}
|
||||
</CollapsibleSection>
|
||||
|
||||
@@ -68,7 +68,7 @@ export function AuthorLink({ author }: { author: string }) {
|
||||
href={`https://github.com/${author}`}
|
||||
target="_blank"
|
||||
rel="noopener noreferrer"
|
||||
className="text-xs font-medium hover:underline cursor-pointer"
|
||||
className="inline-block min-w-0 max-w-full truncate text-xs font-medium hover:underline cursor-pointer sm:max-w-none"
|
||||
>
|
||||
{author}
|
||||
</a>
|
||||
@@ -217,6 +217,7 @@ export function FeedbackItemRow({
|
||||
createdAt,
|
||||
metaBadge,
|
||||
onAddAsContext,
|
||||
trailingAction,
|
||||
isReply,
|
||||
}: {
|
||||
author: string;
|
||||
@@ -225,12 +226,13 @@ export function FeedbackItemRow({
|
||||
createdAt: string;
|
||||
metaBadge?: React.ReactNode;
|
||||
onAddAsContext?: () => void;
|
||||
trailingAction?: React.ReactNode;
|
||||
isReply?: boolean;
|
||||
}) {
|
||||
return (
|
||||
<div className={isReply ? "ml-4 pl-2.5 border-l-2 border-border" : ""}>
|
||||
<div className="px-2.5 py-2 rounded-md border border-border bg-muted/30 space-y-1">
|
||||
<div className="flex items-center gap-2">
|
||||
<div className="block sm:flex sm:flex-nowrap sm:items-center sm:gap-2">
|
||||
<AuthorAvatar src={authorAvatar} author={author} />
|
||||
<AuthorLink author={author} />
|
||||
{metaBadge}
|
||||
@@ -238,6 +240,7 @@ export function FeedbackItemRow({
|
||||
{formatTimeAgo(createdAt)}
|
||||
</span>
|
||||
{onAddAsContext && <AddToContextButton onClick={onAddAsContext} />}
|
||||
{trailingAction}
|
||||
</div>
|
||||
{body && <ExpandableBody body={body} className="pl-7" />}
|
||||
</div>
|
||||
|
||||
@@ -0,0 +1,238 @@
|
||||
import { useCallback, useEffect, useSyncExternalStore } from "react";
|
||||
import { requestPRReviewers } from "@/lib/api/domains/github-review-api";
|
||||
import type { PRReview, RequestedReviewer, TaskPR } from "@/lib/types/github";
|
||||
|
||||
type Toast = (message: {
|
||||
title?: string;
|
||||
description: string;
|
||||
variant: "error" | "success";
|
||||
}) => void;
|
||||
|
||||
type ReviewBaseline = Pick<PRReview, "id" | "author" | "created_at" | "state">;
|
||||
|
||||
type RequestEntry = {
|
||||
identity: string;
|
||||
reviewer: string;
|
||||
baseline: ReviewBaseline | null;
|
||||
status: "requesting" | "optimistic";
|
||||
operationId: number;
|
||||
expiresAt: number | null;
|
||||
};
|
||||
|
||||
const ENTRY_TTL_MS = 5 * 60 * 1000;
|
||||
const entries = new Map<string, RequestEntry>();
|
||||
const listeners = new Set<() => void>();
|
||||
let revision = 0;
|
||||
let nextOperationId = 0;
|
||||
let expiryTimer: ReturnType<typeof setTimeout> | undefined;
|
||||
|
||||
function normalizeLogin(login: string) {
|
||||
return login.trim().toLowerCase();
|
||||
}
|
||||
|
||||
function prIdentity(taskPR: TaskPR) {
|
||||
return `${taskPR.owner.toLowerCase()}:${taskPR.repo.toLowerCase()}:${taskPR.pr_number}`;
|
||||
}
|
||||
|
||||
function entryKey(identity: string, reviewer: string) {
|
||||
return `${identity}:${normalizeLogin(reviewer)}`;
|
||||
}
|
||||
|
||||
function notify() {
|
||||
revision += 1;
|
||||
listeners.forEach((listener) => listener());
|
||||
}
|
||||
|
||||
function pruneExpired(now = Date.now()) {
|
||||
let removed = false;
|
||||
for (const [key, entry] of entries) {
|
||||
if (entry.status === "optimistic" && entry.expiresAt !== null && entry.expiresAt <= now) {
|
||||
entries.delete(key);
|
||||
removed = true;
|
||||
}
|
||||
}
|
||||
return removed;
|
||||
}
|
||||
|
||||
function rescheduleExpiryTimer() {
|
||||
if (expiryTimer !== undefined) {
|
||||
clearTimeout(expiryTimer);
|
||||
expiryTimer = undefined;
|
||||
}
|
||||
if (typeof window === "undefined") return;
|
||||
const nextExpiry = Array.from(entries.values()).reduce<number | null>((nearest, entry) => {
|
||||
if (entry.status !== "optimistic" || entry.expiresAt === null) return nearest;
|
||||
return nearest === null || entry.expiresAt < nearest ? entry.expiresAt : nearest;
|
||||
}, null);
|
||||
if (nextExpiry === null) return;
|
||||
expiryTimer = setTimeout(
|
||||
() => {
|
||||
expiryTimer = undefined;
|
||||
if (pruneExpired()) notify();
|
||||
rescheduleExpiryTimer();
|
||||
},
|
||||
Math.max(0, nextExpiry - Date.now()),
|
||||
);
|
||||
}
|
||||
|
||||
function latestReview(reviews: PRReview[], reviewer: string) {
|
||||
const normalizedReviewer = normalizeLogin(reviewer);
|
||||
return reviews
|
||||
.filter((review) => normalizeLogin(review.author) === normalizedReviewer)
|
||||
.reduce<PRReview | null>((latest, review) => {
|
||||
if (!latest) return review;
|
||||
const reviewTime = new Date(review.created_at).getTime();
|
||||
const latestTime = new Date(latest.created_at).getTime();
|
||||
return reviewTime > latestTime || (reviewTime === latestTime && review.id > latest.id)
|
||||
? review
|
||||
: latest;
|
||||
}, null);
|
||||
}
|
||||
|
||||
function supersedesBaseline(review: PRReview | null, baseline: ReviewBaseline | null) {
|
||||
if (!review || !baseline || review.state === "DISMISSED") return false;
|
||||
const reviewTime = new Date(review.created_at).getTime();
|
||||
const baselineTime = new Date(baseline.created_at).getTime();
|
||||
return reviewTime > baselineTime || (reviewTime === baselineTime && review.id > baseline.id);
|
||||
}
|
||||
|
||||
function reconcile(identity: string, requestedReviewers: RequestedReviewer[], reviews: PRReview[]) {
|
||||
let removed = pruneExpired();
|
||||
const requestedLogins = new Set(
|
||||
requestedReviewers.map((reviewer) => normalizeLogin(reviewer.login)),
|
||||
);
|
||||
for (const [key, entry] of entries) {
|
||||
if (entry.identity !== identity) continue;
|
||||
if (
|
||||
requestedLogins.has(entry.reviewer) ||
|
||||
supersedesBaseline(latestReview(reviews, entry.reviewer), entry.baseline)
|
||||
) {
|
||||
entries.delete(key);
|
||||
removed = true;
|
||||
}
|
||||
}
|
||||
rescheduleExpiryTimer();
|
||||
if (removed) notify();
|
||||
}
|
||||
|
||||
function beginRequest(identity: string, reviewer: string, baseline: ReviewBaseline | null) {
|
||||
const expired = pruneExpired();
|
||||
const key = entryKey(identity, reviewer);
|
||||
if (entries.has(key)) {
|
||||
if (expired) {
|
||||
rescheduleExpiryTimer();
|
||||
notify();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
const operationId = ++nextOperationId;
|
||||
entries.set(key, {
|
||||
identity,
|
||||
reviewer: normalizeLogin(reviewer),
|
||||
baseline,
|
||||
status: "requesting",
|
||||
operationId,
|
||||
expiresAt: null,
|
||||
});
|
||||
rescheduleExpiryTimer();
|
||||
notify();
|
||||
return operationId;
|
||||
}
|
||||
|
||||
function finishRequest(
|
||||
identity: string,
|
||||
reviewer: string,
|
||||
operationId: number,
|
||||
succeeded: boolean,
|
||||
) {
|
||||
const key = entryKey(identity, reviewer);
|
||||
const entry = entries.get(key);
|
||||
if (!entry || entry.operationId !== operationId) return;
|
||||
if (!succeeded) {
|
||||
entries.delete(key);
|
||||
} else {
|
||||
entries.set(key, { ...entry, status: "optimistic", expiresAt: Date.now() + ENTRY_TTL_MS });
|
||||
}
|
||||
rescheduleExpiryTimer();
|
||||
notify();
|
||||
}
|
||||
|
||||
function getEntries(identity: string) {
|
||||
return Array.from(entries.values()).filter((entry) => entry.identity === identity);
|
||||
}
|
||||
|
||||
function subscribe(listener: () => void) {
|
||||
listeners.add(listener);
|
||||
return () => listeners.delete(listener);
|
||||
}
|
||||
|
||||
export function clearPRReviewRequestRegistryForTests() {
|
||||
entries.clear();
|
||||
nextOperationId = 0;
|
||||
rescheduleExpiryTimer();
|
||||
notify();
|
||||
}
|
||||
|
||||
export function usePRScopedReviewRequest(
|
||||
taskPR: TaskPR,
|
||||
requestedReviewers: RequestedReviewer[],
|
||||
reviews: PRReview[],
|
||||
refresh: () => void,
|
||||
toast: Toast,
|
||||
) {
|
||||
const identity = prIdentity(taskPR);
|
||||
useSyncExternalStore(
|
||||
subscribe,
|
||||
() => revision,
|
||||
() => revision,
|
||||
);
|
||||
|
||||
useEffect(() => {
|
||||
reconcile(identity, requestedReviewers, reviews);
|
||||
}, [identity, requestedReviewers, reviews]);
|
||||
|
||||
const reRequest = useCallback(
|
||||
async (reviewer: string) => {
|
||||
const baseline = latestReview(reviews, reviewer);
|
||||
const operationId = beginRequest(identity, reviewer, baseline);
|
||||
if (operationId === null) return;
|
||||
try {
|
||||
await requestPRReviewers(taskPR.owner, taskPR.repo, taskPR.pr_number, [reviewer]);
|
||||
} catch (error) {
|
||||
finishRequest(identity, reviewer, operationId, false);
|
||||
toast({
|
||||
title: "Failed to re-request review",
|
||||
description: error instanceof Error ? error.message : "An error occurred",
|
||||
variant: "error",
|
||||
});
|
||||
return;
|
||||
}
|
||||
finishRequest(identity, reviewer, operationId, true);
|
||||
toast({ description: `Review re-requested from ${reviewer}`, variant: "success" });
|
||||
try {
|
||||
refresh();
|
||||
} catch {
|
||||
// The request remains optimistic until the bounded registry expires or server data resolves it.
|
||||
}
|
||||
},
|
||||
[identity, refresh, reviews, taskPR.owner, taskPR.pr_number, taskPR.repo, toast],
|
||||
);
|
||||
|
||||
const activeEntries = getEntries(identity);
|
||||
const requestingReviewers = activeEntries
|
||||
.filter((entry) => entry.status === "requesting")
|
||||
.map((entry) => entry.reviewer);
|
||||
const optimisticReviewers = activeEntries
|
||||
.filter((entry) => entry.status === "optimistic")
|
||||
.filter(
|
||||
(entry) =>
|
||||
!requestedReviewers.some((reviewer) => normalizeLogin(reviewer.login) === entry.reviewer),
|
||||
)
|
||||
.map((entry) => ({ login: entry.reviewer, type: "user" as const }));
|
||||
|
||||
return {
|
||||
reRequest,
|
||||
requestingReviewers,
|
||||
requestedReviewers: [...requestedReviewers, ...optimisticReviewers],
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user