fix: nest files with timestamp for plugin runners

Author: vmasek

packages/models/src/index.ts

@@ -99,9 +99,11 @@ export {
   onProgressSchema,
   runnerConfigSchema,
   runnerFunctionSchema,
+  runnerFilesPathsSchema,
   type OnProgress,
   type RunnerConfig,
   type RunnerFunction,
+  type RunnerFilesPaths,
 } from './lib/runner-config.js';
 export {
   tableAlignmentSchema,

packages/models/src/lib/runner-config.ts

@@ -37,3 +37,10 @@ export const runnerFunctionSchema = z
   .returns(z.union([auditOutputsSchema, z.promise(auditOutputsSchema)]));
 
 export type RunnerFunction = z.infer<typeof runnerFunctionSchema>;
+
+export const runnerFilesPathsSchema = z.object({
+  runnerConfigPath: filePathSchema.describe('Runner config path'),
+  runnerOutputPath: filePathSchema.describe('Runner output path'),
+});
+
+export type RunnerFilesPaths = z.infer<typeof runnerFilesPathsSchema>;

packages/plugin-coverage/src/bin.ts

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

packages/plugin-coverage/src/lib/runner/constants.ts

@@ -1,12 +1 @@
-import path from 'node:path';
-import { pluginWorkDir } from '@code-pushup/utils';
-
-export const WORKDIR = pluginWorkDir('coverage');
-export const RUNNER_OUTPUT_PATH = path.join(WORKDIR, 'runner-output.json');
-export const PLUGIN_CONFIG_PATH = path.join(
-  process.cwd(),
-  WORKDIR,
-  'plugin-config.json',
-);
-
 export const INVALID_FUNCTION_NAME = '(empty-report)';

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

@@ -1,23 +1,31 @@
 import { bold } from 'ansis';
 import { writeFile } from 'node:fs/promises';
 import path from 'node:path';
-import type { AuditOutputs, RunnerConfig } from '@code-pushup/models';
+import type {
+  AuditOutputs,
+  RunnerConfig,
+  RunnerFilesPaths,
+} from '@code-pushup/models';
 import {
   ProcessError,
+  createRunnerFiles,
   ensureDirectoryExists,
   executeProcess,
   filePathToCliArg,
+  objectToCliArgs,
   readJsonFile,
   ui,
 } from '@code-pushup/utils';
 import type { FinalCoveragePluginConfig } from '../config.js';
 import { applyMaxScoreAboveThreshold } from '../utils.js';
-import { PLUGIN_CONFIG_PATH, RUNNER_OUTPUT_PATH } from './constants.js';
 import { lcovResultsToAuditOutputs } from './lcov/lcov-runner.js';
 
-export async function executeRunner(): Promise<void> {
+export async function executeRunner({
+  runnerConfigPath,
+  runnerOutputPath,
+}: RunnerFilesPaths): Promise<void> {
   const { reports, coverageToolCommand, coverageTypes } =
-    await readJsonFile<FinalCoveragePluginConfig>(PLUGIN_CONFIG_PATH);
+    await readJsonFile<FinalCoveragePluginConfig>(runnerConfigPath);
 
   // Run coverage tool if provided
   if (coverageToolCommand != null) {
@@ -41,24 +49,29 @@ export async function executeRunner(): Promise<void> {
   // Calculate coverage from LCOV results
   const auditOutputs = await lcovResultsToAuditOutputs(reports, coverageTypes);
 
-  await ensureDirectoryExists(path.dirname(RUNNER_OUTPUT_PATH));
-  await writeFile(RUNNER_OUTPUT_PATH, JSON.stringify(auditOutputs));
+  await ensureDirectoryExists(path.dirname(runnerOutputPath));
+  await writeFile(runnerOutputPath, JSON.stringify(auditOutputs));
 }
 
 export async function createRunnerConfig(
   scriptPath: string,
   config: FinalCoveragePluginConfig,
 ): Promise<RunnerConfig> {
   // Create JSON config for executeRunner
-  await ensureDirectoryExists(path.dirname(PLUGIN_CONFIG_PATH));
-  await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));
+  const { runnerConfigPath, runnerOutputPath } = await createRunnerFiles(
+    'coverage',
+    JSON.stringify(config),
+  );
 
   const threshold = config.perfectScoreThreshold;
 
   return {
     command: 'node',
-    args: [filePathToCliArg(scriptPath)],
-    outputFile: RUNNER_OUTPUT_PATH,
+    args: [
+      filePathToCliArg(scriptPath),
+      ...objectToCliArgs({ runnerConfigPath, runnerOutputPath }),
+    ],
+    outputFile: runnerOutputPath,
     ...(threshold != null && {
       outputTransform: outputs =>
         applyMaxScoreAboveThreshold(outputs as AuditOutputs, threshold),

packages/plugin-coverage/src/lib/runner/runner.integration.test.ts

@@ -1,19 +1,12 @@
-import { writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { describe, it } from 'vitest';
 import type {
   AuditOutput,
   AuditOutputs,
   RunnerConfig,
 } from '@code-pushup/models';
-import { readJsonFile, removeDirectoryIfExists } from '@code-pushup/utils';
+import { createRunnerFiles, readJsonFile } from '@code-pushup/utils';
 import type { FinalCoveragePluginConfig } from '../config.js';
-import {
-  PLUGIN_CONFIG_PATH,
-  RUNNER_OUTPUT_PATH,
-  WORKDIR,
-} from './constants.js';
 import { createRunnerConfig, executeRunner } from './index.js';
 
 describe('createRunnerConfig', () => {
@@ -25,26 +18,32 @@ describe('createRunnerConfig', () => {
     });
     expect(runnerConfig).toStrictEqual<RunnerConfig>({
       command: 'node',
-      args: ['"executeRunner.ts"'],
+      args: [
+        '"executeRunner.ts"',
+        expect.stringContaining('plugin-config.json'),
+        expect.stringContaining('runner-output.json'),
+      ],
       outputTransform: expect.any(Function),
       outputFile: expect.stringContaining('runner-output.json'),
     });
   });
 
   it('should provide plugin config to runner in JSON file', async () => {
-    await removeDirectoryIfExists(WORKDIR);
-
     const pluginConfig: FinalCoveragePluginConfig = {
       coverageTypes: ['line'],
       reports: ['coverage/lcov.info'],
       coverageToolCommand: { command: 'npm', args: ['run', 'test'] },
       perfectScoreThreshold: 85,
     };
 
-    await createRunnerConfig('executeRunner.ts', pluginConfig);
+    const { outputFile } = await createRunnerConfig(
+      'executeRunner.ts',
+      pluginConfig,
+    );
 
-    const config =
-      await readJsonFile<FinalCoveragePluginConfig>(PLUGIN_CONFIG_PATH);
+    const config = await readJsonFile<FinalCoveragePluginConfig>(
+      outputFile.replace('runner-output.json', 'plugin-config.json'),
+    );
     expect(config).toStrictEqual(pluginConfig);
   });
 });
@@ -65,10 +64,15 @@ describe('executeRunner', () => {
       coverageTypes: ['line'],
     };
 
-    await writeFile(PLUGIN_CONFIG_PATH, JSON.stringify(config));
-    await executeRunner();
+    const runnerFiles = await createRunnerFiles(
+      'coverage',
+      JSON.stringify(config),
+    );
+    await executeRunner(runnerFiles);
 
-    const results = await readJsonFile<AuditOutputs>(RUNNER_OUTPUT_PATH);
+    const results = await readJsonFile<AuditOutputs>(
+      runnerFiles.runnerOutputPath,
+    );
     expect(results).toStrictEqual([
       expect.objectContaining({
         slug: 'line-coverage',

packages/plugin-eslint/src/lib/__snapshots__/eslint-plugin.integration.test.ts.snap

@@ -349,9 +349,11 @@ exports[`eslintPlugin > should initialize ESLint plugin for React application 1`
   "runner": {
     "args": [
       ""<dirname>/bin.js"",
+      "--runnerConfigPath="<dirname>/node_modules/.code-pushup/eslint/<timestamp>/plugin-config.json"",
+      "--runnerOutputPath="<dirname>/node_modules/.code-pushup/eslint/<timestamp>/runner-output.json"",
     ],
     "command": "node",
-    "outputFile": "node_modules/.code-pushup/eslint/runner-output.json",
+    "outputFile": "<dirname>/node_modules/.code-pushup/eslint/<timestamp>/runner-output.json",
   },
   "slug": "eslint",
   "title": "ESLint",

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

@@ -1,5 +1,6 @@
 import os from 'node:os';
 import path from 'node:path';
+import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import type { MockInstance } from 'vitest';
 import type { Audit, PluginConfig, RunnerConfig } from '@code-pushup/models';
@@ -18,10 +19,22 @@ describe('eslintPlugin', () => {
     ...plugin,
     runner: {
       ...(plugin.runner as RunnerConfig),
-      args: (plugin.runner as RunnerConfig).args?.map(arg =>
-        toUnixPath(arg.replace(path.dirname(thisDir), '<dirname>')),
-      ),
-      outputFile: toUnixPath((plugin.runner as RunnerConfig).outputFile),
+      args: (plugin.runner as RunnerConfig).args?.map(arg => {
+        if (arg.includes('bin.js')) {
+          return toUnixPath(arg.replace(path.dirname(thisDir), '<dirname>'));
+        }
+
+        return toUnixPath(arg.replace(process.cwd(), '<dirname>')).replace(
+          /\/eslint\/\d+\//,
+          '/eslint/<timestamp>/',
+        );
+      }),
+      outputFile: toUnixPath(
+        (plugin.runner as RunnerConfig).outputFile.replace(
+          process.cwd(),
+          '<dirname>',
+        ),
+      ).replace(/\/eslint\/\d+\//, '/eslint/<timestamp>/'),
     },
   });
 
@@ -38,6 +51,7 @@ describe('eslintPlugin', () => {
 
   it('should initialize ESLint plugin for React application', async () => {
     cwdSpy.mockReturnValue(path.join(fixturesDir, 'todos-app'));
+
     const plugin = await eslintPlugin({
       eslintrc: 'eslint.config.js',
       patterns: ['src/**/*.js', 'src/**/*.jsx'],

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

@@ -13,7 +13,7 @@ export { detectConfigVersion, type ConfigFormat } from './versions/index.js';
 
 export async function listAuditsAndGroups(
   targets: ESLintTarget[],
-  customGroups: CustomGroup[] | undefined,
+  customGroups?: CustomGroup[] | undefined,
 ): Promise<{ audits: Audit[]; groups: Group[] }> {
   const rules = await listRules(targets);
 

packages/plugin-eslint/src/lib/runner.integration.test.ts

@@ -2,26 +2,36 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { type MockInstance, describe, expect, it } from 'vitest';
-import type { AuditOutput, AuditOutputs, Issue } from '@code-pushup/models';
+import type {
+  AuditOutput,
+  AuditOutputs,
+  Issue,
+  RunnerFilesPaths,
+} from '@code-pushup/models';
 import { osAgnosticAuditOutputs } from '@code-pushup/test-utils';
 import { readJsonFile } from '@code-pushup/utils';
 import type { ESLintTarget } from './config.js';
 import { listAuditsAndGroups } from './meta/index.js';
-import {
-  RUNNER_OUTPUT_PATH,
-  createRunnerConfig,
-  executeRunner,
-} from './runner/index.js';
+import { createRunnerConfig, executeRunner } from './runner/index.js';
 
 describe('executeRunner', () => {
   let cwdSpy: MockInstance<[], string>;
   let platformSpy: MockInstance<[], NodeJS.Platform>;
 
-  const createPluginConfig = async (eslintrc: ESLintTarget['eslintrc']) => {
+  const createPluginConfig = async (
+    eslintrc: ESLintTarget['eslintrc'],
+  ): Promise<RunnerFilesPaths> => {
     const patterns = ['src/**/*.js', 'src/**/*.jsx'];
     const targets: ESLintTarget[] = [{ eslintrc, patterns }];
     const { audits } = await listAuditsAndGroups(targets);
-    await createRunnerConfig('bin.js', audits, targets);
+    const { outputFile } = await createRunnerConfig('bin.js', audits, targets);
+    return {
+      runnerOutputPath: outputFile,
+      runnerConfigPath: outputFile.replace(
+        'runner-output.json',
+        'plugin-config.json',
+      ),
+    };
   };
 
   const appDir = path.join(
@@ -45,18 +55,22 @@ describe('executeRunner', () => {
   });
 
   it('should execute ESLint and create audit results for React application', async () => {
-    await createPluginConfig('eslint.config.js');
-    await executeRunner();
+    const runnerPaths = await createPluginConfig('eslint.config.js');
+    await executeRunner(runnerPaths);
 
-    const json = await readJsonFile<AuditOutputs>(RUNNER_OUTPUT_PATH);
+    const json = await readJsonFile<AuditOutputs>(runnerPaths.runnerOutputPath);
     expect(osAgnosticAuditOutputs(json)).toMatchSnapshot();
   });
 
   it('should execute runner with custom config using @code-pushup/eslint-config', async () => {
-    await createPluginConfig('code-pushup.eslint.config.mjs');
-    await executeRunner();
+    const runnerPaths = await createPluginConfig(
+      'code-pushup.eslint.config.mjs',
+    );
+    await executeRunner(runnerPaths);
 
-    const json = await readJsonFile<AuditOutput[]>(RUNNER_OUTPUT_PATH);
+    const json = await readJsonFile<AuditOutput[]>(
+      runnerPaths.runnerOutputPath,
+    );
     // expect warnings from unicorn/filename-case rule from default config
     expect(json).toContainEqual(
       expect.objectContaining<Partial<AuditOutput>>({