renovate 41.0.0-next.21 → 41.0.0-next.23

package/dist/util/git/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GIT_MINIMUM_VERSION = exports.setPrivateKey = exports.setNoVerify = void 0;
+exports.GIT_MINIMUM_VERSION = exports.RENOVATE_FORK_UPSTREAM = exports.setPrivateKey = exports.setNoVerify = void 0;
 exports.gitRetry = gitRetry;
 exports.validateGitVersion = validateGitVersion;
 exports.fetchRevSpec = fetchRevSpec;
@@ -18,6 +18,9 @@ exports.branchExists = branchExists;
 exports.getBranchCommit = getBranchCommit;
 exports.getCommitMessages = getCommitMessages;
 exports.checkoutBranch = checkoutBranch;
+exports.checkoutBranchFromRemote = checkoutBranchFromRemote;
+exports.resetHardFromRemote = resetHardFromRemote;
+exports.forcePushToRemote = forcePushToRemote;
 exports.getFileList = getFileList;
 exports.getBranchList = getBranchList;
 exports.isBranchBehindBase = isBranchBehindBase;
@@ -39,6 +42,8 @@ exports.getUrl = getUrl;
 exports.pushCommitToRenovateRef = pushCommitToRenovateRef;
 exports.clearRenovateRefs = clearRenovateRefs;
 exports.listCommitTree = listCommitTree;
+exports.syncForkWithUpstream = syncForkWithUpstream;
+exports.getRemotes = getRemotes;
 const tslib_1 = require("tslib");
 const node_url_1 = tslib_1.__importDefault(require("node:url"));
 const promises_1 = require("timers/promises");
@@ -54,6 +59,7 @@ const logger_1 = require("../../logger");
 const external_host_error_1 = require("../../types/errors/external-host-error");
 const limits_1 = require("../../workers/global/limits");
 const repository_1 = require("../cache/repository");
+const env_1 = require("../env");
 const regex_1 = require("../regex");
 const string_match_1 = require("../string-match");
 const author_1 = require("./author");
