feat(nx-plugin): add executor to nx-plugin

.eslintignore

@@ -1,3 +1,4 @@
 node_modules
 **/*.mock.*
+**/code-pushup.config.ts
 **/mocks/fixtures/**

packages/nx-plugin/executors.json

@@ -0,0 +1,9 @@
+{
+  "executors": {
+    "autorun": {
+      "implementation": "./src/executors/autorun/executor",
+      "schema": "./src/executors/autorun/schema.json",
+      "description": "CodePushup CLI autorun command executor. Executes the @code-pushup/cli autorun command See: https://github.com/code-pushup/cli/blob/main/packages/cli/README.md#autorun-command"
+    }
+  }
+}

packages/nx-plugin/mock/utils/executor.ts

@@ -0,0 +1,16 @@
+import { NormalizedExecutorContext } from '../../src/executors/internal/context';
+
+export function normalizedExecutorContext(
+  nameOrOpt: string | { projectName: string },
+): NormalizedExecutorContext {
+  const { projectName } =
+    typeof nameOrOpt === 'string' ? { projectName: nameOrOpt } : nameOrOpt;
+  return {
+    projectName,
+    workspaceRoot: 'workspaceRoot',
+    projectConfig: {
+      name: projectName,
+      root: 'root',
+    },
+  };
+}

packages/nx-plugin/package.json

@@ -12,5 +12,6 @@
   "type": "commonjs",
   "main": "./src/index.js",
   "typings": "./src/index.d.ts",
-  "generators": "./generators.json"
+  "generators": "./generators.json",
+  "executors": "./executors.json"
 }

packages/nx-plugin/project.json

@@ -3,6 +3,7 @@
   "$schema": "../../node_modules/nx/schemas/project-schema.json",
   "sourceRoot": "packages/nx-plugin/src",
   "projectType": "library",
+  "implicitDependencies": ["cli"],
   "targets": {
     "build": {
       "executor": "@nx/js:tsc",

packages/nx-plugin/src/executors/autorun/README.md

@@ -0,0 +1,60 @@
+# Autorun Executor
+
+This executor is used to run the code-pushup CLI autorun command in a Nx workspace.
+For details on the CLI command read the [CLI autorun documentation](https://github.com/code-pushup/cli/blob/main/packages/cli/README.md#autorun-command).
+
+#### @code-pushup/nx-plugin:autorun
+
+## Usage
+
+// project.json
+
+```json
+{
+  "name": "my-project",
+  "targets": {
+    "code-pushup": {
+      "executor": "@code-pushup/nx-plugin:autorun"
+    }
+  }
+}
+```
+
+By default, the Nx plugin will derive the options from the executor config.
+
+The following things happen:
+
+- the output directory defaults to `${workspaceRoot}/.code-pushup/${projectName}`
+- the config file defaults to `${projectRoot}/code-pushup.config.ts`
+- parses terminal arguments and forwards them to the CLI command (they override the executor config)
+- the CLI command is executed
+
+```jsonc
+{
+  "name": "my-project",
+  "targets": {
+    "code-pushup": {
+      "executor": "@code-pushup/nx-plugin:autorun",
+      "options": {
+        "projectPrefix": "cli", // upload.project = cli-my-project
+        "verbose": true,
+        "progress": false
+        // persist and upload options as defined in CoreConfig
+      }
+    }
+  }
+}
+```
+
+Show what will be executed without actually executing it:
+
+`nx run my-project:code-pushup --dryRun`
+
+## Options
+
+| Name              | type      | description                                                        |
+| ----------------- | --------- | ------------------------------------------------------------------ |
+| **projectPrefix** | `string`  | prefix for upload.project on non root projects                     |
+| **dryRun**        | `boolean` | To debug the executor, dry run the command without real execution. |
+
+For all other options see the [CLI autorun documentation](../../cli/packages/cli/README.md#autorun-command).

packages/nx-plugin/src/executors/autorun/constants.ts

@@ -0,0 +1 @@
+export const AUTORUN_COMMAND = 'autorun';

packages/nx-plugin/src/executors/autorun/executor.integration.test.ts

@@ -0,0 +1,46 @@
+// eslint-disable-next-line n/no-sync
+import { execSync } from 'node:child_process';
+import { afterEach, expect, vi } from 'vitest';
+import { executorContext } from '@code-pushup/test-utils';
+import runAutorunExecutor from './executor';
+import * as utils from './utils';
+
+vi.mock('node:child_process', async () => {
+  const actual = await vi.importActual('node:child_process');
+  return {
+    ...actual,
+    // eslint-disable-next-line n/no-sync
+    execSync: vi.fn(),
+  };
+});
+
+describe('runAutorunExecutor', () => {
+  const parseAutorunExecutorOptionsSpy = vi.spyOn(
+    utils,
+    'parseAutorunExecutorOptions',
+  );
+  afterEach(() => {
+    parseAutorunExecutorOptionsSpy.mockReset();
+  });
+  it('should normalize context, parse CLI options and execute command', async () => {
+    const output = await runAutorunExecutor(
+      { verbose: true },
+      executorContext('utils'),
+    );
+    expect(output.success).toBe(true);
+
+    expect(parseAutorunExecutorOptionsSpy).toHaveBeenCalledTimes(1);
+
+    //is context normalized
+    expect(parseAutorunExecutorOptionsSpy).toHaveBeenCalledWith(
+      { verbose: true },
+      expect.objectContaining({
+        projectConfig: expect.objectContaining({ name: 'utils' }),
+      }),
+    );
+    // eslint-disable-next-line n/no-sync
+    expect(execSync).toHaveBeenCalledTimes(1);
+    // eslint-disable-next-line n/no-sync
+    expect(execSync).toHaveBeenCalledWith(expect.stringContaining('utils'), {});
+  });
+});

packages/nx-plugin/src/executors/autorun/executor.ts

@@ -0,0 +1,53 @@
+import { ExecutorContext, logger } from '@nx/devkit';
+// eslint-disable-next-line n/no-sync
+import { execSync } from 'node:child_process';
+import { createCliCommand } from '../internal/cli';
+import { normalizeContext } from '../internal/context';
+import { AUTORUN_COMMAND } from './constants';
+import { AutorunCommandExecutorOptions } from './schema';
+import { parseAutorunExecutorOptions } from './utils';
+
+export type ExecutorOutput = {
+  success: boolean;
+  command?: string;
+  error?: Error;
+};
+
+export default function runAutorunExecutor(
+  terminalAndExecutorOptions: AutorunCommandExecutorOptions,
+  context: ExecutorContext,
+) {
+  const normalizedContext = normalizeContext(context);
+  const cliArgumentObject = parseAutorunExecutorOptions(
+    terminalAndExecutorOptions,
+    normalizedContext,
+  );
+  const { dryRun, verbose } = terminalAndExecutorOptions;
+  const command = createCliCommand(AUTORUN_COMMAND, cliArgumentObject);
+  const commandOptions = context.cwd ? { cwd: context.cwd } : {};
+  if (verbose) {
+    logger.info(`Run ${AUTORUN_COMMAND} executor`);
+    logger.info(`Command: ${command}`);
+  }
+  if (dryRun) {
+    logger.warn(`DryRun execution of: ${command}`);
+  } else {
+    try {
+      // @TODO use executeProcess instead of execSync -> non blocking, logs #761
+      // eslint-disable-next-line n/no-sync
+      execSync(command, commandOptions);
+    } catch (error) {
+      logger.error(error);
+      return Promise.resolve({
+        success: false,
+        command,
+        error,
+      });
+    }
+  }
+
+  return Promise.resolve({
+    success: true,
+    command,
+  } satisfies ExecutorOutput);
+}

packages/nx-plugin/src/executors/autorun/executor.unit.test.ts

@@ -0,0 +1,115 @@
+import { logger } from '@nx/devkit';
+// eslint-disable-next-line n/no-sync
+import { execSync } from 'node:child_process';
+import { afterEach, beforeEach, expect, vi } from 'vitest';
+import { executorContext } from '@code-pushup/test-utils';
+import runAutorunExecutor from './executor';
+
+vi.mock('node:child_process', async () => {
+  const actual = await vi.importActual('node:child_process');
+
+  return {
+    ...actual,
+    // eslint-disable-next-line n/no-sync
+    execSync: vi.fn((command: string) => {
+      if (command.includes('THROW_ERROR')) {
+        throw new Error(command);
+      }
+    }),
+  };
+});
+
+describe('runAutorunExecutor', () => {
+  const envSpy = vi.spyOn(process, 'env', 'get');
+  const loggerInfoSpy = vi.spyOn(logger, 'info');
+  const loggerWarnSpy = vi.spyOn(logger, 'warn');
+
+  beforeEach(() => {
+    envSpy.mockReturnValue({});
+  });
+  afterEach(() => {
+    loggerWarnSpy.mockReset();
+    loggerInfoSpy.mockReset();
+    envSpy.mockReset().mockReturnValue({});
+  });
+
+  it('should call execSync with autorun command and return result', async () => {
+    const output = await runAutorunExecutor({}, executorContext('utils'));
+    expect(output.success).toBe(true);
+    expect(output.command).toMatch('npx @code-pushup/cli autorun');
+    // eslint-disable-next-line n/no-sync
+    expect(execSync).toHaveBeenCalledWith(
+      expect.stringContaining('npx @code-pushup/cli autorun'),
+      {},
+    );
+  });
+
+  it('should normalize context', async () => {
+    const output = await runAutorunExecutor(
+      {},
+      {
+        ...executorContext('utils'),
+        cwd: 'cwd-form-context',
+      },
+    );
+    expect(output.success).toBe(true);
+    expect(output.command).toMatch('utils');
+    // eslint-disable-next-line n/no-sync
+    expect(execSync).toHaveBeenCalledWith(expect.stringContaining('utils'), {
+      cwd: 'cwd-form-context',
+    });
+  });
+
+  it('should process executorOptions', async () => {
+    const output = await runAutorunExecutor(
+      { persist: { filename: 'REPORT' } },
+      executorContext('testing-utils'),
+    );
+    expect(output.success).toBe(true);
+    expect(output.command).toMatch('--persist.filename="REPORT"');
+  });
+
+  it('should create command from context, options and arguments', async () => {
+    envSpy.mockReturnValue({ CP_PROJECT: 'CLI' });
+    const output = await runAutorunExecutor(
+      { persist: { filename: 'REPORT', format: ['md', 'json'] } },
+      executorContext('core'),
+    );
+    expect(output.command).toMatch('--persist.filename="REPORT"');
+    expect(output.command).toMatch(
+      '--persist.format="md" --persist.format="json"',
+    );
+    expect(output.command).toMatch('--upload.project="CLI"');
+  });
+
+  it('should log information if verbose is set', async () => {
+    const output = await runAutorunExecutor(
+      { verbose: true },
+      { ...executorContext('github-action'), cwd: '<CWD>' },
+    );
+    // eslint-disable-next-line n/no-sync
+    expect(execSync).toHaveBeenCalledTimes(1);
+
+    expect(output.command).toMatch('--verbose');
+    expect(loggerWarnSpy).toHaveBeenCalledTimes(0);
+    expect(loggerInfoSpy).toHaveBeenCalledTimes(2);
+    expect(loggerInfoSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Run autorun executor'),
+    );
+    expect(loggerInfoSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Command: npx @code-pushup/cli autorun'),
+    );
+  });
+
+  it('should log command if dryRun is set', async () => {
+    await runAutorunExecutor({ dryRun: true }, executorContext('utils'));
+
+    expect(loggerInfoSpy).toHaveBeenCalledTimes(0);
+    expect(loggerWarnSpy).toHaveBeenCalledTimes(1);
+    expect(loggerWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'DryRun execution of: npx @code-pushup/cli autorun --dryRun',
+      ),
+    );
+  });
+});