renovate 42.0.0-next.1 → 42.0.0

package/dist/modules/platform/github/index.js

@@ -235,13 +235,28 @@ async function getRepos(config) {
     return topicRepositories.map((repo) => repo.full_name);
 }
 async function getBranchProtection(branchName) {
-    /* v8 ignore start */
     if (config.parentRepo) {
         return {};
-    } /* v8 ignore stop */
-    const res = await common_2.githubApi.getJsonUnchecked(`repos/${config.repository}/branches/${escapeHash(branchName)}/protection`, { cacheProvider: repository_http_cache_provider_1.repoCacheProvider });
+    }
+    const res = await common_2.githubApi.getJson(`repos/${config.repository}/branches/${escapeHash(branchName)}/protection`, { cacheProvider: repository_http_cache_provider_1.repoCacheProvider }, schema_1.GithubBranchProtection);
     return res.body;
 }
+async function getBranchRulesets(branchName) {
+    if (config.parentRepo) {
+        return [];
+    }
+    try {
+        const res = await common_2.githubApi.getJson(`repos/${config.repository}/rules/branches/${escapeHash(branchName)}`, { cacheProvider: repository_http_cache_provider_1.repoCacheProvider }, schema_1.GithubBranchRulesets);
+        return res.body;
+    }
+    catch (err) {
+        if (err.statusCode === 404) {
+            logger_1.logger.debug(`No branch rulesets found for ${branchName}`);
+            return [];
+        }
+        throw err;
+    }
+}
 async function getRawFile(fileName, repoName, branchOrTag) {
     const repo = repoName ?? config.repository;
     // only use cache for the same org
@@ -319,7 +334,7 @@ async function createFork(token, repository, forkOrg) {
             body: {
                 organization: forkOrg ?? undefined,
                 name: config.parentRepo.replace('/', '-_-'),
-                default_branch_only: true, // no baseBranches support yet
+                default_branch_only: true, // no baseBranchPatterns support yet
             },
         })).body;
     }
@@ -570,32 +585,72 @@ async function initRepo({ endpoint, repository, forkCreation, forkOrg, forkToken
     };
     return repoConfig;
 }
