Skip to content
Snippets Groups Projects
Select Git revision
  • c0087cae674282bb6ed7c61b3d97a69b76739987
  • master default protected
  • gh-pages
  • dependabot/npm_and_yarn/neostandard-0.12.2
  • dependabot/npm_and_yarn/eslint-plugin-prettier-5.5.1
  • dependabot/npm_and_yarn/eslint-9.30.1
  • dependabot/npm_and_yarn/cypress-14.5.1
  • dependabot/npm_and_yarn/eslint-plugin-import-2.32.0
  • dependabot/npm_and_yarn/eslint-plugin-jsdoc-51.3.4
  • dependabot/npm_and_yarn/mocha-11.7.1
  • dependabot/npm_and_yarn/typescript-eslint/parser-8.36.0
  • dependabot/npm_and_yarn/nock-14.0.5
  • dependabot/npm_and_yarn/react-19.1.0
  • dependabot/npm_and_yarn/react-dom-19.1.0
  • server-2025-02-01-6100669a
  • server-2024-11-01-87cba042
  • server-2024-10-01-6875b7c8
  • dependabot/npm_and_yarn/path-to-regexp-8.2.0
  • server-2024-09-01-3d52575c
  • daily-tests-gha2
  • daily-tests-gha
  • server-2025-07-01
  • 5.0.2
  • 5.0.1
  • 5.0.0
  • server-2025-06-01
  • server-2025-05-01
  • server-2025-04-03
  • server-2025-03-02
  • server-2025-03-01
  • server-2025-02-02
  • server-2025-01-01
  • server-2024-12-01
  • server-2024-11-02
  • 4.1.0
  • server-2024-09-25
  • server-2024-09-02
  • server-2024-08-01
  • server-2024-07-01
  • 4.0.0
  • server-2024-06-01
41 results

server.js

Blame
  • upgrades.js 5.36 KiB
    const handlebars = require('handlebars');
    const configParser = require('../../config');
    const packageFileWorker = require('../package-file');
    
    let logger = require('../../logger');
    
    module.exports = {
      determineRepoUpgrades,
      groupByBranch,
      generateConfig,
      branchifyUpgrades,
      getPackageFileConfig,
    };
    
    async function determineRepoUpgrades(config) {
      config.logger.trace({ config }, 'determineRepoUpgrades');
      if (config.packageFiles.length === 0) {
        config.logger.warn('No package files found');
      }
      let upgrades = [];
      // Iterate through repositories sequentially
      for (let index = 0; index < config.packageFiles.length; index += 1) {
        const packageFileConfig = module.exports.getPackageFileConfig(
          config,
          index
        );
        upgrades = upgrades.concat(
          await packageFileWorker.renovatePackageFile(packageFileConfig)
        );
      }
      return upgrades;
    }
    
    function generateConfig(branchUpgrades) {
      const config = {
        upgrades: [],
      };
      const hasGroupName = branchUpgrades[0].groupName !== null;
      logger.debug(`hasGroupName: ${hasGroupName}`);
      // Use group settings only if multiple upgrades or lazy grouping is disabled
      const groupEligible =
        branchUpgrades.length > 1 || branchUpgrades[0].lazyGrouping === false;
      logger.debug(`groupEligible: ${groupEligible}`);
      const useGroupSettings = hasGroupName && groupEligible;
      logger.debug(`useGroupSettings: ${useGroupSettings}`);
      for (const branchUpgrade of branchUpgrades) {
        const upgrade = Object.assign({}, branchUpgrade);
        if (useGroupSettings) {
          // Now overwrite original config with group config
          Object.assign(upgrade, upgrade.group);
        } else {
          delete upgrade.groupName;
        }
        // Delete group config regardless of whether it was applied
        delete upgrade.group;
        delete upgrade.lazyGrouping;
        // Delete the semanticPrefix for this upgrade if not enabled
        if (upgrade.semanticCommits) {
          logger.debug('Upgrade has semantic commits enabled');
        } else {
          logger.debug('Upgrade has semantic commits disabled');
          delete upgrade.semanticPrefix;
        }
        // Use templates to generate strings
        logger.debug('Compiling branchName and prTitle');
        upgrade.branchName = handlebars.compile(upgrade.branchName)(upgrade);
        upgrade.prTitle = handlebars.compile(upgrade.prTitle)(upgrade);
        logger.debug(`${upgrade.branchName}, ${upgrade.prTitle}`);
        config.upgrades.push(upgrade);
      }
      // Now assign first upgrade's config as branch config
      return Object.assign(config, config.upgrades[0]);
    }
    
    function groupByBranch(upgrades) {
      logger.trace({ config: upgrades }, 'groupByBranch');
      logger.info(`Processing ${upgrades.length} dependency upgrade(s)`);
      const result = {
        errors: [],
        warnings: [],
        branchUpgrades: {},
      };
      for (const upg of upgrades) {
        const upgrade = Object.assign({}, upg);
        // Split out errors and wrnings first
        if (upgrade.type === 'error') {
          result.errors.push(upgrade);
        } else if (upgrade.type === 'warning') {
          result.warnings.push(upgrade);
        } else {
          // Check whether to use a group name
          let branchName;
          if (upgrade.groupName) {
            // if groupName is defined then use group branchName template for combining
            logger.debug(
              { branch: branchName },
              `Dependency ${upgrade.depName} is part of group '${upgrade.groupName}'`
            );
            upgrade.groupSlug =
              upgrade.groupSlug ||
              upgrade.groupName.toLowerCase().replace(/[^a-z0-9+]+/g, '-');
            branchName = handlebars.compile(upgrade.group.branchName)(upgrade);
          } else {
            // Use regular branchName template
            branchName = handlebars.compile(upgrade.branchName)(upgrade);
          }
          result.branchUpgrades[branchName] =
            result.branchUpgrades[branchName] || [];
          result.branchUpgrades[branchName] = [upgrade].concat(
            result.branchUpgrades[branchName]
          );
        }
      }
      logger.debug(
        `Returning ${Object.keys(result.branchUpgrades).length} branch(es)`
      );
      return result;
    }
    
    async function branchifyUpgrades(upgrades, parentLogger) {
      logger = parentLogger || logger;
      logger.debug('branchifyUpgrades');
      logger.trace({ config: upgrades }, 'branchifyUpgrades');
      const branchConfigs = [];
      const res = module.exports.groupByBranch(upgrades);
      for (const branchName of Object.keys(res.branchUpgrades)) {
        logger = logger.child({ branch: branchName });
        const branchUpgrades = res.branchUpgrades[branchName];
        const branchConfig = module.exports.generateConfig(branchUpgrades);
        branchConfig.branchName = branchName;
        branchConfig.logger = logger;
        branchConfigs.push(branchConfig);
      }
      return {
        errors: res.errors,
        warnings: res.warnings,
        upgrades: branchConfigs,
      };
    }
    
    function getPackageFileConfig(repoConfig, index) {
      let packageFile = repoConfig.packageFiles[index];
      if (typeof packageFile === 'string') {
        packageFile = { packageFile };
      }
      const packageFileConfig = configParser.mergeChildConfig(
        repoConfig,
        packageFile
      );
      repoConfig.logger.trace({ config: repoConfig }, 'repoConfig');
      packageFileConfig.logger = packageFileConfig.logger.child({
        repository: packageFileConfig.repository,
        packageFile: packageFileConfig.packageFile,
      });
      packageFileConfig.logger.trace(
        { config: packageFileConfig },
        'packageFileConfig'
      );
      return configParser.filterConfig(packageFileConfig, 'packageFile');
    }