feat(plugin-eslint): add artifacts options

Author: BioPhoton

packages/models/src/index.ts

@@ -145,4 +145,5 @@ export { uploadConfigSchema, type UploadConfig } from './lib/upload-config.js';
 export {
   artifactGenerationCommandSchema,
   pluginArtifactOptionsSchema,
+  type PluginArtifactOptions,
 } from './lib/configuration.js';

packages/plugin-eslint/src/bin.ts

@@ -1,7 +1,13 @@
+import path from 'node:path';
 import process from 'node:process';
 import { Parser } from 'yargs/helpers';
+import { ESLINT_PLUGIN_SLUG } from './lib/constants.js';
 import { executeRunner } from './lib/runner/index.js';
 
-const { runnerConfigPath, runnerOutputPath } = Parser(process.argv);
+const { runnerConfigPath, runnerOutputPath, outputDir } = Parser(process.argv);
 
-await executeRunner({ runnerConfigPath, runnerOutputPath });
+await executeRunner({
+  runnerConfigPath,
+  runnerOutputPath,
+  persistOutputDir: path.join(outputDir, ESLINT_PLUGIN_SLUG),
+});

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { pluginArtifactOptionsSchema } from '@code-pushup/models';
 import { toArray } from '@code-pushup/utils';
 
 const patternsSchema = z
@@ -61,5 +62,6 @@ export type CustomGroup = z.infer<typeof customGroupSchema>;
 
 export const eslintPluginOptionsSchema = z.object({
   groups: z.array(customGroupSchema).optional(),
+  artifacts: pluginArtifactOptionsSchema.optional(),
 });
 export type ESLintPluginOptions = z.infer<typeof eslintPluginOptionsSchema>;

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

