feat(config): validate reconfigure branch

lib/util/cache/repository/types.ts

@@ -42,6 +42,12 @@ export interface OnboardingBranchCache {
   configFileParsed?: string;
 }
 
+export interface ReconfigureBranchCache {
+  reconfigureBranchSha?: string;
+  configFileName?: string;
+  isConfigValid?: boolean;
+}
+
 export interface PrCache {
   /**
    * Fingerprint of the PR body
@@ -129,6 +135,7 @@ export interface RepoCacheData {
   };
   prComments?: Record<number, Record<string, string>>;
   onboardingBranchCache?: OnboardingBranchCache;
+  reconfigureBranchCache?: ReconfigureBranchCache;
 }
 
 export interface RepoCache {

lib/workers/repository/finalize/index.ts

@@ -5,6 +5,7 @@ import * as repositoryCache from '../../../util/cache/repository';
 import { clearRenovateRefs } from '../../../util/git';
 import { configMigration } from '../config-migration';
 import { PackageFiles } from '../package-files';
+import { validateReconfigureBranch } from '../reconfigure';
 import { pruneStaleBranches } from './prune';
 import {
   runBranchSummary,
@@ -16,6 +17,7 @@ export async function finalizeRepo(
   config: RenovateConfig,
   branchList: string[]
 ): Promise<void> {
+  await validateReconfigureBranch(config);
   await configMigration(config, branchList);
   await repositoryCache.saveCache();
   await pruneStaleBranches(config, branchList);

lib/workers/repository/finalize/prune.spec.ts

@@ -37,6 +37,13 @@ describe('workers/repository/finalize/prune', () => {
       expect(git.getBranchList).toHaveBeenCalledTimes(0);
     });
 
+    it('ignores reconfigure branch', async () => {
+      delete config.branchList;
+      git.getBranchList.mockReturnValueOnce(['renovate/reconfigure']);
+      await cleanup.pruneStaleBranches(config, config.branchList);
+      expect(git.getBranchList).toHaveBeenCalledTimes(0);
+    });
+
     it('returns if no renovate branches', async () => {
       config.branchList = [];
       git.getBranchList.mockReturnValueOnce([]);

lib/workers/repository/finalize/prune.ts

@@ -109,8 +109,10 @@ export async function pruneStaleBranches(
     return;
   }
   // TODO: types (#22198)
-  let renovateBranches = getBranchList().filter((branchName) =>
-    branchName.startsWith(config.branchPrefix!)
+  let renovateBranches = getBranchList().filter(
+    (branchName) =>
+      branchName.startsWith(config.branchPrefix!) &&
+      branchName !== `${config.branchPrefix!}reconfigure`
   );
   if (!renovateBranches?.length) {
     logger.debug('No renovate branches found');

lib/workers/repository/init/merge.ts

@@ -32,7 +32,7 @@ import {
 import { OnboardingState } from '../onboarding/common';
 import type { RepoFileConfig } from './types';
 
-async function detectConfigFile(): Promise<string | null> {
+export async function detectConfigFile(): Promise<string | null> {
   const fileList = await scm.getFileList();
   for (const fileName of configFileNames) {
     if (fileName === 'package.json') {

lib/workers/repository/reconfigure/index.ts

@@ -0,0 +1,141 @@
+import JSON5 from 'json5';
+import upath from 'upath';
+import type { RenovateConfig } from '../../../config/types';
+import { validateConfig } from '../../../config/validation';
+import { logger } from '../../../logger';
+import { platform } from '../../../modules/platform';
+import { scm } from '../../../modules/platform/scm';
+import { getCache } from '../../../util/cache/repository';
+import { readLocalFile } from '../../../util/fs';
+import { getBranchCommit } from '../../../util/git';
+import { detectConfigFile } from '../init/merge';
+import {
+  deleteReconfigureBranchCache,
+  setReconfigureBranchCache,
+} from './reconfigure-cache';
+
+export async function validateReconfigureBranch(
+  config: RenovateConfig
+): Promise<void> {
+  logger.debug('validateReconfigureBranch()');
+  const context = `renovate/config-validation`;
+
+  const branchName = `${config.branchPrefix}reconfigure`;
+  const branchExists = await scm.branchExists(branchName);
+
+  // this is something, the user initiates so skip if no branch exists
+  if (!branchExists) {
+    logger.debug('No reconfigure branch found');
+    deleteReconfigureBranchCache(); // inorder to remove cache when the branch deleted
+    return;
+  }
+
+  // look for config file
+  // 1. check reconfigure branch cache and use the conifgFileName if it exists
+  // 2. checkout reconfigure branch and look for the config file, don't assume default config fileName
+  const branchSha = getBranchCommit(branchName);
+  const cache = getCache();
+  let configFileName: string | null = null;
+  const branchCache = cache.reconfigureBranchCache;
+
+  // only use cached information if it is valid
+  if (branchCache?.reconfigureBranchSha === branchSha) {
+    logger.debug('Cache is valid. Skipping validation check');
+    return;
+  }
+  logger.debug('Cache is outdated. Performing validation check');
+
+  if (!configFileName) {
+    try {
+      await scm.checkoutBranch(branchName);
+      configFileName = await detectConfigFile();
+    } catch (err) {
+      logger.debug(
+        { err },
+        'Error while searching for config file in reconfigure branch'
+      );
+    }
+  }
+
+  if (!configFileName) {
+    logger.warn('No config file found in reconfigure branch');
+    await platform.setBranchStatus({
+      branchName,
+      context,
+      description: 'Validation Failed - No config file found',
+      state: 'red',
+    });
+    await scm.checkoutBranch(config.baseBranch!);
+    return;
+  }
+
+  let configFileRaw: string | null = null;
+  try {
+    configFileRaw = await readLocalFile(configFileName, 'utf8');
+  } catch (err) {
+    logger.debug('Error while reading config file');
+  }
+
+  if (!configFileRaw) {
+    logger.debug('Empty config file');
+    await platform.setBranchStatus({
+      branchName,
+      context,
+      description: 'Validation Failed - Empty config file',
+      state: 'red',
+    });
+    setReconfigureBranchCache(branchSha!, configFileName, false);
+    await scm.checkoutBranch(config.baseBranch!);
+    return;
+  }
+
+  let configFileParsed: any;
+  try {
+    const fileType = upath.extname(configFileName);
+    if (fileType === '.json') {
+      configFileParsed = JSON.parse(
+        (await readLocalFile(configFileName, 'utf8'))!
+      );
+      // ? should we allow package.json
+      // no need to confirm renovate field in package.json we already do it in `detectConfigFile()`
+      if (configFileName === 'package.json') {
+        configFileParsed = configFileParsed.renovate;
+      }
+    } else {
+      configFileParsed = JSON5.parse(
+        (await readLocalFile(configFileName, 'utf8'))!
+      );
+    }
+  } catch (err) {
+    logger.debug({ err }, 'Error while reading config file');
+    await scm.checkoutBranch(config.baseBranch!);
+    return;
+  }
+
+  // perform validation and provide a passing or failing check run based on result
+  const validationResult = await validateConfig(configFileParsed);
+
+  // failing check
+  if (validationResult.errors.length > 0) {
+    await platform.setBranchStatus({
+      branchName,
+      context,
+      description: 'Validation Failed',
+      state: 'red',
+    });
+    setReconfigureBranchCache(branchSha!, configFileName, false);
+    await scm.checkoutBranch(config.baseBranch!);
+    return;
+  }
+
+  // passing check
+  await platform.setBranchStatus({
+    branchName,
+    context,
+    description: 'Validation Successfull',
+    state: 'green',
+  });
+  setReconfigureBranchCache(branchSha!, configFileName, true);
+
+  await scm.checkoutBranch(config.baseBranch!);
+}

lib/workers/repository/reconfigure/reconfigure-cache.ts

@@ -0,0 +1,37 @@
+import is from '@sindresorhus/is';
+import { logger } from '../../../logger';
+import { getCache } from '../../../util/cache/repository';
+
+export function setReconfigureBranchCache(
+  reconfigureBranchSha: string,
+  configFileName: string,
+  isConfigValid: boolean
+): void {
+  // do not update cache if commit is null/undefined
+  if (!is.nonEmptyString(reconfigureBranchSha)) {
+    logger.debug('Onboarding cache not updated');
+    return;
+  }
+
+  const cache = getCache();
+  const reconfigureBranchCache = {
+    reconfigureBranchSha,
+    configFileName,
+    isConfigValid,
+  };
+  if (cache.reconfigureBranchCache) {
+    logger.debug({ reconfigureBranchCache }, 'Update Reconfigure Branch Cache');
+  } else {
+    logger.debug({ reconfigureBranchCache }, 'Create Reconfigure Branch Cache');
+  }
+  cache.reconfigureBranchCache = reconfigureBranchCache;
+}
+
+export function deleteReconfigureBranchCache(): void {
+  const cache = getCache();
+
+  if (cache?.reconfigureBranchCache) {
+    logger.debug('Delete Reconfigure Branch Cache');
+    delete cache.reconfigureBranchCache;
+  }
+}