feat(plugin-eslint): use artifacts options

BioPhoton · BioPhoton · commit 687badaf1e12 · 2025-08-27T18:42:07.000+02:00
diff --git a/packages/plugin-eslint/src/lib/eslint-plugin.int.test.ts b/packages/plugin-eslint/src/lib/eslint-plugin.int.test.ts
@@ -152,7 +152,7 @@ describe('eslintPlugin', () => {
     await expect(
       // @ts-expect-error simulating invalid non-TS config
       eslintPlugin({ eslintrc: '.eslintrc.json' }),
-    ).rejects.toThrow('Invalid input');
+    ).rejects.toThrow('Failed parsing ESLint plugin config');
   });
 
   it("should throw if eslintrc file doesn't exist", async () => {
@@ -176,14 +176,6 @@ describe('eslintPlugin', () => {
       },
     );
 
-    expect(typeof plugin.runner).toBe('object');
-    const runnerConfig = plugin.runner as {
-      command: string;
-      args?: string[];
-      outputFile: string;
-    };
-    expect(runnerConfig.command).toBe('node');
-    expect(runnerConfig.args).toContain('echo "Generating artifacts"');
-    expect(runnerConfig.outputFile).toBe('./artifacts/eslint-output.json');
+    expect(typeof plugin.runner).toBe('function');
   });
 });
