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

package/index.js

@@ -12,18 +12,31 @@ import {
   gitAheadBehind,
   refsInventory,
   crInventory,
-  mergeBlockersFromFacts,
+  buildMergePlanBodyFromFacts,
   ERROR_CODES,
   forgeError,
   forgeIngestCapabilityFacts,
   checkPaginationCapabilityFacts,
+  openPullListCapabilityFacts,
   DEFAULT_CHECK_STATUS_PAGE_SIZE,
   MAX_CHECK_STATUS_PAGES,
+  DEFAULT_OPEN_PULL_LIST_PAGE_SIZE,
   fetchWithIngestPageBackoff,
   paginateOffsetListPages,
   fetchPageWithIngestBackoff,
   withPerPageParam,
   apiProviderCommands,
+  normalizeCrInventorySort,
+  DEFAULT_CR_INVENTORY_SLICE_SORT,
+  isCrInventoryFastPathEligible,
+  validateFastPathPageLength,
+  isNumberSortFastPathEligible,
+  isNumberSortFullCollectRequired,
+  resolvePaginatedEntryCount,
+  resolveListTruncatedWithTrustedTotal,
+  orderOpenPullNumbers,
+  buildOpenPullListMeta,
+  githubOpenPullSortQuery,
 } from '@remogram/core';
 
 const PUBLIC_GITHUB_HOST = 'github.com';
