@remogram/provider-github-api 0.1.0-beta.6 → 0.1.0-beta.9

package/branch-protection-internal.js

@@ -0,0 +1,13 @@
+/** @type {((ctx: object, opts: { branchRef: string }) => Promise<object>) | null} */
+let branchProtectionImpl = null;
+
+export function setBranchProtectionImpl(fn) {
+  branchProtectionImpl = fn;
+}
+
+export async function resolveBranchProtection(ctx, opts) {
+  if (typeof branchProtectionImpl !== 'function') {
+    throw new Error('branch protection impl not registered');
+  }
+  return branchProtectionImpl(ctx, opts);
+}

package/index.js

@@ -15,6 +15,7 @@ import {
   buildMergePlanFromProviderFacts,
   ERROR_CODES,
   forgeError,
+  LIVE_REACHABILITY_TIMEOUT_MS,
   forgeIngestCapabilityFacts,
   checkPaginationCapabilityFacts,
   openPullListCapabilityFacts,
@@ -39,6 +40,7 @@ import {
   githubOpenPullSortQuery,
   buildProviderIdentityFromGitHubUser,
   buildBranchProtectionFromGitHubProtection,
+  buildPrChecksBody,
   buildCrFilesBody,
   buildCrFilesFromGiteaFiles,
   buildCrCommentsBody,
@@ -48,12 +50,17 @@ import {
   buildChecksConclusionObservedEvent,
   appendForgeChangeEvents,
   buildCommitStatusSetBody,
+  idempotencyPacketFields,
   parseStatusSetArgs,
   normalizeStatusSetState,
   statusSetIdempotencyScanCapabilityFacts,
   MAX_OPEN_PULL_IDEMPOTENCY_PAGES,
   assertWriteCommandConfigured,
 } from '@remogram/core';
+import {
+  resolveBranchProtection,
+  setBranchProtectionImpl,
+} from './branch-protection-internal.js';
 
 const PUBLIC_GITHUB_HOST = 'github.com';
 const PUBLIC_GITHUB_API = 'https://api.github.com';
@@ -207,6 +214,25 @@ export async function githubFetch(config, parsed, path, options = {}) {
   });
 }
 
+export async function apiReachability(ctx) {
+  if (!githubToken()) {
+    throw Object.assign(new Error('GitHub token not set'), {
+      forgeError: forgeError(
+        ERROR_CODES.UNAUTHENTICATED_PROVIDER,
+        'GITHUB_TOKEN or GH_TOKEN not set',
+      ),
+    });
+  }
+  const { token } = requireToken();
+  const url = `${apiBase(ctx.config, ctx.parsed)}${repoApiPath(ctx.config)}`;
+  await fetchJson(
+    url,
+    { headers: authHeaders(token) },
+    LIVE_REACHABILITY_TIMEOUT_MS,
+  );
+  return { repo_accessible: true };
+}
+
 const MAX_CHECK_PAGES = MAX_CHECK_STATUS_PAGES;
 
 export function resolveGitHubLinkNextPage({ trustedOrigin, currentUrl, linkHeader, pageIndex, maxPages }) {
@@ -435,10 +461,10 @@ export async function refsCompare(ctx, baseRef, headRef) {
   }
   const counts = gitAheadBehind(ctx.cwd, baseSha, headSha);
   return {
-    base_ref: sanitizeField(baseRef),
-    base_sha: baseSha,
-    head_ref: sanitizeField(headRef),
-    head_sha: headSha,
+    compare_base_ref: sanitizeField(baseRef),
+    compare_base_sha: baseSha,
+    compare_head_ref: sanitizeField(headRef),
+    compare_head_sha: headSha,
     ...counts,
   };
 }
@@ -460,10 +486,10 @@ export async function prView(ctx, opts) {
     url: sanitizeUrl(pr.html_url ?? pr.url),
     title: sanitizeField(pr.title),
     state: sanitizeField(pr.state),
-    base_ref: sanitizeField(pr.base?.ref),
-    base_sha: sanitizeField(pr.base?.sha),
-    head_ref: sanitizeField(pr.head?.ref),
-    head_sha: sanitizeField(pr.head?.sha),
+    forge_target_branch_ref: sanitizeField(pr.base?.ref),
+    forge_target_sha: sanitizeField(pr.base?.sha),
+    forge_source_branch_ref: sanitizeField(pr.head?.ref),
+    forge_source_sha: sanitizeField(pr.head?.sha),
     mergeability: mergeability(pr),
   };
 }