@@ -0,0 +1 @@
+export const ESLINT_PLUGIN_SLUG = 'eslint';

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 {
@@ -9,8 +7,9 @@ import {
   eslintPluginConfigSchema,
   eslintPluginOptionsSchema,
 } 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.
@@ -49,18 +48,12 @@ export async function eslintPlugin(
 
   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');
 
   return {
-    slug: 'eslint',
+    slug: ESLINT_PLUGIN_SLUG,
     title: 'ESLint',
     icon: 'eslint',
     description: 'Official Code PushUp ESLint plugin',
@@ -71,6 +64,10 @@ export async function eslintPlugin(
     audits,
     groups,
 
-    runner: await createRunnerConfig(runnerScriptPath, audits, targets),
+    runner: await createRunnerFunction({
+      audits,
+      targets,
+      artifacts: options?.artifacts,
+    }),
   };
 }

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

@@ -22,13 +22,20 @@ import { lintResultsToAudits, mergeLinterOutputs } from './transform.js';
 export async function executeRunner({
   runnerConfigPath,
   runnerOutputPath,
-}: RunnerFilesPaths): Promise<void> {
+  persistOutputDir,
+}: RunnerFilesPaths & { persistOutputDir: string }): Promise<void> {
   const { slugs, targets } =
     await readJsonFile<ESLintPluginRunnerConfig>(runnerConfigPath);
 
   ui().logger.log(`ESLint plugin executing ${targets.length} lint targets`);
 
-  const linterOutputs = await asyncSequential(targets, lint);
+  const linterOutputs = await asyncSequential(
+    targets.map(target => ({
+      ...target,
+      outputDir: persistOutputDir,
+    })),
+    lint,
+  );
   const lintResults = mergeLinterOutputs(linterOutputs);
   const failedAudits = lintResultsToAudits(lintResults);
 

packages/plugin-eslint/src/lib/runner/index.unit.test.ts

@@ -0,0 +1,110 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { PersistConfig } from '@code-pushup/models';
+import * as utilsModule from '@code-pushup/utils';
+import { createRunnerFunction } from './index.js';
+import * as lintModule from './lint.js';
+import * as transformModule from './transform.js';
+import type { LinterOutput } from './types.js';
+import * as utilsRunnerModule from './utils.js';
+
+describe('createRunnerFunction', () => {
+  const asyncSequentialSpy = vi.spyOn(utilsModule, 'asyncSequential');
+  const uiLoggerLogSpy = vi.fn();
+  vi.spyOn(utilsModule, 'ui').mockReturnValue({
+    logger: {
+      log: uiLoggerLogSpy,
+      flushLogs: vi.fn(),
+    },
+    switchMode: vi.fn(),
+  } as any);
+  const lintSpy = vi.spyOn(lintModule, 'lint');
+  const mergeLinterOutputsSpy = vi.spyOn(transformModule, 'mergeLinterOutputs');
+  const lintResultsToAuditsSpy = vi.spyOn(
+    transformModule,
+    'lintResultsToAudits',
+  );
+  const loadArtifactsSpy = vi.spyOn(utilsRunnerModule, 'loadArtifacts');
+
+  const mockLinterOutputs: LinterOutput[] = [
+    {
+      results: [],
+      ruleOptionsPerFile: {},
+    },
+  ];
+
+  const mockMergedOutput: LinterOutput = {
+    results: [],
+    ruleOptionsPerFile: {},
+  };
+
+  const mockFailedAudits = [
+    {
+      slug: 'no-unused-vars',
+      score: 0,
+      value: 1,
+      displayValue: '1 error',
+      details: { issues: [] },
+    },
+  ];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    asyncSequentialSpy.mockResolvedValue(mockLinterOutputs);
+    mergeLinterOutputsSpy.mockReturnValue(mockMergedOutput);
+    lintResultsToAuditsSpy.mockReturnValue(mockFailedAudits);
+    loadArtifactsSpy.mockResolvedValue(mockLinterOutputs);
+  });
+
+  it('should create a runner function and call dependencies', async () => {
+    const runnerFunction = await createRunnerFunction({
+      audits: [
+        {
+          slug: 'no-unused-vars',
+          title: 'No unused vars',
+          description: 'Test rule',
+        },
+      ],
+      targets: [{ eslintrc: '.eslintrc.js', patterns: ['src/**/*.js'] }],
+    });
+    const persistConfig: PersistConfig = { outputDir: '/tmp/output' };
+    await expect(runnerFunction(persistConfig)).resolves.not.toThrow();
+    expect(uiLoggerLogSpy).toHaveBeenCalledWith(
+      'ESLint plugin executing 1 lint targets',
+    );
+    expect(asyncSequentialSpy).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({
+          outputDir: '/tmp/output',
+        }),
+      ]),
+      lintSpy,
+    );
+    expect(mergeLinterOutputsSpy).toHaveBeenCalledWith(mockLinterOutputs);
+    expect(lintResultsToAuditsSpy).toHaveBeenCalledWith(mockMergedOutput);
+  });
+
+  it('should call loadArtifacts when artifacts provided', async () => {
+    const runnerFunction = await createRunnerFunction({
+      audits: [
+        {
+          slug: 'no-unused-vars',
+          title: 'No unused vars',
+          description: 'Test rule',
+        },
+      ],
+      targets: [{ eslintrc: '.eslintrc.js', patterns: ['src/**/*.js'] }],
+      artifacts: {
+        artifactsPaths: ['/path/to/artifact.json'],
+      },
+    });
+    const persistConfig: PersistConfig = { outputDir: '/tmp/output' };
+    await expect(runnerFunction(persistConfig)).resolves.not.toThrow();
+
+    expect(loadArtifactsSpy).toHaveBeenCalledWith({
+      artifactsPaths: ['/path/to/artifact.json'],
+    });
+    expect(asyncSequentialSpy).not.toHaveBeenCalled();
+    expect(mergeLinterOutputsSpy).toHaveBeenCalledWith(mockLinterOutputs);
+    expect(lintResultsToAuditsSpy).toHaveBeenCalledWith(mockMergedOutput);
+  });
+});