@d-es-ign/stryker-js-core 9.6.0

package/src/initializer/custom-initializers/index.ts

@@ -0,0 +1,31 @@
+import {
+  BaseContext,
+  commonTokens,
+  Injector,
+} from '@stryker-mutator/api/plugin';
+import type { resolveFromCwd } from '@stryker-mutator/util';
+
+import { coreTokens } from '../../di/index.js';
+
+import { AngularInitializer } from './angular-initializer.js';
+import { CustomInitializer } from './custom-initializer.js';
+import { ReactInitializer } from './react-initializer.js';
+import { VueJsInitializer } from './vue-js-initializer.js';
+import { SvelteInitializer } from './svelte-initializer.js';
+
+interface CustomInitializerContext extends BaseContext {
+  [coreTokens.execa]: typeof import('execa').execaCommand;
+  [coreTokens.resolveFromCwd]: typeof resolveFromCwd;
+}
+
+export function createInitializers(
+  injector: Injector<CustomInitializerContext>,
+): CustomInitializer[] {
+  return [
+    injector.injectClass(AngularInitializer),
+    injector.injectClass(ReactInitializer),
+    injector.injectClass(SvelteInitializer),
+    injector.injectClass(VueJsInitializer),
+  ];
+}
+createInitializers.inject = [commonTokens.injector] as const;

package/src/initializer/custom-initializers/react-initializer.ts

@@ -0,0 +1,35 @@
+import { StrykerOptions } from '@stryker-mutator/api/core';
+import { Immutable } from '@stryker-mutator/util';
+
+import {
+  CustomInitializer,
+  CustomInitializerConfiguration,
+} from './custom-initializer.js';
+
+const guideUrl = 'https://stryker-mutator.io/docs/stryker-js/guides/react';
+
+/**
+ * More information can be found in the Stryker handbook:
+ * https://stryker-mutator.io/docs/stryker-js/guides/react
+ */
+export class ReactInitializer implements CustomInitializer {
+  public readonly name = 'create-react-app';
+  private readonly dependencies = ['@stryker-mutator/jest-runner'];
+
+  private readonly config: Immutable<Partial<StrykerOptions>> = {
+    testRunner: 'jest',
+    reporters: ['progress', 'clear-text', 'html'],
+    coverageAnalysis: 'off',
+    jest: {
+      projectType: 'create-react-app',
+    },
+  };
+
+  public createConfig(): Promise<CustomInitializerConfiguration> {
+    return Promise.resolve({
+      config: this.config,
+      guideUrl,
+      dependencies: this.dependencies,
+    });
+  }
+}

package/src/initializer/custom-initializers/svelte-initializer.ts

@@ -0,0 +1,40 @@
+import { inquire } from '../inquire.js';
+import {
+  CustomInitializer,
+  CustomInitializerConfiguration,
+} from './custom-initializer.js';
+
+const guideUrl = 'https://stryker-mutator.io/docs/stryker-js/guides/svelte';
+const reporters = Object.freeze(['progress', 'clear-text', 'html']);
+
+export class SvelteInitializer implements CustomInitializer {
+  public readonly name = 'svelte';
+
+  public async createConfig(): Promise<CustomInitializerConfiguration> {
+    const testRunnerChoices = [{ value: 'jest' }, { value: 'vitest' }];
+    const testRunnerNodeArgs: string[] = [];
+    const testRunner = await inquire.select({
+      message: 'Which test runner are you using?',
+      choices: testRunnerChoices,
+    });
+    if (testRunner === 'jest') {
+      const nativeEsm = await inquire.confirm({
+        message:
+          'Are you using native EcmaScript modules? (see https://jestjs.io/docs/ecmascript-modules)',
+        default: true,
+      });
+      if (nativeEsm) {
+        testRunnerNodeArgs.push('--experimental-vm-modules');
+      }
+    }
+    return {
+      config: {
+        testRunner,
+        ...(testRunnerNodeArgs.length ? { testRunnerNodeArgs } : {}),
+        reporters,
+      },
+      dependencies: [`@stryker-mutator/${testRunner}-runner`],
+      guideUrl,
+    };
+  }
+}

package/src/initializer/custom-initializers/vue-js-initializer.ts

