From a279ab19368cfd70f51972f96b3bc1dc2cfa8cae Mon Sep 17 00:00:00 2001 From: Alex Vallone Date: Tue, 17 Nov 2026 10:34:28 -0800 Subject: [PATCH 1/2] fix(azure-devops): read reviewer votes and attribute review activity Port Julius Marminge's pingdotgg/t3code#31198 at 8bbdacc68f5f1f25618828d34707b95bfb7c507a, including dictionary-first voter identity resolution. Preserve pending-review pagination and the fork's labels, checks, and shared-read behavior. Co-authored-by: Julius Marminge Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../server/AzureDevOpsPullRequestCli.test.ts | 161 +++++++- .../src/server/AzureDevOpsPullRequestCli.ts | 57 ++- .../AzureDevOpsPullRequestProvider.test.ts | 87 +++++ .../server/AzureDevOpsPullRequestProvider.ts | 73 ++-- .../server/azureDevOpsPullRequestJson.test.ts | 349 ++++++++++++++++++ .../src/server/azureDevOpsPullRequestJson.ts | 152 +++++++- 6 files changed, 822 insertions(+), 57 deletions(-) diff --git a/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestCli.test.ts b/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestCli.test.ts index 156caac9e7a58..7108352614191 100644 --- a/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestCli.test.ts +++ b/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestCli.test.ts @@ -169,7 +169,13 @@ layer("AzureDevOpsPullRequestCli.layer", (it) => { mockedExecute .mockReturnValueOnce( Effect.succeed( - output(json({ ...pullRequestRow, lastMergeSourceCommit: { commitId: previousHead } })), + output( + json({ + ...pullRequestRow, + lastMergeSourceCommit: { commitId: previousHead }, + reviewers: [{ uniqueName: "reviewer@acme.dev", vote: 10 }], + }), + ), ), ) .mockReturnValueOnce( @@ -205,6 +211,7 @@ layer("AzureDevOpsPullRequestCli.layer", (it) => { expect(argsOfCall(2)).toContain("iterationId=2"); expect(argsOfCall(4)).toContain("pullRequestLabels"); expect(detail.labels).toEqual([{ name: "release-1.0", color: null }]); + expect(detail.reviewDecision).toBe("approved"); expect(mockedExecute).toHaveBeenCalledTimes(5); }), ); @@ -320,6 +327,7 @@ layer("AzureDevOpsPullRequestCli.layer", (it) => { mockedExecute.mockReturnValueOnce( Effect.succeed(output(JSON.stringify({ name: "bilal@acme.dev", type: "user" }))), ); + const cli = yield* AzureDevOpsPullRequestCli.AzureDevOpsPullRequestCli; const viewer = yield* cli.getViewer({ cwd: "/w" }); @@ -337,6 +345,157 @@ layer("AzureDevOpsPullRequestCli.layer", (it) => { }), ); + it.effect("pages Reviewing over voted and malformed rows without losing group requests", () => + Effect.gen(function* () { + const votes = [10, 0, 0, null, -10, 20, 5, undefined, -5]; + const rows = pullRequestRows(votes.length, 1).map((row, index) => + index === 1 + ? { pullRequestId: "malformed" } + : { + ...row, + reviewers: + index === 3 + ? [{ displayName: "[web]\\Reviewers", uniqueName: "web-reviewers" }] + : [{ uniqueName: "Bilal@acme.dev", vote: votes[index] }], + }, + ); + mockedExecute.mockImplementation((input) => { + const skipIndex = input.args.indexOf("--skip"); + const skip = skipIndex === -1 ? 0 : Number(input.args[skipIndex + 1]); + const top = Number(input.args[input.args.indexOf("--top") + 1]); + return Effect.succeed(output(JSON.stringify(rows.slice(skip, skip + top)))); + }); + const cli = yield* AzureDevOpsPullRequestCli.AzureDevOpsPullRequestCli; + const input = { + cwd: "/w", + repository: "web", + state: "open" as const, + involvement: "reviewing" as const, + viewer: "bilal@acme.dev", + limit: 2, + }; + const first = yield* cli.listPullRequests(input); + const second = yield* cli.listPullRequests({ + ...input, + cursor: { delivered: first.cursorAdvance, updatedBefore: "2026-07-02T00:00:00Z" }, + }); + expect(first.items.map((item) => item.number)).toEqual([3, 4]); + expect(second.items.map((item) => item.number)).toEqual([6, 8]); + expect([first.cursorAdvance, second.cursorAdvance]).toEqual([4, 4]); + expect([first.truncated, second.truncated]).toEqual([true, true]); + const third = yield* cli.listPullRequests({ + ...input, + cursor: { + delivered: first.cursorAdvance + second.cursorAdvance, + updatedBefore: "2026-07-02T00:00:00Z", + }, + }); + expect(third).toEqual({ items: [], truncated: false, cursorAdvance: 1 }); + }), + ); + + it.effect.each([true, false])( + "bounds Reviewing reads only after a resumable row exists (early row: %s)", + (earlyRow) => + Effect.gen(function* () { + let reads = 0; + mockedExecute.mockImplementation((input) => { + reads += 1; + const skipIndex = input.args.indexOf("--skip"); + const skip = skipIndex === -1 ? 0 : Number(input.args[skipIndex + 1]); + const top = Number(input.args[input.args.indexOf("--top") + 1]); + return Effect.succeed( + output( + JSON.stringify( + pullRequestRows(top, skip + 1).map((row, index) => ({ + ...row, + reviewers: [ + { + uniqueName: "bilal@acme.dev", + vote: index === 0 && reads === (earlyRow ? 1 : 4) ? 0 : 10, + }, + ], + })), + ), + ), + ); + }); + const cli = yield* AzureDevOpsPullRequestCli.AzureDevOpsPullRequestCli; + const batch = yield* cli.listPullRequests({ + cwd: "/w", + repository: "web", + state: "all", + involvement: "reviewing", + viewer: "bilal@acme.dev", + limit: 2, + }); + expect(reads).toBe(earlyRow ? 3 : 4); + expect(batch.items.map((item) => item.number)).toEqual([earlyRow ? 1 : 10]); + expect(batch.truncated).toBe(true); + expect(batch.cursorAdvance).toBe(earlyRow ? 7 : 12); + }), + ); + + it.effect("carries decisions and dictionary-attributed vote activity through the provider", () => + Effect.gen(function* () { + const reviewer = { id: "d6245f20-2af8-44f4-9451-8107cb2767db", uniqueName: "jane@acme.dev" }; + mockedExecute.mockImplementation((input) => + Effect.succeed( + output( + input.args.includes("pullRequestThreads") + ? json({ + value: [ + { + id: 2, + properties: { + CodeReviewThreadType: { $value: "VoteUpdate" }, + CodeReviewVoteResult: { $value: "10" }, + CodeReviewVotedByIdentity: { $value: "1" }, + }, + identities: { "1": reviewer }, + comments: [ + { + id: 1, + content: "Vote.", + commentType: "system", + publishedDate: "2026-07-02T00:00:00Z", + }, + ], + }, + ], + }) + : input.args.includes("policy") + ? "[]" + : input.args.includes("list") + ? JSON.stringify([{ ...pullRequestRow, reviewers: [{ ...reviewer, vote: 10 }] }]) + : json({ ...pullRequestRow, reviewers: [{ ...reviewer, vote: 10 }] }), + ), + ), + ); + const provider = yield* AzureDevOpsPullRequestProvider.make; + const target = { cwd: "/w", repository: "platform/web", host: "dev.azure.com" }; + const page = yield* provider.listChangeRequests({ + ...target, + state: "open", + involvement: "all", + viewer: "me@acme.dev", + limit: 10, + }); + const summary = yield* provider.getChangeRequestSummary!({ ...target, number: 42 }); + const activity = yield* provider.getChangeRequestActivity({ ...target, number: 42 }); + expect(page.items[0]?.reviewDecision).toBe("approved"); + expect(summary.reviewDecision).toBe("approved"); + expect(activity.comments).toMatchObject([ + { + id: "2:1", + kind: "review", + reviewState: "APPROVED", + author: { login: "jane@acme.dev" }, + }, + ]); + }), + ); + it.effect("names a token sign-in by the viewer's own pull request", () => Effect.gen(function* () { const notLoggedIn = new AzureDevOpsCli.AzureDevOpsCliAuthenticationError({ diff --git a/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestCli.ts b/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestCli.ts index d3360b42c9ac8..a9560ec9bb49f 100644 --- a/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestCli.ts +++ b/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestCli.ts @@ -32,6 +32,7 @@ import { type AzureDevOpsItemContent, type AzureDevOpsIteration, type AzureDevOpsPullRequest, + type AzureDevOpsPullRequestBatch, type AzureDevOpsRepositoryLocation, } from "./azureDevOpsPullRequestJson.ts"; import type { ProviderListCursor } from "@t3tools/source-control-core/server/PullRequestProvider"; @@ -112,6 +113,11 @@ export type AzureDevOpsPullRequestCliError = const REST_API_VERSION = "7.1"; const PULL_REQUEST_LIST_MAX_OUTPUT_BYTES = 16 * 1024 * 1024; +/** + * Reviewing drops voted rows; bound reads once a row can carry the list service's resume cursor. + * An empty page has no cursor, so it must keep reading until a row or the end. + */ +const PULL_REQUEST_LIST_MAX_READS = 3; /** A 2,000-file page exceeds the default 1 MiB output budget. */ const CHANGE_ENTRIES_MAX_OUTPUT_BYTES = 8 * 1024 * 1024; /** JSON escaping and base64 can exceed the decoded file's size. */ @@ -186,6 +192,7 @@ export class AzureDevOpsPullRequestCli extends Context.Service< readonly cwd: string; readonly location: AzureDevOpsRepositoryLocation; readonly number: number; + readonly reviewersById: AzureDevOpsPullRequest["reviewersById"]; }) => Effect.Effect, AzureDevOpsPullRequestCliError>; /** `az repos pr show` returns null labels, so the detail reads them here. */ @@ -279,6 +286,26 @@ function involvementArgs(input: { } } +/** Azure's `--reviewer` also returns requests the viewer has already voted on. */ +function withoutVotedByViewer( + batch: AzureDevOpsPullRequestBatch, + viewer: string, +): AzureDevOpsPullRequestBatch { + const login = viewer.toLowerCase(); + const isViewer = (candidate: string) => candidate.toLowerCase() === login; + const kept = batch.items.flatMap((item, index) => + item.reviewers.some((reviewer) => isViewer(reviewer.login)) && + !item.reviewRequestLogins.some(isViewer) + ? [] + : [{ item, rawIndex: batch.rawIndexes[index] ?? 0 }], + ); + return { + items: kept.map((entry) => entry.item), + rawIndexes: kept.map((entry) => entry.rawIndex), + rawCount: batch.rawCount, + }; +} + function actionArgs( action: PullRequestAction, mergeMethod: PullRequestMergeMethod | undefined, @@ -412,6 +439,7 @@ export const make = Effect.gen(function* () { readonly limit: number; readonly skip: number; readonly cursorAdvance: number; + readonly reads: number; readonly items: ReadonlyArray; }): Effect.Effect< { @@ -465,28 +493,36 @@ export const make = Effect.gen(function* () { ); } - const lastItemIndex = decoded.success.rawIndexes[remaining - 1]; + const batch = + input.involvement === "reviewing" + ? withoutVotedByViewer(decoded.success, input.viewer) + : decoded.success; + const lastItemIndex = batch.rawIndexes[remaining - 1]; if (lastItemIndex !== undefined) { const consumed = lastItemIndex + 1; return Effect.succeed({ - items: [...input.items, ...decoded.success.items.slice(0, remaining)], - truncated: consumed < decoded.success.rawCount || decoded.success.rawCount === top, + items: [...input.items, ...batch.items.slice(0, remaining)], + truncated: consumed < batch.rawCount || batch.rawCount === top, cursorAdvance: input.cursorAdvance + consumed, }); } - const items = [...input.items, ...decoded.success.items]; - if (decoded.success.rawCount < top) { + const items = [...input.items, ...batch.items]; + if ( + batch.rawCount < top || + (items.length > 0 && input.reads + 1 >= PULL_REQUEST_LIST_MAX_READS) + ) { return Effect.succeed({ items, - truncated: false, - cursorAdvance: input.cursorAdvance + decoded.success.rawCount, + truncated: batch.rawCount === top, + cursorAdvance: input.cursorAdvance + batch.rawCount, }); } return listPullRequestPage({ ...input, - skip: input.skip + decoded.success.rawCount, - cursorAdvance: input.cursorAdvance + decoded.success.rawCount, + skip: input.skip + batch.rawCount, + cursorAdvance: input.cursorAdvance + batch.rawCount, + reads: input.reads + 1, items, }); }), @@ -558,6 +594,7 @@ export const make = Effect.gen(function* () { limit: input.limit, skip: input.cursor?.delivered ?? 0, cursorAdvance: 0, + reads: 0, items: [], }); }), @@ -636,7 +673,7 @@ export const make = Effect.gen(function* () { resource: "pullRequestThreads", routeParameters: pullRequestRoute(input), maxOutputBytes: REVIEW_HISTORY_MAX_OUTPUT_BYTES, - decode: decodeThreadsJson, + decode: (raw) => decodeThreadsJson(raw, input.reviewersById), }); }), diff --git a/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestProvider.test.ts b/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestProvider.test.ts index 83cda1bff15b0..877498de13b53 100644 --- a/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestProvider.test.ts +++ b/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestProvider.test.ts @@ -39,6 +39,8 @@ const PULL_REQUEST = { body: "", reviewRequestLogins: [], reviewers: [], + reviewersById: new Map(), + reviewDecision: null, labels: [], location: { project: "acme", repository: "web" }, autoMergeEnabled: false, @@ -243,6 +245,91 @@ describe("getChangeRequest", () => { expect(reads).toBe(1); }), ); + + it.effect.each(["summary-first", "activity-first"] as const)( + "shares overlapping summary and activity reads (%s) without caching the vote", + (order) => + Effect.gen(function* () { + let reads = 0; + const release = yield* Deferred.make(); + const provider = yield* make.pipe( + Effect.provide( + Layer.mock(AzureDevOpsPullRequestCli.AzureDevOpsPullRequestCli)({ + getPullRequest: () => + Effect.sync(() => { + reads += 1; + }).pipe(Effect.andThen(Deferred.await(release)), Effect.as(PULL_REQUEST)), + listPolicyChecks: () => Effect.succeed([]), + listThreads: () => Effect.succeed([]), + }), + ), + ); + const input = { cwd: "/w", repository: "acme/web", host: "dev.azure.com", number: 7 }; + const first = + order === "summary-first" + ? provider.getChangeRequestSummary!(input).pipe(Effect.asVoid) + : provider.getChangeRequestActivity(input).pipe(Effect.asVoid); + const second = + order === "summary-first" + ? provider.getChangeRequestActivity(input).pipe(Effect.asVoid) + : provider.getChangeRequestSummary!(input).pipe(Effect.asVoid); + const a = yield* Effect.forkChild(first, { startImmediately: true }); + const b = yield* Effect.forkChild(second, { startImmediately: true }); + yield* Deferred.succeed(release, undefined); + yield* Fiber.join(a); + yield* Fiber.join(b); + expect(reads).toBe(1); + yield* provider.getChangeRequestActivity(input); + expect(reads).toBe(2); + }), + ); + + it.effect.each(["failure", "interruption"] as const)( + "retries an overlapping owner's %s without losing the activity read", + (outcome) => + Effect.gen(function* () { + let reads = 0; + const release = yield* Deferred.make(); + const provider = yield* make.pipe( + Effect.provide( + Layer.mock(AzureDevOpsPullRequestCli.AzureDevOpsPullRequestCli)({ + getPullRequest: () => + Effect.suspend(() => { + reads += 1; + return reads > 1 + ? Effect.succeed(PULL_REQUEST) + : Deferred.await(release).pipe( + Effect.andThen( + Effect.fail( + new AzureDevOpsPullRequestCli.AzureDevOpsPullRequestReadError({ + command: "az", + cwd: "/w", + operation: "getPullRequest", + cause: "unavailable", + }), + ), + ), + ); + }), + listPolicyChecks: () => Effect.succeed([]), + listThreads: () => Effect.succeed([]), + }), + ), + ); + const input = { cwd: "/w", repository: "acme/web", host: "dev.azure.com", number: 7 }; + const owner = yield* Effect.forkChild( + Effect.exit(provider.getChangeRequestSummary!(input)), + { startImmediately: true }, + ); + const reader = yield* Effect.forkChild(provider.getChangeRequestActivity(input), { + startImmediately: true, + }); + if (outcome === "interruption") yield* Fiber.interrupt(owner); + else yield* Deferred.succeed(release, undefined); + yield* Fiber.join(reader); + expect(reads).toBe(2); + }), + ); }); describe("policy checks", () => { diff --git a/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestProvider.ts b/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestProvider.ts index b329561c36360..5bf5bcb6af5d2 100644 --- a/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestProvider.ts +++ b/packages/source-control-azure-devops/src/server/AzureDevOpsPullRequestProvider.ts @@ -1,7 +1,6 @@ import { resolvePullRequestAuthorFilter, SourceControlProviderKind } from "@t3tools/contracts"; import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; -import * as Exit from "effect/Exit"; import * as Semaphore from "effect/Semaphore"; import { rollupCheckStatuses } from "@t3tools/source-control-core/server/pullRequestChecks"; import type { PullRequestCapabilities, PullRequestViewerPermissions } from "@t3tools/contracts"; @@ -149,6 +148,7 @@ function toChangeRequest(pullRequest: AzureDevOpsPullRequest): ProviderChangeReq mergedAt: pullRequest.state === "merged" ? pullRequest.closedAt : null, updatedAt: pullRequest.updatedAt, reviewRequestLogins: pullRequest.reviewRequestLogins, + reviewDecision: pullRequest.reviewDecision, labels: pullRequest.labels, }; } @@ -167,6 +167,7 @@ function toSummary(pullRequest: AzureDevOpsPullRequest): ProviderChangeRequestSu closedAt: pullRequest.state === "closed" ? pullRequest.closedAt : null, mergedAt: pullRequest.state === "merged" ? pullRequest.closedAt : null, updatedAt: pullRequest.updatedAt, + reviewDecision: pullRequest.reviewDecision, }; } @@ -206,11 +207,11 @@ export const make = Effect.gen(function* () { const knownIterations = new Map>(); const iterationChanges = new Map(); - // Reads still running, so a location lookup joins one instead of spawning its own az process. - const pendingLocations = new Map< + // Concurrent detail and activity readers share the live PR, including its reviewer identities. + const pendingPullRequests = new Map< string, Deferred.Deferred< - AzureDevOpsRepositoryLocation | null, + AzureDevOpsPullRequest, AzureDevOpsPullRequestCli.AzureDevOpsPullRequestCliError > >(); @@ -218,28 +219,32 @@ export const make = Effect.gen(function* () { const readPullRequest = (input: { readonly cwd: string; readonly number: number }) => Effect.suspend(() => { const key = `${input.cwd} ${input.number}`; - const pending = Deferred.makeUnsafe< - AzureDevOpsRepositoryLocation | null, - AzureDevOpsPullRequestCli.AzureDevOpsPullRequestCliError - >(); - pendingLocations.set(key, pending); - return cli.getPullRequest({ cwd: input.cwd, number: input.number }).pipe( - Effect.map((pullRequest) => { - if (pullRequest.location !== null) { - remember(locations, LOCATION_CACHE_CAPACITY, key, pullRequest.location); - } - return pullRequest; - }), - Effect.onExit((exit) => - Effect.sync(() => { - if (pendingLocations.get(key) === pending) pendingLocations.delete(key); - Deferred.doneUnsafe( - pending, - Exit.map(exit, (pullRequest) => pullRequest.location), - ); + const ownRead = Effect.suspend(() => { + const pending = Deferred.makeUnsafe< + AzureDevOpsPullRequest, + AzureDevOpsPullRequestCli.AzureDevOpsPullRequestCliError + >(); + pendingPullRequests.set(key, pending); + return cli.getPullRequest({ cwd: input.cwd, number: input.number }).pipe( + Effect.map((pullRequest) => { + if (pullRequest.location !== null) { + remember(locations, LOCATION_CACHE_CAPACITY, key, pullRequest.location); + } + return pullRequest; }), - ), - ); + Effect.onExit((exit) => + Effect.sync(() => { + if (pendingPullRequests.get(key) === pending) pendingPullRequests.delete(key); + Deferred.doneUnsafe(pending, exit); + }), + ), + ); + }); + const pending = pendingPullRequests.get(key); + // Another request's failed or interrupted read does not cancel this reader's own request. + return pending === undefined + ? ownRead + : Deferred.await(pending).pipe(Effect.catchCause(() => ownRead)); }); const locationOf = (input: { readonly cwd: string; readonly number: number }) => @@ -247,14 +252,7 @@ export const make = Effect.gen(function* () { const key = `${input.cwd} ${input.number}`; const held = recall(locations, key); if (held !== undefined) return Effect.succeed(held); - const ownRead = readPullRequest(input).pipe( - Effect.map((pullRequest) => pullRequest.location), - ); - const pending = pendingLocations.get(key); - // A read that failed or was interrupted under another request is retried here. - return pending === undefined - ? ownRead - : Deferred.await(pending).pipe(Effect.catchCause(() => ownRead)); + return readPullRequest(input).pipe(Effect.map((pullRequest) => pullRequest.location)); }); const readChecks = (input: { readonly cwd: string }, pullRequest: AzureDevOpsPullRequest) => @@ -493,16 +491,17 @@ export const make = Effect.gen(function* () { ), getChangeRequestActivity: (input) => - locationOf(input).pipe( + readPullRequest(input).pipe( Effect.mapError(fail("getChangeRequestActivity")), - Effect.flatMap((location) => - (location === null + Effect.flatMap((pullRequest) => + (pullRequest.location === null ? Effect.succeed({ comments: [], truncated: true }) : cli .listThreads({ cwd: input.cwd, - location, + location: pullRequest.location, number: input.number, + reviewersById: pullRequest.reviewersById, }) .pipe( Effect.map((comments) => ({ comments, truncated: false })), diff --git a/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.test.ts b/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.test.ts index 48cc27b00e007..e57648bb3651f 100644 --- a/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.test.ts +++ b/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.test.ts @@ -40,6 +40,52 @@ function expectSuccess(result: Result.Result): A { const asJson = (value: unknown) => JSON.stringify(value); +const JANE_ID = "d6245f20-2af8-44f4-9451-8107cb2767db"; +const BILAL_ID = "8c8c7d32-6b1b-47f4-b2e9-30b477b5ab3d"; + +function reviewersById() { + const detail = expectSuccess( + decodePullRequestJson( + asJson( + pullRequest({ + reviewers: [ + { id: JANE_ID, displayName: "Jane Doe", uniqueName: "jane@acme.dev", vote: 10 }, + { id: BILAL_ID, displayName: "Bilal Hassan", uniqueName: "bilal@acme.dev", vote: -10 }, + ], + }), + ), + ), + ); + if (detail === null) throw new Error("expected a pull request"); + return detail.reviewersById; +} + +function voteThread(input: { + readonly id: number; + readonly vote: string | number | null; + readonly voterId: string; + readonly voterName: string; +}) { + return { + id: input.id, + properties: { + CodeReviewThreadType: { $value: "VoteUpdate" }, + ...(input.vote === null ? {} : { CodeReviewVoteResult: { $value: input.vote } }), + CodeReviewVotedByTfId: { $value: input.voterId }, + CodeReviewVotedByDisplayName: { $value: input.voterName }, + }, + comments: [ + { + id: 1, + content: "Localized vote notification.", + commentType: "system", + author: { displayName: "Service account", uniqueName: "service@acme.dev" }, + publishedDate: `2026-07-${String(input.id).padStart(2, "0")}T00:00:00Z`, + }, + ], + }; +} + describe("decodePullRequestListJson", () => { it("reads a pull request as a change request", () => { const batch = expectSuccess( @@ -47,6 +93,7 @@ describe("decodePullRequestListJson", () => { asJson([ pullRequest({ labels: [{ id: "4f1c", name: "release-1.0", active: true, url: null }], + reviewers: [{ uniqueName: "jane@acme.dev", vote: 10 }], }), ]), ), @@ -63,6 +110,8 @@ describe("decodePullRequestListJson", () => { isDraft: false, mergeability: "mergeable", labels: [{ name: "release-1.0" }], + reviewDecision: "approved", + reviewRequestLogins: [], }); }); @@ -175,6 +224,83 @@ describe("decodePullRequestJson", () => { expect(detail).toBeNull(); }); + + it.each([ + ["approved by a required reviewer", [{ vote: 10, isRequired: true }], [], "approved"], + ["rejected", [{ vote: -10 }], [], "changes-requested"], + ["not yet voted on", [{ vote: 0, isRequired: true }], ["me@example.com"], "review-required"], + [ + "approved but waiting on a required group", + [{ vote: 10 }, { uniqueName: "reviewers", vote: 0, isRequired: true }], + ["reviewers"], + "review-required", + ], + [ + "approved with suggestions, with an optional reviewer still to vote", + [{ vote: 5 }, { uniqueName: "jane@example.com", vote: 0 }], + ["jane@example.com"], + "approved", + ], + [ + "sent back to its author despite an approval", + [{ vote: -5 }, { uniqueName: "jane@example.com", vote: 10, isRequired: true }], + [], + "changes-requested", + ], + ["without reviewers", [], [], null], + ["approved only by its author", [{ uniqueName: "BILAL@ACME.DEV", vote: 10 }], [], null], + [ + "rejected only by its author", + [{ uniqueName: "BILAL@ACME.DEV", vote: -10 }, { vote: 5 }], + [], + "approved", + ], + ["with a new positive vote", [{ vote: 20 }], ["me@example.com"], "review-required"], + ["with a new negative vote", [{ vote: -20 }], ["me@example.com"], "review-required"], + [ + "waiting on an unknown required vote despite an approval", + [{ vote: 10 }, { uniqueName: "required", vote: 20, isRequired: true }], + ["required"], + "review-required", + ], + ["with an absent vote", [{}], ["me@example.com"], "review-required"], + ["with a null vote", [{ vote: null }], ["me@example.com"], "review-required"], + ])( + "reads the reviewers' votes on a pull request %s", + (_case, votes, reviewRequestLogins, reviewDecision) => { + const detail = expectSuccess( + decodePullRequestJson( + asJson( + pullRequest({ + reviewers: votes.map((vote) => ({ + displayName: "Reviewer", + uniqueName: "me@example.com", + ...vote, + })), + }), + ), + ), + ); + expect(detail).toMatchObject({ reviewRequestLogins, reviewDecision }); + }, + ); + + it("recognizes the author's normalized identity even when their login changed", () => { + const detail = expectSuccess( + decodePullRequestJson( + asJson( + pullRequest({ + createdBy: { id: BILAL_ID, uniqueName: "new@acme.dev" }, + reviewers: [ + { id: BILAL_ID.replaceAll("-", "").toUpperCase(), uniqueName: "old", vote: -10 }, + { id: JANE_ID, uniqueName: "jane@acme.dev", vote: 10 }, + ], + }), + ), + ), + ); + expect(detail?.reviewDecision).toBe("approved"); + }); }); describe("decodeThreadsJson", () => { @@ -280,6 +406,229 @@ describe("decodeThreadsJson", () => { expect(comments).toEqual([]); }); + + it.each([ + ["10", "APPROVED"], + [5, "APPROVED"], + ["-10", "CHANGES_REQUESTED"], + [-5, "CHANGES_REQUESTED"], + ["0", "DISMISSED"], + [0, "DISMISSED"], + ])("reads legacy vote %s as %s without using the system author", (vote, reviewState) => { + const thread = voteThread({ + id: 2, + vote, + voterId: JANE_ID.replaceAll("-", "").toUpperCase(), + voterName: "Jane Doe", + }); + const comments = expectSuccess(decodeThreadsJson(asJson({ value: [thread] }), reviewersById())); + expect(comments).toMatchObject([ + { + id: "2:1", + kind: "review", + reviewState, + author: { login: "jane@acme.dev" }, + createdAt: "2026-07-02T00:00:00Z", + path: null, + }, + ]); + }); + + it("resolves the voter dictionary before legacy fields, not the initiating identity or author", () => { + const thread = voteThread({ id: 2, vote: "10", voterId: BILAL_ID, voterName: "Bilal" }); + const comments = expectSuccess( + decodeThreadsJson( + asJson({ + value: [ + { + ...thread, + properties: { + ...thread.properties, + CodeReviewVotedByIdentity: { $value: "1" }, + CodeReviewVotedByInitiatorIdentity: { $value: "2" }, + }, + identities: { + "1": { id: JANE_ID.replaceAll("-", "").toUpperCase(), displayName: "Old name" }, + "2": { id: BILAL_ID, uniqueName: "initiator@acme.dev" }, + }, + }, + { + ...thread, + id: 3, + properties: { + CodeReviewThreadType: { $value: "VoteUpdate" }, + CodeReviewVoteResult: { $value: "-5" }, + CodeReviewVotedByIdentity: { $value: 1 }, + }, + identities: { "1": { id: JANE_ID, uniqueName: "jane@acme.dev" } }, + comments: [{ ...thread.comments[0], author: { uniqueName: "jane@acme.dev" } }], + }, + ], + }), + reviewersById(), + ), + ); + expect(comments.map((comment) => [comment.author?.login, comment.reviewState])).toEqual([ + ["jane@acme.dev", "APPROVED"], + ["jane@acme.dev", "CHANGES_REQUESTED"], + ]); + }); + + it.each(["legacy", "dictionary"] as const)( + "keeps former voters with the same display name distinct through %s identities", + (source) => { + const threads = ["0f0f0f0f", "0e0e0e0e"].map((prefix, index) => { + const id = `${prefix}-0000-0000-0000-000000000000`; + const thread = voteThread({ id: index + 2, vote: 10, voterId: id, voterName: "Sam Lee" }); + return source === "legacy" + ? thread + : { + ...thread, + properties: { + CodeReviewThreadType: { $value: "VoteUpdate" }, + CodeReviewVoteResult: { $value: "10" }, + CodeReviewVotedByIdentity: { $value: "1" }, + }, + identities: { "1": { id, displayName: "Sam Lee" } }, + }; + }); + const comments = expectSuccess( + decodeThreadsJson(asJson({ value: threads }), reviewersById()), + ); + expect(comments.map((comment) => comment.author)).toEqual([ + { login: "0f0f0f0f000000000000000000000000", name: "Sam Lee", avatarUrl: null }, + { login: "0e0e0e0e000000000000000000000000", name: "Sam Lee", avatarUrl: null }, + ]); + }, + ); + + it("keeps a dictionary voter's login after they leave the reviewer list", () => { + const thread = voteThread({ id: 2, vote: "10", voterId: BILAL_ID, voterName: "Bilal" }); + const comments = expectSuccess( + decodeThreadsJson( + asJson({ + value: [ + { + ...thread, + properties: { + CodeReviewThreadType: { $value: "VoteUpdate" }, + CodeReviewVoteResult: { $value: "10" }, + CodeReviewVotedByIdentity: { $value: "1" }, + }, + identities: { + "1": { id: JANE_ID, displayName: "Jane", uniqueName: "former@acme.dev" }, + }, + }, + ], + }), + ), + ); + expect(comments[0]?.author?.login).toBe("former@acme.dev"); + }); + + it("falls back to legacy identity fields when the dictionary reference is absent or unusable", () => { + const thread = voteThread({ id: 2, vote: "10", voterId: JANE_ID, voterName: "Jane" }); + const comments = expectSuccess( + decodeThreadsJson( + asJson({ + value: [ + { ...thread, identities: null }, + { + ...thread, + id: 3, + properties: { + ...thread.properties, + CodeReviewVotedByIdentity: { $value: "missing" }, + }, + identities: {}, + }, + { + ...thread, + id: 4, + properties: { ...thread.properties, CodeReviewVotedByIdentity: { $value: "1" } }, + identities: { "1": {} }, + }, + { + ...thread, + id: 5, + properties: { + ...thread.properties, + CodeReviewVotedByIdentity: { $value: "1" }, + }, + identities: { "1": null }, + }, + ], + }), + reviewersById(), + ), + ); + expect(comments.map((comment) => comment.author?.login)).toEqual([ + "jane@acme.dev", + "jane@acme.dev", + "jane@acme.dev", + "jane@acme.dev", + ]); + }); + + it("replays resets once with stable ids and leaves unrelated replies as comments", () => { + const threads = [5, 0, 5].map((vote, index) => + voteThread({ id: index + 2, vote, voterId: JANE_ID, voterName: "Jane" }), + ); + const first = threads[0]; + if (first === undefined) throw new Error("expected a vote thread"); + const payload = asJson({ + value: [ + ...threads, + { + ...first, + id: 5, + comments: [ + { ...first.comments[0], content: "Unknown voter." }, + { id: 2, content: "Thanks.", publishedDate: "2026-07-06T00:00:00Z" }, + ], + properties: { + CodeReviewThreadType: { $value: "VoteUpdate" }, + CodeReviewVoteResult: { $value: "10" }, + }, + }, + ], + }); + const comments = expectSuccess(decodeThreadsJson(payload, reviewersById())); + expect(expectSuccess(decodeThreadsJson(payload, reviewersById()))).toEqual(comments); + expect(comments.map((comment) => [comment.id, comment.reviewState])).toEqual([ + ["2:1", "APPROVED"], + ["3:1", "DISMISSED"], + ["4:1", "APPROVED"], + ["5:1", "APPROVED"], + ["5:2", null], + ]); + expect(comments[3]?.author).toBeNull(); + expect(comments[4]?.kind).toBe("issue-comment"); + }); + + it.each([null, "", " ", "not a vote", "20", "-20"])( + "does not infer a vote from prose when its value is %s", + (vote) => { + const thread = voteThread({ id: 2, vote, voterId: JANE_ID, voterName: "Jane" }); + const comments = expectSuccess( + decodeThreadsJson( + asJson({ + value: [ + { + ...thread, + comments: [ + { ...thread.comments[0], content: "Jane approved the pull request." }, + { id: 2, content: "Ordinary reply.", publishedDate: "2026-07-03T00:00:00Z" }, + ], + }, + ], + }), + reviewersById(), + ), + ); + expect(comments).toMatchObject([{ id: "2:2", kind: "issue-comment", reviewState: null }]); + }, + ); }); describe("decodeIterationsJson", () => { diff --git a/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.ts b/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.ts index 40bdcf72c7fbd..21a0365cba9f8 100644 --- a/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.ts +++ b/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.ts @@ -13,6 +13,7 @@ import type { PullRequestLabel, PullRequestMergeMethod, PullRequestMergeability, + PullRequestReviewDecision, PullRequestState, } from "@t3tools/contracts"; import { TrimmedNonEmptyString } from "@t3tools/contracts"; @@ -22,11 +23,23 @@ import { azureDevOpsPullRequestWebUrl } from "./azureDevOpsPullRequests.ts"; // CLI fields vary by command; unknown enum values must not fail the payload. const RawIdentitySchema = Schema.Struct({ + id: Schema.optional(Schema.NullOr(Schema.String)), displayName: Schema.optional(Schema.NullOr(Schema.String)), uniqueName: Schema.optional(Schema.NullOr(Schema.String)), imageUrl: Schema.optional(Schema.NullOr(Schema.String)), }); +const RawReviewerSchema = Schema.Struct({ + ...RawIdentitySchema.fields, + /** 10 approved, 5 approved with suggestions, 0 none, -5 waiting for author, -10 rejected. */ + vote: Schema.optional(Schema.NullOr(Schema.Number)), + isRequired: Schema.optional(Schema.NullOr(Schema.Boolean)), +}); + +const RawThreadPropertySchema = Schema.optional( + Schema.NullOr(Schema.Struct({ $value: Schema.optional(Schema.Unknown) })), +); + const RawLabelSchema = Schema.Struct({ name: Schema.optional(Schema.NullOr(Schema.String)) }); const RawPullRequestSchema = Schema.Struct({ @@ -47,7 +60,7 @@ const RawPullRequestSchema = Schema.Struct({ ), mergeStatus: Schema.optional(Schema.NullOr(Schema.String)), createdBy: Schema.optional(Schema.NullOr(RawIdentitySchema)), - reviewers: Schema.optional(Schema.NullOr(Schema.Array(RawIdentitySchema))), + reviewers: Schema.optional(Schema.NullOr(Schema.Array(RawReviewerSchema))), /** `az repos pr list` fills this; `az repos pr show` returns null. */ labels: Schema.optional(Schema.NullOr(Schema.Array(RawLabelSchema))), sourceRefName: TrimmedNonEmptyString, @@ -80,6 +93,18 @@ const RawPullRequestSchema = Schema.Struct({ const RawThreadSchema = Schema.Struct({ id: Schema.Int, isDeleted: Schema.optional(Schema.NullOr(Schema.Boolean)), + properties: Schema.optional( + Schema.NullOr( + Schema.Struct({ + CodeReviewThreadType: RawThreadPropertySchema, + CodeReviewVoteResult: RawThreadPropertySchema, + CodeReviewVotedByTfId: RawThreadPropertySchema, + CodeReviewVotedByDisplayName: RawThreadPropertySchema, + CodeReviewVotedByIdentity: RawThreadPropertySchema, + }), + ), + ), + identities: Schema.optional(Schema.NullOr(Schema.Record(Schema.String, Schema.Unknown))), threadContext: Schema.optional( Schema.NullOr(Schema.Struct({ filePath: Schema.optional(Schema.NullOr(Schema.String)) })), ), @@ -163,6 +188,9 @@ export interface AzureDevOpsPullRequest { readonly body: string; readonly reviewRequestLogins: ReadonlyArray; readonly reviewers: ReadonlyArray; + /** Keyed by `identityKey`; vote threads can name the voter only by identity id. */ + readonly reviewersById: ReadonlyMap; + readonly reviewDecision: PullRequestReviewDecision | null; readonly labels: ReadonlyArray; readonly location: AzureDevOpsRepositoryLocation | null; readonly autoMergeEnabled: boolean; @@ -177,6 +205,11 @@ function toActor(raw: Schema.Schema.Type | null | unde : { login, name: trimmed(raw?.displayName), avatarUrl: trimmed(raw?.imageUrl) }; } +/** Azure writes identity ids both with and without dashes. */ +function identityKey(id: string | null | undefined): string | null { + return trimmed(id)?.replaceAll("-", "").toLowerCase() || null; +} + function toLabels( raw: ReadonlyArray> | null | undefined, ): ReadonlyArray { @@ -236,13 +269,107 @@ function toAutoMergeMethod( } } +function reviewStateForVote( + vote: number | null | undefined, +): "APPROVED" | "CHANGES_REQUESTED" | "DISMISSED" | null { + switch (vote) { + case 10: + case 5: + return "APPROVED"; + case -10: + case -5: + return "CHANGES_REQUESTED"; + case 0: + return "DISMISSED"; + default: + return null; + } +} + +function isPendingReviewer(reviewer: Schema.Schema.Type): boolean { + const state = reviewStateForVote(reviewer.vote); + return state === null || state === "DISMISSED"; +} + +function toReviewDecision( + allReviewers: ReadonlyArray>, + author: Schema.Schema.Type | null | undefined, +): PullRequestReviewDecision | null { + const authorId = identityKey(author?.id); + const authorLogin = toActor(author)?.login.toLowerCase(); + // An author's own vote is not a review, even if Azure lists them among the reviewers. + const reviewers = allReviewers.filter( + (reviewer) => + !(authorId !== null && identityKey(reviewer.id) === authorId) && + !(authorLogin !== undefined && toActor(reviewer)?.login.toLowerCase() === authorLogin), + ); + if (reviewers.length === 0) return null; + const states = reviewers.map((reviewer) => reviewStateForVote(reviewer.vote)); + if (states.includes("CHANGES_REQUESTED")) return "changes-requested"; + if (reviewers.some((reviewer) => reviewer.isRequired === true && isPendingReviewer(reviewer))) { + return "review-required"; + } + return states.includes("APPROVED") ? "approved" : "review-required"; +} + +type RawThreadProperties = NonNullable["properties"]>; + +function propertyText(property: RawThreadProperties[keyof RawThreadProperties]): string | null { + const value = property?.$value; + return typeof value === "string" || typeof value === "number" ? trimmed(String(value)) : null; +} + +function toVoteReviewState(properties: RawThreadProperties | null | undefined) { + if (propertyText(properties?.CodeReviewThreadType) !== "VoteUpdate") return null; + return reviewStateForVote(Number(propertyText(properties?.CodeReviewVoteResult) ?? NaN)); +} + +const decodeIdentity = Schema.decodeUnknownExit(RawIdentitySchema); + +function toVoter( + thread: Schema.Schema.Type, + reviewersById: ReadonlyMap, +): PullRequestActor | null { + const properties = thread.properties; + // The voter reference, unlike the initiator, indexes this thread's identity dictionary. + const ref = propertyText(properties?.CodeReviewVotedByIdentity); + const identity = ref === null ? undefined : decodeIdentity(thread.identities?.[ref]); + if (identity !== undefined && Exit.isSuccess(identity)) { + const raw = identity.value; + const key = identityKey(raw.id); + const reviewer = key === null ? undefined : reviewersById.get(key); + if (reviewer !== undefined) return reviewer; + // Display names are not unique; former reviewers keep a login or stable Azure identity. + const login = trimmed(raw.uniqueName) ?? key ?? trimmed(raw.displayName); + if (login !== null) { + return { login, name: trimmed(raw.displayName), avatarUrl: trimmed(raw.imageUrl) }; + } + } + const key = identityKey(propertyText(properties?.CodeReviewVotedByTfId)); + const reviewer = key === null ? undefined : reviewersById.get(key); + if (reviewer !== undefined) return reviewer; + const name = propertyText(properties?.CodeReviewVotedByDisplayName); + const login = key ?? name; + return login === null ? null : { login, name, avatarUrl: null }; +} + function toPullRequest( raw: Schema.Schema.Type, ): AzureDevOpsPullRequest | null { const autoMergeMethod = toAutoMergeMethod(raw); - const reviewers = (raw.reviewers ?? []).flatMap((reviewer) => { + const rawReviewers = raw.reviewers ?? []; + const reviewers: PullRequestActor[] = []; + const reviewersById = new Map(); + for (const reviewer of rawReviewers) { const actor = toActor(reviewer); - return actor === null ? [] : [actor]; + if (actor === null) continue; + reviewers.push(actor); + const key = identityKey(reviewer.id); + if (key !== null) reviewersById.set(key, actor); + } + const reviewRequestLogins = rawReviewers.flatMap((reviewer) => { + const login = isPendingReviewer(reviewer) ? toActor(reviewer)?.login : undefined; + return login === undefined ? [] : [login]; }); const closedAt = trimmed(raw.closedDate); const url = trimmed( @@ -272,8 +399,10 @@ function toPullRequest( updatedAt: closedAt ?? raw.creationDate, closedAt, body: raw.description ?? "", - reviewRequestLogins: reviewers.map((reviewer) => reviewer.login), + reviewRequestLogins, reviewers, + reviewersById, + reviewDecision: toReviewDecision(rawReviewers, raw.createdBy), labels: toLabels(raw.labels), location: toLocation(raw), autoMergeEnabled: (raw.autoCompleteSetBy ?? null) !== null, @@ -355,6 +484,7 @@ export function decodeLabelsJson( export function decodeThreadsJson( raw: string, + reviewersById: ReadonlyMap = new Map(), ): Result.Result, DecodeFailure> { const decoded = decodeThreadPage(raw); if (!Result.isSuccess(decoded)) { @@ -367,25 +497,29 @@ export function decodeThreadsJson( const thread = decodedThread.value; if (thread.isDeleted === true) continue; const path = toRepositoryPath(thread.threadContext?.filePath); + const voteReviewState = toVoteReviewState(thread.properties); + const voter = voteReviewState === null ? null : toVoter(thread, reviewersById); for (const comment of thread.comments ?? []) { const publishedDate = trimmed(comment.publishedDate); + const isSystem = comment.commentType?.trim().toLowerCase() === "system"; if ( comment.isDeleted === true || - comment.commentType?.trim().toLowerCase() === "system" || + (isSystem && voteReviewState === null) || (comment.content ?? "").trim().length === 0 || publishedDate === null ) { continue; } + const reviewState = isSystem ? voteReviewState : null; comments.push({ id: `${thread.id}:${comment.id ?? 0}`, - kind: path === null ? "issue-comment" : "review-comment", - author: toActor(comment.author), + kind: reviewState !== null ? "review" : path === null ? "issue-comment" : "review-comment", + author: reviewState === null ? toActor(comment.author) : voter, body: comment.content ?? "", createdAt: publishedDate, url: null, - path, - reviewState: null, + path: reviewState === null ? path : null, + reviewState, }); } } From ac3151a7baabcfb5b8e0bd0faceb229f7290bbb0 Mon Sep 17 00:00:00 2001 From: Alex Vallone Date: Tue, 17 Nov 2026 10:39:31 -0800 Subject: [PATCH 2/2] test(azure-devops): give unrelated vote its own history timestamp Keep the reset/reapproval fixture in its intended chronological order without changing production sorting or weakening its assertions. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- .../src/server/azureDevOpsPullRequestJson.test.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.test.ts b/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.test.ts index e57648bb3651f..2aecc22937e3c 100644 --- a/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.test.ts +++ b/packages/source-control-azure-devops/src/server/azureDevOpsPullRequestJson.test.ts @@ -583,7 +583,11 @@ describe("decodeThreadsJson", () => { ...first, id: 5, comments: [ - { ...first.comments[0], content: "Unknown voter." }, + { + ...first.comments[0], + content: "Unknown voter.", + publishedDate: "2026-07-05T00:00:00Z", + }, { id: 2, content: "Thanks.", publishedDate: "2026-07-06T00:00:00Z" }, ], properties: {