feat(config): migrate inline with the same sort

lib/config/migration.ts

@@ -5,7 +5,7 @@ import { logger } from '../logger';
 import { clone } from '../util/clone';
 import { regEx } from '../util/regex';
 import { getGlobalConfig } from './global';
-import { applyMigrations } from './migrations';
+import { MigrationsService } from './migrations';
 import { getOptions } from './options';
 import { removedPresets } from './presets/common';
 import type {
@@ -20,23 +20,6 @@ const options = getOptions();
 
 let optionTypes: Record<string, RenovateOptions['type']>;
 
-const removedOptions = [
-  'maintainYarnLock',
-  'yarnCacheFolder',
-  'yarnMaintenanceBranchName',
-  'yarnMaintenanceCommitMessage',
-  'yarnMaintenancePrTitle',
-  'yarnMaintenancePrBody',
-  'groupBranchName',
-  'groupBranchName',
-  'groupCommitMessage',
-  'groupPrTitle',
-  'groupPrBody',
-  'statusCheckVerify',
-  'lazyGrouping',
-  'supportPolicy',
-];
-
 // Returns a migrated config
 export function migrateConfig(
   config: RenovateConfig,
@@ -50,7 +33,8 @@ export function migrateConfig(
         optionTypes[option.name] = option.type;
       });
     }