@@ -0,0 +1,30 @@
+import { PartialStrykerOptions } from '@stryker-mutator/api/core';
+import { Immutable } from '@stryker-mutator/util';
+
+import {
+  CustomInitializer,
+  CustomInitializerConfiguration,
+} from './custom-initializer.js';
+
+const guideUrl = 'https://stryker-mutator.io/docs/stryker-js/guides/vuejs';
+
+/**
+ * More information can be found in the Stryker handbook:
+ * https://stryker-mutator.io/docs/stryker-js/guides/vuejs
+ */
+export class VueJsInitializer implements CustomInitializer {
+  public readonly name = 'vue';
+
+  private readonly vitestConf: Immutable<PartialStrykerOptions> = {
+    testRunner: 'vitest',
+    reporters: ['progress', 'clear-text', 'html'],
+  };
+
+  public createConfig(): Promise<CustomInitializerConfiguration> {
+    return Promise.resolve({
+      config: this.vitestConf,
+      dependencies: ['@stryker-mutator/vitest-runner'],
+      guideUrl,
+    });
+  }
+}

package/src/initializer/gitignore-writer.ts

@@ -0,0 +1,33 @@
+import os from 'os';
+import { existsSync, promises as fs } from 'fs';
+
+import { tokens } from '@stryker-mutator/api/plugin';
+
+import { defaultOptions } from '../config/index.js';
+
+import { initializerTokens } from './index.js';
+
+const GITIGNORE_FILE = '.gitignore';
+
+export class GitignoreWriter {
+  public static inject = tokens(initializerTokens.out);
+  constructor(private readonly out: typeof console.log) {}
+
+  public async addStrykerTempFolder(): Promise<void> {
+    const defaultTempDirName = defaultOptions.tempDirName;
+    if (existsSync(GITIGNORE_FILE)) {
+      const gitignoreContent = await fs.readFile(GITIGNORE_FILE);
+      if (!gitignoreContent.toString().includes(defaultTempDirName)) {
+        const strykerTempFolderSpecification = `${os.EOL}# stryker temp files${os.EOL}${defaultTempDirName}${os.EOL}`;
+        await fs.appendFile(GITIGNORE_FILE, strykerTempFolderSpecification);
+        this.out(
+          'Note: Your .gitignore file has been updated to include recommended git ignore patterns for Stryker',
+        );
+      }
+    } else {
+      this.out(
+        'No .gitignore file could be found. Please add the following to your .gitignore file: *.stryker-tmp',
+      );
+    }
+  }
+}

package/src/initializer/index.ts

@@ -0,0 +1,35 @@
+import { Injector } from 'typed-inject';
+import { execaCommand, execaCommandSync } from 'execa';
+import { resolveFromCwd } from '@stryker-mutator/util';
+
+import { coreTokens } from '../di/index.js';
+
+import * as initializerTokens from './initializer-tokens.js';
+import { NpmClient } from './npm-client.js';
+import { StrykerConfigWriter } from './stryker-config-writer.js';
+import { StrykerInitializer } from './stryker-initializer.js';
+import { StrykerInquirer } from './stryker-inquirer.js';
+import { createInitializers } from './custom-initializers/index.js';
+import { GitignoreWriter } from './gitignore-writer.js';
+import { createNpmRegistryClient, getRegistry } from './npm-registry.js';
+import { provideLogging, provideLoggingBackend } from '../logging/index.js';
+
+export async function initializerFactory(
+  injector: Injector,
+): Promise<StrykerInitializer> {
+  return provideLogging(await provideLoggingBackend(injector, process.stdout))
+    .provideValue(initializerTokens.out, console.log)
+    .provideValue(coreTokens.execa, execaCommand)
+    .provideValue(coreTokens.execaSync, execaCommandSync)
+    .provideValue(coreTokens.resolveFromCwd, resolveFromCwd)
+    .provideFactory(initializerTokens.npmRegistry, getRegistry)
+    .provideFactory(initializerTokens.restClientNpm, createNpmRegistryClient)
+    .provideClass(initializerTokens.npmClient, NpmClient)
+    .provideClass(initializerTokens.configWriter, StrykerConfigWriter)
+    .provideClass(initializerTokens.gitignoreWriter, GitignoreWriter)
+    .provideClass(initializerTokens.inquirer, StrykerInquirer)
+    .provideFactory(initializerTokens.customInitializers, createInitializers)
+    .injectClass(StrykerInitializer);
+}
+
+export { initializerTokens };

