fetchApprovalRules: light batched approval-rules query

packages/glance/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mattstack/glance",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "GitHub and GitLab API client: REST, GraphQL, and real-time ActionCable subscriptions",
   "type": "module",
   "main": "dist/index.js",

packages/glance/src/GitLabProvider.ts

@@ -6,10 +6,12 @@ import type {
   BranchProtectionRule,
   CreatePullRequestInput,
   DiffStats,
+  FetchApprovalRulesOptions,
   InvalidationBatch,
   JobDetail,
   MergeabilityCheck,
   MergePullRequestInput,
+  MRApprovalRules,
   MRDetail,
   Pipeline,
   PipelineJob,
@@ -607,6 +609,39 @@ interface MRProjectResponse {
   } | null;
 }
 
+/** Approval-rules discovery fragment: deliberately minimal. Wide queries
+    carrying per-MR dashboard resolvers are the timeout class the scoped
+    sync exists to avoid; this one is iid + rules only. */
+const MR_APPROVAL_RULES_QUERY = `
+  query GlanceMRApprovalRules($projectPath: ID!, $ua: Time, $first: Int!, $after: String) {
+    project(fullPath: $projectPath) {
+      mergeRequests(state: opened, updatedAfter: $ua, draft: false, first: $first, after: $after, sort: UPDATED_DESC) {
+        pageInfo { hasNextPage endCursor }
+        nodes { iid approvalState { rules { type approved section } } }
+      }
+    }
+  }
+`;
+
+const MR_APPROVAL_RULES_BY_IID_QUERY = `
+  query GlanceMRApprovalRulesByIid($projectPath: ID!, $iids: [String!]) {
+    project(fullPath: $projectPath) {
+      mergeRequests(iids: $iids) {
+        nodes { iid approvalState { rules { type approved section } } }
+      }
+    }
+  }
+`;
+
+interface ApprovalRulesResponse {
+  project: {
+    mergeRequests: {
+      pageInfo?: { hasNextPage: boolean; endCursor: string | null };
+      nodes: Array<{ iid: string; approvalState: { rules: Array<{ type: string; approved: boolean; section: string | null }> } | null }>;
+    } | null;
+  } | null;
+}
+
 // ---------------------------------------------------------------------------
 // GitLabProvider
 // ---------------------------------------------------------------------------
@@ -925,6 +960,59 @@ export class GitLabProvider implements GitProvider {
     return filterSet ? prs.filter((pr) => filterSet.has(pr.state as MRState)) : prs;
   }
 