-async function getBranchForceRebase(branchName) {
-    config.branchForceRebase ??= {};
-    if (config.branchForceRebase[branchName] === undefined) {
-        try {
-            config.branchForceRebase[branchName] = false;
-            const branchProtection = await getBranchProtection(branchName);
-            logger_1.logger.debug(`Found branch protection for branch ${branchName}`);
-            if (branchProtection?.required_status_checks?.strict) {
-                logger_1.logger.debug(`Branch protection: PRs must be up-to-date before merging for ${branchName}`);
-                config.branchForceRebase[branchName] = true;
-            }
-        }
-        catch (err) {
-            if (err.statusCode === 404) {
-                logger_1.logger.debug(`No branch protection found for ${branchName}`);
-            }
-            else if (err.message === error_messages_1.PLATFORM_INTEGRATION_UNAUTHORIZED ||
-                err.statusCode === 403) {
-                logger_1.logger.once.debug('Branch protection: Do not have permissions to detect branch protection');
-            }
-            else {
-                throw err;
+async function checkRulesetsForForceRebase(branchName) {
+    try {
+        const rulesets = await getBranchRulesets(branchName);
+        logger_1.logger.trace(`Ruleset: Found ${rulesets.length} rulesets for branch ${branchName}`);
+        return rulesets.some((rule) => {
+            if (rule.type === 'required_status_checks' &&
+                rule.parameters?.strict_required_status_checks_policy === true) {
+                logger_1.logger.debug(`Ruleset: strict required status checks found for ${branchName}`);
+                return true;
             }
+            return false;
+        });
+    }
+    catch (err) {
+        handleBranchProtectionError('rulesets', err, branchName);
+        return false;
+    }
+}
+async function checkBranchProtectionForForceRebase(branchName) {
+    try {
+        const branchProtection = await getBranchProtection(branchName);
+        logger_1.logger.trace(`Found branch protection for branch ${branchName}`);
+        const strictStatusChecks = branchProtection?.required_status_checks?.strict;
+        if (strictStatusChecks) {
+            logger_1.logger.debug(`Branch protection: PRs must be up-to-date before merging for ${branchName}`);
+            return true;
         }
+        return false;
+    }
+    catch (err) {
+        handleBranchProtectionError('branch-protection', err, branchName);
+        return false;
     }
-    return !!config.branchForceRebase[branchName];
+}
+async function getBranchForceRebase(branchName) {
+    config.branchForceRebase ??= {};
+    const cachedResult = config.branchForceRebase[branchName];
+    if (cachedResult !== undefined) {
+        return cachedResult;
+    }
+    // Initialize to false before checking branch protection
+    config.branchForceRebase[branchName] = false;
+    // Check rulesets first (newer API)
+    const hasRulesetForceRebase = await checkRulesetsForForceRebase(branchName);
+    if (hasRulesetForceRebase) {
+        config.branchForceRebase[branchName] = true;
+        return true;
+    }
+    // Fall back to legacy branch protection
+    const hasBranchProtectionForceRebase = await checkBranchProtectionForForceRebase(branchName);
+    if (hasBranchProtectionForceRebase) {
+        config.branchForceRebase[branchName] = true;
+    }
+    return config.branchForceRebase[branchName];
+}
+function handleBranchProtectionError(protection, err, branchName) {
+    if (err.statusCode === 404) {
+        logger_1.logger.debug(`No ${protection} found for ${branchName}`);
+        return;
+    }
+    const isUnauthorized = err.message === error_messages_1.PLATFORM_INTEGRATION_UNAUTHORIZED || err.statusCode === 403;
+    if (isUnauthorized) {
+        logger_1.logger.once.debug(`Branch protection: Do not have permissions to detect ${protection} for ${branchName}`);
+        return;
+    }
+    throw err;
 }
 function cachePr(pr) {
     config.prList ??= [];
@@ -736,7 +791,7 @@ async function getBranchPr(branchName) {
     }
     return null;
 }
-async function tryReuseAutoclosedPr(autoclosedPr) {
+async function tryReuseAutoclosedPr(autoclosedPr, newTitle) {
     const { sha, number, sourceBranch: branchName } = autoclosedPr;
     try {
         await ensureBranchSha(branchName, sha);
@@ -747,15 +802,19 @@ async function tryReuseAutoclosedPr(autoclosedPr) {
         return null;
     }
     try {
-        const title = autoclosedPr.title.replace((0, regex_1.regEx)(/ - autoclosed$/), '');
         const { body: ghPr } = await common_2.githubApi.patchJson(`repos/${config.repository}/pulls/${number}`, {
             body: {
                 state: 'open',
-                title,
+                title: newTitle,
             },
         });
-        logger_1.logger.info({ branchName, title, number }, 'Successfully reopened autoclosed PR');
+        logger_1.logger.info({ branchName, oldTitle: autoclosedPr.title, newTitle, number }, 'Successfully reopened autoclosed PR');
         const result = (0, common_2.coerceRestPr)(ghPr);
+        const localSha = git.getBranchCommit(branchName);
+        if (localSha && localSha !== sha) {
+            await git.forcePushToRemote(branchName, 'origin');
+            result.sha = localSha;
+        }
         cachePr(result);
         return result;
     }
@@ -1028,7 +1087,7 @@ async function ensureIssue({ title, reuseTitle, body: rawBody, labels, once = fa
                 logger_1.logger.debug('Issue is open and up to date - nothing to do');
                 return null;
             }
-            if (shouldReOpen) {
+            if (shouldReOpen || issue.state === 'open') {
                 logger_1.logger.debug('Patching issue');
                 const data = { body, state: 'open', title };
                 if (labels) {
@@ -1494,7 +1553,7 @@ async function getVulnerabilityAlerts() {
             paginate: true,
             headers: { accept: 'application/vnd.github+json' },
             cacheProvider: repository_http_cache_provider_1.repoCacheProvider,
-        }, schema_1.VulnerabilityAlertSchema)).body;
+        }, schema_1.GithubVulnerabilityAlert)).body;
     }
     catch (err) /* v8 ignore start */ {
         logger_1.logger.debug({ err }, 'Error retrieving vulnerability alerts');