package/src/initializer/initializer-tokens.ts

@@ -0,0 +1,8 @@
+export const restClientNpm = 'restClientNpm';
+export const npmClient = 'npmClient';
+export const npmRegistry = 'npmRegistry';
+export const customInitializers = 'strykerPresets';
+export const configWriter = 'configWriter';
+export const gitignoreWriter = 'gitignoreWriter';
+export const inquirer = 'inquirer';
+export const out = 'out';

package/src/initializer/inquire.ts

@@ -0,0 +1,17 @@
+import { select, confirm, input, checkbox, Separator } from '@inquirer/prompts';
+/**
+ * @description Small wrapper around inquire prompts to make it easier to mock in tests
+ */
+export const inquire: {
+  select: typeof select;
+  confirm: typeof confirm;
+  input: typeof input;
+  checkbox: typeof checkbox;
+  separator: () => Separator;
+} = {
+  select,
+  confirm,
+  input,
+  checkbox,
+  separator: () => new Separator(),
+};

package/src/initializer/npm-client.ts

@@ -0,0 +1,103 @@
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import { errorToString } from '@stryker-mutator/util';
+import type {
+  IRestResponse,
+  RestClient,
+} from 'typed-rest-client/RestClient.js';
+
+import { PackageInfo, PackageSummary } from './package-info.js';
+import { PromptOption } from './prompt-option.js';
+
+import { initializerTokens } from './index.js';
+
+export interface NpmSearchResult {
+  total: number;
+  objects: Array<{ package: PackageSummary }>;
+}
+
+const getName = (packageName: string) => {
+  return packageName
+    .replace('@stryker-mutator/', '')
+    .replace('stryker-', '')
+    .split('-')[0];
+};
+
+const mapSearchResultToPromptOption = (
+  searchResults: NpmSearchResult,
+): PromptOption[] =>
+  searchResults.objects.map((result) => ({
+    name: getName(result.package.name),
+    pkg: result.package,
+  }));
+
+const handleResult =
+  (from: string) =>
+  <T>(response: IRestResponse<T>): T => {
+    if (response.statusCode === 200 && response.result) {
+      return response.result;
+    } else {
+      throw new Error(
+        `Path ${from} resulted in http status code: ${response.statusCode}.`,
+      );
+    }
+  };
+
+export class NpmClient {
+  public static inject = tokens(
+    commonTokens.logger,
+    initializerTokens.restClientNpm,
+    initializerTokens.npmRegistry,
+  );
+  constructor(
+    private readonly log: Logger,
+    private readonly innerNpmClient: RestClient,
+    private readonly npmRegistry: string,
+  ) {}
+
+  public getTestRunnerOptions(): Promise<PromptOption[]> {
+    return this.search(
+      `/-/v1/search?text=keywords:${encodeURIComponent('@stryker-mutator/test-runner-plugin')}`,
+    ).then(mapSearchResultToPromptOption);
+  }
+
+  public getTestReporterOptions(): Promise<PromptOption[]> {
+    return this.search(
+      `/-/v1/search?text=keywords:${encodeURIComponent('@stryker-mutator/reporter-plugin')}`,
+    ).then(mapSearchResultToPromptOption);
+  }
+
+  public async getAdditionalConfig(
+    pkgInfo: PackageSummary,
+  ): Promise<PackageInfo> {
+    const path = `/${encodeURIComponent(pkgInfo.name)}/${pkgInfo.version}`;
+    try {
+      const response = await this.innerNpmClient.get<PackageInfo>(path);
+      return handleResult(path)(response);
+    } catch (err) {
+      this.log.warn(
+        `Could not fetch additional initialization config for dependency ${pkgInfo.name}. You might need to configure it manually`,
+        err,
+      );
+      return pkgInfo;
+    }
+  }
+
+  private async search(path: string): Promise<NpmSearchResult> {
+    this.log.debug(`Searching: ${path}`);
+    try {
+      const response = await this.innerNpmClient.get<NpmSearchResult>(path);
+      return handleResult(path)(response);
+    } catch (err) {
+      this.log.error(
+        `Unable to reach '${this.npmRegistry}' (for query ${path}). Please check your internet connection.`,
+        errorToString(err),
+      );
+      const result: NpmSearchResult = {
+        objects: [],
+        total: 0,
+      };
+      return result;
+    }
+  }
+}