@@ -509,6 +535,7 @@ export async function prChecks(ctx, opts) {
   apiBase(ctx.config, ctx.parsed);
   requireToken();
   let sha;
+  let requiredContexts = [];
   if (opts.ref) {
     assertGitRef(opts.ref, 'ref');
     sha = gitRevParse(ctx.cwd, opts.ref);
@@ -520,6 +547,11 @@ export async function prChecks(ctx, opts) {
   } else {
     const pr = await fetchPullGraphql(ctx.config, ctx.parsed, opts.number);
     sha = pr.head?.sha;
+    const targetBranch = pr.base?.ref;
+    if (targetBranch) {
+      const protection = await resolveBranchProtection(ctx, { branchRef: targetBranch });
+      requiredContexts = protection.required_status_contexts ?? [];
+    }
   }
   if (!sha) {
     throw Object.assign(new Error('No SHA'), {
@@ -541,20 +573,27 @@ export async function prChecks(ctx, opts) {
     context: sanitizeField(s.context),
     state: normalizeCommitStatusState(s.state),
     description: sanitizeField(s.description),
+    ...(s.target_url ? { target_url: sanitizeField(s.target_url) } : {}),
+    sha,
+    source: 'commit_status',
   }));
   const mappedCheckRuns = checkRunRecords.map((run) => ({
     context: sanitizeField(run.name),
     state: normalizeCheckRunState(run),
     description: sanitizeField(checkRunDescription(run)),
+    ...(run.details_url ? { target_url: sanitizeField(run.details_url) } : {}),
+    sha: sanitizeField(run.head_sha) || sha,
+    source: 'check_run',
   }));
   const mapped = [...mappedStatuses, ...mappedCheckRuns];
   const checks_truncated = statusResult.truncated || checkRunResult.truncated;
-  return {
-    head_sha: sha,
+  return buildPrChecksBody({
+    forge_source_sha: sha,
     check_conclusion: summarizeChecks(mapped),
     checks_truncated,
     statuses: mapped,
-  };
+    required_contexts: requiredContexts,
+  });
 }
 
 export async function mergePlan(ctx, opts) {
@@ -743,28 +782,54 @@ async function paginateGitHubOpenPullList(ctx, opts, sliceSort, paginationOpts =
       : 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;
+    if (seededFirstPage?.linkHeader) {
+      const trustedOrigin = new URL(base).origin;
+      const startUrl = seededFirstPage.listUrl ?? `${base}${listPath}`;
+      const linkSeed = {
+        items: seededFirstPage.items,
+        linkHeader: seededFirstPage.linkHeader,
+        currentUrl: startUrl,
+        usedLimit: seededFirstPage.usedLimit,
+      };
+      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: 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}${listPath}`;
@@ -1000,12 +1065,18 @@ export async function findCommitStatusByContext(ctx, sha, context) {
 
 export async function statusSet(ctx, args) {
   assertWriteCommandConfigured(ctx.config, 'status_set');
-  const parsed = parseStatusSetArgs(args);
+  const { idempotencyFingerprint = null, ...rest } = args;
+  const parsed = parseStatusSetArgs(rest);
   const existing = await findCommitStatusByContext(ctx, parsed.sha, parsed.context);
   if (existing) {
     const existingState = normalizeStatusSetState(existing.state ?? existing.status);
     if (existingState === parsed.state) {
-      return buildCommitStatusSetBody(existing, parsed, { reusedExisting: true });
+      return buildCommitStatusSetBody(existing, parsed, {
+        reusedExisting: true,
+        idempotencyFields: idempotencyFingerprint
+          ? idempotencyPacketFields(idempotencyFingerprint, { reusedExisting: true })
+          : null,
+      });
     }
   }
   const payload = {
@@ -1019,7 +1090,11 @@ export async function statusSet(ctx, args) {
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(payload),
   });
-  return buildCommitStatusSetBody(response, parsed);
+  return buildCommitStatusSetBody(response, parsed, {
+    idempotencyFields: idempotencyFingerprint
+      ? idempotencyPacketFields(idempotencyFingerprint, { reusedExisting: false })
+      : null,
+  });
 }
 
 export async function branchProtection(ctx, { branchRef }) {
@@ -1043,6 +1118,7 @@ export async function branchProtection(ctx, { branchRef }) {
 export const provider = {
   id: 'github-api',
   providerCapabilities,
+  apiReachability,
   repoStatus,
   refsCompare,
   refsInventory,
@@ -1059,3 +1135,5 @@ export const provider = {
   forgeChanges,
   statusSet,
 };
+
+setBranchProtectionImpl(branchProtection);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remogram/provider-github-api",
-  "version": "0.1.0-beta.6",
+  "version": "0.1.0-beta.9",
   "description": "GitHub API provider for remogram",
   "type": "module",
   "license": "MIT",
@@ -16,12 +16,13 @@
     "*.js"
   ],
   "exports": {
-    ".": "./index.js"
+    ".": "./index.js",
+    "./branch-protection-internal.js": "./branch-protection-internal.js"
   },
   "engines": {
     "node": ">=20"
   },
   "dependencies": {
-    "@remogram/core": "0.1.0-beta.6"
+    "@remogram/core": "0.1.0-beta.9"
   }
 }