+  async fetchApprovalRules(options: FetchApprovalRulesOptions): Promise<MRApprovalRules[]> {
+    if (options.updatedAfter !== undefined && options.iids !== undefined) {
+      throw new Error('fetchApprovalRules: updatedAfter and iids are mutually exclusive');
+    }
+
+    const projectPath = options.projectPath;
+    const mapNodes = (resp: ApprovalRulesResponse): MRApprovalRules[] =>
+      (resp.project?.mergeRequests?.nodes ?? []).map((n) => ({
+        iid: Number(n.iid),
+        rules: n.approvalState?.rules ?? [],
+      }));
+
+    if (options.iids) {
+      const out: MRApprovalRules[] = [];
+      const chunkSize = 100;
+      for (let i = 0; i < options.iids.length; i += chunkSize) {
+        const chunk = options.iids.slice(i, i + chunkSize).map(String);
+        const resp = await this.runQuery<ApprovalRulesResponse>(
+          'fetchApprovalRules.iids', MR_APPROVAL_RULES_BY_IID_QUERY,
+          { projectPath, iids: chunk },
+        );
+        out.push(...mapNodes(resp));
+      }
+      return out;
+    }
+
+    parseUpdatedAfter(options.updatedAfter);
+    if (options.pageSize !== undefined) {
+      if (!Number.isInteger(options.pageSize) || !Number.isFinite(options.pageSize) || options.pageSize <= 0) {
+        throw new Error('fetchApprovalRules: pageSize must be a positive integer');
+      }
+    }
+    const first = options.pageSize ?? 100;
+    const out: MRApprovalRules[] = [];
+    let after: string | null = null;
+    do {
+      const resp: ApprovalRulesResponse = await this.runQuery<ApprovalRulesResponse>(
+        'fetchApprovalRules.project', MR_APPROVAL_RULES_QUERY,
+        { projectPath, ua: options.updatedAfter ?? null, first, after },
+      );
+      out.push(...mapNodes(resp));
+      const conn = resp.project?.mergeRequests;
+      const next = conn?.pageInfo?.hasNextPage ? (conn.pageInfo.endCursor ?? null) : null;
+      // Stricter than fetchPullRequests.project's guard on purpose: hasNextPage
+      // with a null or repeated cursor is an infinite loop either way.
+      if (conn?.pageInfo?.hasNextPage && (next === null || next === after)) {
+        throw new Error(`fetchApprovalRules.project: non-advancing cursor '${next}' for ${projectPath}`);
+      }
+      after = next;
+    } while (after);
+    return out;
+  }
+
   async fetchMRDiscussions(repositoryId: string, mrIid: number): Promise<MRDetail> {
     const projectId = parseGitLabRepoId(repositoryId);
     return this.mrDetailFetcher.fetchDetail(projectId, mrIid);

packages/glance/src/index.ts

@@ -25,6 +25,9 @@ type _ProvidersConform = ProviderParameterDrift;
 export type {
   PullRequest,
   PullRequestsSnapshot,
+  ApprovalRuleLite,
+  MRApprovalRules,
+  FetchApprovalRulesOptions,
   MergeabilityCheck,
   CreatePullRequestInput,
   UpdatePullRequestInput,

packages/glance/src/types.ts

@@ -616,6 +616,34 @@ export interface PullRequestsSnapshot {
   items: PullRequest[];
 }
 
+/** One approval rule as returned by GitLab's `approvalState`. */
+export interface ApprovalRuleLite {
+  type: string;
+  approved: boolean;
+  section: string | null;
+}
+
+/** Approval rules for a single MR, keyed by IID rather than global ID. */
+export interface MRApprovalRules {
+  iid: number;
+  rules: ApprovalRuleLite[];
+}
+
+/**
+ * Options for `GitLabProvider.fetchApprovalRules`. `updatedAfter` and `iids`
+ * are mutually exclusive: the former drives windowed discovery, the latter
+ * the targeted events-heal path.
+ */
+export interface FetchApprovalRulesOptions {
+  projectPath: string;
+  /** ISO timestamp; windowed mode. Mutually exclusive with iids... enforced at runtime. */
+  updatedAfter?: string;
+  /** Targeted mode: just these MRs (the events-heal path). Mutually exclusive with updatedAfter... enforced at runtime. */
+  iids?: number[];
+  /** Page size, default 100. */
+  pageSize?: number;
+}
+
 /** Feed event emitted as `feed_event` (incremental) or inside `feed_snapshot` (initial batch). */
 export interface FeedEvent {
   /** Stable event ID, e.g. "note-1234" or "projEvent-5678". */

packages/glance/tests/approval-rules.test.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env bun
+/**
+ * fetchApprovalRules: the light batched rules query. Wide discovery must
+ * never carry the heavy dashboard fragment (the a6601b1 wedge class), so
+ * this method has its own minimal query: iid + rules{type,approved,section}.
+ */
+import { describe, expect, test } from 'bun:test';
+import { GitLabProvider } from '../src/GitLabProvider.ts';
+
+function stubRunQuery(provider: GitLabProvider, pages: any[]) {
+  const calls: Array<{ op: string; query: string; vars: any }> = [];
+  let i = 0;
+  (provider as any).runQuery = async (op: string, query: string, vars: any) => {
+    calls.push({ op, query, vars });
+    return pages[Math.min(i++, pages.length - 1)];
+  };
+  return calls;
+}
+
+const node = (iid: number, rules: any[]) => ({ iid: String(iid), approvalState: { rules } });
+const page = (nodes: any[], hasNext: boolean, cursor: string | null) => ({
+  project: { mergeRequests: { pageInfo: { hasNextPage: hasNext, endCursor: cursor }, nodes } },
+});
+
+describe('fetchApprovalRules', () => {
+  test('windowed mode paginates and maps iids to numbers', async () => {
+    const p = new GitLabProvider('https://gitlab.example', 't');
+    const calls = stubRunQuery(p, [
+      page([node(1, [{ type: 'CODE_OWNER', approved: false, section: 'Acme' }])], true, 'c1'),
+      page([node(2, [{ type: 'REGULAR', approved: true, section: null }])], false, null),
+    ]);
+    const out = await p.fetchApprovalRules({ projectPath: 'g/p', updatedAfter: '2026-07-26T00:00:00Z' });
+    expect(out).toEqual([
+      { iid: 1, rules: [{ type: 'CODE_OWNER', approved: false, section: 'Acme' }] },
+      { iid: 2, rules: [{ type: 'REGULAR', approved: true, section: null }] },
+    ]);
+    expect(calls).toHaveLength(2);
+    expect(calls[0]!.op).toBe('fetchApprovalRules.project');
+    expect(calls[0]!.vars).toMatchObject({ projectPath: 'g/p', ua: '2026-07-26T00:00:00Z', first: 100, after: null });
+    expect(calls[1]!.vars.after).toBe('c1');
+    // The wide query must stay light: no dashboard-fragment fields.
+    expect(calls[0]!.query).not.toContain('diffStatsSummary');
+    expect(calls[0]!.query).toContain('draft: false');
+  });
+
+  test('targeted mode queries by iids and omits the window', async () => {
+    const p = new GitLabProvider('https://gitlab.example', 't');
+    const calls = stubRunQuery(p, [
+      page([node(7, [{ type: 'CODE_OWNER', approved: true, section: 'Acme' }])], false, null),
+    ]);
+    const out = await p.fetchApprovalRules({ projectPath: 'g/p', iids: [7] });
+    expect(out).toEqual([{ iid: 7, rules: [{ type: 'CODE_OWNER', approved: true, section: 'Acme' }] }]);
+    expect(calls[0]!.op).toBe('fetchApprovalRules.iids');
+    expect(calls[0]!.vars).toMatchObject({ projectPath: 'g/p', iids: ['7'] });
+  });
+
+  test('non-advancing cursor throws instead of looping', async () => {
+    const p = new GitLabProvider('https://gitlab.example', 't');
+    stubRunQuery(p, [page([node(1, [])], true, null)]);
+    await expect(p.fetchApprovalRules({ projectPath: 'g/p', updatedAfter: '2026-07-26T00:00:00Z' }))
+      .rejects.toThrow(/non-advancing cursor/);
+  });
+
+  test('chunks iids into batches of 100', async () => {
+    const p = new GitLabProvider('https://gitlab.example', 't');
+    const iids = Array.from({ length: 150 }, (_, i) => i + 1);
+    const calls = stubRunQuery(p, [
+      page(iids.slice(0, 100).map((id) => node(id, [])), false, null),
+      page(iids.slice(100, 150).map((id) => node(id, [])), false, null),
+    ]);
+    const out = await p.fetchApprovalRules({ projectPath: 'g/p', iids });
+    expect(out).toHaveLength(150);
+    expect(calls).toHaveLength(2);
+    expect(calls[0]!.vars.iids).toHaveLength(100);
+    expect(calls[1]!.vars.iids).toHaveLength(50);
+    expect(calls[0]!.vars.iids[0]).toBe('1');
+    expect(calls[0]!.vars.iids[99]).toBe('100');
+    expect(calls[1]!.vars.iids[0]).toBe('101');
+    expect(calls[1]!.vars.iids[49]).toBe('150');
+  });
+
+  test('rejects when both updatedAfter and iids are provided', async () => {
+    const p = new GitLabProvider('https://gitlab.example', 't');
+    stubRunQuery(p, [page([], false, null)]);
+    await expect(
+      p.fetchApprovalRules({
+        projectPath: 'g/p',
+        updatedAfter: '2026-07-26T00:00:00Z',
+        iids: [1, 2, 3],
+      }),
+    ).rejects.toThrow(/updatedAfter and iids are mutually exclusive/);
+    await expect(
+      p.fetchApprovalRules({
+        projectPath: 'g/p',
+        updatedAfter: '',
+        iids: [1, 2, 3],
+      }),
+    ).rejects.toThrow(/updatedAfter and iids are mutually exclusive/);
+  });
+
+  test('validates pageSize: rejects non-positive, fractional, and non-finite values', async () => {
+    const p = new GitLabProvider('https://gitlab.example', 't');
+    stubRunQuery(p, [page([], false, null)]);
+    const invalidValues = [0, -1, -100, 1.5, 3.14, Infinity, -Infinity, NaN];
+    for (const value of invalidValues) {
+      await expect(
+        p.fetchApprovalRules({
+          projectPath: 'g/p',
+          updatedAfter: '2026-07-26T00:00:00Z',
+          pageSize: value,
+        }),
+      ).rejects.toThrow(/pageSize must be a positive integer/);
+    }
+  });
+
+  test('accepts valid pageSize like 200 and passes it through as first', async () => {
+    const p = new GitLabProvider('https://gitlab.example', 't');
+    const calls = stubRunQuery(p, [
+      page([node(1, [])], false, null),
+    ]);
+    await p.fetchApprovalRules({
+      projectPath: 'g/p',
+      updatedAfter: '2026-07-26T00:00:00Z',
+      pageSize: 200,
+    });
+    expect(calls[0]!.vars.first).toBe(200);
+  });
+});