How to use the @stryker-mutator/api/plugin.tokens function in @stryker-mutator/api

import { Config, ConfigEditor } from '@stryker-mutator/api/config';
import { tokens } from '@stryker-mutator/api/plugin';

import MochaOptionsLoader from './MochaOptionsLoader';
import { mochaOptionsKey } from './utils';

export default class MochaConfigEditor implements ConfigEditor {
  public static inject = tokens('loader');
  constructor(private readonly loader: MochaOptionsLoader) {}

  public edit(config: Config): void {
    config[mochaOptionsKey] = this.loader.load(config);
  }
}

import { StrykerOptions } from '@stryker-mutator/api/core';
import { Logger } from '@stryker-mutator/api/logging';
import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
import { childProcessAsPromised, fsAsPromised } from '@stryker-mutator/util';

import PresetConfiguration from './presets/PresetConfiguration';
import PromptOption from './PromptOption';

import { initializerTokens } from '.';

const STRYKER_CONFIG_FILE = 'stryker.conf.js';

export default class StrykerConfigWriter {
  public static inject = tokens(commonTokens.logger, initializerTokens.out);
  constructor(private readonly log: Logger, private readonly out: typeof console.log) {}

  public guardForExistingConfig() {
    if (fsAsPromised.existsSync(STRYKER_CONFIG_FILE)) {
      const msg = 'Stryker config file "stryker.conf.js" already exists in the current directory. Please remove it and try again.';
      this.log.error(msg);
      throw new Error(msg);
    }
  }

  /**
   * Create stryker.conf.js based on the chosen framework and test runner
   * @function
   */
  public write(
    selectedTestRunner: null | PromptOption,

* A small object that keeps the timing variables of a test run.
 */
interface Timing {
  /**
   * The time that the test runner was actually executing tests in milliseconds.
   */
  net: number;
  /**
   * the time that was spend not executing tests in milliseconds.
   * So the time it took to start the test runner and to report the result.
   */
  overhead: number;
}

export default class InitialTestExecutor {
  public static inject = tokens(
    commonTokens.options,
    commonTokens.logger,
    coreTokens.inputFiles,
    coreTokens.testFramework,
    coreTokens.timer,
    coreTokens.loggingContext,
    coreTokens.transpiler,
    coreTokens.temporaryDirectory
  );

  constructor(
    private readonly options: StrykerOptions,
    private readonly log: Logger,
    private readonly inputFiles: InputFileCollection,
    private readonly testFramework: TestFramework | null,
    private readonly timer: Timer,

const mapSearchResultToPromptOption = (searchResults: NpmSearchResult): PromptOption[] =>
  searchResults.results.map(result => ({
    name: getName(result.package.name),
    pkg: result.package
  }));

const handleResult = (from: string) => (response: IRestResponse): T => {
  if (response.statusCode === 200 && response.result) {
    return response.result;
  } else {
    throw new Error(`Path ${from} resulted in http status code: ${response.statusCode}.`);
  }
};

export default class NpmClient {
  public static inject = tokens(commonTokens.logger, initializerTokens.restClientNpmSearch, initializerTokens.restClientNpm);
  constructor(private readonly log: Logger, private readonly searchClient: RestClient, private readonly packageClient: RestClient) {}

  public getTestRunnerOptions(): Promise {
    return this.search('/v2/search?q=keywords:@stryker-mutator/test-runner-plugin').then(mapSearchResultToPromptOption);
  }

  public getTestFrameworkOptions(testRunnerFilter: string | null): Promise {
    return this.search('/v2/search?q=keywords:@stryker-mutator/test-framework-plugin')
      .then(searchResult => {
        if (testRunnerFilter) {
          searchResult.results = searchResult.results.filter(framework => framework.package.keywords.includes(testRunnerFilter));
        }
        return searchResult;
      })
      .then(mapSearchResultToPromptOption);
  }

optionsApi?: Partial;
}

export const CONFIG_KEY = 'babel';
export const FILE_KEY: keyof StrykerBabelConfig = 'optionsFile';
export const OPTIONS_KEY: keyof StrykerBabelConfig = 'options';
export const EXTENSIONS_KEY: keyof StrykerBabelConfig = 'extensions';

const DEFAULT_BABEL_CONFIG: Readonly = Object.freeze({
  extensions: Object.freeze([]),
  options: Object.freeze({}),
  optionsFile: '.babelrc'
});

export class BabelConfigReader {
  public static inject = tokens(commonTokens.logger);
  constructor(private readonly log: Logger) {}

  public readConfig(strykerOptions: StrykerOptions): StrykerBabelConfig {
    const babelConfig: StrykerBabelConfig = {
      ...DEFAULT_BABEL_CONFIG,
      ...strykerOptions[CONFIG_KEY]
    };
    babelConfig.options = {
      ...this.readBabelOptionsFromFile(babelConfig.optionsFile, babelConfig.optionsApi),
      ...babelConfig.options
    };
    this.log.debug(`Babel config is: ${JSON.stringify(babelConfig, null, 2)}`);
    return babelConfig;
  }

  private readBabelOptionsFromFile(relativeFileName: string | null, optionsApi?: Partial): babel.TransformOptions {

import generate from '@babel/generator';
import { parse, ParserOptions } from '@babel/parser';
import traverse, { NodePath } from '@babel/traverse';
import * as types from '@babel/types';
import { Logger } from '@stryker-mutator/api/logging';
import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
import { MutatorDescriptor } from '@stryker-mutator/api/core';

import { NodeWithParent } from './ParentNode';

export default class BabelParser {
  public static inject = tokens(commonTokens.logger, commonTokens.mutatorDescriptor);
  private readonly options: ParserOptions;

  constructor(private readonly log: Logger, mutatorDescriptor: MutatorDescriptor) {
    this.options = this.createOptions(mutatorDescriptor.plugins);
  }

  public parse(code: string): types.File {
    return parse(code, this.options);
  }

  private createOptions(pluginOverrides: string[] | null): ParserOptions {
    const plugins = pluginOverrides || [
      'asyncGenerators',
      'bigInt',
      'classProperties',
      'dynamicImport',

import * as ts from 'typescript';

import flatMap = require('lodash.flatmap');

import { getTSConfig, parseFile } from './helpers/tsHelpers';
import { nodeMutators } from './mutator';
import NodeMutator from './mutator/NodeMutator';

export function typescriptMutatorFactory(injector: Injector): TypescriptMutator {
  return injector.provideValue(MUTATORS_TOKEN, nodeMutators).injectClass(TypescriptMutator);
}
typescriptMutatorFactory.inject = tokens(commonTokens.injector);

export const MUTATORS_TOKEN = 'mutators';
export class TypescriptMutator {
  public static inject = tokens(commonTokens.options, MUTATORS_TOKEN);
  constructor(private readonly options: StrykerOptions, public readonly mutators: readonly NodeMutator[]) {}

  public mutate(inputFiles: File[]): Mutant[] {
    const tsConfig = getTSConfig(this.options);
    const mutants = flatMap(inputFiles, inputFile => {
      const sourceFile = parseFile(inputFile, tsConfig && tsConfig.options && tsConfig.options.target);
      return this.mutateForNode(sourceFile, sourceFile);
    });
    return mutants;
  }

  private mutateForNode(node: T, sourceFile: ts.SourceFile): Mutant[] {
    if (shouldNodeBeSkipped(node)) {
      return [];
    } else {
      const targetMutators = this.mutators.filter(mutator => mutator.guard(node));