package/src/initializer/npm-registry.ts

@@ -0,0 +1,48 @@
+import { execaCommandSync } from 'execa';
+import { RestClient } from 'typed-rest-client';
+import * as initializerTokens from './initializer-tokens.js';
+import { coreTokens } from '../di/index.js';
+import { errorToString } from '@stryker-mutator/util';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens } from '@stryker-mutator/api/plugin';
+
+const DEFAULT_NPM_REGISTRY = 'https://registry.npmjs.com';
+
+function getRegistry(
+  logger: Logger,
+  execaSync: typeof execaCommandSync,
+): string {
+  if (process.env.npm_config_registry) {
+    return process.env.npm_config_registry;
+  } else if (process.env.npm_command) {
+    // if running inside npm and not having the registry than it's the default one
+    return DEFAULT_NPM_REGISTRY;
+  } else {
+    // Using global as when trying to get the registry inside npm workspace it would fail
+    try {
+      const registry = execaSync('npm config get --global registry', {
+        stdout: 'pipe',
+        timeout: 20000,
+      });
+
+      return registry.stdout.trim();
+    } catch (e) {
+      logger.warn(
+        'Could not run `npm config get --global registry` falling back to default npm registry.',
+        errorToString(e),
+      );
+
+      return DEFAULT_NPM_REGISTRY;
+    }
+  }
+}
+
+getRegistry.inject = [commonTokens.logger, coreTokens.execaSync] as const;
+
+function createNpmRegistryClient(npmRegistry: string): RestClient {
+  return new RestClient('npm', npmRegistry);
+}
+
+createNpmRegistryClient.inject = [initializerTokens.npmRegistry] as const;
+
+export { createNpmRegistryClient, getRegistry };

package/src/initializer/package-info.ts

@@ -0,0 +1,10 @@
+export interface PackageInfo extends PackageSummary {
+  homepage?: string;
+  initStrykerConfig?: Record<string, unknown>;
+}
+
+export interface PackageSummary {
+  name: string;
+  keywords: string[];
+  version: string;
+}

package/src/initializer/prompt-option.ts

@@ -0,0 +1,6 @@
+import { PackageInfo } from './package-info.js';
+
+export interface PromptOption {
+  name: string;
+  pkg: PackageInfo | null;
+}

package/src/initializer/stryker-config-writer.ts

