fix(forgejo): find merged pull requests whose head branch was deleted (#33675)

Author: juliusmarminge

packages/source-control-forgejo/src/server/ForgejoSourceControlProvider.test.ts

@@ -961,6 +961,77 @@ it.effect("loads Forgejo pull request references from files and commits views",
   ),
 );
 
+it.effect("finds a merged Forgejo pull request whose head branch was deleted", () =>
+  Effect.gen(function* () {
+    const provider = yield* ForgejoSourceControlProvider.make;
+    const found = yield* provider.listChangeRequests({
+      cwd: "/repo",
+      headSelector: "feature",
+      state: "merged",
+    });
+    assert.deepStrictEqual(
+      found.map((pr) => [pr.number, pr.headRefName]),
+      [[7, "feature"]],
+    );
+  }).pipe(
+    Effect.provide(
+      Layer.mergeAll(
+        Layer.succeed(FileSystem.FileSystem, FileSystem.makeNoop({})),
+        TestSourceControlHost.layer({ process: {} }),
+        Layer.mock(ForgejoCli.ForgejoCli)({
+          resolveRepository: () =>
+            Effect.succeed({
+              login: "work",
+              repository: "maria/project",
+              baseUrl: "https://forgejo.test",
+            }),
+          api: (input) => {
+            const repo = { full_name: "maria/project", owner: { login: "maria" } };
+            const page = new URLSearchParams(input.path.split("?")[1]).get("page");
+            return encodeJsonEffect(
+              page === "1"
+                ? [
+                    {
+                      number: 7,
+                      title: "Merged feature",
+                      html_url: "https://forgejo.test/maria/project/pulls/7",
+                      state: "closed",
+                      merged: true,
+                      merged_at: "2026-10-12T00:00:00Z",
+                      base: { ref: "main", label: "main", sha: "base", repo },
+                      head: { ref: "refs/pull/7/head", label: "feature", sha: "head", repo },
+                    },
+                    {
+                      number: 8,
+                      title: "Merged from a deleted fork",
+                      html_url: "https://forgejo.test/maria/project/pulls/8",
+                      state: "closed",
+                      merged: true,
+                      merged_at: "2026-10-11T00:00:00Z",
+                      base: { ref: "main", label: "main", sha: "base", repo },
+                      head: { ref: "refs/pull/8/head", label: "feature", sha: "fork", repo: null },
+                    },
+                    {
+                      number: 9,
+                      title: "AGit topic",
+                      html_url: "https://forgejo.test/maria/project/pulls/9",
+                      state: "closed",
+                      merged: true,
+                      merged_at: "2026-10-10T00:00:00Z",
+                      flow: 1,
+                      base: { ref: "main", label: "main", sha: "base", repo },
+                      head: { ref: "refs/pull/9/head", label: "feature", sha: "topic", repo },
+                    },
+                  ]
+                : [],
+            ).pipe(Effect.orDie, Effect.map(processOutput));
+          },
+        }),
+      ),
+    ),
+  ),
+);
+
 it.effect(
   "loads Forgejo reactions on comments, reviews and inline threads and resolves review mutations",
   () => {

packages/source-control-forgejo/src/server/ForgejoSourceControlProvider.ts

@@ -343,13 +343,13 @@ export const make = Effect.gen(function* () {
             Schema.Array(ForgejoPullRequestSchema),
           );
           for (const item of items) {
+            const normalized = toForgejoChangeRequest(item);
             if (
-              item.head.ref !== branch ||
+              normalized.headRefName !== branch ||
               (source?.repository && item.head.repo?.full_name !== source.repository) ||
               (source?.owner && item.head.repo?.owner.login !== source.owner)
             )
               continue;
-            const normalized = toForgejoChangeRequest(item);
             if (input.state === "all" || normalized.state === input.state) results.push(normalized);
           }
           if (items.length === 0) break;

packages/source-control-forgejo/src/server/forgejoPullRequestJson.test.ts

@@ -3,12 +3,15 @@ import * as Schema from "effect/Schema";
 
 import {
   ForgejoComment,
+  ForgejoPullRequest,
   ForgejoReview,
+  forgejoChangeRequest,
   forgejoComment,
   forgejoReview,
 } from "./forgejoPullRequestJson.ts";
 
 const decodeForgejoComment = Schema.decodeSync(ForgejoComment);
+const decodeForgejoPullRequest = Schema.decodeSync(ForgejoPullRequest);
 const decodeForgejoReview = Schema.decodeSync(ForgejoReview);
 
 describe("forgejoComment", () => {
@@ -41,6 +44,46 @@ describe("forgejoComment", () => {
   });
 });
 
+describe("forgejoChangeRequest", () => {
+  const headBranch = (
+    head: { ref: string; label?: string; repo: { full_name: string } | null },
+    flow?: number,
+  ) =>
+    forgejoChangeRequest(
+      decodeForgejoPullRequest({
+        number: 7,
+        title: "Merged feature",
+        body: null,
+        html_url: "https://forgejo.test/maria/project/pulls/7",
+        user: null,
+        state: "closed",
+        merged: true,
+        ...(flow === undefined ? {} : { flow }),
+        head: { ...head, sha: "head" },
+        base: { ref: "main", label: "main", sha: "base", repo: null },
+        created_at: "2026-10-10T19:52:40Z",
+        updated_at: "2026-10-12T00:00:00Z",
+        closed_at: "2026-10-12T00:00:00Z",
+        merged_at: "2026-10-12T00:00:00Z",
+        labels: null,
+      }),
+    ).headBranch;
+
+  it("reads a deleted head branch from its label", () => {
+    const head = { ref: "refs/pull/7/head", label: "feature" };
+    const repo = { full_name: "maria/project" };
+    assert.strictEqual(headBranch({ ...head, repo }, 0), "feature");
+    // A deleted fork leaves no repository to say whose `feature` that was.
+    assert.strictEqual(headBranch({ ...head, repo: null }), "refs/pull/7/head");
+    // An AGit label is a `user/topic` name, not a branch.
+    assert.strictEqual(headBranch({ ...head, label: "alice/topic", repo }, 1), "refs/pull/7/head");
+  });
+
+  it("keeps the ref when the server sends no label", () => {
+    assert.strictEqual(headBranch({ ref: "feature", repo: null }), "feature");
+  });
+});
+
 describe("forgejoReview", () => {
   it.each([
     ["REQUEST_CHANGES", false, "CHANGES_REQUESTED"],

packages/source-control-forgejo/src/server/forgejoPullRequestJson.ts

@@ -12,6 +12,7 @@ import type {
 } from "@t3tools/contracts";
 import type { ProviderChangeRequest } from "@t3tools/source-control-core/server/PullRequestProvider";
 import { dedupeChecks } from "@t3tools/source-control-core/server/pullRequestChecks";
+import { forgejoHeadBranch } from "./forgejoPullRequests.ts";
 
 export const ForgejoUser = Schema.Struct({
   login: Schema.String,
@@ -36,6 +37,7 @@ export const ForgejoRepository = Schema.Struct({
 });
 const Branch = Schema.Struct({
   ref: Schema.String,
+  label: Schema.optional(Schema.String),
   sha: Schema.String,
   repo: Schema.NullOr(ForgejoRepository),
 });
@@ -47,6 +49,7 @@ export const ForgejoPullRequest = Schema.Struct({
   user: Schema.NullOr(ForgejoUser),
   state: Schema.String,
   draft: Schema.optional(Schema.Boolean),
+  flow: Schema.optional(Schema.Int),
   merged: Schema.Boolean,
   mergeable: Schema.optional(Schema.Boolean),
   is_locked: Schema.optional(Schema.Boolean),
@@ -130,7 +133,7 @@ export function forgejoChangeRequest(pr: typeof ForgejoPullRequest.Type) {
     title: pr.title,
     url: pr.html_url,
     author: forgejoActor(pr.user),
-    headBranch: pr.head.ref,
+    headBranch: forgejoHeadBranch(pr),
     baseBranch: pr.base.ref,
     headRepositoryNameWithOwner: pr.head.repo?.full_name ?? null,
     state: pr.merged ? "merged" : pr.state === "closed" ? "closed" : "open",

packages/source-control-forgejo/src/server/forgejoPullRequests.ts

@@ -9,16 +9,33 @@ const Repository = Schema.Struct({
 });
 const Branch = Schema.Struct({
   ref: Schema.String,
+  label: Schema.optional(Schema.String),
   sha: Schema.String,
   repo: Schema.NullOr(Repository),
 });
+// Once a pull request's head branch is deleted, Forgejo reports `ref` as `refs/pull/<N>/head`
+// and keeps the branch name only in `label`. An AGit pull request (`flow` 1) has no branch, only a
+// `user/topic` label, and without `repo` (a deleted fork) the label could name any repository's
+// branch, so the ref stays in both cases.
+export function forgejoHeadBranch(pr: {
+  readonly flow?: number | undefined;
+  readonly head: {
+    readonly ref: string;
+    readonly label?: string | undefined;
+    readonly repo: unknown;
+  };
+}) {
+  const { ref, label, repo } = pr.head;
+  return ref.startsWith("refs/pull/") && label && repo !== null && pr.flow !== 1 ? label : ref;
+}
 export const ForgejoPullRequestSchema = Schema.Struct({
   number: Schema.Int,
   title: Schema.String,
   html_url: Schema.String,
   state: Schema.String,
   merged: Schema.Boolean,
   draft: Schema.optional(Schema.Boolean),
+  flow: Schema.optional(Schema.Int),
   base: Branch,
   head: Branch,
   closed_at: Schema.optional(Schema.NullOr(Schema.String)),
@@ -34,7 +51,7 @@ export function toForgejoChangeRequest(raw: typeof ForgejoPullRequestSchema.Type
     state: raw.merged ? "merged" : raw.state === "closed" ? "closed" : "open",
     isDraft: raw.draft ?? /^(?:\[WIP\]|WIP:)/i.test(raw.title),
     baseRefName: raw.base.ref,
-    headRefName: raw.head.ref,
+    headRefName: forgejoHeadBranch(raw),
     ...(raw.head.sha.trim().length > 0 ? { headSha: raw.head.sha.trim() } : {}),
     closedAt: raw.closed_at ?? null,
     mergedAt: raw.merged_at ?? null,