-    const migratedConfig = clone(config) as MigratedRenovateConfig;
+    const newConfig = MigrationsService.run(config);
+    const migratedConfig = clone(newConfig) as MigratedRenovateConfig;
     const depTypes = [
       'dependencies',
       'devDependencies',
@@ -59,11 +43,8 @@ export function migrateConfig(
       'peerDependencies',
     ];
     const { migratePresets } = getGlobalConfig();
-    applyMigrations(config, migratedConfig);
     for (const [key, val] of Object.entries(config)) {
-      if (removedOptions.includes(key)) {
-        delete migratedConfig[key];
-      } else if (key === 'pathRules') {
+      if (key === 'pathRules') {
         if (is.array(val)) {
           migratedConfig.packageRules = is.array(migratedConfig.packageRules)
             ? migratedConfig.packageRules
@@ -85,13 +66,6 @@ export function migrateConfig(
           migratedConfig[newKey] = true;
         }
         delete migratedConfig[key];
-      } else if (key === 'gomodTidy') {
-        if (val) {
-          migratedConfig.postUpdateOptions =
-            migratedConfig.postUpdateOptions || [];
-          migratedConfig.postUpdateOptions.push('gomodTidy');
-        }
-        delete migratedConfig.gomodTidy;
       } else if (key === 'semanticCommits') {
         if (val === true) {
           migratedConfig.semanticCommits = 'enabled';
@@ -211,16 +185,6 @@ export function migrateConfig(
         if (val === false) {
           migratedConfig.rebaseWhen = 'never';
         }
-      } else if (key === 'exposeEnv') {
-        migratedConfig.exposeAllEnv = val;
-        delete migratedConfig.exposeEnv;
-      } else if (key === 'trustLevel') {
-        delete migratedConfig.trustLevel;
-        if (val === 'high') {
-          migratedConfig.allowCustomCrateRegistries ??= true;
-          migratedConfig.allowScripts ??= true;
-          migratedConfig.exposeAllEnv ??= true;
-        }
       } else if (key === 'ignoreNpmrcFile') {
         delete migratedConfig.ignoreNpmrcFile;
         if (!is.string(migratedConfig.npmrc)) {
@@ -305,9 +269,6 @@ export function migrateConfig(
           }
         }
         delete migratedConfig.unpublishSafe;
-      } else if (key === 'versionScheme') {
-        migratedConfig.versioning = val;
-        delete migratedConfig.versionScheme;
       } else if (
         key === 'automergeType' &&
         is.string(val) &&
@@ -322,25 +283,16 @@ export function migrateConfig(
         migratedConfig.major = migratedConfig.major || {};
         migratedConfig.major.automerge = !!val;
         delete migratedConfig[key];
-      } else if (key === 'multipleMajorPrs') {
-        delete migratedConfig.multipleMajorPrs;
-        migratedConfig.separateMultipleMajor = val;
       } else if (key === 'renovateFork' && is.boolean(val)) {
         delete migratedConfig.renovateFork;
         migratedConfig.includeForks = val;
       } else if (key === 'separateMajorReleases') {
         delete migratedConfig.separateMultipleMajor;
         migratedConfig.separateMajorMinor = val;
-      } else if (key === 'separatePatchReleases') {
-        delete migratedConfig.separatePatchReleases;
-        migratedConfig.separateMinorPatch = val;
       } else if (key === 'automergePatch') {
         migratedConfig.patch = migratedConfig.patch || {};
         migratedConfig.patch.automerge = !!val;
         delete migratedConfig[key];
-      } else if (key === 'ignoreNodeModules') {
-        delete migratedConfig.ignoreNodeModules;
-        migratedConfig.ignorePaths = val ? ['node_modules/'] : [];
       } else if (
         key === 'automerge' &&
         is.string(val) &&
@@ -374,9 +326,6 @@ export function migrateConfig(
           migratedConfig.packages
         );
         delete migratedConfig.packages;
-      } else if (key === 'excludedPackageNames') {
-        migratedConfig.excludePackageNames = val;
-        delete migratedConfig.excludedPackageNames;
       } else if (key === 'packageName') {
         migratedConfig.packageNames = [val];
         delete migratedConfig.packageName;
@@ -541,8 +490,6 @@ export function migrateConfig(
             migratedConfig.suppressNotifications || [];
           migratedConfig.suppressNotifications.push('deprecationWarningIssues');
         }
-      } else if (key === 'binarySource' && val === 'auto') {
-        migratedConfig.binarySource = 'global';
       } else if (key === 'composerIgnorePlatformReqs') {
         if (val === true) {
           migratedConfig.composerIgnorePlatformReqs = [];

lib/config/migrations/base/abstract-migration.ts

@@ -0,0 +1,26 @@
+import type { RenovateConfig } from '../../types';
+import type { Migration } from '../types';
+
+export abstract class AbstractMigration implements Migration {
+  readonly propertyName: string;
+
+  protected readonly originalConfig: RenovateConfig;
+
+  protected readonly migratedConfig: RenovateConfig;
+
+  constructor(
+    propertyName: string,
+    originalConfig: RenovateConfig,
+    migratedConfig: RenovateConfig
+  ) {
+    this.propertyName = propertyName;
+    this.originalConfig = originalConfig;
+    this.migratedConfig = migratedConfig;
+  }
+
+  abstract run(): void;
+
+  protected delete(property: string): void {
+    delete this.migratedConfig[property];
+  }
+}

lib/config/migrations/base/remove-property-migration.ts

@@ -0,0 +1,7 @@
+import { AbstractMigration } from './abstract-migration';
+
+export class RemovePropertyMigration extends AbstractMigration {
+  override run(): void {
+    this.delete(this.propertyName);
+  }
+}

lib/config/migrations/base/rename-property-migration.ts

@@ -0,0 +1,23 @@
+import type { RenovateConfig } from '../../types';
+import { AbstractMigration } from './abstract-migration';
+
+export class RenamePropertyMigration extends AbstractMigration {
+  protected readonly newPropertyName: string;
+
+  constructor(
+    deprecatedPropertyName: string,
+    newPropertyName: string,
+    originalConfig: RenovateConfig,
+    migratedConfig: RenovateConfig
+  ) {
+    super(deprecatedPropertyName, originalConfig, migratedConfig);
+    this.newPropertyName = newPropertyName;
+  }
+
+  override run(): void {
+    this.delete(this.propertyName);
+
+    this.migratedConfig[this.newPropertyName] =
+      this.originalConfig[this.propertyName];
+  }
+}

lib/config/migrations/custom/binary-source-migration.spec.ts

@@ -0,0 +1,11 @@
+import { MigrationsService } from '../migrations-service';
+
+describe('config/migrations/custom/binary-source-migration', () => {
+  it('should migrate "auto" to "global"', () => {
+    const migratedConfig = MigrationsService.run({
+      binarySource: 'auto',
+    });
+
+    expect(migratedConfig.binarySource).toBe('global');
+  });
+});

lib/config/migrations/custom/binary-source-migration.ts

@@ -0,0 +1,14 @@
+import type { RenovateConfig } from '../../types';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class BinarySourceMigration extends AbstractMigration {
+  constructor(originalConfig: RenovateConfig, migratedConfig: RenovateConfig) {
+    super('binarySource', originalConfig, migratedConfig);
+  }
+
+  override run(): void {
+    if (this.originalConfig.binarySource === 'auto') {
+      this.migratedConfig.binarySource = 'global';
+    }
+  }
+}

lib/config/migrations/custom/go-mod-tidy-migration.spec.ts

@@ -0,0 +1,31 @@
+import { MigrationsService } from '../migrations-service';
+
+describe('config/migrations/custom/go-mod-tidy-migration', () => {
+  it('should add postUpdateOptions option when true', () => {
+    const migratedConfig = MigrationsService.run({
+      gomodTidy: true,
+      postUpdateOptions: ['test'],
+    });
+
+    expect(migratedConfig).not.toHaveProperty('gomodTidy');
+    expect(migratedConfig.postUpdateOptions).toEqual(['test', 'gomodTidy']);
+  });
+
+  it('should handle case when postUpdateOptions is not defined ', () => {
+    const migratedConfig = MigrationsService.run({
+      gomodTidy: true,
+    });
+
+    expect(migratedConfig).not.toHaveProperty('gomodTidy');
+    expect(migratedConfig.postUpdateOptions).toEqual(['gomodTidy']);
+  });
+
+  it('should only remove when false', () => {
+    const migratedConfig = MigrationsService.run({
+      gomodTidy: false,
+    });
+
+    expect(migratedConfig).not.toHaveProperty('gomodTidy');
+    expect(migratedConfig).not.toHaveProperty('postUpdateOptions');
+  });
+});

lib/config/migrations/custom/go-mod-tidy-migration.ts

@@ -0,0 +1,19 @@
+import type { RenovateConfig } from '../../types';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class GoModTidyMigration extends AbstractMigration {
+  constructor(originalConfig: RenovateConfig, migratedConfig: RenovateConfig) {
+    super('gomodTidy', originalConfig, migratedConfig);
+  }
+
+  override run(): void {
+    const { gomodTidy, postUpdateOptions } = this.originalConfig;
+
+    this.delete(this.propertyName);
+
+    if (gomodTidy) {
+      this.migratedConfig.postUpdateOptions ??= postUpdateOptions ?? [];
+      this.migratedConfig.postUpdateOptions.push('gomodTidy');
+    }
+  }
+}

lib/config/migrations/custom/ignore-node-modules-migration.spec.ts

@@ -0,0 +1,11 @@
+import { MigrationsService } from '../migrations-service';
+
+describe('config/migrations/custom/ignore-node-modules-migration', () => {
+  it('should migrate to ignorePaths', () => {
+    const migratedConfig = MigrationsService.run({
+      ignoreNodeModules: true,
+    });
+
+    expect(migratedConfig.ignorePaths).toEqual(['node_modules/']);
+  });
+});

lib/config/migrations/custom/ignore-node-modules-migration.ts

@@ -0,0 +1,16 @@
+import type { RenovateConfig } from '../../types';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class IgnoreNodeModulesMigration extends AbstractMigration {
+  constructor(originalConfig: RenovateConfig, migratedConfig: RenovateConfig) {
+    super('ignoreNodeModules', originalConfig, migratedConfig);
+  }
+
+  override run(): void {
+    this.delete(this.propertyName);
+
+    this.migratedConfig.ignorePaths = this.originalConfig.ignoreNodeModules
+      ? ['node_modules/']
+      : [];
+  }
+}

lib/config/migrations/custom/required-status-checks-migration.spec.ts

@@ -0,0 +1,12 @@
+import { MigrationsService } from '../migrations-service';
+
+describe('config/migrations/custom/required-status-checks-migration', () => {
+  it('should migrate requiredStatusChecks=null to ignoreTests=true', () => {
+    const migratedConfig = MigrationsService.run({
+      requiredStatusChecks: null,
+    });
+
+    expect(migratedConfig).not.toHaveProperty('requiredStatusChecks');
+    expect(migratedConfig.ignoreTests).toBeTrue();
+  });
+});

lib/config/migrations/custom/required-status-checks-migration.ts

@@ -0,0 +1,16 @@
+import type { RenovateConfig } from '../../types';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class RequiredStatusChecksMigration extends AbstractMigration {
+  constructor(originalConfig: RenovateConfig, migratedConfig: RenovateConfig) {
+    super('requiredStatusChecks', originalConfig, migratedConfig);
+  }
+
+  override run(): void {
+    this.delete(this.propertyName);
+
+    if (this.originalConfig.requiredStatusChecks === null) {
+      this.migratedConfig.ignoreTests = true;
+    }
+  }
+}

lib/config/migrations/custom/trust-level-migration.spec.ts

@@ -0,0 +1,26 @@
+import { MigrationsService } from '../migrations-service';
+
+describe('config/migrations/custom/trust-level-migration', () => {
+  it('should handle hight level', () => {
+    const migratedConfig = MigrationsService.run({
+      trustLevel: 'high',
+    });
+
+    expect(migratedConfig.allowCustomCrateRegistries).toBeTrue();
+    expect(migratedConfig.allowScripts).toBeTrue();
+    expect(migratedConfig.exposeAllEnv).toBeTrue();
+  });
+
+  it('should not rewrite provided properties', () => {
+    const migratedConfig = MigrationsService.run({
+      allowCustomCrateRegistries: false,
+      allowScripts: false,
+      exposeAllEnv: false,
+      trustLevel: 'high',
+    });
+
+    expect(migratedConfig.allowCustomCrateRegistries).toBeFalse();
+    expect(migratedConfig.allowScripts).toBeFalse();
+    expect(migratedConfig.exposeAllEnv).toBeFalse();
+  });
+});

lib/config/migrations/custom/trust-level-migration.ts

@@ -0,0 +1,21 @@
+import type { RenovateConfig } from '../../types';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class TrustLevelMigration extends AbstractMigration {
+  constructor(originalConfig: RenovateConfig, migratedConfig: RenovateConfig) {
+    super('trustLevel', originalConfig, migratedConfig);
+  }
+
+  override run(): void {
+    this.delete(this.propertyName);
+
+    if (this.originalConfig.trustLevel === 'high') {
+      this.migratedConfig.allowCustomCrateRegistries =
+        this.originalConfig.allowCustomCrateRegistries ?? true;
+      this.migratedConfig.allowScripts =
+        this.originalConfig.allowScripts ?? true;
+      this.migratedConfig.exposeAllEnv =
+        this.originalConfig.exposeAllEnv ?? true;
+    }
+  }
+}