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

package/src/concurrent/pool.ts

@@ -0,0 +1,209 @@
+import { TestRunner } from '@stryker-mutator/api/test-runner';
+import { notEmpty } from '@stryker-mutator/util';
+import {
+  BehaviorSubject,
+  filter,
+  ignoreElements,
+  lastValueFrom,
+  mergeMap,
+  Observable,
+  ReplaySubject,
+  Subject,
+  takeUntil,
+  tap,
+  zip,
+} from 'rxjs';
+import { Disposable, tokens } from 'typed-inject';
+
+import { CheckerFacade } from '../checker/index.js';
+import { coreTokens } from '../di/index.js';
+
+const MAX_CONCURRENT_INIT = 2;
+
+/**
+ * Represents a TestRunner that is also a Resource (with an init and dispose)
+ */
+export type TestRunnerResource = Resource & TestRunner;
+
+export interface Resource extends Partial<Disposable> {
+  init?(): Promise<void>;
+}
+
+createTestRunnerPool.inject = tokens(
+  coreTokens.testRunnerFactory,
+  coreTokens.testRunnerConcurrencyTokens,
+);
+export function createTestRunnerPool(
+  factory: () => TestRunnerResource,
+  concurrencyToken$: Observable<number>,
+): Pool<TestRunner> {
+  return new Pool(factory, concurrencyToken$);
+}
+
+createCheckerPool.inject = tokens(
+  coreTokens.checkerFactory,
+  coreTokens.checkerConcurrencyTokens,
+);
+export function createCheckerPool(
+  factory: () => CheckerFacade,
+  concurrencyToken$: Observable<number>,
+): Pool<CheckerFacade> {
+  return new Pool<CheckerFacade>(factory, concurrencyToken$);
+}
+
+/**
+ * Represents a work item: an input with a task and with a `result$` observable where the result (exactly one) will be streamed to.
+ */
+class WorkItem<TResource extends Resource, TIn, TOut> {
+  private readonly resultSubject = new Subject<TOut>();
+  public readonly result$ = this.resultSubject.asObservable();
+
+  /**
+   * @param input The input to the ask
+   * @param task The task, where a resource and input is presented
+   */
+  constructor(
+    private readonly input: TIn,
+    private readonly task: (
+      resource: TResource,
+      input: TIn,
+    ) => Promise<TOut> | TOut,
+  ) {}
+
+  public async execute(resource: TResource) {
+    try {
+      const output = await this.task(resource, this.input);
+      this.resultSubject.next(output);
+      this.resultSubject.complete();
+    } catch (err) {
+      this.resultSubject.error(err);
+    }
+  }
+
+  public reject(error: unknown) {
+    this.resultSubject.error(error);
+  }
+
+  public complete() {
+    this.resultSubject.complete();
+  }
+}
+
+/**
+ * Represents a pool of resources. Use `schedule` to schedule work to be executed on the resources.
+ * The pool will automatically recycle the resources, but will make sure only one task is executed
+ * on one resource at any one time. Creates as many resources as the concurrency tokens allow.
+ * Also takes care of the initialing of the resources (with `init()`)
+ */
+export class Pool<TResource extends Resource> implements Disposable {
+  // The init subject. Using an RxJS subject instead of a promise, so errors are silently ignored when nobody is listening
+  private readonly initSubject = new ReplaySubject<void>();
+
+  // The disposedSubject emits true when it is disposed, and false when not disposed yet
+  private readonly disposedSubject = new BehaviorSubject(false);
+
+  // The dispose$ only emits one `true` value when disposed (never emits `false`). Useful for `takeUntil`
+  private readonly dispose$ = this.disposedSubject.pipe(
+    filter((isDisposed) => isDisposed),
+  );
+
+  private readonly createdResources: TResource[] = [];
+  // The queued work items. This is a replay subject, so scheduled work items can easily be rejected after it was picked up
+  private readonly todoSubject = new ReplaySubject<
+    WorkItem<TResource, any, any>
+  >();
+
+  constructor(factory: () => TResource, concurrencyToken$: Observable<number>) {
+    // Stream resources that are ready to pick up work
+    const resourcesSubject = new Subject<TResource>();
+
+    // Stream ongoing work.
+    zip(resourcesSubject, this.todoSubject)
+      .pipe(
+        mergeMap(async ([resource, workItem]) => {
+          await workItem.execute(resource);
+          resourcesSubject.next(resource); // recycle resource so it can pick up more work
+        }),
+        ignoreElements(),
+        takeUntil(this.dispose$),
+      )
+      .subscribe({
+        error: (error) => {
+          this.todoSubject.subscribe((workItem) => workItem.reject(error));
+        },
+      });
+
+    // Create resources
+    concurrencyToken$
+      .pipe(
+        takeUntil(this.dispose$),
+        mergeMap(async () => {
+          if (this.disposedSubject.value) {
+            // Don't create new resources when disposed
+            return;
+          }
+          const resource = factory();
+          this.createdResources.push(resource);
+          await resource.init?.();
+          return resource;
+        }, MAX_CONCURRENT_INIT),
+        filter(notEmpty),
+        tap({
+          complete: () => {
+            // Signal init complete
+            this.initSubject.next();
+            this.initSubject.complete();
+          },
+          error: (err) => {
+            this.initSubject.error(err);
+          },
+        }),
+      )
+      .subscribe({
+        next: (resource) => resourcesSubject.next(resource),
+        error: (err) => resourcesSubject.error(err),
+      });
+  }
+
+  /**
+   * Returns a promise that resolves if all concurrency tokens have resulted in initialized resources.
+   * This is optional, resources will get initialized either way.
+   */
+  public async init(): Promise<void> {
+    await lastValueFrom(this.initSubject);
+  }
+
+  /**
+   * Schedules a task to be executed on resources in the pool. Each input is paired with a resource, which allows async work to be done.
+   * @param input$ The inputs to pair up with a resource.
+   * @param task The task to execute on each resource
+   */
+  public schedule<TIn, TOut>(
+    input$: Observable<TIn>,
+    task: (resource: TResource, input: TIn) => Promise<TOut> | TOut,
+  ): Observable<TOut> {
+    return input$.pipe(
+      mergeMap((input) => {
+        const workItem = new WorkItem(input, task);
+        this.todoSubject.next(workItem);
+        return workItem.result$;
+      }),
+    );
+  }
+
+  /**
+   * Dispose the pool
+   */
+  public async dispose(): Promise<void> {
+    if (!this.disposedSubject.value) {
+      this.disposedSubject.next(true);
+      this.todoSubject.subscribe((workItem) => workItem.complete());
+      this.todoSubject.complete();
+      await Promise.all(
+        // We're mixing promises with undefined values, which triggers the lint warning. We can safely ignore it here.
+        // eslint-disable-next-line @typescript-eslint/await-thenable
+        this.createdResources.map((resource) => resource.dispose?.()),
+      );
+    }
+  }
+}

