diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts index f047fe771f1d2..e25888ca251f9 100644 --- a/apps/server/src/orchestration-v2/Orchestrator.ts +++ b/apps/server/src/orchestration-v2/Orchestrator.ts @@ -5065,6 +5065,9 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio conflicting: existing.endedWatch.conflicting, rebaseRequired: existing.endedWatch.rebaseRequired, }), + ...(existing.endedWatch?.failedRuns !== undefined && { + failedRuns: existing.endedWatch.failedRuns, + }), awaitingBaseline: existing.endedWatch ? existing.endedWatch.awaitingBaseline : "all", diff --git a/apps/server/src/orchestration-v2/PullRequestWatchReactor.ts b/apps/server/src/orchestration-v2/PullRequestWatchReactor.ts index 3485765a0ed93..4b5f8c64873b6 100644 --- a/apps/server/src/orchestration-v2/PullRequestWatchReactor.ts +++ b/apps/server/src/orchestration-v2/PullRequestWatchReactor.ts @@ -206,6 +206,7 @@ function watchesEqual(left: ThreadPullRequestWatch, right: ThreadPullRequestWatc left.startedAt === right.startedAt && left.headSha === right.headSha && left.failedChecks.join("\n") === right.failedChecks.join("\n") && + left.failedRuns?.join("\n") === right.failedRuns?.join("\n") && left.passed === right.passed && left.passedChecks.join("\n") === right.passedChecks.join("\n") && (left.owedChecks ?? []).join("\n") === (right.owedChecks ?? []).join("\n") && diff --git a/apps/server/src/orchestration-v2/pullRequestWatch.test.ts b/apps/server/src/orchestration-v2/pullRequestWatch.test.ts index 7275fd845b373..f4bf63c5b1e99 100644 --- a/apps/server/src/orchestration-v2/pullRequestWatch.test.ts +++ b/apps/server/src/orchestration-v2/pullRequestWatch.test.ts @@ -480,6 +480,89 @@ describe("evaluatePullRequestWatch", () => { ]); }); + it("reports a rerun that fails again between two reads", () => { + const run = (job: number): PullRequestCheck => ({ + ...check("lint", "failure"), + url: `https://ci.example/lint/job/${job}`, + required: true, + }); + const first = evaluatePullRequestWatch(watch(), detail({ checks: [run(1)] }), noRemarks); + assert.deepEqual(first.changes, [{ kind: "checks-failed", failed: [run(1)] }]); + const again = evaluatePullRequestWatch(first.next, detail({ checks: [run(2)] }), noRemarks); + assert.deepEqual(again.changes, [{ kind: "checks-failed", failed: [run(2)] }]); + // A status can link a build shared with another check; it is that check's run, not lint's. + const shared = { ...check("test", "failure"), url: "https://ci.example/lint/job/3" }; + const both = evaluatePullRequestWatch( + again.next, + detail({ checks: [run(2), shared] }), + noRemarks, + ); + assert.deepEqual( + evaluatePullRequestWatch(both.next, detail({ checks: [run(3), shared] }), noRemarks).changes, + [{ kind: "checks-failed", failed: [run(3)] }], + ); + // Neither the same run nor one told earlier on this head is news again. + for (const job of [2, 1]) { + assert.deepEqual( + evaluatePullRequestWatch(again.next, detail({ checks: [run(job)] }), noRemarks).changes, + [], + ); + } + // A GitLab pipeline retry keeps its URL; only when it finished tells the runs apart. + const pipeline = (finishedAt: string) => ({ ...check("Pipeline", "failure"), finishedAt }); + const told = evaluatePullRequestWatch( + watch(), + detail({ checks: [pipeline("00:01")] }), + noRemarks, + ); + assert.deepEqual( + evaluatePullRequestWatch(told.next, detail({ checks: [pipeline("00:03")] }), noRemarks) + .changes, + [{ kind: "checks-failed", failed: [pipeline("00:03")] }], + ); + }); + + it("reports one failure of a check whose push and pull_request runs both fail", () => { + const run = (job: number, startedAt: string, finishedAt: string): PullRequestCheck => ({ + ...check("lint", "failure"), + url: `https://ci.example/lint/job/${job}`, + startedAt: `2026-11-16T00:${startedAt}Z`, + finishedAt: `2026-11-16T00:${finishedAt}Z`, + }); + const push = run(1, "00:00", "01:00"); + const pullRequest = run(2, "00:01", "02:00"); + const rerunOfPush = run(3, "02:30", "03:00"); + const first = evaluatePullRequestWatch(watch(), detail({ checks: [push] }), noRemarks); + const second = evaluatePullRequestWatch( + first.next, + detail({ checks: [pullRequest] }), + noRemarks, + ); + assert.deepEqual(second.changes, []); + // The read may also show only the pull_request run first, the push one never seen. + const onlyPullRequest = evaluatePullRequestWatch( + watch(), + detail({ checks: [pullRequest] }), + noRemarks, + ); + for (const told of [second.next, onlyPullRequest.next]) { + assert.deepEqual( + evaluatePullRequestWatch(told, detail({ checks: [rerunOfPush] }), noRemarks).changes, + [{ kind: "checks-failed", failed: [rerunOfPush] }], + ); + } + }); + + it("does not repeat a failure an older watch told by name", () => { + const older = watch({ headSha: "aaaaaaaaaa", failedChecks: ["lint"] }); + const failed = detail({ checks: [check("lint", "failure")] }); + const report = evaluatePullRequestWatch(older, failed, noRemarks); + assert.deepEqual(report.changes, []); + assert.deepEqual(report.next.failedRuns, [ + JSON.stringify(["lint", "https://ci.example/lint", null]), + ]); + }); + it("reports passed once the required checks pass, whatever the others do", () => { const required = (name: string, status: PullRequestCheck["status"]) => ({ ...check(name, status), diff --git a/apps/server/src/orchestration-v2/pullRequestWatch.ts b/apps/server/src/orchestration-v2/pullRequestWatch.ts index e4a00f0624244..61c30df174d0f 100644 --- a/apps/server/src/orchestration-v2/pullRequestWatch.ts +++ b/apps/server/src/orchestration-v2/pullRequestWatch.ts @@ -61,6 +61,7 @@ export function evaluatePullRequestWatch( // Hosts can return no checks on read failure; preserve prior state. let failedChecks = headMoved ? [] : watch.failedChecks; + let failedRuns = headMoved ? [] : watch.failedRuns; let passed = headMoved ? false : watch.passed; let passedChecks = headMoved ? [] : watch.passedChecks; let owedChecks = headMoved ? [] : (watch.owedChecks ?? []); @@ -77,7 +78,27 @@ export function evaluatePullRequestWatch( if (checks.length > 0) { // A run awaiting approval waits on a person, like a review, so only running checks count. checksPending = checks.some((check) => check.status === "pending"); - const newlyFailed = failed.filter((check) => !failedChecks.includes(check.name)); + // A new failed run of a failing check is a rerun that failed again between reads. A GitLab + // pipeline retry keeps its URL, so its finish time tells it apart. + const toldRuns = failedRuns; + const runOf = (check: PullRequestCheck) => + check.url === null ? null : JSON.stringify([check.name, check.url, check.finishedAt ?? null]); + const isRerun = (check: PullRequestCheck) => { + const run = runOf(check); + if (toldRuns === undefined || run === null || toldRuns.includes(run)) return false; + if (check.startedAt === undefined) return true; + // A run that started before every failure seen of its check finished ran beside them, like + // GitHub's push and pull_request runs of one commit: the same failure, not a rerun. + const toldFinishes = toldRuns.flatMap((told) => { + const [name, , finishedAt] = JSON.parse(told) as [string, string, string | null]; + return name === check.name && finishedAt !== null ? [Date.parse(finishedAt)] : []; + }); + const startedAt = Date.parse(check.startedAt); + return toldFinishes.length === 0 || toldFinishes.some((finishedAt) => startedAt > finishedAt); + }; + const newlyFailed = failed.filter( + (check) => !failedChecks.includes(check.name) || isRerun(check), + ); if (!checksBaseline && newlyFailed.length > 0) { changes.push({ kind: "checks-failed", failed: newlyFailed }); } @@ -86,6 +107,10 @@ export function evaluatePullRequestWatch( approvalAnnounced = true; } failedChecks = failed.map((check) => check.name); + // Runs told stay told for the head: GitHub can show either event's failed run of one check. + failedRuns = [ + ...new Set([...(toldRuns ?? []), ...failed.flatMap((check) => runOf(check) ?? [])]), + ]; // Approval reads can omit gated runs. Keep each hold until its jobs finish. const awaitingNow = [...new Set(awaiting.map(approvalKey))]; @@ -238,6 +263,7 @@ export function evaluatePullRequestWatch( startedAt: watch.startedAt, headSha, failedChecks, + ...(failedRuns !== undefined && { failedRuns }), passed, passedChecks, owedChecks, diff --git a/packages/contracts/src/pullRequest.ts b/packages/contracts/src/pullRequest.ts index d438080369a40..710c80922370b 100644 --- a/packages/contracts/src/pullRequest.ts +++ b/packages/contracts/src/pullRequest.ts @@ -116,6 +116,9 @@ export const PullRequestCheck = Schema.Struct({ description: Schema.NullOr(Schema.String), url: Schema.NullOr(Schema.String), required: Schema.optional(Schema.Boolean), + /** When a finished run started and finished, so a watch can tell a rerun from a run beside it. */ + startedAt: Schema.optional(Schema.String), + finishedAt: Schema.optional(Schema.String), /** * Not a check: it stands for ones the host could not list, such as workflow runs awaiting * approval when that read fails, so nothing waits on it or counts it as passing. diff --git a/packages/contracts/src/threadPullRequest.ts b/packages/contracts/src/threadPullRequest.ts index 0c8d7a61fe92d..e22e7d23fbb9d 100644 --- a/packages/contracts/src/threadPullRequest.ts +++ b/packages/contracts/src/threadPullRequest.ts @@ -84,6 +84,8 @@ export const ThreadPullRequestWatch = Schema.Struct({ startedAt: IsoDateTime, headSha: Schema.NullOr(TrimmedNonEmptyString), failedChecks: Schema.Array(TrimmedNonEmptyString), + /** Each failed run seen on this head (check, URL, finish time), so a rerun failing is news. */ + failedRuns: Schema.optional(Schema.Array(Schema.String)), passed: Schema.Boolean, passedChecks: Schema.Array(TrimmedNonEmptyString).pipe( Schema.withDecodingDefault(Effect.succeed([])), diff --git a/packages/source-control-core/src/server/pullRequestChecks.test.ts b/packages/source-control-core/src/server/pullRequestChecks.test.ts index 4f6538f833f9a..f083735804653 100644 --- a/packages/source-control-core/src/server/pullRequestChecks.test.ts +++ b/packages/source-control-core/src/server/pullRequestChecks.test.ts @@ -59,6 +59,21 @@ describe("dedupeChecks", () => { expect([forward[0]?.status, reversed[0]?.status]).toEqual(["failure", "failure"]); }); + it("reports the same run for two events' failures finished at once, whichever is listed first", () => { + const failed = (event: string) => ({ + ...entry("lint", "failure", { at: "2026-11-07T00:01:00Z" }), + check: { name: "lint", status: "failure" as const, description: null, url: event }, + event, + }); + + expect( + [ + [failed("push"), failed("pull_request")], + [failed("pull_request"), failed("push")], + ].map((runs) => dedupeChecks(runs)[0]?.url), + ).toEqual(["push", "push"]); + }); + it("takes the higher sequence when instants tie, whichever is listed first", () => { const final = entry("build", "success", { at: "2026-10-12T10:14:29Z", sequence: 15 }); const pending = entry("build", "pending", { at: "2026-10-12T10:14:29Z", sequence: 14 }); diff --git a/packages/source-control-core/src/server/pullRequestChecks.ts b/packages/source-control-core/src/server/pullRequestChecks.ts index c4cea3e162dec..280d58fcdbf80 100644 --- a/packages/source-control-core/src/server/pullRequestChecks.ts +++ b/packages/source-control-core/src/server/pullRequestChecks.ts @@ -59,9 +59,18 @@ export function sortChecks( ); } +// Runs of one check for different events: a failure outranks a run in progress, which outranks a +// pass, which outranks a run cancelled beside it (a concurrency group superseding it). +function eventSeverity(status: PullRequestCheck["status"]): number { + if (status === "failure" || status === "action-required") return 3; + if (status === "pending") return 2; + return status === "success" ? 1 : 0; +} + /** * Rollups repeat checks during reruns or overlapping runs, and checks carry no ids. * Identify checks by workflow plus name because different workflows may share job names. + * Within one event the newest run wins; across events the worse run does. */ export function dedupeChecks( entries: ReadonlyArray<{ @@ -70,12 +79,15 @@ export function dedupeChecks( readonly at: string | null; // Hosts with one-second timestamps can date a final and an earlier status alike. readonly sequence?: number; + /** What triggered the run, where the host says (GitHub's `push` or `pull_request`). */ + readonly event?: string | null; }>, ): ReadonlyArray { - const newestByCheck = new Map(); + type Entry = (typeof entries)[number]; + const newestByRun = new Map(); for (const entry of entries) { - const key = JSON.stringify([entry.workflowName ?? "", entry.check.name]); - const kept = newestByCheck.get(key); + const key = JSON.stringify([entry.workflowName ?? "", entry.check.name, entry.event ?? null]); + const kept = newestByRun.get(key); if (kept !== undefined) { if (!isAtLeastAsNew(entry.at, kept.at)) continue; if ( @@ -86,7 +98,29 @@ export function dedupeChecks( ) continue; } - newestByCheck.set(key, entry); + newestByRun.set(key, entry); + } + const newestByCheck = new Map(); + for (const entry of newestByRun.values()) { + const key = JSON.stringify([entry.workflowName ?? "", entry.check.name]); + const kept = newestByCheck.get(key); + if (kept === undefined) { + newestByCheck.set(key, entry); + continue; + } + const severity = eventSeverity(entry.check.status) - eventSeverity(kept.check.status); + const newer = isAtLeastAsNew(entry.at, kept.at); + // Equal times break on the event, so a reordered rollup cannot flip the run a watch was told. + const tied = newer && isAtLeastAsNew(kept.at, entry.at); + const later = tied ? (entry.event ?? "") > (kept.event ?? "") : newer; + const worse = severity > 0 || (severity === 0 && later); + const chosen = worse ? entry : kept; + newestByCheck.set( + key, + entry.check.required === true || kept.check.required === true + ? { ...chosen, check: { ...chosen.check, required: true } } + : chosen, + ); } const survivors = [...newestByCheck.values()]; const countsByName = new Map(); diff --git a/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts b/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts index 5668eedceb69f..392bfe23631c7 100644 --- a/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts +++ b/packages/source-control-github/src/server/GitHubPullRequestApi.test.ts @@ -3755,13 +3755,17 @@ layer("GitHubPullRequestApi.layer", (it) => { name: "build", status: "COMPLETED", conclusion: "SUCCESS", - checkSuite: { workflowRun: { workflow: { name: "linux" } } }, + checkSuite: { + workflowRun: { event: "push", workflow: { name: "linux" } }, + }, }), checkRun({ name: "build", status: "COMPLETED", conclusion: "FAILURE", - checkSuite: { workflowRun: { workflow: { name: "windows" } } }, + checkSuite: { + workflowRun: { event: "push", workflow: { name: "windows" } }, + }, }), ], pageInfo: { hasNextPage: false, endCursor: null }, diff --git a/packages/source-control-github/src/server/gitHubPullRequestJson.test.ts b/packages/source-control-github/src/server/gitHubPullRequestJson.test.ts index 5f084ac203fb6..1ad4e70860794 100644 --- a/packages/source-control-github/src/server/gitHubPullRequestJson.test.ts +++ b/packages/source-control-github/src/server/gitHubPullRequestJson.test.ts @@ -362,7 +362,7 @@ describe("pull request detail decoding", () => { const inWorkflow = ({ workflowName, ...fields }: Record) => check({ ...fields, - checkSuite: { workflowRun: { workflow: { name: workflowName } } }, + checkSuite: { workflowRun: { event: "pull_request", workflow: { name: workflowName } } }, }); const coreJson = ( @@ -633,6 +633,76 @@ describe("pull request detail decoding", () => { } }); + it("keeps a failed push run failing while the pull_request run of it runs or passes", () => { + const run = (event: string, fields: Record) => + check({ + name: "lint", + checkSuite: { workflowRun: { event, workflow: { name: "CI" } } }, + ...fields, + }); + const pushFailed = run("push", { + status: "COMPLETED", + conclusion: "FAILURE", + startedAt: "2026-10-08T04:06:10Z", + completedAt: "2026-10-08T04:08:00Z", + }); + // Only the losing run says the check is required; the merged check must still say so. + const pullRequestRunning = run("pull_request", { + isRequired: true, + status: "IN_PROGRESS", + conclusion: null, + startedAt: "2026-10-08T04:06:13Z", + completedAt: "0001-01-01T00:00:00Z", + }); + const pullRequestPassed = run("pull_request", { + isRequired: true, + status: "COMPLETED", + conclusion: "SUCCESS", + startedAt: "2026-10-08T04:06:13Z", + completedAt: "2026-10-08T04:12:00Z", + }); + const checksOf = (rollup: ReadonlyArray>) => { + const detail = detailOf(rollup); + return [ + detail.checks.map((check) => [check.name, check.status, check.required]), + detail.checksState, + ]; + }; + + const rollups = [ + [pushFailed, pullRequestRunning], + [pullRequestRunning, pushFailed], + [pushFailed, pullRequestPassed], + [pullRequestPassed, pushFailed], + ]; + expect(rollups.map(checksOf)).toEqual( + rollups.map(() => [[["lint", "failure", true]], "failing"]), + ); + }); + + it("does not fail a check whose run of one event was cancelled beside a passing run", () => { + const run = (event: string, conclusion: string, completedAt: string) => + check({ + name: "lint", + conclusion, + completedAt, + checkSuite: { workflowRun: { event, workflow: { name: "CI" } } }, + }); + const passed = run("push", "SUCCESS", "2026-10-08T04:10:00Z"); + const cancelled = run("pull_request", "CANCELLED", "2026-10-08T04:12:00Z"); + + for (const rollup of [ + [passed, cancelled], + [cancelled, passed], + ]) { + const detail = detailOf(rollup); + expect([detail.checks.map((check) => check.status), detail.checksState]).toEqual([ + ["success"], + "passing", + ]); + } + }); + it("merges reviews with comments in time order and keeps a bodyless approval", () => { const detail = expectSuccess(activity(JSON.parse(detailJson) as Record)); expect(detail.comments.map((comment) => comment.id)).toEqual(["r1", "c1", "r2"]); diff --git a/packages/source-control-github/src/server/gitHubPullRequestJson.ts b/packages/source-control-github/src/server/gitHubPullRequestJson.ts index a2b3f3c2c3edd..47a3b286545a0 100644 --- a/packages/source-control-github/src/server/gitHubPullRequestJson.ts +++ b/packages/source-control-github/src/server/gitHubPullRequestJson.ts @@ -143,6 +143,8 @@ interface CheckFields { readonly targetUrl?: string | null | undefined; /** Empty for app-owned runs; absent for commit statuses. */ readonly workflowName?: string | null | undefined; + /** Absent for commit statuses and `gh` JSON; null for app-owned runs. */ + readonly workflowRun?: { readonly event: string } | null | undefined; readonly startedAt?: string | null | undefined; readonly completedAt?: string | null | undefined; /** Branch protection requires this check; asked for on github.com only. */ @@ -617,16 +619,19 @@ function isNamelessCheck(raw: CheckFields): boolean { return trimmed(raw.name) === null && trimmed(raw.context) === null; } -/** Unfinished runs outrank finished runs of the same check across push/PR workflows. */ +/** Unfinished runs outrank finished runs of the same check, so a rerun replaces its run. */ function toCheckEntries(raw: ReadonlyArray | null | undefined): ReadonlyArray<{ readonly check: PullRequestCheck; readonly workflowName: string | null; readonly at: string | null; + readonly event: string | null; }> { return (raw ?? []).flatMap((check) => { const name = trimmed(check.name) ?? trimmed(check.context); if (name === null) return []; const status = toCheckStatus(check); + const startedAt = realTimestamp(check.startedAt); + const finishedAt = status === "pending" ? null : realTimestamp(check.completedAt); return [ { check: { @@ -635,8 +640,10 @@ function toCheckEntries(raw: ReadonlyArray | null | undefined): Rea description: trimmed(check.description), url: trimmed(check.detailsUrl) ?? trimmed(check.targetUrl), ...(typeof check.isRequired === "boolean" ? { required: check.isRequired } : {}), + ...(startedAt !== null && finishedAt !== null && { startedAt, finishedAt }), }, workflowName: trimmed(check.workflowName), + event: trimmed(check.workflowRun?.event), at: status === "pending" ? STILL_RUNNING @@ -1242,7 +1249,11 @@ export type GitHubCheckContext = CheckFields; function toCheckContexts(nodes: ReadonlyArray): ReadonlyArray { return nodes.map((check) => check.__typename === "CheckRun" - ? { ...check, workflowName: check.checkSuite.workflowRun?.workflow.name ?? null } + ? { + ...check, + workflowName: check.checkSuite.workflowRun?.workflow.name ?? null, + workflowRun: check.checkSuite.workflowRun, + } : check, ); } diff --git a/packages/source-control-github/src/server/pullRequestReads.graphql b/packages/source-control-github/src/server/pullRequestReads.graphql index 88fbe80828e1e..86edaa794a566 100644 --- a/packages/source-control-github/src/server/pullRequestReads.graphql +++ b/packages/source-control-github/src/server/pullRequestReads.graphql @@ -42,6 +42,7 @@ fragment CheckContext on StatusCheckRollupContext { isRequired(pullRequestNumber: $number) @include(if: $required) checkSuite { workflowRun { + event workflow { name } diff --git a/packages/source-control-github/src/server/pullRequestReads.graphql.ts b/packages/source-control-github/src/server/pullRequestReads.graphql.ts index a12334d8f98c3..a60d5f624aeae 100644 --- a/packages/source-control-github/src/server/pullRequestReads.graphql.ts +++ b/packages/source-control-github/src/server/pullRequestReads.graphql.ts @@ -30,6 +30,8 @@ export interface Workflow extends Schema.Struct.Type {} /** A workflow run. */ export const WorkflowRun = Schema.Struct({ + /** The event that triggered the workflow run */ + event: Schema.String, /** The workflow executed in this workflow run. */ workflow: Workflow }) @@ -539,7 +541,7 @@ export const PullRequestCore = GraphQL.query("PullRequestCore", { { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){mergeCommitAllowed squashMergeAllowed rebaseMergeAllowed autoMergeAllowed viewerPermission pullRequest(number:$", "number", "){number title url body state isDraft mergeable mergeStateStatus reviewDecision additions deletions changedFiles createdAt updatedAt mergedAt closedAt headRefName baseRefName headRefOid isCrossRepository maintainerCanModify headRepositoryOwner{__typename login}headRepository{nameWithOwner viewerPermission}headRef{id}author{__typename login avatarUrl...on User{id name}}autoMergeRequest{mergeMethod}mergeQueueRemovals:timelineItems(last:1 itemTypes:[REMOVED_FROM_MERGE_QUEUE_EVENT])@include(if:$", "mergeQueue", "){nodes{__typename...on RemovedFromMergeQueueEvent{id createdAt reason}}}viewerCanUpdate viewerDidAuthor viewerCanUpdateBranch baseRef{compare(headRef:$", "headRef", "){behindBy}}reviewRequests(first:$", "requestedReviewers", "){nodes{requestedReviewer{__typename...on User{login name}...on Bot{login}...on Team{slug combinedSlug teamName:name teamAvatarUrl:avatarUrl}}}}labels(first:100){nodes{name color description}}commits(last:1){nodes{commit{statusCheckRollup{contexts(first:100){nodes{__typename...", "CheckContext", "}pageInfo{hasNextPage endCursor}}}}}}}}"] } ], fragments: [ - { name: "CheckContext", body: ["on StatusCheckRollupContext{__typename...on StatusContext{context state targetUrl createdAt description isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")}...on CheckRun{name status conclusion startedAt completedAt detailsUrl isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")checkSuite{workflowRun{workflow{name}}}}}"] } + { name: "CheckContext", body: ["on StatusCheckRollupContext{__typename...on StatusContext{context state targetUrl createdAt description isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")}...on CheckRun{name status conclusion startedAt completedAt detailsUrl isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")checkSuite{workflowRun{event workflow{name}}}}}"] } ] }, variables: { @@ -591,7 +593,7 @@ export const PullRequestCheckContexts = GraphQL.query("PullRequestCheckContexts" { name: "repository", body: ["(owner:$", "owner", " name:$", "name", "){pullRequest(number:$", "number", "){headRefOid commits(last:1){nodes{commit{statusCheckRollup{contexts(first:100 after:$", "after", "){nodes{__typename...", "CheckContext", "}pageInfo{hasNextPage endCursor}}}}}}}}"] } ], fragments: [ - { name: "CheckContext", body: ["on StatusCheckRollupContext{__typename...on StatusContext{context state targetUrl createdAt description isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")}...on CheckRun{name status conclusion startedAt completedAt detailsUrl isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")checkSuite{workflowRun{workflow{name}}}}}"] } + { name: "CheckContext", body: ["on StatusCheckRollupContext{__typename...on StatusContext{context state targetUrl createdAt description isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")}...on CheckRun{name status conclusion startedAt completedAt detailsUrl isRequired(pullRequestNumber:$", "number", ")@include(if:$", "required", ")checkSuite{workflowRun{event workflow{name}}}}}"] } ] }, variables: { diff --git a/packages/source-control-gitlab/src/server/gitLabMergeRequestJson.test.ts b/packages/source-control-gitlab/src/server/gitLabMergeRequestJson.test.ts index 6905daf47d729..498810c21f2db 100644 --- a/packages/source-control-gitlab/src/server/gitLabMergeRequestJson.test.ts +++ b/packages/source-control-gitlab/src/server/gitLabMergeRequestJson.test.ts @@ -168,6 +168,7 @@ describe("decodeMergeRequestDetailJson", () => { status: "success", web_url: "https://gitlab.com/acme/web/-/pipelines/9", source: "merge_request_event", + finished_at: "2026-11-10T00:39:53.753Z", }, }), ), @@ -182,6 +183,7 @@ describe("decodeMergeRequestDetailJson", () => { status: "success", description: "merge_request_event", url: "https://gitlab.com/acme/web/-/pipelines/9", + finishedAt: "2026-11-10T00:39:53.753Z", }, ]); }); diff --git a/packages/source-control-gitlab/src/server/gitLabMergeRequestJson.ts b/packages/source-control-gitlab/src/server/gitLabMergeRequestJson.ts index daf00998711c7..5435ea5526631 100644 --- a/packages/source-control-gitlab/src/server/gitLabMergeRequestJson.ts +++ b/packages/source-control-gitlab/src/server/gitLabMergeRequestJson.ts @@ -41,6 +41,7 @@ const RawPipelineSchema = Schema.Struct({ status: Schema.optional(Schema.NullOr(Schema.String)), web_url: Schema.optional(Schema.NullOr(Schema.String)), source: Schema.optional(Schema.NullOr(Schema.String)), + finished_at: Schema.optional(Schema.NullOr(Schema.String)), }); const RawTriggerJobSchema = Schema.Struct({ @@ -317,12 +318,14 @@ function toChecks( ): ReadonlyArray { const pipeline = raw.head_pipeline; if (!pipeline) return []; + const finishedAt = trimmed(pipeline.finished_at); return [ { name: "Pipeline", status: toPipelineStatus(pipeline.status), description: trimmed(pipeline.source), url: trimmed(pipeline.web_url), + ...(finishedAt !== null && { finishedAt }), }, ]; }