fix(gitlab): merge requests show their approval state

packages/source-control-gitlab/src/server/GitLabPullRequestCli.ts

@@ -19,6 +19,7 @@ import type {
   PullRequestReaction,
   PullRequestReactionContent,
   PullRequestReviewCommentDraft,
+  PullRequestReviewDecision,
   PullRequestReviewPosition,
   PullRequestReviewThread,
   PullRequestReviewVerdict,
@@ -43,9 +44,11 @@ import {
   decodeProjectLabelsJson,
   decodeProjectUsersJson,
   decodeRepositoryBlobsJson,
+  decodeReviewDecisionsJson,
   decodeViewerJson,
   gitLabAwardName,
   REPOSITORY_BLOBS_GRAPHQL_QUERY,
+  REVIEW_DECISIONS_GRAPHQL_QUERY,
   type GitLabDiffRefs,
   type GitLabMergeRequestDetail,
   type GitLabMergeRequestListItem,
@@ -237,6 +240,15 @@ export class GitLabPullRequestCli extends Context.Service<
       readonly number: number;
     }) => Effect.Effect<GitLabMergeRequestDetail, GitLabPullRequestCliError>;
 
+    readonly getReviewDecisions: (input: {
+      readonly cwd: string;
+      readonly repository: string;
+      readonly numbers: ReadonlyArray<number>;
+    }) => Effect.Effect<
+      ReadonlyMap<number, PullRequestReviewDecision | null>,
+      GitLabPullRequestCliError
+    >;
+
     readonly listNotes: (input: {
       readonly cwd: string;
       readonly repository: string;
@@ -1094,6 +1106,38 @@ export const make = Effect.gen(function* () {
           }),
         );
 
+  const reviewDecisionsOf = (input: {
+    readonly cwd: string;
+    readonly repository: string;
+    readonly numbers: ReadonlyArray<number>;
+  }): Effect.Effect<
+    ReadonlyMap<number, PullRequestReviewDecision | null>,
+    GitLabPullRequestCliError
+  > =>
+    api({
+      cwd: input.cwd,
+      path: "graphql",
+      method: "POST",
+      stdin: JSON.stringify({
+        query: REVIEW_DECISIONS_GRAPHQL_QUERY,
+        variables: { fullPath: input.repository, iids: input.numbers.map(String) },
+      }),
+    }).pipe(
+      Effect.flatMap((result) => {
+        const decoded = decodeReviewDecisionsJson(result.stdout.trim());
+        return Result.isSuccess(decoded)
+          ? Effect.succeed(decoded.success)
+          : Effect.fail(
+              new GitLabMergeRequestReadError({
+                command: "glab",
+                cwd: input.cwd,
+                operation: "getReviewDecisions",
+                cause: decoded.failure,
+              }),
+            );
+      }),
+    );
+
   const viewerUsername = (input: { readonly cwd: string }) =>
     api({ cwd: input.cwd, path: "user" }).pipe(
       Effect.flatMap((result): Effect.Effect<string, GitLabPullRequestCliError> => {
@@ -1125,6 +1169,16 @@ export const make = Effect.gen(function* () {
 
     getMergeRequestDetail: mergeRequestDetail,
 
+    getReviewDecisions: Effect.fn("GitLabPullRequestCli.getReviewDecisions")(function (input) {
+      const batches: Array<ReadonlyArray<number>> = [];
+      for (let at = 0; at < input.numbers.length; at += MAX_PAGE_SIZE) {
+        batches.push(input.numbers.slice(at, at + MAX_PAGE_SIZE));
+      }
+      return Effect.forEach(batches, (numbers) => reviewDecisionsOf({ ...input, numbers }), {
+        concurrency: 2,
+      }).pipe(Effect.map((pages) => new Map(pages.flatMap((page) => [...page]))));
+    }),
+
     listNotes: Effect.fn("GitLabPullRequestCli.listNotes")(function (input) {
       return notesPage({ ...input, page: 1, collected: [] });
     }),

packages/source-control-gitlab/src/server/GitLabPullRequestProvider.test.ts

@@ -73,6 +73,7 @@ describe("getChangeRequest base freshness", () => {
           Effect.provide(
             Layer.mock(GitLabPullRequestCli.GitLabPullRequestCli)({
               getMergeRequestDetail: () => Effect.succeed(detail),
+              getReviewDecisions: () => Effect.succeed(new Map()),
             }),
           ),
         );
@@ -221,3 +222,101 @@ describe("optional activity reads", () => {
     }),
   );
 });
+
+describe("review decisions", () => {
+  const reference = { cwd: "/w", repository: "acme/web", host: "gitlab.com", number: 7 };
+  const item = {
+    number: 7,
+    title: "Merge request 7",
+    url: "https://gitlab.com/acme/web/-/merge_requests/7",
+    author: null,
+    headBranch: "feat/page",
+    baseBranch: "main",
+    state: "open" as const,
+    isDraft: false,
+    mergeability: "mergeable" as const,
+    additions: 0,
+    deletions: 0,
+    createdAt: "2026-07-01T00:00:00Z",
+    updatedAt: "2026-07-02T00:00:00Z",
+    reviewRequestLogins: [],
+    labels: [],
+  };
+  const detail = {
+    ...item,
+    body: "",
+    changedFiles: 1,
+    mergedAt: null,
+    closedAt: null,
+    reviewers: [],
+    checks: [],
+    viewerCanMerge: true,
+    reviewerIds: [],
+  };
+  const providerWith = (
+    getReviewDecisions: GitLabPullRequestCli.GitLabPullRequestCli["Service"]["getReviewDecisions"],
+  ) =>
+    make.pipe(
+      Effect.provide(
+        Layer.mock(GitLabPullRequestCli.GitLabPullRequestCli)({
+          listMergeRequests: () =>
+            Effect.succeed({
+              items: [item, { ...item, number: 8 }],
+              truncated: false,
+              cursorAdvance: 2,
+            }),
+          getMergeRequestDetail: () => Effect.succeed(detail),
+          getReviewDecisions,
+        }),
+      ),
+    );
+  const listing = {
+    cwd: "/w",
+    repository: "acme/web",
+    host: "gitlab.com",
+    state: "open" as const,
+    involvement: "all" as const,
+    viewer: "julius",
+    limit: 2,
+  };
+
+  it.effect("puts GitLab's approval state on listed and summarized merge requests", () =>
+    Effect.gen(function* () {
+      const provider = yield* providerWith(() =>
+        Effect.succeed(
+          new Map([
+            [7, "approved" as const],
+            [8, null],
+          ]),
+        ),
+      );
+      const listed = yield* provider.listChangeRequests(listing);
+      assert.isDefined(provider.getChangeRequestSummary);
+      const summary = yield* provider.getChangeRequestSummary(reference);
+
+      expect(listed.items.map(({ reviewDecision }) => reviewDecision)).toEqual(["approved", null]);
+      expect(summary.reviewDecision).toBe("approved");
+    }),
+  );
+
+  it.effect("lists merge requests with an unknown decision when GitLab will not say", () =>
+    Effect.gen(function* () {
+      const provider = yield* providerWith(() =>
+        Effect.fail(
+          new GitLabPullRequestCli.GitLabMergeRequestReadError({
+            command: "glab",
+            cwd: "/w",
+            operation: "getReviewDecisions",
+            cause: null,
+          }),
+        ),
+      );
+      const listed = yield* provider.listChangeRequests(listing);
+
+      expect(listed.items.map(({ reviewDecision }) => reviewDecision)).toEqual([
+        undefined,
+        undefined,
+      ]);
+    }),
+  );
+});

packages/source-control-gitlab/src/server/GitLabPullRequestProvider.ts

@@ -3,6 +3,7 @@ import * as Effect from "effect/Effect";
 import type {
   PullRequestCapabilities,
   PullRequestReaction,
+  PullRequestReviewDecision,
   PullRequestViewerPermissions,
 } from "@t3tools/contracts";
 
@@ -111,6 +112,9 @@ export const make = Effect.gen(function* () {
       }),
     );
 
+  const reviewDecisions = (input: Parameters<typeof cli.getReviewDecisions>[0]) =>
+    recoverRead(cli.getReviewDecisions(input), new Map<number, PullRequestReviewDecision | null>());
+
   const provider: PullRequestProviderApi = {
     kind: SourceControlProviderKind.make("gitlab"),
     capabilities: CAPABILITIES,
@@ -133,8 +137,20 @@ export const make = Effect.gen(function* () {
           filters: input.filters,
         })
         .pipe(
+          Effect.flatMap((batch) =>
+            reviewDecisions({
+              cwd: input.cwd,
+              repository: input.repository,
+              numbers: batch.items.map((item) => item.number),
+            }).pipe(
+              Effect.map((decisions) => ({
+                ...batch,
+                items: batch.items.map((item) => withReviewDecision(item, decisions)),
+                continues: true,
+              })),
+            ),
+          ),
           Effect.mapError(fail("listChangeRequests")),
-          Effect.map((batch) => ({ ...batch, continues: true })),
         ),
 
     getChangeRequestChecks: (input) =>
@@ -148,7 +164,20 @@ export const make = Effect.gen(function* () {
       cli.getMergeRequestDetail(input).pipe(Effect.mapError(fail("getChangeRequestPreview"))),
 
     getChangeRequestSummary: (input) =>
-      cli.getMergeRequestDetail(input).pipe(Effect.mapError(fail("getChangeRequestSummary"))),
+      Effect.all(
+        [
+          cli.getMergeRequestDetail(input),
+          reviewDecisions({
+            cwd: input.cwd,
+            repository: input.repository,
+            numbers: [input.number],
+          }),
+        ],
+        { concurrency: 2 },
+      ).pipe(
+        Effect.map(([mergeRequest, decisions]) => withReviewDecision(mergeRequest, decisions)),
+        Effect.mapError(fail("getChangeRequestSummary")),
+      ),
 
     getChangeRequest: (input) =>
       Effect.all(
@@ -330,3 +359,11 @@ export const make = Effect.gen(function* () {
 
   return provider;
 });
+
+function withReviewDecision<Item extends { readonly number: number }>(
+  item: Item,
+  decisions: ReadonlyMap<number, PullRequestReviewDecision | null>,
+): Item & { readonly reviewDecision?: PullRequestReviewDecision | null } {
+  const reviewDecision = decisions.get(item.number);
+  return reviewDecision === undefined ? item : { ...item, reviewDecision };
+}

packages/source-control-gitlab/src/server/gitLabMergeRequestJson.test.ts

@@ -10,6 +10,7 @@ import {
   decodeMergeRequestListJson,
   decodeNotesJson,
   decodeOwnAwardIdJson,
+  decodeReviewDecisionsJson,
 } from "./gitLabMergeRequestJson.ts";
 
 function listJson(entries: ReadonlyArray<Record<string, unknown>>): string {
@@ -620,3 +621,65 @@ describe("decodeRepositoryBlobsJson", () => {
     ).toEqual(new Map());
   });
 });
+
+describe("decodeReviewDecisionsJson", () => {
+  const decisionsOf = (enterprise: boolean, nodes: ReadonlyArray<unknown>) =>
+    expectSuccess(
+      decodeReviewDecisionsJson(
+        JSON.stringify({
+          data: { metadata: { enterprise }, project: { mergeRequests: { nodes } } },
+        }),
+      ),
+    );
+  const approvedBy = (...usernames: ReadonlyArray<string>) => ({
+    nodes: usernames.map((username) => ({ username })),
+  });
+
+  it.each([
+    {
+      reading: "an approval short of Enterprise approval rules",
+      enterprise: true,
+      approval: { approved: false, approvedBy: approvedBy("GitLabDuo") },
+      decision: "review-required",
+    },
+    {
+      reading: "Enterprise approval rules no one has approved against",
+      enterprise: true,
+      approval: { approved: false, approvedBy: approvedBy() },
+      decision: "review-required",
+    },
+    {
+      reading: "Enterprise approval rules met",
+      enterprise: true,
+      approval: { approved: true, approvedBy: approvedBy("julius") },
+      decision: "approved",
+    },
+    {
+      reading: "Enterprise without approval rules or approvals",
+      enterprise: true,
+      approval: { approved: true, approvedBy: approvedBy() },
+      decision: null,
+    },
+    {
+      reading: "Community Edition with an approval",
+      enterprise: false,
+      approval: { approved: true, approvedBy: approvedBy("julius") },
+      decision: "approved",
+    },
+    {
+      reading: "Community Edition without approvals",
+      enterprise: false,
+      approval: { approved: false, approvedBy: approvedBy() },
+      decision: null,
+    },
+  ])("reads $reading as $decision", ({ enterprise, approval, decision }) => {
+    expect([...decisionsOf(enterprise, [{ iid: "7", ...approval }])]).toEqual([[7, decision]]);
+  });
+
+  it("leaves out a merge request it cannot key, and a project the reader cannot see", () => {
+    expect([...decisionsOf(true, [null, { iid: "x", approved: true }])]).toEqual([]);
+    expect(
+      expectSuccess(decodeReviewDecisionsJson(JSON.stringify({ data: { project: null } }))),
+    ).toEqual(new Map());
+  });
+});