package/src/concurrent/resource-decorator.ts

@@ -0,0 +1,28 @@
+import { Resource } from './pool.js';
+
+export abstract class ResourceDecorator<
+  T extends Resource,
+> implements Resource {
+  protected innerResource: T;
+
+  constructor(private readonly producer: () => T) {
+    this.innerResource = producer();
+  }
+
+  public async init(): Promise<void> {
+    await this.innerResource.init?.();
+  }
+
+  public async dispose(): Promise<void> {
+    await this.innerResource.dispose?.();
+  }
+  /**
+   * Disposes the current test runner and creates a new one
+   * To be used in decorators that need recreation.
+   */
+  protected async recover(): Promise<void> {
+    await this.dispose();
+    this.innerResource = this.producer();
+    return this.init();
+  }
+}

package/src/config/config-file-formats.ts

@@ -0,0 +1,31 @@
+const combine = (
+  prefixes: string[],
+  suffixes: string[],
+  extensions: string[],
+): string[] => {
+  const fileNames: string[] = [];
+  for (const prefix of prefixes) {
+    for (const suffix of suffixes) {
+      for (const extension of extensions) {
+        fileNames.push(`${prefix}stryker${suffix}.${extension}`);
+      }
+    }
+  }
+  return fileNames;
+};
+
+export const SUPPORTED_CONFIG_FILE_NAMES = Object.freeze(
+  combine(
+    // Prefixes.
+    ['', '.'],
+    // Suffixes.
+    ['.conf', '.config'],
+    // Extensions.
+    ['json', 'js', 'mjs', 'cjs'],
+  ),
+);
+
+export const DEFAULT_CONFIG_FILE_NAMES = Object.freeze({
+  JSON: 'stryker.config.json',
+  JAVASCRIPT: 'stryker.config.mjs',
+} as const);

package/src/config/config-reader.ts

