perf(plugin-eslint): lint nx projects in separate processes

packages/plugin-eslint/mocks/fixtures/todos-app/.eslintrc.js

@@ -1,5 +1,6 @@
 /** @type {import('eslint').ESLint.ConfigData} */
 module.exports = {
+  root: true,
   env: {
     browser: true,
     es2021: true,

packages/plugin-eslint/src/lib/config.ts

@@ -1,26 +1,30 @@
 import type { ESLint } from 'eslint';
 import { type ZodType, z } from 'zod';
+import { toArray } from '@code-pushup/utils';
 
-export const eslintPluginConfigSchema = z.object({
+export const eslintTargetSchema = z.object({
   eslintrc: z.union(
     [
       z.string({ description: 'Path to ESLint config file' }),
       z.record(z.string(), z.unknown(), {
         description: 'ESLint config object',
       }) as ZodType<ESLint.ConfigData>,
     ],
     { description: 'ESLint config as file path or inline object' },
   ),
   patterns: z.union([z.string(), z.array(z.string()).min(1)], {
     description:
       'Lint target files. May contain file paths, directory paths or glob patterns',
   }),
 });
+export type ESLintTarget = z.infer<typeof eslintTargetSchema>;
 
-export type ESLintPluginConfig = z.infer<typeof eslintPluginConfigSchema>;
+export const eslintPluginConfigSchema = z
+  .union([eslintTargetSchema, z.array(eslintTargetSchema).min(1)])
+  .transform(toArray);
+export type ESLintPluginConfig = z.input<typeof eslintPluginConfigSchema>;
 
 export type ESLintPluginRunnerConfig = {
-  eslintrc: string;
+  targets: ESLintTarget[];
   slugs: string[];
-  patterns: string[];
 };

packages/plugin-eslint/src/lib/eslint-plugin.ts

@@ -1,71 +1,55 @@
-import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { PluginConfig } from '@code-pushup/models';
 import { name, version } from '../../package.json';
 import { ESLintPluginConfig, eslintPluginConfigSchema } from './config';
 import { listAuditsAndGroups } from './meta';
-import { ESLINTRC_PATH, createRunnerConfig } from './runner';
-import { setupESLint } from './setup';
+import { createRunnerConfig } from './runner';
 
 /**
  * Instantiates Code PushUp ESLint plugin for use in core config.
  *
  * @example
  * import eslintPlugin from '@code-pushup/eslint-plugin'
  *
  * export default {
  *   // ... core config ...
  *   plugins: [
  *     // ... other plugins ...
  *     await eslintPlugin({
  *       eslintrc: '.eslintrc.json',
  *       patterns: ['src', 'test/*.spec.js']
  *     })
  *   ]
  * }
  *
  * @param config Configuration options.
  * @returns Plugin configuration as a promise.
  */
 export async function eslintPlugin(
   config: ESLintPluginConfig,
 ): Promise<PluginConfig> {
-  const { eslintrc, patterns } = eslintPluginConfigSchema.parse(config);
+  const targets = eslintPluginConfigSchema.parse(config);
 
-  const eslint = setupESLint(eslintrc);
-
-  const { audits, groups } = await listAuditsAndGroups(eslint, patterns);
-
-  // save inline config to file so runner can access it later
-  if (typeof eslintrc !== 'string') {
-    await mkdir(dirname(ESLINTRC_PATH), { recursive: true });
-    await writeFile(ESLINTRC_PATH, JSON.stringify(eslintrc));
-  }
-  const eslintrcPath = typeof eslintrc === 'string' ? eslintrc : ESLINTRC_PATH;
+  const { audits, groups } = await listAuditsAndGroups(targets);
 
   const runnerScriptPath = join(
     fileURLToPath(dirname(import.meta.url)),
     'bin.js',
   );
 
   return {
     slug: 'eslint',
     title: 'ESLint',
     icon: 'eslint',
     description: 'Official Code PushUp ESLint plugin',
     docsUrl: 'https://www.npmjs.com/package/@code-pushup/eslint-plugin',
     packageName: name,
     version,
 
     audits,
     groups,
 
-    runner: await createRunnerConfig(
-      runnerScriptPath,
-      audits,
-      eslintrcPath,
-      patterns,
-    ),
+    runner: await createRunnerConfig(runnerScriptPath, audits, targets),
   };
 }

packages/plugin-eslint/src/lib/meta/index.ts

@@ -1,14 +1,13 @@
-import type { ESLint } from 'eslint';
 import type { Audit, Group } from '@code-pushup/models';
+import type { ESLintTarget } from '../config';
 import { groupsFromRuleCategories, groupsFromRuleTypes } from './groups';
 import { listRules } from './rules';
 import { ruleToAudit } from './transform';
 
 export async function listAuditsAndGroups(
-  eslint: ESLint,
-  patterns: string | string[],
+  targets: ESLintTarget[],
 ): Promise<{ audits: Audit[]; groups: Group[] }> {
-  const rules = await listRules(eslint, patterns);
+  const rules = await listRules(targets);
 
   const audits = rules.map(ruleToAudit);
 

packages/plugin-eslint/src/lib/meta/rules.ts

@@ -1,5 +1,7 @@
 import type { ESLint, Linter, Rule } from 'eslint';
 import { distinct, toArray, ui } from '@code-pushup/utils';
+import type { ESLintTarget } from '../config';
+import { setupESLint } from '../setup';
 import { jsonHash } from './hash';
 
 export type RuleData = {
@@ -8,10 +10,23 @@
   options: unknown[] | undefined;
 };
 
-export async function listRules(
+type RulesMap = Record<string, Record<string, RuleData>>;
+
+export async function listRules(targets: ESLintTarget[]): Promise<RuleData[]> {
+  const rulesMap = await targets.reduce(async (acc, { eslintrc, patterns }) => {
+    const eslint = setupESLint(eslintrc);
+    const prev = await acc;
+    const curr = await loadRulesMap(eslint, patterns);
+    return mergeRulesMaps(prev, curr);
+  }, Promise.resolve<RulesMap>({}));
+
+  return Object.values(rulesMap).flatMap<RuleData>(Object.values);
+}
+
+async function loadRulesMap(
   eslint: ESLint,
   patterns: string | string[],
-): Promise<RuleData[]> {
+): Promise<RulesMap> {
   const configs = await toArray(patterns).reduce(
     async (acc, pattern) => [
       ...(await acc),
@@ -31,35 +46,43 @@
     } as ESLint.LintResult,
   ]);
 
-  const rulesMap = configs
+  return configs
     .flatMap(config => Object.entries(config.rules ?? {}))
     .filter(([, ruleEntry]) => ruleEntry != null && !isRuleOff(ruleEntry))
-    .reduce<Record<string, Record<string, RuleData>>>(
-      (acc, [ruleId, ruleEntry]) => {
-        const meta = rulesMeta[ruleId];
-        if (!meta) {
-          ui().logger.warning(`Metadata not found for ESLint rule ${ruleId}`);
-          return acc;
-        }
-        const options = toArray(ruleEntry).slice(1);
-        const optionsHash = jsonHash(options);
-        const ruleData: RuleData = {
-          ruleId,
-          meta,
-          options,
-        };
-        return {
-          ...acc,
-          [ruleId]: {
-            ...acc[ruleId],
-            [optionsHash]: ruleData,
-          },
-        };
-      },
-      {},
-    );
+    .reduce<RulesMap>((acc, [ruleId, ruleEntry]) => {
+      const meta = rulesMeta[ruleId];
+      if (!meta) {
+        ui().logger.warning(`Metadata not found for ESLint rule ${ruleId}`);
+        return acc;
+      }
+      const options = toArray(ruleEntry).slice(1);
+      const optionsHash = jsonHash(options);
+      const ruleData: RuleData = {
+        ruleId,
+        meta,
+        options,
+      };
+      return {
+        ...acc,
+        [ruleId]: {
+          ...acc[ruleId],
+          [optionsHash]: ruleData,
+        },
+      };
+    }, {});
+}
 
-  return Object.values(rulesMap).flatMap<RuleData>(Object.values);
+function mergeRulesMaps(prev: RulesMap, curr: RulesMap): RulesMap {
+  return Object.entries(curr).reduce(
+    (acc, [ruleId, ruleVariants]) => ({
+      ...acc,
+      [ruleId]: {
+        ...acc[ruleId],
+        ...ruleVariants,
+      },
+    }),
+    prev,
+  );
 }
 
 function isRuleOff(entry: Linter.RuleEntry<unknown[]>): boolean {

packages/plugin-eslint/src/lib/meta/rules.unit.test.ts

@@ -1,7 +1,7 @@
-import { ESLint } from 'eslint';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { MockInstance } from 'vitest';
+import type { ESLintTarget } from '../config';
 import { RuleData, listRules, parseRuleId } from './rules';
 
 describe('listRules', () => {
@@ -28,22 +28,19 @@ describe('listRules', () => {
     const appRootDir = join(fixturesDir, 'todos-app');
     const eslintrc = join(appRootDir, '.eslintrc.js');
 
-    const eslint = new ESLint({
-      useEslintrc: false,
-      baseConfig: { extends: eslintrc },
-    });
     const patterns = ['src/**/*.js', 'src/**/*.jsx'];
+    const targets: ESLintTarget[] = [{ eslintrc, patterns }];
 
     beforeAll(() => {
       cwdSpy.mockReturnValue(appRootDir);
     });
 
     it('should list expected number of rules', async () => {
-      await expect(listRules(eslint, patterns)).resolves.toHaveLength(47);
+      await expect(listRules(targets)).resolves.toHaveLength(47);
     });
 
     it('should include explicitly set built-in rule', async () => {
-      await expect(listRules(eslint, patterns)).resolves.toContainEqual({
+      await expect(listRules(targets)).resolves.toContainEqual({
         ruleId: 'no-const-assign',
         meta: {
           docs: {
@@ -62,7 +59,7 @@ describe('listRules', () => {
     });
 
     it('should include explicitly set plugin rule', async () => {
-      await expect(listRules(eslint, patterns)).resolves.toContainEqual({
+      await expect(listRules(targets)).resolves.toContainEqual({
         ruleId: 'react/jsx-key',
         meta: {
           docs: {
@@ -94,24 +91,21 @@ describe('listRules', () => {
     const nxRootDir = join(fixturesDir, 'nx-monorepo');
     const eslintrc = join(nxRootDir, 'packages/utils/.eslintrc.json');
 
-    const eslint = new ESLint({
-      useEslintrc: false,
-      baseConfig: { extends: eslintrc },
-    });
     const patterns = ['packages/utils/**/*.ts', 'packages/utils/**/*.json'];
+    const targets: ESLintTarget[] = [{ eslintrc, patterns }];
 
     beforeAll(() => {
       cwdSpy.mockReturnValue(nxRootDir);
     });
 
     it('should list expected number of rules', async () => {
-      const rules = await listRules(eslint, patterns);
+      const rules = await listRules(targets);
       expect(rules.length).toBeGreaterThanOrEqual(50);
     });
 
     it('should include explicitly set plugin rule with custom options', async () => {
       // set in root .eslintrc.json
-      await expect(listRules(eslint, patterns)).resolves.toContainEqual({
+      await expect(listRules(targets)).resolves.toContainEqual({
         ruleId: '@nx/enforce-module-boundaries',
         meta: expect.any(Object),
         options: [
@@ -131,7 +125,7 @@ describe('listRules', () => {
 
     it('should include built-in rule set implicitly by extending recommended config', async () => {
       // extended via @nx/typescript -> @typescript-eslint/eslint-recommended
-      await expect(listRules(eslint, patterns)).resolves.toContainEqual({
+      await expect(listRules(targets)).resolves.toContainEqual({
         ruleId: 'no-var',
         meta: expect.any(Object),
         options: [],
@@ -140,7 +134,7 @@ describe('listRules', () => {
 
     it('should include plugin rule set implicitly by extending recommended config', async () => {
       // extended via @nx/typescript -> @typescript-eslint/recommended
-      await expect(listRules(eslint, patterns)).resolves.toContainEqual({
+      await expect(listRules(targets)).resolves.toContainEqual({
         ruleId: '@typescript-eslint/no-unused-vars',
         meta: expect.any(Object),
         options: [],
@@ -149,7 +143,7 @@ describe('listRules', () => {
 
     it('should not include rule which was turned off in extended config', async () => {
       // extended TypeScript config sets "no-unused-semi": "off"
-      await expect(listRules(eslint, patterns)).resolves.not.toContainEqual(
+      await expect(listRules(targets)).resolves.not.toContainEqual(
         expect.objectContaining({
           ruleId: 'no-unused-vars',
         } satisfies Partial<RuleData>),
@@ -158,7 +152,7 @@ describe('listRules', () => {
 
     it('should include rule added to root config by project config', async () => {
       // set only in packages/utils/.eslintrc.json
-      await expect(listRules(eslint, patterns)).resolves.toContainEqual({
+      await expect(listRules(targets)).resolves.toContainEqual({
         ruleId: '@nx/dependency-checks',
         meta: expect.any(Object),
         options: [],