refactor(enabled-managers): implement custom.<customMgrName> syntax

docs/usage/configuration-options.md

@@ -881,6 +881,16 @@ Example:
 }
 ```
 
+To enable custom managers you will need to add `custom.` prefix before their names
+
+Example:
+
+```json
+{
+  "enabledManagers": ["custom.regex"]
+}
+```
+
 For the full list of available managers, see the [Supported Managers](https://docs.renovatebot.com/modules/manager/#supported-managers) documentation.
 
 ## encrypted

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

@@ -4,10 +4,20 @@ describe('config/migrations/custom/enabled-managers-migration', () => {
   it('should replace yarn with npm', () => {
     expect(EnabledManagersMigration).toMigrate(
       {
-        enabledManagers: ['test1', 'yarn', 'test2'],
+        enabledManagers: ['test1', 'yarn', 'test2', 'regex'],
       },
       {
-        enabledManagers: ['test1', 'npm', 'test2'],
+        enabledManagers: ['test1', 'npm', 'test2', 'custom.regex'],
+      }
+    );
+
+    // coverage
+    expect(EnabledManagersMigration).not.toMigrate(
+      {
+        enabledManagers: undefined,
+      },
+      {
+        enabledManagers: undefined,
       }
     );
   });

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

@@ -1,15 +1,26 @@
 import is from '@sindresorhus/is';
+import { isCustomManager } from '../../../modules/manager/custom';
 import { AbstractMigration } from '../base/abstract-migration';
 
 export class EnabledManagersMigration extends AbstractMigration {
   override readonly propertyName = 'enabledManagers';
 
   override run(value: unknown): void {
-    if (is.array(value)) {
-      const newValue = value.map((manager) =>
-        manager === 'yarn' ? 'npm' : manager
-      );
-      this.rewrite(newValue);
+    if (!is.array<string>(value, is.string)) {
+      return;
     }
+
+    const newValue = value.map((manager) => {
+      if (manager === 'yarn') {
+        return 'npm';
+      }
+
+      if (isCustomManager(manager)) {
+        return `custom.${manager}`;
+      }
+
+      return manager;
+    });
+    this.rewrite(newValue);
   }
 }

lib/config/validation.spec.ts

@@ -238,7 +238,7 @@ describe('config/validation', () => {
       [
         'multiple enabled managers',
         {
-          enabledManagers: ['npm', 'gradle', 'maven', 'regex'],
+          enabledManagers: ['npm', 'gradle', 'maven', 'custom.regex'],
         },
       ],
     ])('validates enabled managers for %s', async (_case, config) => {

lib/config/validation.ts

@@ -65,7 +65,7 @@ function validatePlainObject(val: Record<string, unknown>): true | string {
 
 function getUnsupportedEnabledManagers(enabledManagers: string[]): string[] {
   return enabledManagers.filter(
-    (manager) => !allManagersList.includes(manager)
+    (manager) => !allManagersList.includes(manager.replace('custom.', ''))
   );
 }
 

lib/modules/manager/custom/index.spec.ts

@@ -9,6 +9,7 @@ describe('modules/manager/custom/index', () => {
     it('works', () => {
       expect(customManager.isCustomManager('npm')).toBe(false);
       expect(customManager.isCustomManager('regex')).toBe(true);
+      expect(customManager.isCustomManager('custom.regex')).toBe(false);
     });
   });
 });

lib/modules/manager/index.spec.ts

@@ -37,6 +37,16 @@ describe('modules/manager/index', () => {
     });
   });
 
+  describe('getEnabledManagersList()', () => {
+    it('works', () => {
+      expect(manager.getEnabledManagersList()).toEqual(manager.allManagersList);
+      expect(manager.getEnabledManagersList(['custom.regex', 'npm'])).toEqual([
+        'regex',
+        'npm',
+      ]);
+    });
+  });
+
   it('validates', () => {
     function validate(module: ManagerApi, moduleName: string): boolean {
       // no need to validate custom as it is a wrapper and not an actual manager

lib/modules/manager/index.ts

@@ -103,3 +103,15 @@ export function getRangeStrategy(config: RangeConfig): RangeStrategy | null {
 
   return config.rangeStrategy;
 }
+
+export function getEnabledManagersList(enabledManagers?: string[]): string[] {
+  if (enabledManagers?.length) {
+    return allManagersList.filter(
+      (manager) =>
+        enabledManagers.includes(manager) ||
+        enabledManagers.includes(`custom.${manager}`)
+    );
+  }
+
+  return allManagersList;
+}

lib/workers/repository/extract/extract-fingerprint-config.spec.ts

@@ -19,7 +19,7 @@ describe('workers/repository/extract/extract-fingerprint-config', () => {
           notStable: 'http://some.link.2',
         },
       },
-      enabledManagers: ['npm', 'regex'],
+      enabledManagers: ['npm', 'custom.regex'],
       regexManagers: [
         {
           customType: 'regex',

lib/workers/repository/extract/extract-fingerprint-config.ts

@@ -3,7 +3,7 @@ import type {
   RegexManagerTemplates,
   RenovateConfig,
 } from '../../../config/types';
-import { allManagersList } from '../../../modules/manager';
+import { getEnabledManagersList } from '../../../modules/manager';
 import { isCustomManager } from '../../../modules/manager/custom';
 import { validMatchFields } from '../../../modules/manager/custom/regex/utils';
 import type { CustomExtractConfig } from '../../../modules/manager/types';
@@ -56,13 +56,9 @@ export function generateFingerprintConfig(
   config: RenovateConfig
 ): FingerprintExtractConfig {
   const managerExtractConfigs: WorkerExtractConfig[] = [];
-  let managerList: Set<string>;
-  const { enabledManagers } = config;
-  if (enabledManagers?.length) {
-    managerList = new Set(enabledManagers);
-  } else {
-    managerList = new Set(allManagersList);
-  }
+  const managerList: Set<string> = new Set(
+    getEnabledManagersList(config.enabledManagers)
+  );
 
   for (const manager of managerList) {
     const managerConfig = getManagerConfig(config, manager);

lib/workers/repository/extract/index.spec.ts

@@ -43,10 +43,17 @@ describe('workers/repository/extract/index', () => {
     });
 
     it('warns if no packages found for a enabled manager', async () => {
-      config.enabledManagers = ['npm'];
+      config.enabledManagers = ['npm', 'custom.regex'];
       managerFiles.getManagerPackageFiles.mockResolvedValue([]);
       expect((await extractAllDependencies(config)).packageFiles).toEqual({});
-      expect(logger.debug).toHaveBeenCalled();
+      // expect(logger.debug).toHaveBeenCalledWith(
+      //   { manager: 'npm' },
+      //   `Manager explicitly enabled in "enabledManagers" config, but found no results. Possible config error?`
+      // );
+      expect(logger.debug).toHaveBeenCalledWith(
+        { manager: 'regex' },
+        `Manager explicitly enabled in "enabledManagers" config, but found no results. Possible config error?`
+      );
     });
 
     it('warns if packageFiles is null', async () => {

lib/workers/repository/extract/index.ts

@@ -2,7 +2,7 @@ import is from '@sindresorhus/is';
 import { getManagerConfig, mergeChildConfig } from '../../../config';
 import type { ManagerConfig, RenovateConfig } from '../../../config/types';
 import { logger } from '../../../logger';
-import { allManagersList, hashMap } from '../../../modules/manager';
+import { getEnabledManagersList, hashMap } from '../../../modules/manager';
 import { isCustomManager } from '../../../modules/manager/custom';
 import { scm } from '../../../modules/platform/scm';
 import type { ExtractResult, WorkerExtractConfig } from '../../types';
@@ -12,14 +12,7 @@ import { getManagerPackageFiles } from './manager-files';
 export async function extractAllDependencies(
   config: RenovateConfig
 ): Promise<ExtractResult> {
-  let managerList = allManagersList;
-  const { enabledManagers } = config;
-  if (is.nonEmptyArray(enabledManagers)) {
-    logger.debug('Applying enabledManagers filtering');
-    managerList = managerList.filter((manager) =>
-      enabledManagers.includes(manager)
-    );
-  }
+  const managerList = getEnabledManagersList(config.enabledManagers);
   const extractList: WorkerExtractConfig[] = [];
   const fileList = await scm.getFileList();
 
@@ -86,9 +79,10 @@ export async function extractAllDependencies(
   // If not, log a warning to indicate possible misconfiguration.
   if (is.nonEmptyArray(config.enabledManagers)) {
     for (const enabledManager of config.enabledManagers) {
-      if (!(enabledManager in extractResult.packageFiles)) {
+      const massagedMgr = enabledManager.replace('custom.', '');
+      if (!(massagedMgr in extractResult.packageFiles)) {
         logger.debug(
-          { manager: enabledManager },
+          { manager: massagedMgr },
           `Manager explicitly enabled in "enabledManagers" config, but found no results. Possible config error?`
         );
       }