@@ -0,0 +1,193 @@
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+
+import {
+  PartialStrykerOptions,
+  StrykerOptions,
+} from '@stryker-mutator/api/core';
+import { Logger } from '@stryker-mutator/api/logging';
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import { deepMerge, I } from '@stryker-mutator/util';
+
+import { coreTokens } from '../di/index.js';
+import { ConfigError } from '../errors.js';
+import { fileUtils } from '../utils/file-utils.js';
+
+import { OptionsValidator } from './options-validator.js';
+import { SUPPORTED_CONFIG_FILE_NAMES } from './config-file-formats.js';
+
+export const CONFIG_SYNTAX_HELP = `
+Example of how a config file should look:
+/**
+  * @type {import('@stryker-mutator/api/core').StrykerOptions}
+  */
+export default {
+  // You're options here!
+}
+
+Or using commonjs:
+/**
+  * @type {import('@stryker-mutator/api/core').StrykerOptions}
+  */
+module.exports = {
+  // You're options here!
+}
+
+See https://stryker-mutator.io/docs/stryker-js/config-file for more information.`.trim();
+
+export class ConfigReader {
+  public static inject = tokens(
+    commonTokens.logger,
+    coreTokens.optionsValidator,
+  );
+  constructor(
+    private readonly log: Logger,
+    private readonly validator: I<OptionsValidator>,
+  ) {}
+
+  public async readConfig(
+    cliOptions: PartialStrykerOptions,
+  ): Promise<StrykerOptions> {
+    const options = await this.loadOptionsFromConfigFile(cliOptions);
+
+    // merge the config from config file and cliOptions (precedence)
+    deepMerge(options, cliOptions);
+    this.validator.validate(options);
+    if (this.log.isDebugEnabled()) {
+      this.log.debug(`Loaded config: ${JSON.stringify(options, null, 2)}`);
+    }
+    return options;
+  }
+
+  private async loadOptionsFromConfigFile(
+    cliOptions: PartialStrykerOptions,
+  ): Promise<PartialStrykerOptions> {
+    const configFile = await this.findConfigFile(cliOptions.configFile);
+    if (!configFile) {
+      this.log.info(
+        'No config file specified. Running with command line arguments.',
+      );
+      this.log.info('Use `stryker init` command to generate your config file.');
+      return {};
+    }
+    this.log.debug(`Loading config from ${configFile}`);
+
+    if (path.extname(configFile).toLocaleLowerCase() === '.json') {
+      return this.readJsonConfig(configFile);
+    } else {
+      return this.importJSConfig(configFile);
+    }
+  }
+
+  private async findConfigFile(
+    configFileName: unknown,
+  ): Promise<string | undefined> {
+    if (typeof configFileName === 'string') {
+      if (await fileUtils.exists(configFileName)) {
+        return configFileName;
+      } else {
+        throw new ConfigReaderError('File does not exist!', configFileName);
+      }
+    }
+    for (const fileName of SUPPORTED_CONFIG_FILE_NAMES) {
+      if (await fileUtils.exists(fileName)) {
+        return fileName;
+      }
+    }
+    return undefined;
+  }
+
+  private async readJsonConfig(
+    configFile: string,
+  ): Promise<PartialStrykerOptions> {
+    const fileContent = await fs.promises.readFile(configFile, 'utf-8');
+    try {
+      return JSON.parse(fileContent);
+    } catch (err) {
+      throw new ConfigReaderError(
+        'File contains invalid JSON',
+        configFile,
+        err,
+      );
+    }
+  }
+
+  private async importJSConfig(
+    configFile: string,
+  ): Promise<PartialStrykerOptions> {
+    const importedModule = await this.importJSConfigModule(configFile);
+
+    if (this.hasDefaultExport(importedModule)) {
+      const maybeOptions = importedModule.default;
+      if (typeof maybeOptions !== 'object') {
+        if (typeof maybeOptions === 'function') {
+          this.log.fatal(
+            `Invalid config file. Exporting a function is no longer supported. Please export an object with your configuration instead, or use a "stryker.conf.json" file.\n${CONFIG_SYNTAX_HELP}`,
+          );
+        } else {
+          this.log.fatal(
+            `Invalid config file. It must export an object, found a "${typeof maybeOptions}"!\n${CONFIG_SYNTAX_HELP}`,
+          );
+        }
+        throw new ConfigReaderError(
+          'Default export of config file must be an object!',
+          configFile,
+        );
+      }
+      if (!maybeOptions || !Object.keys(maybeOptions).length) {
+        this.log.warn(
+          `Stryker options were empty. Did you forget to export options from ${configFile}?`,
+        );
+      }
+
+      return { ...maybeOptions } as PartialStrykerOptions;
+    } else {
+      this.log.fatal(
+        `Invalid config file. It is missing a default export. ${describeNamedExports()}\n${CONFIG_SYNTAX_HELP}`,
+      );
+      throw new ConfigReaderError(
+        'Config file must have a default export!',
+        configFile,
+      );
+
+      function describeNamedExports() {
+        const namedExports: string[] =
+          (typeof importedModule === 'object' &&
+            Object.keys(importedModule ?? {})) ||
+          [];
+        if (namedExports.length === 0) {
+          return "In fact, it didn't export anything.";
+        } else {
+          return `Found named export(s): ${new Intl.ListFormat('en').format(namedExports.map((name) => `"${name}"`))}.`;
+        }
+      }
+    }
+  }
+
+  private async importJSConfigModule(configFile: string): Promise<unknown> {
+    try {
+      return await fileUtils.importModule(
+        pathToFileURL(path.resolve(configFile)).toString(),
+      );
+    } catch (err) {
+      throw new ConfigReaderError('Error during import', configFile, err);
+    }
+  }
+
+  private hasDefaultExport(
+    importedModule: unknown,
+  ): importedModule is { default: unknown } {
+    return importedModule &&
+      typeof importedModule === 'object' &&
+      'default' in importedModule
+      ? true
+      : false;
+  }
+}
+
+export class ConfigReaderError extends ConfigError {
+  constructor(message: string, configFileName: string, cause?: unknown) {
+    super(`Invalid config file "${configFileName}". ${message}`, cause);
+  }
+}