@@ -0,0 +1,158 @@
+import { promises as fs } from 'fs';
+
+import {
+  PartialStrykerOptions,
+  StrykerOptions,
+} from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import { Immutable, childProcessAsPromised } from '@stryker-mutator/util';
+
+import { fileUtils } from '../utils/file-utils.js';
+import { CommandTestRunner } from '../test-runner/command-test-runner.js';
+import {
+  SUPPORTED_CONFIG_FILE_NAMES,
+  DEFAULT_CONFIG_FILE_NAMES,
+} from '../config/index.js';
+
+import { PromptOption } from './prompt-option.js';
+import { CustomInitializerConfiguration } from './custom-initializers/custom-initializer.js';
+
+import { initializerTokens } from './index.js';
+
+export class StrykerConfigWriter {
+  public static inject = tokens(commonTokens.logger, initializerTokens.out);
+  constructor(
+    private readonly log: Logger,
+    private readonly out: typeof console.log,
+  ) {}
+
+  public async guardForExistingConfig(): Promise<void> {
+    for (const fileName of SUPPORTED_CONFIG_FILE_NAMES) {
+      await this.checkIfConfigFileExists(fileName);
+    }
+  }
+
+  private async checkIfConfigFileExists(file: string) {
+    if (await fileUtils.exists(file)) {
+      const msg = `Stryker config file "${file}" already exists in the current directory. Please remove it and try again.`;
+      this.log.error(msg);
+      throw new Error(msg);
+    }
+  }
+
+  /**
+   * Create config based on the chosen framework and test runner
+   * @function
+   */
+  public write(
+    selectedTestRunner: PromptOption,
+    buildCommand: PromptOption,
+    selectedReporters: PromptOption[],
+    selectedPackageManager: PromptOption,
+    requiredPlugins: string[],
+    additionalPiecesOfConfig: Array<Partial<StrykerOptions>>,
+    homepageOfSelectedTestRunner: string,
+    exportAsJson: boolean,
+  ): Promise<string> {
+    const configObject: Partial<StrykerOptions> & { _comment: string } = {
+      _comment:
+        "This config was generated using 'stryker init'. Please take a look at: https://stryker-mutator.io/docs/stryker-js/configuration/ for more information.",
+      packageManager: selectedPackageManager.name as 'npm' | 'pnpm' | 'yarn',
+      reporters: selectedReporters.map((rep) => rep.name),
+      testRunner: selectedTestRunner.name,
+      testRunner_comment: `Take a look at ${homepageOfSelectedTestRunner} for information about the ${selectedTestRunner.name} plugin.`,
+      coverageAnalysis: CommandTestRunner.is(selectedTestRunner.name)
+        ? 'off'
+        : 'perTest',
+    };
+
+    // Only write buildCommand to config file if non-empty
+    if (buildCommand.name) {
+      configObject.buildCommand = buildCommand.name;
+    }
+
+    // Automatic plugin discovery doesn't work with pnpm, so explicitly specify the required plugins in the config file
+    if (selectedPackageManager.name === 'pnpm') {
+      configObject.plugins = requiredPlugins;
+    }
+
+    Object.assign(configObject, ...additionalPiecesOfConfig);
+    return this.writeStrykerConfig(
+      configObject as Immutable<PartialStrykerOptions>,
+      exportAsJson,
+    );
+  }
+
+  /**
+   * Create config based on the chosen preset
+   * @function
+   */
+  public async writeCustomInitializer(
+    initializerConfig: CustomInitializerConfiguration,
+    exportAsJson: boolean,
+  ): Promise<string> {
+    const config = {
+      _comment: `This config was generated using 'stryker init'. Please see the guide for more information: ${initializerConfig.guideUrl}`,
+      ...initializerConfig.config,
+    };
+
+    return this.writeStrykerConfig(config, exportAsJson);
+  }
+
+  private writeStrykerConfig(
+    config: Immutable<PartialStrykerOptions>,
+    exportAsJson: boolean,
+  ) {
+    if (exportAsJson) {
+      return this.writeJsonConfig(config);
+    } else {
+      return this.writeJsConfig(config);
+    }
+  }
+
+  private async writeJsConfig(
+    commentedConfig: Immutable<PartialStrykerOptions>,
+  ) {
+    const configFileName = DEFAULT_CONFIG_FILE_NAMES.JAVASCRIPT;
+    this.out(`Writing & formatting ${configFileName} ...`);
+    const rawConfig = this.stringify(commentedConfig);
+
+    const formattedConfig = `// @ts-check
+    /** @type {import('@stryker-mutator/api/core').PartialStrykerOptions} */
+      const config = ${rawConfig};
+      export default config;`;
+    await fs.writeFile(configFileName, formattedConfig);
+    try {
+      await childProcessAsPromised.exec(
+        `npx prettier --write ${configFileName}`,
+      );
+    } catch (error) {
+      this.log.debug('Prettier exited with error', error);
+      this.out(
+        `Unable to format ${configFileName} file for you. This is not a big problem, but it might look a bit messy 🙈.`,
+      );
+    }
+    return configFileName;
+  }
+
+  private async writeJsonConfig(
+    commentedConfig: Immutable<PartialStrykerOptions>,
+  ) {
+    const configFileName = DEFAULT_CONFIG_FILE_NAMES.JSON;
+    this.out(`Writing & formatting ${configFileName}...`);
+    const typedConfig = {
+      $schema:
+        './node_modules/@stryker-mutator/core/schema/stryker-schema.json',
+      ...commentedConfig,
+    };
+    const formattedConfig = this.stringify(typedConfig);
+    await fs.writeFile(configFileName, formattedConfig);
+
+    return configFileName;
+  }
+
+  private stringify(input: Record<string, unknown>): string {
+    return JSON.stringify(input, undefined, 2);
+  }
+}