@remogram/provider-gitlab-api 0.1.0-beta.2 → 0.1.0-beta.4

package/index.js

@@ -1,5 +1,6 @@
 import {
   fetchJson,
+  fetchJsonWithMeta,
   sanitizeField,
   sanitizeUrl,
   assertGitRef,
@@ -7,10 +8,35 @@ import {
   gitRevParse,
   gitCurrentBranch,
   gitAheadBehind,
+  refsInventory,
+  crInventory,
+  buildMergePlanBodyFromFacts,
   ERROR_CODES,
   forgeError,
   forgeIngestCapabilityFacts,
+  checkPaginationCapabilityFacts,
+  openPullListCapabilityFacts,
+  DEFAULT_CHECK_STATUS_PAGE_SIZE,
+  MAX_CHECK_STATUS_PAGES,
+  DEFAULT_OPEN_PULL_LIST_PAGE_SIZE,
+  paginateCheckStatusPages,
+  paginateOffsetListPages,
+  fetchWithIngestPageBackoff,
+  fetchPageWithIngestBackoff,
+  withPerPageParam,
   apiProviderCommands,
+  normalizeCrInventorySort,
+  DEFAULT_CR_INVENTORY_SLICE_SORT,
+  parseTotalCountHeader,
+  isCrInventoryFastPathEligible,
+  validateFastPathPageLength,
+  isNumberSortFastPathEligible,
+  isNumberSortFullCollectRequired,
+  resolveListTruncatedWithTrustedTotal,
+  orderOpenPullNumbers,
+  buildOpenPullListMeta,
+  gitlabOpenPullSortQuery,
+  appendSortQuery,
 } from '@remogram/core';
 
 const PUBLIC_GITLAB_HOST = 'gitlab.com';
@@ -18,6 +44,8 @@ const PUBLIC_GITLAB_API = 'https://gitlab.com/api/v4';
 const AUTH_CAPABILITIES = [
   'repo_status',
   'ref_compare',
+  'ref_inventory',
+  'cr_inventory',
   'pr_status',
   'pr_checks',
   'merge_plan',
@@ -116,35 +144,53 @@ export async function gitlabFetch(config, parsed, path, options = {}) {
   });
 }
 
-const MAX_CHECK_PAGES = 50;
+export async function gitlabFetchWithMeta(config, parsed, path, options = {}) {
+  const base = apiBase(config, parsed);
+  const token = requireToken();
+  const url = `${base}${path}`;
+  return fetchJsonWithMeta(url, {
+    ...options,
+    headers: { ...authHeaders(token), ...(options.headers || {}) },
+  });
+}
+
+const MAX_CHECK_PAGES = MAX_CHECK_STATUS_PAGES;
 const GITLAB_PAGE_SIZE = 100;
 
 export async function gitlabFetchPaginated(config, parsed, path) {
-  const all = [];
-  for (let page = 1; page <= MAX_CHECK_PAGES; page += 1) {
-    const separator = path.includes('?') ? '&' : '?';
-    const body = await gitlabFetch(
-      config,
-      parsed,
-      `${path}${separator}per_page=${GITLAB_PAGE_SIZE}&page=${page}`,
-    );
-    const items = Array.isArray(body) ? body : [];
-    all.push(...items);
-    if (items.length < GITLAB_PAGE_SIZE) break;
-  }
-  return all;
+  return paginateCheckStatusPages({
+    fetchPage: async ({ page, limit }) => {
+      const separator = path.includes('?') ? '&' : '?';
+      const body = await gitlabFetch(
+        config,
+        parsed,
+        `${path}${separator}per_page=${limit}&page=${page}`,
+      );
+      return Array.isArray(body) ? body : [];
+    },
+  });
 }
 
 export function providerCapabilities() {
+  const check_sources = ['commit_statuses', 'pipelines'];
   return {
     commands: STRUCTURED_COMMANDS,
     auth_envs: ['GITLAB_TOKEN'],
-    check_sources: ['commit_statuses', 'pipelines'],
+    check_sources,
     mergeability_confidence: 'derived',
     host_binding: 'verified_remote_host',
     pagination: 'supported',
     write_support: false,
     ...forgeIngestCapabilityFacts(),
+    ...checkPaginationCapabilityFacts({
+      strategy: 'offset_limit',
+      pageSizeParam: 'per_page',
+      sourceCount: check_sources.length,
+    }),
+    ...openPullListCapabilityFacts({
+      totalCountSource: 'response_header',
+      totalCountHeader: 'X-Total',
+    }),
   };
 }
 
