@remogram/provider-github-api 0.1.0-beta.1 → 0.1.0-beta.3

package/index.js

@@ -2,6 +2,7 @@ import {
   fetchJson,
   fetchJsonWithMeta,
   parseLinkHeader,
+  isTrustedPaginationUrl,
   sanitizeField,
   sanitizeUrl,
   assertGitRef,
@@ -9,9 +10,20 @@ import {
   gitRevParse,
   gitCurrentBranch,
   gitAheadBehind,
+  refsInventory,
+  crInventory,
+  mergeBlockersFromFacts,
   ERROR_CODES,
   forgeError,
   forgeIngestCapabilityFacts,
+  checkPaginationCapabilityFacts,
+  DEFAULT_CHECK_STATUS_PAGE_SIZE,
+  MAX_CHECK_STATUS_PAGES,
+  fetchWithIngestPageBackoff,
+  paginateOffsetListPages,
+  fetchPageWithIngestBackoff,
+  withPerPageParam,
+  apiProviderCommands,
 } from '@remogram/core';
 
 const PUBLIC_GITHUB_HOST = 'github.com';
@@ -39,13 +51,15 @@ query RemogramPrView($owner: String!, $repo: String!, $number: Int!) {
 const AUTH_CAPABILITIES = [
   'repo_status',
   'ref_compare',
+  'ref_inventory',
+  'cr_inventory',
   'pr_status',
   'pr_checks',
   'merge_plan',
   'sync_plan',
 ];
 
-const STRUCTURED_COMMANDS = AUTH_CAPABILITIES.map((name) => ({ name, implemented: true }));
+const STRUCTURED_COMMANDS = apiProviderCommands();
 
 export function githubToken() {
   if (process.env.GITHUB_TOKEN) return { token: process.env.GITHUB_TOKEN, env: 'GITHUB_TOKEN' };
@@ -152,22 +166,77 @@ export async function githubFetch(config, parsed, path, options = {}) {
   });
 }
 
-const MAX_CHECK_PAGES = 50;
+const MAX_CHECK_PAGES = MAX_CHECK_STATUS_PAGES;
 
-export async function githubFetchPaginated(config, parsed, path, slice) {
-  const base = apiBase(config, parsed);
-  const { token } = requireToken();
+export function resolveGitHubLinkNextPage({ trustedOrigin, currentUrl, linkHeader, pageIndex, maxPages }) {
+  const nextRaw = parseLinkHeader(linkHeader).next ?? null;
+  if (!nextRaw) {
+    return { nextUrl: null, truncated: false };
+  }
+  if (!isTrustedPaginationUrl(trustedOrigin, nextRaw, currentUrl)) {
+    return { nextUrl: null, truncated: true };
+  }
+  if (pageIndex === maxPages - 1) {
+    return { nextUrl: null, truncated: true };
+  }
+  return { nextUrl: new URL(nextRaw, currentUrl).href, truncated: false };
+}
+
+async function paginateGitHubLinkPages({
+  trustedOrigin,
+  startUrl,
+  token,
+  initialLimit = DEFAULT_CHECK_STATUS_PAGE_SIZE,
+  mapPageItems,
+}) {
   const all = [];
-  let url = `${base}${path}`;
+  let truncated = false;
+  let url = startUrl;
+  let activeLimit = initialLimit;
   for (let page = 0; page < MAX_CHECK_PAGES && url; page += 1) {
-    const { body, headers } = await fetchJsonWithMeta(url, {
-      headers: authHeaders(token),
-    });
-    all.push(...slice(body));
+    const currentUrl = url;
+    let usedLimit = activeLimit;
+    const { body, headers } = await fetchWithIngestPageBackoff(
+      (attemptUrl) =>
+        fetchJsonWithMeta(attemptUrl, {
+          headers: authHeaders(token),
+        }),
+      (limit) => {
+        usedLimit = limit;
+        return withPerPageParam(currentUrl, limit);
+      },
+      activeLimit,
+    );
+    activeLimit = usedLimit;
+    all.push(...mapPageItems(body));
     const linkHeader = headers?.get?.('link') ?? headers?.get?.('Link') ?? null;
-    url = parseLinkHeader(linkHeader).next ?? null;
+    const linkPage = resolveGitHubLinkNextPage({
+      trustedOrigin,
+      currentUrl,
+      linkHeader,
+      pageIndex: page,
+      maxPages: MAX_CHECK_PAGES,
+    });
+    if (linkPage.truncated) {
+      truncated = true;
+    }
+    url = linkPage.nextUrl ? withPerPageParam(linkPage.nextUrl, activeLimit) : null;
   }
-  return all;
+  return { items: all, truncated };
+}
+
+export async function githubFetchPaginated(config, parsed, path, slice) {
+  const base = apiBase(config, parsed);
+  const trustedOrigin = new URL(base).origin;
+  const { token } = requireToken();
+  const pageQuery = `${path.includes('?') ? '&' : '?'}per_page=${DEFAULT_CHECK_STATUS_PAGE_SIZE}`;
+  const startUrl = `${base}${path}${pageQuery}`;
+  return paginateGitHubLinkPages({
+    trustedOrigin,
+    startUrl,
+    token,
+    mapPageItems: (body) => slice(body),
+  });
 }
 
 export function graphqlEndpoint(config, parsed = {}) {
@@ -263,15 +332,21 @@ export async function repoStatus(ctx) {
 }
 
 export function providerCapabilities() {
+  const check_sources = ['commit_statuses', 'check_runs'];
   return {
     commands: STRUCTURED_COMMANDS,
     auth_envs: ['GITHUB_TOKEN', 'GH_TOKEN'],
-    check_sources: ['commit_statuses', 'check_runs'],
+    check_sources,
     mergeability_confidence: 'derived',
     host_binding: 'verified_remote_host',
     pagination: 'supported',
     write_support: false,
     ...forgeIngestCapabilityFacts(),
+    ...checkPaginationCapabilityFacts({
+      strategy: 'link_header',
+      pageSizeParam: 'per_page',
+      sourceCount: check_sources.length,
+    }),
   };
 }
 
@@ -382,12 +457,14 @@ export async function prChecks(ctx, opts) {
 
   const statusPath = repoApiPath(ctx.config, 'commits', sha, 'statuses');
   const checkRunsPath = repoApiPath(ctx.config, 'commits', sha, 'check-runs');
-  const [statusRecords, checkRunRecords] = await Promise.all([
+  const [statusResult, checkRunResult] = await Promise.all([
     githubFetchPaginated(ctx.config, ctx.parsed, statusPath, (body) =>
       Array.isArray(body) ? body : [],
     ),
     githubFetchPaginated(ctx.config, ctx.parsed, checkRunsPath, (body) => body?.check_runs ?? []),
   ]);
+  const statusRecords = statusResult.items;
+  const checkRunRecords = checkRunResult.items;
   const mappedStatuses = statusRecords.map((s) => ({
     context: sanitizeField(s.context),
     state: normalizeCommitStatusState(s.state),
@@ -399,18 +476,19 @@ export async function prChecks(ctx, opts) {
     description: sanitizeField(checkRunDescription(run)),
   }));
   const mapped = [...mappedStatuses, ...mappedCheckRuns];
-  return { head_sha: sha, check_conclusion: summarizeChecks(mapped), statuses: mapped };
+  const checks_truncated = statusResult.truncated || checkRunResult.truncated;
+  return {
+    head_sha: sha,
+    check_conclusion: summarizeChecks(mapped),
+    checks_truncated,
+    statuses: mapped,
+  };
 }
 
 export async function mergePlan(ctx, opts) {
   const view = await prView(ctx, opts);
   const checks = await prChecks(ctx, { number: view.pr_number });
-  const blockers = [];
-  if (view.mergeability === 'conflicted') blockers.push('merge_conflict');
-  if (view.state !== 'open') blockers.push('pr_not_open');
-  if (checks.check_conclusion === 'failure') blockers.push('checks_failed');
-  if (checks.check_conclusion === 'missing') blockers.push('checks_missing');
-  if (checks.check_conclusion === 'pending') blockers.push('checks_pending');
+  const blockers = mergeBlockersFromFacts(view, checks);
   return {
     pr_number: view.pr_number,
     mergeability: view.mergeability,
@@ -419,6 +497,68 @@ export async function mergePlan(ctx, opts) {
   };
 }
 
+export async function listOpenPullsWithMeta(ctx, opts = {}) {
+  apiBase(ctx.config, ctx.parsed);
+  requireToken();
+  const base = apiBase(ctx.config, ctx.parsed);
+  const { token } = requireToken();
+  const listLimit =
+    opts.limit != null && Number.isInteger(Number(opts.limit)) && Number(opts.limit) > 0
+      ? Number(opts.limit)
+      : null;
+  const GITHUB_PAGE_SIZE = 100;
+  const all = [];
+  let listTruncated = false;
+
+  if (listLimit == null) {
+    const trustedOrigin = new URL(base).origin;
+    const startUrl = `${base}${repoApiPath(ctx.config, 'pulls')}?state=open`;
+    const { items: linkItems, truncated: linkTruncated } = await paginateGitHubLinkPages({
+      trustedOrigin,
+      startUrl,
+      token,
+      mapPageItems: (body) => (Array.isArray(body) ? body : []),
+    });
+    all.push(...linkItems);
+    listTruncated = linkTruncated;
+  } else {
+    const { items: limitItems, list_truncated: limitTruncated } = await paginateOffsetListPages({
+      pageSize: GITHUB_PAGE_SIZE,
+      listLimit,
+      // GitHub/GitLab use fixed pageSize with optional listLimit; mark truncated at maxPages.
+      // Gitea passes pageSize=min(listLimit, cap) so the limit branch often exits in one page.
+      maxPagesTruncatesWithLimit: true,
+      fetchPage: async ({ page, limit }) => {
+        const pageUrl = `${base}${repoApiPath(ctx.config, 'pulls')}?state=open&page=${page}`;
+        const { body } = await fetchJsonWithMeta(withPerPageParam(pageUrl, limit), {
+          headers: authHeaders(token),
+        });
+        return Array.isArray(body) ? body : [];
+      },
+    });
+    all.push(...limitItems);
+    listTruncated = limitTruncated;
+  }
+
+  let numbers = all
+    .map((pr) => pr.number)
+    .filter((number) => Number.isInteger(number))
+    .sort((a, b) => a - b);
+  if (listLimit != null && numbers.length > listLimit) {
+    numbers = numbers.slice(0, listLimit);
+  }
+  return { numbers, list_truncated: listTruncated };
+}
+
+export async function listOpenPulls(ctx, opts = {}) {
+  const meta = await listOpenPullsWithMeta(ctx, opts);
+  return meta.numbers;
+}
+
+export async function crInventorySlice(ctx, opts = {}) {
+  return crInventory(ctx, { listOpenPulls, listOpenPullsWithMeta, prView, prChecks }, opts);
+}
+
 export async function syncPlan(ctx, remoteName = 'origin') {
   assertGitRemote(remoteName, 'remote');
   apiBase(ctx.config, ctx.parsed);
@@ -452,6 +592,9 @@ export const provider = {
   providerCapabilities,
   repoStatus,
   refsCompare,
+  refsInventory,
+  listOpenPulls,
+  crInventory: crInventorySlice,
   prView,
   prChecks,
   mergePlan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remogram/provider-github-api",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.3",
   "description": "GitHub API provider for remogram",
   "type": "module",
   "license": "MIT",
@@ -22,6 +22,6 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@remogram/core": "0.1.0-beta.1"
+    "@remogram/core": "0.1.0-beta.3"
   }
 }