[DRAFT] Mutation server

packages/api/src/plugin/tokens.ts

@@ -19,6 +19,7 @@ export const commonTokens = Object.freeze({
   options: stringLiteral('options'),
   fileDescriptions: stringLiteral('fileDescriptions'),
   target,
+  abortSignal: stringLiteral('abortSignal'),
 });
 
 /**

packages/core/bin/stryker-server.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { StrykerServer } from '../dist/src/index.js';
+
+process.title = 'stryker-server';
+new StrykerServer(process.argv);

packages/core/package.json

@@ -21,7 +21,8 @@
     "test:all": "npm run test:unit && npm run test:integration",
     "test:unit": "mocha 'dist/test/unit/**/*.js'",
     "test:integration": "mocha --timeout 60000 'dist/test/integration/**/*.js'",
-    "stryker": "node bin/stryker.js run"
+    "stryker": "node bin/stryker.js run",
+    "stryker-server": "node bin/stryker-server.js"
   },
   "repository": {
     "type": "git",
@@ -65,7 +66,8 @@
   },
   "homepage": "https://stryker-mutator.io/",
   "bin": {
-    "stryker": "./bin/stryker.js"
+    "stryker": "./bin/stryker.js",
+    "stryker-server": "./bin/stryker-server.js"
   },
   "dependencies": {
     "@stryker-mutator/api": "8.2.6",
@@ -81,6 +83,7 @@
     "get-port": "~7.0.0",
     "glob": "~10.3.10",
     "inquirer": "~9.2.13",
+    "json-rpc-2.0": "^1.7.0",
     "lodash.groupby": "~4.6.0",
     "log4js": "~6.9.1",
     "minimatch": "~9.0.3",
@@ -95,7 +98,8 @@
     "tree-kill": "~1.2.2",
     "tslib": "2.6.2",
     "typed-inject": "~4.0.0",
-    "typed-rest-client": "~1.8.11"
+    "typed-rest-client": "~1.8.11",
+    "ws": "^8.16.0"
   },
   "devDependencies": {
     "@stryker-mutator/test-helpers": "8.2.6",
@@ -105,6 +109,7 @@
     "@types/node": "20.12.7",
     "@types/progress": "2.0.7",
     "@types/semver": "7.5.8",
+    "@types/ws": "^8.5.10",
     "flatted": "3.3.1"
   }
 }

packages/core/src/index.ts

@@ -1,7 +1,8 @@
 import { StrykerCli } from './stryker-cli.js';
+import { StrykerServer } from './stryker-server.js';
 import { Stryker } from './stryker.js';
 
-export { Stryker, StrykerCli };
+export { Stryker, StrykerCli, StrykerServer };
 
 // One default export for backward compatibility
 // eslint-disable-next-line import/no-default-export

packages/core/src/process/1-prepare-executor.ts

@@ -14,7 +14,6 @@ import { Timer } from '../utils/timer.js';
 import { MetaSchemaBuilder, OptionsValidator } from '../config/index.js';
 import { BroadcastReporter } from '../reporters/broadcast-reporter.js';
 import { UnexpectedExitHandler } from '../unexpected-exit-handler.js';
-
 import { FileSystem, ProjectReader } from '../fs/index.js';
 
 import { MutantInstrumenterContext } from './index.js';

packages/core/src/process/4-mutation-test-executor.ts

@@ -1,5 +1,5 @@
-import { from, partition, merge, Observable, lastValueFrom, EMPTY, concat, bufferTime, mergeMap } from 'rxjs';
-import { toArray, map, shareReplay, tap } from 'rxjs/operators';
+import { from, partition, merge, Observable, lastValueFrom, EMPTY, concat, bufferTime, mergeMap, fromEvent } from 'rxjs';
+import { toArray, map, shareReplay, tap, take, takeUntil } from 'rxjs/operators';
 import { tokens, commonTokens } from '@stryker-mutator/api/plugin';
 import { MutantResult, Mutant, StrykerOptions, PlanKind, MutantTestPlan, MutantRunPlan } from '@stryker-mutator/api/core';
 import { TestRunner, CompleteDryRunResult } from '@stryker-mutator/api/test-runner';