package/src/config/file-matcher.ts

@@ -0,0 +1,36 @@
+import path from 'path';
+
+import { minimatch } from 'minimatch';
+import { normalizeFileName } from '@stryker-mutator/util';
+
+/**
+ * A helper class for matching files using the `disableTypeChecks` setting.
+ */
+export class FileMatcher {
+  private readonly pattern: boolean | string;
+
+  constructor(
+    pattern: boolean | string,
+    private readonly allowHiddenFiles = true,
+  ) {
+    if (typeof pattern === 'string') {
+      this.pattern = normalizeFileName(path.resolve(pattern));
+    } else if (pattern) {
+      this.pattern = '**/*.{js,ts,jsx,tsx,html,vue,mjs,mts,cts,cjs}';
+    } else {
+      this.pattern = pattern;
+    }
+  }
+
+  public matches(fileName: string): boolean {
+    if (typeof this.pattern === 'string') {
+      return minimatch(
+        normalizeFileName(path.resolve(fileName)),
+        this.pattern,
+        { dot: this.allowHiddenFiles },
+      );
+    } else {
+      return this.pattern;
+    }
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,5 @@
+export * from './options-validator.js';
+export * from './file-matcher.js';
+export * from './meta-schema-builder.js';
+export * from './config-reader.js';
+export * from './config-file-formats.js';

package/src/config/meta-schema-builder.ts

@@ -0,0 +1,50 @@
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin';
+import type { JSONSchema7 } from 'json-schema';
+import { Logger } from '@stryker-mutator/api/logging';
+
+import { coreTokens } from '../di/index.js';
+
+export class MetaSchemaBuilder {
+  public static inject = tokens(
+    coreTokens.validationSchema,
+    commonTokens.logger,
+  );
+  constructor(
+    private readonly schema: JSONSchema7,
+    private readonly log: Logger,
+  ) {}
+
+  public buildMetaSchema(
+    pluginSchemaContributions: Array<Record<string, unknown>>,
+  ): JSONSchema7 {
+    this.log.debug(
+      'Contributing %s schemas from plugins to options validation.',
+      pluginSchemaContributions.length,
+    );
+    return mergedSchema(this.schema, pluginSchemaContributions);
+  }
+}
+function mergedSchema(
+  mainSchema: JSONSchema7,
+  additionalSchemas: JSONSchema7[],
+): JSONSchema7 {
+  const schema = {
+    ...mainSchema,
+    properties: {
+      ...mainSchema.properties,
+    },
+    definitions: {
+      ...mainSchema.definitions,
+    },
+  };
+
+  Object.assign(
+    schema.properties,
+    ...additionalSchemas.map((s) => s.properties),
+  );
+  Object.assign(
+    schema.definitions,
+    ...additionalSchemas.map((s) => s.definitions),
+  );
+  return schema;
+}