feat(migrations): split

lib/config/migration.spec.ts

@@ -452,35 +452,6 @@ describe('config/migration', () => {
       });
       expect(isMigrated).toBeTrue();
     });
-    it('it migrates semanticCommits', () => {
-      let config: TestRenovateConfig;
-      let res: MigratedConfig;
-
-      config = { semanticCommits: true as never };
-      res = configMigration.migrateConfig(config);
-      expect(res.isMigrated).toBeTrue();
-      expect(res.migratedConfig).toMatchObject({ semanticCommits: 'enabled' });
-
-      config = { semanticCommits: false as never };
-      res = configMigration.migrateConfig(config);
-      expect(res.isMigrated).toBeTrue();
-      expect(res.migratedConfig).toMatchObject({ semanticCommits: 'disabled' });
-
-      config = { semanticCommits: null as never };
-      res = configMigration.migrateConfig(config);
-      expect(res.isMigrated).toBeTrue();
-      expect(res.migratedConfig).toMatchObject({ semanticCommits: 'auto' });
-
-      config = { semanticCommits: 'enabled' };
-      res = configMigration.migrateConfig(config);
-      expect(res.isMigrated).toBeFalse();
-      expect(res.migratedConfig).toMatchObject({ semanticCommits: 'enabled' });
-
-      config = { semanticCommits: 'disabled' };
-      res = configMigration.migrateConfig(config);
-      expect(res.isMigrated).toBeFalse();
-      expect(res.migratedConfig).toMatchObject({ semanticCommits: 'disabled' });
-    });
 
     it('it migrates preset strings to array', () => {
       let config: TestRenovateConfig;

lib/config/migration.ts

@@ -68,19 +68,6 @@ export function migrateConfig(
           migratedConfig[newKey] = true;
         }
         delete migratedConfig[key];
-      } else if (key === 'semanticCommits') {
-        if (val === true) {
-          migratedConfig.semanticCommits = 'enabled';
-        } else if (val === false) {
-          migratedConfig.semanticCommits = 'disabled';
-        } else if (val !== 'enabled' && val !== 'disabled') {
-          migratedConfig.semanticCommits = 'auto';
-        }
-      } else if (key === 'enabledManagers' && is.array(val)) {
-        // Replace yarn with npm, since yarn actually uses npm as package manager
-        migratedConfig.enabledManagers = migratedConfig.enabledManagers.map(
-          (element) => (element === 'yarn' ? 'npm' : element)
-        );
       } else if (parentKey === 'hostRules' && key === 'platform') {
         migratedConfig.hostType = val;
         delete migratedConfig.platform;
@@ -150,13 +137,6 @@ export function migrateConfig(
         delete depTypePackageRule.packageRules;
         migratedConfig.packageRules.push(depTypePackageRule);
         delete migratedConfig[key];
-      } else if (key === 'pinVersions') {
-        delete migratedConfig.pinVersions;
-        if (val === true) {
-          migratedConfig.rangeStrategy = 'pin';
-        } else if (val === false) {
-          migratedConfig.rangeStrategy = 'replace';
-        }
       } else if (is.string(val) && val.includes('{{baseDir}}')) {
         migratedConfig[key] = val.replace(
           regEx(/{{baseDir}}/g),
@@ -169,24 +149,6 @@ export function migrateConfig(
         );
       } else if (key === 'gitFs') {
         delete migratedConfig.gitFs;
-      } else if (key === 'rebaseStalePrs') {
-        delete migratedConfig.rebaseStalePrs;
-        if (!migratedConfig.rebaseWhen) {
-          if (val === null) {
-            migratedConfig.rebaseWhen = 'auto';
-          }
-          if (val === true) {
-            migratedConfig.rebaseWhen = 'behind-base-branch';
-          }
-          if (val === false) {
-            migratedConfig.rebaseWhen = 'conflicted';
-          }
-        }
-      } else if (key === 'rebaseConflictedPrs') {
-        delete migratedConfig.rebaseConflictedPrs;
-        if (val === false) {
-          migratedConfig.rebaseWhen = 'never';
-        }
       } else if (key === 'ignoreNpmrcFile') {
         delete migratedConfig.ignoreNpmrcFile;
         if (!is.string(migratedConfig.npmrc)) {

lib/config/migrations/custom/enabled-managers-migration.spec.ts

@@ -0,0 +1,14 @@
+import { EnabledManagersMigration } from './enabled-managers-migration';
+
+describe('config/migrations/custom/enabled-managers-migration', () => {
+  it('should replace yarn with npm', () => {
+    expect(EnabledManagersMigration).toMigrate(
+      {
+        enabledManagers: ['test1', 'yarn', 'test2'],
+      },
+      {
+        enabledManagers: ['test1', 'npm', 'test2'],
+      }
+    );
+  });
+});

lib/config/migrations/custom/enabled-managers-migration.ts

@@ -0,0 +1,15 @@
+import is from '@sindresorhus/is';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class EnabledManagersMigration extends AbstractMigration {
+  readonly propertyName = 'enabledManagers';
+
+  override run(value: string[]): void {
+    if (is.array(value)) {
+      const newValue = value.map((manager) =>
+        manager === 'yarn' ? 'npm' : manager
+      );
+      this.rewrite(newValue);
+    }
+  }
+}

lib/config/migrations/custom/pin-versions-migration.spec.ts

@@ -0,0 +1,25 @@
+import { PinVersionsMigration } from './pin-versions-migration';
+
+describe('config/migrations/custom/pin-versions-migration', () => {
+  it('should migrate true', () => {
+    expect(PinVersionsMigration).toMigrate(
+      {
+        pinVersions: true,
+      },
+      {
+        rangeStrategy: 'pin',
+      }
+    );
+  });
+
+  it('should migrate false', () => {
+    expect(PinVersionsMigration).toMigrate(
+      {
+        pinVersions: false,
+      },
+      {
+        rangeStrategy: 'replace',
+      }
+    );
+  });
+});

lib/config/migrations/custom/pin-versions-migration.ts

@@ -0,0 +1,13 @@
+import is from '@sindresorhus/is';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class PinVersionsMigration extends AbstractMigration {
+  override readonly deprecated = true;
+  readonly propertyName = 'pinVersions';
+
+  override run(value): void {
+    if (is.boolean(value)) {
+      this.setSafely('rangeStrategy', value ? 'pin' : 'replace');
+    }
+  }
+}

lib/config/migrations/custom/rebase-conflicted-prs-migration.spec.ts

@@ -0,0 +1,14 @@
+import { RebaseConflictedPrs } from './rebase-conflicted-prs-migration';
+
+describe('config/migrations/custom/rebase-conflicted-prs-migration', () => {
+  it('should migrate false', () => {
+    expect(RebaseConflictedPrs).toMigrate(
+      {
+        rebaseConflictedPrs: false,
+      },
+      {
+        rebaseWhen: 'never',
+      }
+    );
+  });
+});

lib/config/migrations/custom/rebase-conflicted-prs-migration.ts

@@ -0,0 +1,12 @@
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class RebaseConflictedPrs extends AbstractMigration {
+  override readonly deprecated = true;
+  readonly propertyName = 'rebaseConflictedPrs';
+
+  override run(value): void {
+    if (value === false) {
+      this.setSafely('rebaseWhen', 'never');
+    }
+  }
+}

lib/config/migrations/custom/rebase-stale-prs-migration.spec.ts

@@ -0,0 +1,36 @@
+import { RebaseStalePrsMigration } from './rebase-stale-prs-migration';
+
+describe('config/migrations/custom/rebase-stale-prs-migration', () => {
+  it('should migrate true', () => {
+    expect(RebaseStalePrsMigration).toMigrate(
+      {
+        rebaseStalePrs: true,
+      },
+      {
+        rebaseWhen: 'behind-base-branch',
+      }
+    );
+  });
+
+  it('should migrate false', () => {
+    expect(RebaseStalePrsMigration).toMigrate(
+      {
+        rebaseStalePrs: false,
+      },
+      {
+        rebaseWhen: 'conflicted',
+      }
+    );
+  });
+
+  it('should migrate null', () => {
+    expect(RebaseStalePrsMigration).toMigrate(
+      {
+        rebaseStalePrs: null,
+      },
+      {
+        rebaseWhen: 'auto',
+      }
+    );
+  });
+});

lib/config/migrations/custom/rebase-stale-prs-migration.ts

@@ -0,0 +1,24 @@
+import is from '@sindresorhus/is';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class RebaseStalePrsMigration extends AbstractMigration {
+  override readonly deprecated = true;
+  readonly propertyName = 'rebaseStalePrs';
+
+  override run(value): void {
+    const rebaseConflictedPrs = this.get('rebaseConflictedPrs');
+
+    if (rebaseConflictedPrs !== false) {
+      if (is.boolean(value)) {
+        this.setSafely(
+          'rebaseWhen',
+          value ? 'behind-base-branch' : 'conflicted'
+        );
+      }
+
+      if (is.null_(value)) {
+        this.setSafely('rebaseWhen', 'auto');
+      }
+    }
+  }
+}

lib/config/migrations/custom/semantic-commits-migration.spec.ts

@@ -0,0 +1,59 @@
+import { SemanticCommitsMigration } from './semantic-commits-migration';
+
+describe('config/migrations/custom/semantic-commits-migration', () => {
+  it('should migrate true to "enabled"', () => {
+    expect(SemanticCommitsMigration).toMigrate(
+      {
+        semanticCommits: true,
+      } as any,
+      { semanticCommits: 'enabled' }
+    );
+  });
+
+  it('should migrate false to "disabled"', () => {
+    expect(SemanticCommitsMigration).toMigrate(
+      {
+        semanticCommits: false,
+      } as any,
+      { semanticCommits: 'disabled' }
+    );
+  });
+
+  it('should migrate null to "auto"', () => {
+    expect(SemanticCommitsMigration).toMigrate(
+      {
+        semanticCommits: null,
+      } as any,
+      { semanticCommits: 'auto' }
+    );
+  });
+
+  it('should migrate random string to "auto"', () => {
+    expect(SemanticCommitsMigration).toMigrate(
+      {
+        semanticCommits: 'test',
+      } as any,
+      { semanticCommits: 'auto' }
+    );
+  });
+
+  it('should not migrate valid enabled config', () => {
+    expect(SemanticCommitsMigration).toMigrate(
+      {
+        semanticCommits: 'enabled',
+      } as any,
+      { semanticCommits: 'enabled' },
+      false
+    );
+  });
+
+  it('should not migrate valid disabled config', () => {
+    expect(SemanticCommitsMigration).toMigrate(
+      {
+        semanticCommits: 'disabled',
+      } as any,
+      { semanticCommits: 'disabled' },
+      false
+    );
+  });
+});

lib/config/migrations/custom/semantic-commits-migration.ts

@@ -0,0 +1,14 @@
+import is from '@sindresorhus/is';
+import { AbstractMigration } from '../base/abstract-migration';
+
+export class SemanticCommitsMigration extends AbstractMigration {
+  readonly propertyName = 'semanticCommits';
+
+  override run(value): void {
+    if (is.boolean(value)) {
+      this.rewrite(value ? 'enabled' : 'disabled');
+    } else if (value !== 'enabled' && value !== 'disabled') {
+      this.rewrite('auto');
+    }
+  }
+}

lib/config/migrations/migrations-service.ts

@@ -3,9 +3,14 @@ import type { RenovateConfig } from '../types';
 import { RemovePropertyMigration } from './base/remove-property-migration';
 import { RenamePropertyMigration } from './base/rename-property-migration';
 import { BinarySourceMigration } from './custom/binary-source-migration';
+import { EnabledManagersMigration } from './custom/enabled-managers-migration';
 import { GoModTidyMigration } from './custom/go-mod-tidy-migration';
 import { IgnoreNodeModulesMigration } from './custom/ignore-node-modules-migration';
+import { PinVersionsMigration } from './custom/pin-versions-migration';
+import { RebaseConflictedPrs } from './custom/rebase-conflicted-prs-migration';
+import { RebaseStalePrsMigration } from './custom/rebase-stale-prs-migration';
 import { RequiredStatusChecksMigration } from './custom/required-status-checks-migration';
+import { SemanticCommitsMigration } from './custom/semantic-commits-migration';
 import { TrustLevelMigration } from './custom/trust-level-migration';
 import type { Migration, MigrationConstructor } from './types';
 
@@ -37,9 +42,14 @@ export class MigrationsService {
 
   static readonly customMigrations: ReadonlyArray<MigrationConstructor> = [
     BinarySourceMigration,
+    EnabledManagersMigration,
     GoModTidyMigration,
     IgnoreNodeModulesMigration,
+    PinVersionsMigration,
+    RebaseConflictedPrs,
+    RebaseStalePrsMigration,
     RequiredStatusChecksMigration,
+    SemanticCommitsMigration,
     TrustLevelMigration,
   ];