@@ -50,6 +50,7 @@ export class MutationTestExecutor {
     coreTokens.timer,
     coreTokens.concurrencyTokenProvider,
     coreTokens.dryRunResult,
+    commonTokens.abortSignal,
   );
 
   constructor(
@@ -64,6 +65,7 @@ export class MutationTestExecutor {
     private readonly timer: I<Timer>,
     private readonly concurrencyTokenProvider: I<ConcurrencyTokenProvider>,
     private readonly dryRunResult: CompleteDryRunResult,
+    private readonly abortSignal: AbortSignal | undefined,
   ) {}
 
   public async execute(): Promise<MutantResult[]> {
@@ -72,17 +74,21 @@ export class MutationTestExecutor {
       return [];
     }
 
-    if (this.dryRunResult.tests.length === 0 && this.options.allowEmpty) {
+    if ((this.dryRunResult.tests.length === 0 && this.options.allowEmpty) || this.abortSignal?.aborted) {
       this.logDone();
       return [];
     }
 
+    const stop = this.abortSignal ? fromEvent(this.abortSignal, 'abort').pipe(take(1)) : EMPTY;
+
     const mutantTestPlans = await this.planner.makePlan(this.mutants);
     const { earlyResult$, runMutant$ } = this.executeEarlyResult(from(mutantTestPlans));
     const { passedMutant$, checkResult$ } = this.executeCheck(runMutant$);
     const { coveredMutant$, noCoverageResult$ } = this.executeNoCoverage(passedMutant$);
     const testRunnerResult$ = this.executeRunInTestRunner(coveredMutant$);
-    const results = await lastValueFrom(merge(testRunnerResult$, checkResult$, noCoverageResult$, earlyResult$).pipe(toArray()));
+
+    const results = await lastValueFrom(merge(testRunnerResult$, checkResult$, noCoverageResult$, earlyResult$).pipe(takeUntil(stop), toArray()));
+
     await this.mutationTestReportHelper.reportAll(results);
     await this.reporter.wrapUp();
     this.logDone();

packages/core/src/reporters/index.ts

@@ -20,6 +20,7 @@ export const strykerPlugins = [
   declareClassPlugin(PluginKind.Reporter, 'event-recorder', EventRecorderReporter),
   declareClassPlugin(PluginKind.Reporter, 'html', HtmlReporter),
   declareClassPlugin(PluginKind.Reporter, 'json', JsonReporter),
+  declareClassPlugin(PluginKind.Reporter, 'empty', class {}),
   declareFactoryPlugin(PluginKind.Reporter, 'dashboard', dashboardReporterFactory),
 ];
 

packages/core/src/server/index.ts

@@ -0,0 +1,4 @@
+export * from './mutation-server-protocol-handler.js';
+export * from './mutation-server-protocol.js';
+export * from './server-tokens.js';
+export * as serverTokens from './server-tokens.js';

packages/core/src/server/methods/index.ts

@@ -0,0 +1,2 @@
+export * from './instrument-method.js';
+export * from './mutation-test-method.js';

packages/core/src/server/methods/instrument-method.ts

@@ -0,0 +1,27 @@
+import { createInjector } from 'typed-inject';
+import { MutantResult, PartialStrykerOptions } from '@stryker-mutator/api/core';
+
+import { provideLogger } from './../../di/provide-logger.js';
+import { PrepareExecutor } from './../../process/1-prepare-executor.js';
+import { MutantInstrumenterExecutor as ServerMutantInstrumenterExecutor } from './process/mutant-instrument-executor.js';
+
+export class InstrumentMethod {
+  /**
+   * Get the mutant results for the given glob patterns, without running the mutation tests.
+   * @param globPatterns The glob patterns to instrument.
+   * @returns The mutant results.
+   */
+  public static async runInstrumentation(options: PartialStrykerOptions, injectorFactory = createInjector): Promise<MutantResult[]> {
+    const rootInjector = injectorFactory();
+
+    const loggerProvider = provideLogger(rootInjector);
+
+    const prepareExecutor = loggerProvider.injectClass(PrepareExecutor);
+
+    const mutantInstrumenterInjector = await prepareExecutor.execute(options);
+
+    const mutantInstrumenter = mutantInstrumenterInjector.injectClass(ServerMutantInstrumenterExecutor);
+
+    return await mutantInstrumenter.execute();
+  }
+}

packages/core/src/server/methods/mutation-test-method.ts

@@ -0,0 +1,98 @@
+import { createInjector } from 'typed-inject';
+import { MutantResult, PartialStrykerOptions } from '@stryker-mutator/api/core';
+import { commonTokens } from '@stryker-mutator/api/plugin';
+
+import { MutationTestExecutor } from '../../process/4-mutation-test-executor.js';
+import { provideLogger } from '../../di/provide-logger.js';
+import { PrepareExecutor } from '../../process/1-prepare-executor.js';
+import { MutantInstrumenterExecutor } from '../../process/2-mutant-instrumenter-executor.js';
+import { Stryker } from '../../stryker.js';
+import { BroadcastReporter } from '../../reporters/index.js';
+import { DryRunExecutor } from '../../process/3-dry-run-executor.js';
+import { coreTokens } from '../../di/index.js';
+import { ConfigError, retrieveCause } from '../../errors.js';
+import { LogConfigurator } from '../../logging/log-configurator.js';
+
+export class MutationTestMethod {
+  constructor(private readonly injectorFactory = createInjector) {}
+
+  /**
+   * Run a mutation test and get partial results via a callback.
+   * @param globPatterns  The glob patterns to mutation test.
+   * @param onMutantTested  A callback that is called when a mutant is tested.
+   */
+  public async runMutationTestRealtime(
+    options: PartialStrykerOptions,
+    abortSignal: AbortSignal,
+    onMutantTested: (result: Readonly<MutantResult>) => void,
+  ): Promise<void> {
+    options.reporters = ['empty']; // used to stream results
+
+    const rootInjector = this.injectorFactory();
+    const loggerProvider = provideLogger(rootInjector);
+
+    try {
+      // 1. Prepare. Load Stryker configuration, load the input files and starts the logging server
+      const prepareExecutor = loggerProvider.injectClass(PrepareExecutor);
+
+      const mutantInstrumenterInjector = await prepareExecutor.execute(options);
+
+      const broadcastReporter = mutantInstrumenterInjector.resolve(coreTokens.reporter) as BroadcastReporter;
+      const emptyReporter = broadcastReporter.reporters.empty;
+      if (!emptyReporter) {
+        throw new Error('Reporter unavailable');
+      }
+
+      emptyReporter.onMutantTested = onMutantTested;
+      try {
+        // 2. Mutate and instrument the files and write to the sandbox.
+        const mutantInstrumenter = mutantInstrumenterInjector.injectClass(MutantInstrumenterExecutor);
+        const dryRunExecutorInjector = await mutantInstrumenter.execute();
+
+        // 3. Perform a 'dry run' (initial test run). Runs the tests without active mutants and collects coverage.
+        const dryRunExecutor = dryRunExecutorInjector.injectClass(DryRunExecutor);
+        const mutationRunExecutorInjector = (await dryRunExecutor.execute()).provideValue(commonTokens.abortSignal, abortSignal);
+
+        // 4. Actual mutation testing. Will check every mutant and if valid run it in an available test runner.
+        const mutationRunExecutor = mutationRunExecutorInjector.injectClass(MutationTestExecutor);
+
+        await mutationRunExecutor.execute();
+      } catch (error) {
+        if (mutantInstrumenterInjector.resolve(commonTokens.options).cleanTempDir !== 'always') {
+          const log = loggerProvider.resolve(commonTokens.getLogger)(Stryker.name);
+          log.debug('Not removing the temp dir because an error occurred');
+          mutantInstrumenterInjector.resolve(coreTokens.temporaryDirectory).removeDuringDisposal = false;
+        }
+        throw error;
+      }
+    } catch (error) {
+      const log = loggerProvider.resolve(commonTokens.getLogger)(Stryker.name);
+      const cause = retrieveCause(error);
+      if (cause instanceof ConfigError) {
+        log.error(cause.message);
+      } else {
+        log.error('Unexpected error occurred while running Stryker', error);
+        log.info('This might be a known problem with a solution documented in our troubleshooting guide.');
+        log.info('You can find it at https://stryker-mutator.io/docs/stryker-js/troubleshooting/');
+        if (!log.isTraceEnabled()) {
+          log.info(
+            'Still having trouble figuring out what went wrong? Try `npx stryker run --fileLogLevel trace --logLevel debug` to get some more info.',
+          );
+        }
+      }
+      throw cause;
+    } finally {
+      await rootInjector.dispose();
+      await LogConfigurator.shutdown();
+    }
+  }
+
+  /**
+   * Run a mutation test.
+   * @param globPatterns The glob patterns to mutation test.
+   * @returns The mutant results.
+   */
+  public static async runMutationTest(abortSignal: AbortSignal, options: PartialStrykerOptions): Promise<MutantResult[]> {
+    return await new Stryker(options).runMutationTest(abortSignal);
+  }
+}