@@ -188,12 +201,36 @@ async function paginateGitHubLinkPages({
   token,
   initialLimit = DEFAULT_CHECK_STATUS_PAGE_SIZE,
   mapPageItems,
+  seededFirstPage = null,
 }) {
   const all = [];
   let truncated = false;
+  let walkedCount = 0;
   let url = startUrl;
   let activeLimit = initialLimit;
-  for (let page = 0; page < MAX_CHECK_PAGES && url; page += 1) {
+  let pageIndex = 0;
+
+  if (seededFirstPage) {
+    const { items, linkHeader, currentUrl, usedLimit } = seededFirstPage;
+    activeLimit = usedLimit;
+    const mapped = mapPageItems(items);
+    walkedCount += mapped.length;
+    all.push(...mapped);
+    const linkPage = resolveGitHubLinkNextPage({
+      trustedOrigin,
+      currentUrl,
+      linkHeader,
+      pageIndex: 0,
+      maxPages: MAX_CHECK_PAGES,
+    });
+    if (linkPage.truncated) {
+      truncated = true;
+    }
+    url = linkPage.nextUrl ? withPerPageParam(linkPage.nextUrl, activeLimit) : null;
+    pageIndex = 1;
+  }
+
+  for (let page = pageIndex; page < MAX_CHECK_PAGES && url; page += 1) {
     const currentUrl = url;
     let usedLimit = activeLimit;
     const { body, headers } = await fetchWithIngestPageBackoff(
@@ -208,7 +245,9 @@ async function paginateGitHubLinkPages({
       activeLimit,
     );
     activeLimit = usedLimit;
-    all.push(...mapPageItems(body));
+    const mapped = mapPageItems(body);
+    walkedCount += mapped.length;
+    all.push(...mapped);
     const linkHeader = headers?.get?.('link') ?? headers?.get?.('Link') ?? null;
     const linkPage = resolveGitHubLinkNextPage({
       trustedOrigin,
@@ -222,7 +261,7 @@ async function paginateGitHubLinkPages({
     }
     url = linkPage.nextUrl ? withPerPageParam(linkPage.nextUrl, activeLimit) : null;
   }
-  return { items: all, truncated };
+  return { items: all, truncated, walked_count: walkedCount };
 }
 
 export async function githubFetchPaginated(config, parsed, path, slice) {
@@ -347,6 +386,9 @@ export function providerCapabilities() {
       pageSizeParam: 'per_page',
       sourceCount: check_sources.length,
     }),
+    ...openPullListCapabilityFacts({
+      totalCountSource: 'search_api',
+    }),
   };
 }
 
@@ -488,48 +530,167 @@ export async function prChecks(ctx, opts) {
 export async function mergePlan(ctx, opts) {
   const view = await prView(ctx, opts);
   const checks = await prChecks(ctx, { number: view.pr_number });
-  const blockers = mergeBlockersFromFacts(view, checks);
+  return buildMergePlanBodyFromFacts(ctx, view, checks, opts);
+}
+
+const GITHUB_OPEN_PULL_COMPLIANT_MAX =
+  DEFAULT_OPEN_PULL_LIST_PAGE_SIZE * MAX_CHECK_STATUS_PAGES;
+const GITHUB_PAGE_SIZE = 100;
+
+function githubOpenPullsListPath(config, sliceSort) {
+  const params = new URLSearchParams({ state: 'open', ...githubOpenPullSortQuery(sliceSort) });
+  return `${repoApiPath(config, 'pulls')}?${params.toString()}`;
+}
+
+async function fetchGitHubOpenPullSearchTotal(ctx) {
+  const base = apiBase(ctx.config, ctx.parsed);
+  const { token } = requireToken();
+  const owner = encodeURIComponent(ctx.config.owner);
+  const repo = encodeURIComponent(ctx.config.repo);
+  const searchPath = `/search/issues?q=repo:${owner}/${repo}+is:pr+state:open&per_page=1`;
+  try {
+    const { body } = await fetchJsonWithMeta(`${base}${searchPath}`, {
+      headers: authHeaders(token),
+    });
+    if (!body || body.incomplete_results === true) return null;
+    const total = Number(body.total_count);
+    const maxTrusted = GITHUB_OPEN_PULL_COMPLIANT_MAX * 2;
+    if (!Number.isInteger(total) || total <= 0 || total > maxTrusted) return null;
+    return total;
+  } catch {
+    return null;
+  }
+}
+
+async function probeGitHubOpenPullPageOne(ctx, retainMax, sliceSort) {
+  const totalCount = await fetchGitHubOpenPullSearchTotal(ctx);
+  if (totalCount == null) return null;
+
+  const base = apiBase(ctx.config, ctx.parsed);
+  const { token } = requireToken();
+  const requestLimit = Math.min(retainMax, GITHUB_PAGE_SIZE);
+  const listPath = githubOpenPullsListPath(ctx.config, sliceSort);
+  const listUrl = withPerPageParam(`${base}${listPath}`, requestLimit);
+  try {
+    const { body, headers } = await fetchJsonWithMeta(listUrl, {
+      headers: authHeaders(token),
+    });
+    if (!Array.isArray(body)) return null;
+    const listTruncated = totalCount > GITHUB_OPEN_PULL_COMPLIANT_MAX;
+    const linkHeader = headers?.get?.('link') ?? headers?.get?.('Link') ?? null;
+    return { body, totalCount, listTruncated, requestLimit, listUrl, linkHeader };
+  } catch {
+    return null;
+  }
+}
+
+function buildGitHubOpenPullMetaFromPage(body, retainMax, sliceSort, totalCount, listTruncated) {
+  let numbers = orderOpenPullNumbers(body, (pr) => pr?.number, sliceSort);
+  if (numbers.length > retainMax) numbers = numbers.slice(0, retainMax);
+  return buildOpenPullListMeta({
+    totalCount,
+    numbers,
+    listTruncated,
+    sliceSort,
+  });
+}
+
+function githubProbePaginationOpts(probe) {
+  const { body, totalCount, requestLimit, listUrl, linkHeader } = probe;
   return {
-    pr_number: view.pr_number,
-    mergeability: view.mergeability,
-    checks_conclusion: checks.check_conclusion,
-    blockers,
+    trustedTotalCount: totalCount,
+    seededFirstPage: { items: body, usedLimit: requestLimit, listUrl, linkHeader },
   };
 }
 
-export async function listOpenPullsWithMeta(ctx, opts = {}) {
-  apiBase(ctx.config, ctx.parsed);
-  requireToken();
+async function paginateGitHubOpenPullList(ctx, opts, sliceSort, paginationOpts = {}) {
+  const {
+    trustedTotalCount = null,
+    seededFirstPage = null,
+    numberSortFullCollect = false,
+  } = paginationOpts;
   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;
+  let walkedCount = 0;
+  const listPath = githubOpenPullsListPath(ctx.config, sliceSort);
+  const retainMax =
+    listLimit == null &&
+    opts.retain_max != null &&
+    Number.isInteger(Number(opts.retain_max)) &&
+    Number(opts.retain_max) > 0
+      ? Number(opts.retain_max)
+      : null;
 
-  if (listLimit == null) {
+  if (listLimit == null && numberSortFullCollect) {
+    const {
+      items: offsetItems,
+      list_truncated: offsetTruncated,
+      walked_count: offsetWalkedCount,
+    } = await paginateOffsetListPages({
+      pageSize: GITHUB_PAGE_SIZE,
+      retainMax: null,
+      trustedEntryCount: trustedTotalCount,
+      seededFirstPage: seededFirstPage
+        ? { items: seededFirstPage.items, usedLimit: seededFirstPage.usedLimit }
+        : null,
+      fetchPage: async ({ page, limit }) => {
+        const pageUrl = `${base}${listPath}&page=${page}`;
+        const { body } = await fetchJsonWithMeta(withPerPageParam(pageUrl, limit), {
+          headers: authHeaders(token),
+        });
+        return Array.isArray(body) ? body : [];
+      },
+    });
+    all.push(...offsetItems);
+    listTruncated = offsetTruncated;
+    walkedCount = offsetWalkedCount;
+  } else 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({
+    const startUrl = `${base}${listPath}`;
+    const linkSeed = seededFirstPage
+      ? {
+          items: seededFirstPage.items,
+          linkHeader: seededFirstPage.linkHeader,
+          currentUrl: seededFirstPage.listUrl,
+          usedLimit: seededFirstPage.usedLimit,
+        }
+      : null;
+    const {
+      items: linkItems,
+      truncated: linkTruncated,
+      walked_count: linkWalkedCount,
+    } = await paginateGitHubLinkPages({
       trustedOrigin,
       startUrl,
       token,
+      initialLimit: seededFirstPage?.usedLimit ?? DEFAULT_CHECK_STATUS_PAGE_SIZE,
       mapPageItems: (body) => (Array.isArray(body) ? body : []),
+      seededFirstPage: linkSeed,
     });
     all.push(...linkItems);
     listTruncated = linkTruncated;
+    walkedCount = linkWalkedCount;
   } else {
-    const { items: limitItems, list_truncated: limitTruncated } = await paginateOffsetListPages({
+    const {
+      items: limitItems,
+      list_truncated: limitTruncated,
+      walked_count: limitWalkedCount,
+    } = 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,
+      trustedEntryCount: trustedTotalCount,
+      seededFirstPage: seededFirstPage
+        ? { items: seededFirstPage.items, usedLimit: seededFirstPage.usedLimit }
+        : null,
       fetchPage: async ({ page, limit }) => {
-        const pageUrl = `${base}${repoApiPath(ctx.config, 'pulls')}?state=open&page=${page}`;
+        const pageUrl = `${base}${listPath}&page=${page}`;
         const { body } = await fetchJsonWithMeta(withPerPageParam(pageUrl, limit), {
           headers: authHeaders(token),
         });
@@ -538,16 +699,70 @@ export async function listOpenPullsWithMeta(ctx, opts = {}) {
     });
     all.push(...limitItems);
     listTruncated = limitTruncated;
+    walkedCount = limitWalkedCount;
+  }
+
+  let numbers = orderOpenPullNumbers(all, (pr) => pr?.number, sliceSort);
+  const outputCap = listLimit ?? retainMax;
+  if (outputCap != null && numbers.length > outputCap) {
+    numbers = numbers.slice(0, outputCap);
+  }
+  const entryCount =
+    trustedTotalCount != null
+      ? resolvePaginatedEntryCount(trustedTotalCount, walkedCount)
+      : undefined;
+  return {
+    numbers,
+    list_truncated: resolveListTruncatedWithTrustedTotal({
+      listTruncated,
+      trustedTotalCount,
+      walkedCount,
+      fullCollect: numberSortFullCollect,
+    }),
+    slice_sort: sliceSort,
+    ...(entryCount != null ? { entry_count: entryCount } : {}),
+  };
+}
+
+export async function listOpenPullsWithMeta(ctx, opts = {}) {
+  apiBase(ctx.config, ctx.parsed);
+  requireToken();
+  const sliceSort = normalizeCrInventorySort(opts.sort ?? DEFAULT_CR_INVENTORY_SLICE_SORT);
+  if (!isCrInventoryFastPathEligible(opts)) {
+    return paginateGitHubOpenPullList(ctx, opts, sliceSort);
   }
 
-  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);
+  const retainMax = Number(opts.retain_max);
+  const probe = await probeGitHubOpenPullPageOne(ctx, retainMax, sliceSort);
+  if (!probe) {
+    return paginateGitHubOpenPullList(ctx, opts, sliceSort);
   }
-  return { numbers, list_truncated: listTruncated };
+
+  const { body, totalCount, listTruncated, requestLimit } = probe;
+
+  if (listTruncated) {
+    if (body.length === 0) {
+      return paginateGitHubOpenPullList(ctx, opts, sliceSort, githubProbePaginationOpts(probe));
+    }
+    return buildGitHubOpenPullMetaFromPage(body, retainMax, sliceSort, totalCount, true);
+  }
+
+  if (
+    isNumberSortFastPathEligible(totalCount, retainMax, sliceSort) &&
+    validateFastPathPageLength(totalCount, requestLimit, body.length)
+  ) {
+    return buildGitHubOpenPullMetaFromPage(body, retainMax, sliceSort, totalCount, false);
+  }
+
+  return paginateGitHubOpenPullList(
+    ctx,
+    opts,
+    sliceSort,
+    {
+      ...githubProbePaginationOpts(probe),
+      numberSortFullCollect: isNumberSortFullCollectRequired(totalCount, retainMax, sliceSort),
+    },
+  );
 }
 
 export async function listOpenPulls(ctx, opts = {}) {

package/package.json

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