@@ -71,6 +77,7 @@ Object.defineProperty(exports, "setPrivateKey", { enumerable: true, get: functio
 const retryCount = 5;
 const delaySeconds = 3;
 const delayFactor = 2;
+exports.RENOVATE_FORK_UPSTREAM = 'renovate-fork-upstream';
 // A generic wrapper for simpleGit.* calls to make them more fault-tolerant
 async function gitRetry(gitFunc) {
     let round = 0;
@@ -116,6 +123,7 @@ async function isDirectory(dir) {
     }
 }
 async function getDefaultBranch(git) {
+    logger_1.logger.debug('getDefaultBranch()');
     // see https://stackoverflow.com/a/62352647/3005034
     try {
         let res = await git.raw(['rev-parse', '--abbrev-ref', 'origin/HEAD']);
@@ -134,6 +142,7 @@ async function getDefaultBranch(git) {
         /* v8 ignore start -- TODO: add test */
     }
     catch (err) {
+        logger_1.logger.debug({ err }, 'Error getting default branch');
         const errChecked = (0, error_1.checkForPlatformFailure)(err);
         if (errChecked) {
             throw errChecked;
@@ -142,7 +151,7 @@ async function getDefaultBranch(git) {
             throw new Error(error_messages_1.REPOSITORY_EMPTY);
         }
         if (err.message.includes("fatal: ambiguous argument 'origin/HEAD'")) {
-            logger_1.logger.warn({ err }, 'Error getting default branch');
+            logger_1.logger.warn('Error getting default branch');
             throw new Error(error_messages_1.TEMPORARY_ERROR);
         }
         throw err;
@@ -181,9 +190,11 @@ async function validateGitVersion() {
     logger_1.logger.debug(`Found valid git version: ${version}`);
     return true;
 }
-async function fetchBranchCommits() {
+async function fetchBranchCommits(preferUpstream = true) {
     config.branchCommits = {};
-    const opts = ['ls-remote', '--heads', config.url];
+    const url = preferUpstream && config.upstreamUrl ? config.upstreamUrl : config.url;
+    logger_1.logger.debug(`fetchBranchCommits(): url=${url}`);
+    const opts = ['ls-remote', '--heads', url];
     if (config.extraCloneOpts) {
         Object.entries(config.extraCloneOpts).forEach((e) => 
         // TODO: types (#22198)
@@ -223,8 +234,9 @@ async function initRepo(args) {
     config.ignoredAuthors = [];
     config.additionalBranches = [];
     config.branchIsModified = {};
+    // TODO: safe to pass all env variables? use `getChildEnv` instead?
     git = (0, simple_git_1.simpleGit)(global_1.GlobalConfig.get('localDir'), (0, config_1.simpleGitConfig)()).env({
-        ...process.env,
+        ...(0, env_1.getEnv)(),
         LANG: 'C.UTF-8',
         LC_ALL: 'C.UTF-8',
     });
@@ -346,7 +358,7 @@ function isCloned() {
 async function syncGit() {
     if (gitInitialized) {
         /* v8 ignore next 3 -- TODO: add test */
-        if (process.env.RENOVATE_X_CLEAR_HOOKS) {
+        if ((0, env_1.getEnv)().RENOVATE_X_CLEAR_HOOKS) {
             await git.raw(['config', 'core.hooksPath', '/dev/null']);
         }
         return;
@@ -357,10 +369,11 @@ async function syncGit() {
     }
     gitInitialized = true;
     const localDir = global_1.GlobalConfig.get('localDir');
-    logger_1.logger.debug(`Initializing git repository into ${localDir}`);
+    logger_1.logger.debug(`syncGit(): Initializing git repository into ${localDir}`);
     const gitHead = upath_1.default.join(localDir, '.git/HEAD');
     let clone = true;
     if (await fs_extra_1.default.pathExists(gitHead)) {
+        logger_1.logger.debug(`syncGit(): Found existing git repository, attempting git fetch`);
         try {
             await git.raw(['remote', 'set-url', 'origin', config.url]);
             const fetchStart = Date.now();
@@ -378,7 +391,7 @@ async function syncGit() {
             if (err.message === error_messages_1.REPOSITORY_EMPTY) {
                 throw err;
             }
-            logger_1.logger.info({ err }, 'git fetch error');
+            logger_1.logger.info({ err }, 'git fetch error, falling back to git clone');
         }
     }
     if (clone) {
@@ -453,6 +466,21 @@ async function syncGit() {
             (await getDefaultBranch(git));
     /* v8 ignore next -- TODO: add test */
     delete (0, repository_1.getCache)()?.semanticCommits;
+    // If upstreamUrl is set then the bot is running in fork mode
+    // The "upstream" remote is the original repository which was forked from
+    if (config.upstreamUrl) {
+        logger_1.logger.debug(`Bringing default branch up-to-date with ${exports.RENOVATE_FORK_UPSTREAM}, to get latest config`);
+        // Add remote if it does not exist
+        const remotes = await git.getRemotes(true);
+        if (!remotes.some((remote) => remote.name === exports.RENOVATE_FORK_UPSTREAM)) {
+            logger_1.logger.debug(`Adding remote ${exports.RENOVATE_FORK_UPSTREAM}`);
+            await git.addRemote(exports.RENOVATE_FORK_UPSTREAM, config.upstreamUrl);
+        }
+        await syncForkWithUpstream(config.currentBranch);
+        await fetchBranchCommits(false);
+    }
+    config.currentBranchSha = (await git.revparse('HEAD')).trim();
+    logger_1.logger.debug(`Current branch SHA: ${config.currentBranchSha}`);
 }
 async function getRepoStatus(path) {
     if (is_1.default.string(path)) {
@@ -501,7 +529,7 @@ async function checkoutBranch(branchName) {
         config.currentBranchSha = (await git.raw(['rev-parse', 'HEAD'])).trim();
         const latestCommitDate = (await git.log({ n: 1 }))?.latest?.date;
         if (latestCommitDate) {
-            logger_1.logger.debug({ branchName, latestCommitDate }, 'latest commit');
+            logger_1.logger.debug({ branchName, latestCommitDate, sha: config.currentBranchSha }, 'latest commit');
         }
         await git.reset(simple_git_1.ResetMode.HARD);
         return config.currentBranchSha;
@@ -519,12 +547,56 @@ async function checkoutBranch(branchName) {
         throw err;
     }
 }
+async function checkoutBranchFromRemote(branchName, remoteName) {
+    logger_1.logger.debug(`Checking out branch ${branchName} from remote ${remoteName}`);
+    await syncGit();
+    try {
+        await gitRetry(() => git.checkoutBranch(branchName, `${remoteName}/${branchName}`));
+        config.currentBranch = branchName;
+        config.currentBranchSha = (await git.revparse('HEAD')).trim();
+        logger_1.logger.debug(`Checked out branch ${branchName} from remote ${remoteName}`);
+        config.branchCommits[branchName] = config.currentBranchSha;
+        return config.currentBranchSha;
+    }
+    catch (err) {
+        const errChecked = (0, error_1.checkForPlatformFailure)(err);
+        /* v8 ignore next 3 -- hard to test */
+        if (errChecked) {
+            throw errChecked;
+        }
+        if (err.message?.includes('fatal: ambiguous argument')) {
+            logger_1.logger.warn({ err }, 'Failed to checkout branch');
+            throw new Error(error_messages_1.TEMPORARY_ERROR);
+        }
+        throw err;
+    }
+}
+async function resetHardFromRemote(remoteAndBranch) {
+    try {
+        const resetLog = await git.reset(['--hard', remoteAndBranch]);
+        logger_1.logger.debug({ resetLog }, 'git reset log');
+    }
+    catch (err) {
+        logger_1.logger.error({ err }, 'Error during git reset --hard');
+        throw err;
+    }
+}
+async function forcePushToRemote(branchName, remote) {
+    try {
+        const pushLog = await git.push([remote, branchName, '--force']);
+        logger_1.logger.debug({ pushLog }, 'git push log');
+    }
+    catch (err) {
+        logger_1.logger.error({ err }, 'Error during git push --force');
+        throw err;
+    }
+}
 async function getFileList() {
     await syncGit();
     const branch = config.currentBranch;
     let files;
     try {
-        files = await git.raw(['ls-tree', '-r', branch]);
+        files = await git.raw(['ls-tree', '-r', `refs/heads/${branch}`]);
         /* v8 ignore next 10 -- TODO: add test */
     }
     catch (err) {
@@ -1184,4 +1256,62 @@ async function listCommitTree(commitSha) {
     }
     return result;
 }
+async function localBranchExists(branchName) {
+    await syncGit();
+    const localBranches = await git.branchLocal();
+    return localBranches.all.includes(branchName);
+}
+/**
+ * Synchronize a forked branch with its upstream counterpart.
+ *
+ * syncForkWithUpstream updates the fork's branch, to match the corresponding branch in the upstream repository.
+ * The steps are:
+ * 1. Check if the branch exists locally.
+ * 2. If the branch exists locally: checkout the local branch.
+ * 3. If the branch does _not_ exist locally: checkout the upstream branch.
+ * 4. Reset the local branch to match the upstream branch.
+ * 5. Force push the (updated) local branch to the origin repository.
+ *
+ * @param {string} branchName - The name of the branch to synchronize.
+ * @returns A promise that resolves to True if the synchronization is successful, or `false` if an error occurs.
+ */
+async function syncForkWithUpstream(branchName) {
+    if (!config.upstreamUrl) {
+        return;
+    }
+    logger_1.logger.debug(`Synchronizing fork with "${exports.RENOVATE_FORK_UPSTREAM}" remote for branch ${branchName}`);
+    const remotes = await getRemotes();
+    /* v8 ignore next 3 -- this should not be possible if upstreamUrl exists */
+    if (!remotes.some((r) => r === exports.RENOVATE_FORK_UPSTREAM)) {
+        throw new Error('No upstream remote exists, cannot sync fork');
+    }
+    try {
+        await git.fetch([exports.RENOVATE_FORK_UPSTREAM]);
+        if (await localBranchExists(branchName)) {
+            await checkoutBranch(branchName);
+        }
+        else {
+            await checkoutBranchFromRemote(branchName, exports.RENOVATE_FORK_UPSTREAM);
+        }
+        await resetHardFromRemote(`${exports.RENOVATE_FORK_UPSTREAM}/${branchName}`);
+        await forcePushToRemote(branchName, 'origin');
+    }
+    catch (err) /* v8 ignore next 3 -- shouldn't happen */ {
+        logger_1.logger.error({ err }, 'Error synchronizing fork');
+        throw new Error(error_messages_1.UNKNOWN_ERROR);
+    }
+}
+async function getRemotes() {
+    logger_1.logger.debug('git.getRemotes()');
+    try {
+        await syncGit();
+        const remotes = await git.getRemotes();
+        logger_1.logger.debug(`Found remotes: ${remotes.map((r) => r.name).join(', ')}`);
+        return remotes.map((remote) => remote.name);
+    }
+    catch (err) /* v8 ignore start */ {
+        logger_1.logger.error({ err }, 'Error getting remotes');
+        throw err;
+    } /* v8 ignore stop */
+}
 //# sourceMappingURL=index.js.map