diff --git a/packages/plugin-eslint/src/lib/eslint-plugin.ts b/packages/plugin-eslint/src/lib/eslint-plugin.ts
@@ -1,6 +1,4 @@
 import { createRequire } from 'node:module';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import type { PluginConfig } from '@code-pushup/models';
 import { parseSchema } from '@code-pushup/utils';
 import {
@@ -11,7 +9,7 @@ import {
 } from './config.js';
 import { ESLINT_PLUGIN_SLUG } from './constants.js';
 import { listAuditsAndGroups } from './meta/index.js';
-import { createRunnerConfig } from './runner/index.js';
+import { createRunnerFunction } from './runner/index.js';
 
 /**
  * Instantiates Code PushUp ESLint plugin for use in core config.
@@ -42,22 +40,14 @@ export async function eslintPlugin(
     schemaType: 'ESLint plugin config',
   });
 
-  const parsedOptions = options
+  const { groups: customGroups, artifacts } = options
     ? parseSchema(eslintPluginOptionsSchema, options, {
         schemaType: 'ESLint plugin options',
       })
-    : undefined;
-
-  const customGroups = parsedOptions?.groups;
+    : {};
 
   const { audits, groups } = await listAuditsAndGroups(targets, customGroups);
 
-  const runnerScriptPath = path.join(
-    fileURLToPath(path.dirname(import.meta.url)),
-    '..',
-    'bin.js',
-  );
-
   const packageJson = createRequire(import.meta.url)(
     '../../package.json',
   ) as typeof import('../../package.json');
@@ -74,11 +64,10 @@ export async function eslintPlugin(
     audits,
     groups,
 
-    runner: await createRunnerConfig(
-      runnerScriptPath,
+    runner: await createRunnerFunction({
       audits,
       targets,
-      parsedOptions?.artifacts,
-    ),
+      ...(artifacts ? { artifacts } : {}),
+    }),
   };
 }
diff --git a/packages/plugin-eslint/src/lib/runner/index.ts b/packages/plugin-eslint/src/lib/runner/index.ts
@@ -4,11 +4,12 @@ import type {
   Audit,
   AuditOutput,
   AuditOutputs,
+  PersistConfig,
   PluginArtifactOptions,
   RunnerConfig,
   RunnerFilesPaths,
+  RunnerFunction,
 } from '@code-pushup/models';
-import { pluginArtifactOptionsSchema } from '@code-pushup/models';
 import {
   asyncSequential,
   createRunnerFiles,
@@ -55,91 +56,62 @@ export async function createRunnerConfig(
   scriptPath: string,
   audits: Audit[],
   targets: ESLintTarget[],
-  artifactOptions?: PluginArtifactOptions,
 ): Promise<RunnerConfig> {
-  const parsedOptions = artifactOptions
-    ? pluginArtifactOptionsSchema.parse(artifactOptions)
-    : undefined;
-
   const config: ESLintPluginRunnerConfig = {
     targets,
-    slugs: audits.map(a => a.slug),
+    slugs: audits.map(audit => audit.slug),
   };
-
-  const { runnerConfigPath, runnerOutputPath } = parsedOptions
-    ? await createCustomRunnerPaths(parsedOptions, config)
-    : await createRunnerFiles('eslint', JSON.stringify(config));
-
-  const args = [
-    filePathToCliArg(scriptPath),
-    ...objectToCliArgs({ runnerConfigPath, runnerOutputPath }),
-    ...resolveCommandArgs(parsedOptions?.generateArtifactsCommand),
-  ];
+  const { runnerConfigPath, runnerOutputPath } = await createRunnerFiles(
+    'eslint',
+    JSON.stringify(config),
+  );
 
   return {
     command: 'node',
-    args,
+    args: [
+      filePathToCliArg(scriptPath),
+      ...objectToCliArgs({ runnerConfigPath, runnerOutputPath }),
+    ],
     configFile: runnerConfigPath,
     outputFile: runnerOutputPath,
   };
 }
 
-export async function generateAuditOutputs(options: {
+export function createRunnerFunction(options: {
   audits: Audit[];
   targets: ESLintTarget[];
   artifacts?: PluginArtifactOptions;
-}): Promise<AuditOutputs> {
+}): RunnerFunction {
   const { audits, targets, artifacts } = options;
   const config: ESLintPluginRunnerConfig = {
     targets,
     slugs: audits.map(audit => audit.slug),
   };
 
-  ui().logger.log(`ESLint plugin executing ${targets.length} lint targets`);
-
-  const linterOutputs = artifacts
-    ? await loadArtifacts(artifacts)
-    : await asyncSequential(targets, lint);
-  const lintResults = mergeLinterOutputs(linterOutputs);
-  const failedAudits = lintResultsToAudits(lintResults);
-
-  return config.slugs.map(
-    (slug): AuditOutput =>
-      failedAudits.find(audit => audit.slug === slug) ?? {
-        slug,
-        score: 1,
-        value: 0,
-        displayValue: 'passed',
-        details: { issues: [] },
-      },
-  );
-}
-
-async function createCustomRunnerPaths(
-  options: PluginArtifactOptions,
-  config: ESLintPluginRunnerConfig,
-): Promise<RunnerFilesPaths> {
-  const artifactPaths = Array.isArray(options.artifactsPaths)
-    ? options.artifactsPaths
-    : [options.artifactsPaths];
-
-  const runnerOutputPath = artifactPaths[0] ?? '';
-  const runnerConfigPath = path.join(
-    path.dirname(runnerOutputPath),
-    'plugin-config.json',
-  );
-
-  await ensureDirectoryExists(path.dirname(runnerConfigPath));
-  await writeFile(runnerConfigPath, JSON.stringify(config));
-
-  return { runnerConfigPath, runnerOutputPath };
-}
-
-function resolveCommandArgs(
-  command?: string | { command: string; args?: string[] },
-): string[] {
-  if (!command) return [];
-  return typeof command === 'string'
-    ? [command]
-    : [command.command, ...(command.args ?? [])];
+  return async ({ outputDir }: PersistConfig): Promise<AuditOutputs> => {
+    ui().logger.log(`ESLint plugin executing ${targets.length} lint targets`);
+
+    const linterOutputs = artifacts
+      ? await loadArtifacts(artifacts)
+      : await asyncSequential(
+          targets.map(target => ({
+            ...target,
+            outputDir,
+          })),
+          lint,
+        );
+    const lintResults = mergeLinterOutputs(linterOutputs);
+    const failedAudits = lintResultsToAudits(lintResults);
+
+    return config.slugs.map(
+      (slug): AuditOutput =>
+        failedAudits.find(audit => audit.slug === slug) ?? {
+          slug,
+          score: 1,
+          value: 0,
+          displayValue: 'passed',
+          details: { issues: [] },
+        },
+    );
+  };
 }
diff --git a/packages/plugin-eslint/src/lib/runner/index.unit.test.ts b/packages/plugin-eslint/src/lib/runner/index.unit.test.ts
@@ -7,12 +7,33 @@ import type {
 } from '@code-pushup/models';
 import { ui } from '@code-pushup/utils';
 import type { ESLintTarget } from '../config.js';
-import { generateAuditOutputs } from './index.js';
+import { createRunnerFunction } from './index.js';
 import * as lintModule from './lint.js';
 import type { LinterOutput } from './types.js';
 import * as utilsFileModule from './utils.js';
 
-describe('generateAuditOutputs', () => {
+describe('call createRunnerFunction', () => {
+  it('should create runnerFunction correctly', () => {
+    expect(
+      createRunnerFunction({
+        audits: [
+          { slug: 'max-lines', title: 'Max lines', description: 'Test' },
+          {
+            slug: 'no-unused-vars',
+            title: 'No unused vars',
+            description: 'Test',
+          },
+        ],
+        targets: [{ patterns: ['src/**/*.ts'] }],
+        artifacts: {
+          artifactsPaths: ['path/to/artifacts.json'],
+        },
+      }),
+    ).toStrictEqual(expect.any(Function));
+  });
+});
+
+describe('execute created runnerFunction', () => {
   const loadArtifactsSpy = vi.spyOn(utilsFileModule, 'loadArtifacts');
   const lintSpy = vi.spyOn(lintModule, 'lint');
 
@@ -120,11 +141,11 @@ describe('generateAuditOutputs', () => {
     loadArtifactsSpy.mockResolvedValue(mockLinterOutputs);
 
     await expect(
-      generateAuditOutputs({
+      createRunnerFunction({
         audits: mockAudits,
         targets: mockTargets,
         artifacts,
-      }),
+      })({}),
     ).resolves.toStrictEqual(mockedAuditOutputs);
 
     expect(loadArtifactsSpy).toHaveBeenCalledWith(artifacts);
@@ -137,9 +158,10 @@ describe('generateAuditOutputs', () => {
     lintSpy.mockResolvedValueOnce(mockLinterOutputs.at(0)!);
 
     await expect(
-      generateAuditOutputs({
+      createRunnerFunction({
         audits: mockAudits,
         targets: mockTargets,
+      })({
         outputDir: 'custom-output',
       }),
     ).resolves.toStrictEqual(mockedAuditOutputs);