@@ -260,7 +306,7 @@ export async function prChecks(ctx, opts) {
     });
   }
 
-  const [statusRecords, pipelineRecords] = await Promise.all([
+  const [statusResult, pipelineResult] = await Promise.all([
     gitlabFetchPaginated(
       ctx.config,
       ctx.parsed,
@@ -272,6 +318,8 @@ export async function prChecks(ctx, opts) {
       `${projectApiPath(ctx.config, 'pipelines')}?sha=${encodeURIComponent(sha)}`,
     ),
   ]);
+  const statusRecords = statusResult.items;
+  const pipelineRecords = pipelineResult.items;
   const mappedStatuses = statusRecords.map((status) => ({
     context: sanitizeField(status.name || status.context),
     state: normalizeStatusState(status.status),
@@ -283,26 +331,180 @@ export async function prChecks(ctx, opts) {
     description: sanitizeField(pipeline.status),
   }));
   const mapped = [...mappedStatuses, ...mappedPipelines];
-  return { head_sha: sha, check_conclusion: summarizeChecks(mapped), statuses: mapped };
+  const checks_truncated = statusResult.truncated || pipelineResult.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');
+  return buildMergePlanBodyFromFacts(ctx, view, checks, opts);
+}
+
+const GITLAB_OPEN_PULL_COMPLIANT_MAX =
+  DEFAULT_OPEN_PULL_LIST_PAGE_SIZE * MAX_CHECK_STATUS_PAGES;
+
+async function probeGitlabOpenPullPageOne(ctx, retainMax, sliceSort) {
+  const maxTrusted = GITLAB_OPEN_PULL_COMPLIANT_MAX * 2;
+  let path = `${projectApiPath(ctx.config, 'merge_requests')}?state=opened`;
+  path = appendSortQuery(path, gitlabOpenPullSortQuery(sliceSort));
+  const separator = path.includes('?') ? '&' : '?';
+  const requestLimit = Math.min(retainMax, GITLAB_PAGE_SIZE);
+  try {
+    const { body, headers } = await gitlabFetchWithMeta(
+      ctx.config,
+      ctx.parsed,
+      `${path}${separator}per_page=${requestLimit}&page=1`,
+    );
+    if (!Array.isArray(body)) return null;
+    const totalCount = parseTotalCountHeader(headers, 'X-Total', { maxTrusted });
+    if (totalCount == null) return null;
+    const listTruncated = totalCount > GITLAB_OPEN_PULL_COMPLIANT_MAX;
+    return { body, totalCount, listTruncated, requestLimit };
+  } catch {
+    return null;
+  }
+}
+
+function buildGitlabOpenPullMetaFromPage(body, retainMax, sliceSort, totalCount, listTruncated) {
+  let numbers = orderOpenPullNumbers(body, (mr) => mr?.iid, sliceSort);
+  if (numbers.length > retainMax) numbers = numbers.slice(0, retainMax);
+  return buildOpenPullListMeta({
+    totalCount,
+    numbers,
+    listTruncated,
+    sliceSort,
+  });
+}
+
+function gitlabProbePaginationOpts(probe, extra = {}) {
+  const { body, totalCount, requestLimit } = probe;
   return {
-    pr_number: view.pr_number,
-    mergeability: view.mergeability,
-    checks_conclusion: checks.check_conclusion,
-    blockers,
+    trustedTotalCount: totalCount,
+    seededFirstPage: { items: body, usedLimit: requestLimit },
+    ...extra,
   };
 }
 
+async function paginateGitlabOpenPullList(ctx, opts, sliceSort, paginationOpts = {}) {
+  const {
+    trustedTotalCount = null,
+    numberSortFullCollect = false,
+    seededFirstPage = null,
+    startPage = 1,
+    maxPages = MAX_CHECK_STATUS_PAGES,
+    suppressFinalPageProbe = false,
+  } = paginationOpts;
+  const listLimit =
+    opts.limit != null && Number.isInteger(Number(opts.limit)) && Number(opts.limit) > 0
+      ? Number(opts.limit)
+      : null;
+  const retainMax =
+    listLimit == null &&
+    opts.retain_max != null &&
+    Number.isInteger(Number(opts.retain_max)) &&
+    Number(opts.retain_max) > 0
+      ? Number(opts.retain_max)
+      : null;
+  let path = `${projectApiPath(ctx.config, 'merge_requests')}?state=opened`;
+  path = appendSortQuery(path, gitlabOpenPullSortQuery(sliceSort));
+  const separator = path.includes('?') ? '&' : '?';
+  const effectiveRetainMax = numberSortFullCollect ? null : retainMax;
+  const {
+    items: all,
+    list_truncated: listTruncated,
+    entry_count: entryCount,
+    walked_count: walkedCount,
+  } = await paginateOffsetListPages({
+    pageSize: GITLAB_PAGE_SIZE,
+    listLimit,
+    retainMax: effectiveRetainMax,
+    trustedEntryCount: trustedTotalCount,
+    seededFirstPage,
+    startPage,
+    maxPages,
+    suppressFinalPageProbe,
+    ...(listLimit != null ? { maxPagesTruncatesWithLimit: true } : {}),
+    fetchPage: async ({ page, limit }) => {
+        const body = await gitlabFetch(
+          ctx.config,
+          ctx.parsed,
+          `${path}${separator}per_page=${limit}&page=${page}`,
+        );
+        return Array.isArray(body) ? body : [];
+      },
+    });
+  let numbers = orderOpenPullNumbers(all, (mr) => mr?.iid, sliceSort);
+  const outputCap = listLimit ?? retainMax;
+  if (outputCap != null && numbers.length > outputCap) {
+    numbers = numbers.slice(0, outputCap);
+  }
+  return {
+    numbers,
+    list_truncated: resolveListTruncatedWithTrustedTotal({
+      listTruncated,
+      trustedTotalCount,
+      walkedCount,
+      fullCollect: numberSortFullCollect,
+    }),
+    ...(entryCount != null ? { entry_count: entryCount } : {}),
+    slice_sort: sliceSort,
+  };
+}
+
+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 paginateGitlabOpenPullList(ctx, opts, sliceSort);
+  }
+
+  const retainMax = Number(opts.retain_max);
+  const probe = await probeGitlabOpenPullPageOne(ctx, retainMax, sliceSort);
+  if (!probe) {
+    return paginateGitlabOpenPullList(ctx, opts, sliceSort);
+  }
+
+  const { body, totalCount, listTruncated, requestLimit } = probe;
+
+  if (listTruncated) {
+    if (body.length === 0) {
+      return paginateGitlabOpenPullList(ctx, opts, sliceSort, gitlabProbePaginationOpts(probe));
+    }
+    return buildGitlabOpenPullMetaFromPage(body, retainMax, sliceSort, totalCount, true);
+  }
+
+  if (
+    isNumberSortFastPathEligible(totalCount, retainMax, sliceSort) &&
+    validateFastPathPageLength(totalCount, requestLimit, body.length)
+  ) {
+    return buildGitlabOpenPullMetaFromPage(body, retainMax, sliceSort, totalCount, false);
+  }
+
+  const numberSortFullCollect = isNumberSortFullCollectRequired(totalCount, retainMax, sliceSort);
+  return paginateGitlabOpenPullList(
+    ctx,
+    opts,
+    sliceSort,
+    gitlabProbePaginationOpts(probe, { numberSortFullCollect }),
+  );
+}
+
+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);
@@ -336,6 +538,9 @@ export const provider = {
   providerCapabilities,
   repoStatus,
   refsCompare,
+  refsInventory,
+  listOpenPulls,
+  crInventory: crInventorySlice,
   prView,
   prChecks,
   mergePlan,

package/package.json

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