@systemfsoftware/stryker-js-typescript-checker 1.2.3 → 1.4.0

package/src/grouping/create-groups.ts

@@ -1,77 +0,0 @@
-import type { Mutant } from '@stryker-mutator/api/core'
-
-import { toPosixFileName } from '../tsconfig-helpers.js'
-
-import { TSFileNode } from './ts-file-node.js'
-
-/**
- * To speed up the type-checking we want to check multiple mutants at once.
- * When multiple mutants in different files don't have overlap in affected files (or have small overlap), we can type-check them simultaneously.
- * These mutants who can be tested at the same time are called a group.
- * Therefore, the return type is an array of arrays, in other words: an array of groups.
- *
- * @param mutants All the mutants of the test project.
- * @param nodes A graph representation of the test project.
- */
-export function createGroups(
-  mutants: Mutant[],
-  nodes: Map<string, TSFileNode>,
-): string[][] {
-  const groups: string[][] = []
-  const mutantsToGroup = new Set(mutants)
-
-  while (mutantsToGroup.size) {
-    const group: string[] = []
-    const groupNodes = new Set<TSFileNode>()
-    const nodesToIgnore = new Set<TSFileNode>()
-
-    for (const currentMutant of mutantsToGroup) {
-      const currentNode = findNode(currentMutant.fileName, nodes)
-      if (
-        !nodesToIgnore.has(currentNode) &&
-        !parentsHaveOverlapWith(currentNode, groupNodes)
-      ) {
-        group.push(currentMutant.id)
-        groupNodes.add(currentNode)
-        mutantsToGroup.delete(currentMutant)
-        addRangeOfNodesToSet(
-          nodesToIgnore,
-          currentNode.getAllParentReferencesIncludingSelf(),
-        )
-      }
-    }
-    groups.push(group)
-  }
-
-  return groups
-}
-
-function addRangeOfNodesToSet(
-  nodes: Set<TSFileNode>,
-  nodesToAdd: Iterable<TSFileNode>,
-) {
-  for (const parent of nodesToAdd) {
-    nodes.add(parent)
-  }
-}
-
-function findNode(fileName: string, nodes: Map<string, TSFileNode>) {
-  const node = nodes.get(toPosixFileName(fileName))
-  if (node == null) {
-    throw new Error(`Node not in graph: ${fileName}`)
-  }
-  return node
-}
-
-function parentsHaveOverlapWith(
-  currentNode: TSFileNode,
-  groupNodes: Set<TSFileNode>,
-) {
-  for (const parentNode of currentNode.getAllParentReferencesIncludingSelf()) {
-    if (groupNodes.has(parentNode)) {
-      return true
-    }
-  }
-
-  return false
-}

package/src/grouping/ts-file-node.ts

@@ -1,54 +0,0 @@
-import type { Mutant } from '@stryker-mutator/api/core'
-
-import { toPosixFileName } from '../tsconfig-helpers.js'
-
-// This class exists so we can have a two-way dependency graph.
-// The two-way dependency graph is used to search for mutants related to typescript errors.
-export class TSFileNode {
-  constructor(
-    public fileName: string,
-    public parents: TSFileNode[],
-    public children: TSFileNode[],
-  ) {}
-
-  public getAllParentReferencesIncludingSelf(
-    allParentReferences: Set<TSFileNode> = new Set<TSFileNode>(),
-  ): Set<TSFileNode> {
-    allParentReferences.add(this)
-    this.parents.forEach((parent) => {
-      if (!allParentReferences.has(parent)) {
-        parent.getAllParentReferencesIncludingSelf(allParentReferences)
-      }
-    })
-    return allParentReferences
-  }
-
-  public getAllChildReferencesIncludingSelf(
-    allChildReferences: Set<TSFileNode> = new Set<TSFileNode>(),
-  ): Set<TSFileNode> {
-    allChildReferences.add(this)
-    this.children.forEach((child) => {
-      if (!allChildReferences.has(child)) {
-        child.getAllChildReferencesIncludingSelf(allChildReferences)
-      }
-    })
-    return allChildReferences
-  }
-
-  public getMutantsWithReferenceToChildrenOrSelf(
-    mutants: Mutant[],
-    nodesChecked: string[] = [],
-  ): Mutant[] {
-    if (nodesChecked.includes(this.fileName)) {
-      return []
-    }
-
-    nodesChecked.push(this.fileName)
-
-    const relatedMutants = mutants.filter(
-      (m) => toPosixFileName(m.fileName) === this.fileName,
-    )
-    const childResult = this.children.flatMap((c) => c.getMutantsWithReferenceToChildrenOrSelf(mutants, nodesChecked))
-    return [...relatedMutants, ...childResult]
-  }
-}

package/src/index.ts

@@ -1,18 +0,0 @@
-import { readFileSync } from 'fs'
-
-import { declareFactoryPlugin, PluginKind } from '@stryker-mutator/api/plugin'
-
-import { create } from './typescript-checker.js'
-
-export const strykerPlugins = [
-  declareFactoryPlugin(PluginKind.Checker, 'typescript', create),
-]
-
-export const createTypescriptChecker = create
-
-export const strykerValidationSchema: Record<string, unknown> = JSON.parse(
-  readFileSync(
-    new URL('../schema/typescript-checker-options.json', import.meta.url),
-    'utf-8',
-  ),
-)

package/src/plugin-tokens.ts

@@ -1,2 +0,0 @@
-export const fs = 'fs'
-export const tsCompiler = 'tsCompiler'

package/src/tsconfig-helpers.ts

@@ -1,187 +0,0 @@
-import { readFileSync } from 'fs'
-import { createRequire } from 'module'
-import path from 'path'
-
-import { parse } from '@std/jsonc'
-import { Data, Either, Schema as S } from 'effect'
-import semver from 'semver'
-
-// Override some compiler options that have to do with code quality. When mutating, we're not interested in the resulting code quality
-// See https://github.com/stryker-mutator/stryker-js/issues/391 for more info
-const COMPILER_OPTIONS_OVERRIDES: Readonly<Record<string, unknown>> = Object.freeze({
-  allowUnreachableCode: true,
-  noUnusedLocals: false,
-  noUnusedParameters: false,
-})
-
-// When we're running in 'single-project' mode, we can safely disable emit
-const NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT: Readonly<Record<string, unknown>> = Object.freeze({
-  noEmit: true,
-  incremental: false, // incremental and composite off: https://github.com/microsoft/TypeScript/issues/36917
-  tsBuildInfoFile: undefined,
-  composite: false,
-})
-
-// When we're running in 'project references' mode, we need to enable declaration output
-const LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES: Readonly<Record<string, unknown>> = Object.freeze({
-  emitDeclarationOnly: true,
-  noEmit: false,
-  declarationMap: true,
-  declaration: true,
-})
-
-let cachedTSVersion: string | undefined
-
-export function getTSVersion(): string {
-  if (cachedTSVersion === undefined) {
-    const require = createRequire(import.meta.url)
-    const pkg = JSON.parse(
-      readFileSync(require.resolve('typescript/package.json'), 'utf-8'),
-    ) as { version: string }
-    cachedTSVersion = pkg.version
-  }
-  return cachedTSVersion
-}
-
-export function guardTSVersion(version = getTSVersion()): void {
-  if (!semver.satisfies(version, '>=7.0.0', { includePrerelease: true })) {
-    throw new Error(
-      `@systemfsoftware/stryker-js-typescript-checker only supports typescript@7.0.0 or higher. Found typescript@${version}`,
-    )
-  }
-}
-
-/**
- * Error returned when a tsconfig file fails to parse or does not match the shape this package consumes.
- */
-export class TsConfigParseError extends Data.TaggedError('TsConfigParseError')<{
-  readonly file: string
-  readonly reason: string
-}> {}
-
-const JsonRecord = S.Record({ key: S.String, value: S.Unknown })
-const TsConfigSchema = S.Struct(
-  {
-    references: S.optional(S.Array(S.Struct({ path: S.String }, JsonRecord))),
-    compilerOptions: S.optional(JsonRecord),
-  },
-  JsonRecord,
-)
-type TsConfig = S.Schema.Type<typeof TsConfigSchema>
-
-/**
- * Parses the raw text of a tsconfig file into a typed config, rejecting shapes this package cannot consume.
- * @param fileName The tsconfig file name, used for error reporting
- * @param jsonText The raw tsconfig content
- */
-export function parseTsConfig(fileName: string, jsonText: string): Either.Either<TsConfig, TsConfigParseError> {
-  // `@std/jsonc`'s whitespace set excludes U+FEFF, so it rejects a leading BOM, while `tsc` tolerates one.
-  try {
-    const value = parse(jsonText.replace(/^\uFEFF/, ''))
-    // Rebuilds the object, reordering keys (declared fields hoist). Safe here: this
-    // package only reads the config, and `overrideOptions` builds a fresh object anyway.
-    // The core sibling (`packages/stryker-js/core/src/sandbox/parse-config-helper.ts`)
-    // deliberately uses an `S.is` guard instead — it mutates the parsed config and writes
-    // it back with `JSON.stringify`, so a rebuild there would reorder the user's tsconfig
-    // on disk. Independent boundaries by KTD-2; this note keeps the divergence deliberate.
-    return Either.mapLeft(
-      S.decodeUnknownEither(TsConfigSchema)(value),
-      (issue) => new TsConfigParseError({ file: fileName, reason: issue.message }),
-    )
-  } catch (error) {
-    return Either.left(
-      new TsConfigParseError({
-        file: fileName,
-        reason: error instanceof Error ? error.message : String(error),
-      }),
-    )
-  }
-}
-
-/**
- * Determines whether or not to use `--build` mode based on "references" being there in the config file
- * @param tsconfigFileName The tsconfig file to parse
- */
-export function determineBuildModeEnabled(tsconfigFileName: string): boolean {
-  const tsconfigFile = readFileSync(tsconfigFileName, 'utf-8')
-  const parsed = parseTsConfig(tsconfigFileName, tsconfigFile)
-  return Either.match(parsed, {
-    onLeft: () => false,
-    onRight: (config) => config.references !== undefined,
-  })
-}
-
-/**
- * Overrides some options to speed up compilation and disable some code quality checks we don't want during mutation testing
- * @param config The parsed config file
- * @param useBuildMode whether or not `--build` mode is used
- */
-export function overrideOptions(config: TsConfig, useBuildMode: boolean): string {
-  // `target` and `moduleResolution` are deliberately absent: both belong to the consumer.
-  // Forcing `moduleResolution` contradicts `module: NodeNext`/`Node16` (TS5095 + TS5109),
-  // and forcing `target` hides lib features the consumer's own target allows (TS2550).
-  const compilerOptions: Record<string, unknown> = {
-    ...config.compilerOptions,
-    ...COMPILER_OPTIONS_OVERRIDES,
-    ...(useBuildMode ? LOW_EMIT_OPTIONS_FOR_PROJECT_REFERENCES : NO_EMIT_OPTIONS_FOR_SINGLE_PROJECT),
-  }
-
-  if (
-    !useBuildMode &&
-    compilerOptions['declarationDir'] !== undefined &&
-    compilerOptions['declarationDir'] !== null
-  ) {
-    // because composite and/or declaration was disabled in non-build mode, we have to disable declarationDir as well
-    // otherwise, error TS5069: Option 'declarationDir' cannot be specified without specifying option 'declaration' or option 'composite'.
-    delete compilerOptions['declarationDir']
-  }
-
-  if (useBuildMode) {
-    // Remove the options to place declarations files in different locations to decrease the complexity of searching the source file in the TypescriptCompiler class.
-    delete compilerOptions['inlineSourceMap']
-    delete compilerOptions['inlineSources']
-    delete compilerOptions['mapRoute']
-    delete compilerOptions['sourceRoot']
-    delete compilerOptions['outFile']
-  }
-
-  return JSON.stringify({
-    ...config,
-    compilerOptions,
-  })
-}
-
-/**
- * Retrieves the referenced config files based on parsed configuration
- * @param config The parsed config file
- * @param fromDirName The directory where to resolve from
- */
-export function retrieveReferencedProjects(config: TsConfig, fromDirName: string): string[] {
-  return (config.references ?? []).map((reference) => {
-    let resolved = path.resolve(fromDirName, reference.path)
-    if (!path.basename(resolved).endsWith('.json')) {
-      resolved = path.join(resolved, 'tsconfig.json')
-    }
-    return toPosixFileName(resolved)
-  })
-}
-
-/**
- * Replaces backslashes with forward slashes (used by typescript)
- * @param fileName The file name that may contain backslashes `\`
- * @returns posix and ts complaint file name (with `/`)
- */
-export function toPosixFileName(fileName: string): string {
-  return fileName.replace(/\\/g, '/')
-}
-
-/**
- * Find source file in declaration file
- * @param content The content of the declaration file
- * @returns URL of the source file or undefined if not found
- */
-const findSourceMapRegex = /\/\/# sourceMappingURL=(.+)$/m
-export function getSourceMappingURL(content: string): string | undefined {
-  findSourceMapRegex.lastIndex = 0
-  return findSourceMapRegex.exec(content)?.[1]
-}

package/src/typescript-checker-options-with-stryker-options.ts

@@ -1,9 +0,0 @@
-import type { StrykerOptions } from '@stryker-mutator/api/core'
-
-export interface TypescriptCheckerPluginOptions {
-  typescriptChecker: {
-    prioritizePerformanceOverAccuracy?: boolean
-  }
-}
-
-export interface TypescriptCheckerOptionsWithStrykerOptions extends TypescriptCheckerPluginOptions, StrykerOptions {}

package/src/typescript-checker.ts

@@ -1,223 +0,0 @@
-import { EOL } from 'os'
-
-import type { Checker, CheckResult } from '@stryker-mutator/api/check'
-import { CheckStatus } from '@stryker-mutator/api/check'
-import type { Mutant, StrykerOptions } from '@stryker-mutator/api/core'
-import type { Logger, LoggerFactoryMethod } from '@stryker-mutator/api/logging'
-import { commonTokens, Scope, tokens } from '@stryker-mutator/api/plugin'
-import type { Injector, PluginContext } from '@stryker-mutator/api/plugin'
-import { split, strykerReportBugUrl } from '@stryker-mutator/util'
-import { DiagnosticCategory } from 'typescript/unstable/sync'
-import type { Diagnostic } from 'typescript/unstable/sync'
-
-import { HybridFileSystem } from './fs/hybrid-file-system.js'
-import { createGroups } from './grouping/create-groups.js'
-import { TSFileNode } from './grouping/ts-file-node.js'
-import * as pluginTokens from './plugin-tokens.js'
-import { toPosixFileName } from './tsconfig-helpers.js'
-import type { TypescriptCheckerOptionsWithStrykerOptions } from './typescript-checker-options-with-stryker-options.js'
-import { TypescriptCompiler } from './typescript-compiler.js'
-
-const typescriptCheckerLoggerFactory = Object.assign(
-  (
-    loggerFactory: LoggerFactoryMethod,
-    target: Function | undefined,
-  ): Logger => {
-    const targetName = target?.name ?? TypescriptChecker.name
-    const category = targetName === TypescriptChecker.name
-      ? TypescriptChecker.name
-      : `${TypescriptChecker.name}.${targetName}`
-    return loggerFactory(category)
-  },
-  {
-    inject: tokens(commonTokens.getLogger, commonTokens.target),
-  },
-)
-
-export const create = Object.assign(
-  (injector: Injector<PluginContext>): TypescriptChecker =>
-    injector
-      .provideFactory(
-        commonTokens.logger,
-        typescriptCheckerLoggerFactory,
-        Scope.Transient,
-      )
-      .provideClass(pluginTokens.fs, HybridFileSystem)
-      .provideClass(pluginTokens.tsCompiler, TypescriptCompiler)
-      .injectClass(TypescriptChecker),
-  {
-    inject: tokens(commonTokens.injector),
-  },
-)
-
-export class TypescriptChecker implements Checker {
-  public static inject = tokens(
-    commonTokens.logger,
-    commonTokens.options,
-    pluginTokens.tsCompiler,
-  )
-
-  private readonly options: TypescriptCheckerOptionsWithStrykerOptions
-
-  constructor(
-    private readonly logger: Logger,
-    options: StrykerOptions,
-    private readonly tsCompiler: TypescriptCompiler,
-  ) {
-    this.options = options as TypescriptCheckerOptionsWithStrykerOptions
-  }
-
-  public async init(): Promise<void> {
-    const errors = await this.tsCompiler.init()
-
-    if (errors.length) {
-      throw new Error(
-        `Typescript error(s) found in dry run compilation: ${this.createErrorText(errors)}`,
-      )
-    }
-  }
-
-  public async check(mutants: Mutant[]): Promise<Record<string, CheckResult>> {
-    const result: Record<string, CheckResult> = Object.fromEntries(
-      mutants.map((mutant) => [mutant.id, { status: CheckStatus.Passed }]),
-    )
-
-    // Check if this is the group with unrelated files and return check status passed if so
-    if (!this.tsCompiler.nodes.get(toPosixFileName(mutants[0]!.fileName))) {
-      return result
-    }
-
-    const mutantErrorRelationMap = await this.checkErrors(
-      mutants,
-      {},
-      this.tsCompiler.nodes,
-    )
-    for (const [id, errors] of Object.entries(mutantErrorRelationMap)) {
-      result[id] = {
-        status: CheckStatus.CompileError,
-        reason: this.createErrorText(errors),
-      }
-    }
-
-    return result
-  }
-
-  public group(mutants: Mutant[]): Promise<string[][]> {
-    if (!this.options.typescriptChecker?.prioritizePerformanceOverAccuracy) {
-      return Promise.resolve(mutants.map((m) => [m.id]))
-    }
-    const { nodes } = this.tsCompiler
-    const [mutantsOutsideProject, mutantsInProject] = split(
-      mutants,
-      (m) => nodes.get(toPosixFileName(m.fileName)) == null,
-    )
-
-    const groups = createGroups(mutantsInProject, nodes)
-    if (mutantsOutsideProject.length) {
-      return Promise.resolve([
-        mutantsOutsideProject.map((m) => m.id),
-        ...groups,
-      ])
-    } else {
-      return Promise.resolve(groups)
-    }
-  }
-
-  private async checkErrors(
-    mutants: Mutant[],
-    errorsMap: Record<string, Diagnostic[]>,
-    nodes: Map<string, TSFileNode>,
-  ): Promise<Record<string, Diagnostic[]>> {
-    const errors = await this.tsCompiler.check(mutants)
-    const mutantsThatCouldNotBeTestedInGroups = new Set<Mutant>()
-
-    // If there is only a single mutant the error has to originate from the single mutant
-    if (errors.length && mutants.length === 1) {
-      errorsMap[mutants[0]!.id] = errors
-      return errorsMap
-    }
-
-    for (const error of errors) {
-      if (!error.fileName) {
-        throw new Error(
-          `Typescript error: '${error.text}' was reported without a corresponding file. This shouldn't happen. Please open an issue using this link: ${
-            strykerReportBugUrl(
-              `[BUG]: TypeScript checker reports compile error without a corresponding file: ${error.text}`,
-            )
-          }`,
-        )
-      }
-      const nodeErrorWasThrownIn = nodes.get(error.fileName)
-      if (!nodeErrorWasThrownIn) {
-        throw new Error(
-          `Typescript error: '${error.text}' was reported in an unrelated file (${error.fileName}). This file is not part of your project, or referenced from your project. This shouldn't happen, please open an issue using this link: ${
-            strykerReportBugUrl(
-              `[BUG]: TypeScript checker reports compile error in an unrelated file: ${error.text}`,
-            )
-          }`,
-        )
-      }
-      const mutantsRelatedToError = nodeErrorWasThrownIn.getMutantsWithReferenceToChildrenOrSelf(mutants)
-
-      if (mutantsRelatedToError.length === 0) {
-        // In rare cases there are no mutants related to the typescript error
-        // Having to test all mutants individually to know which mutant thrown the error
-        for (const mutant of mutants) {
-          mutantsThatCouldNotBeTestedInGroups.add(mutant)
-        }
-      } else if (mutantsRelatedToError.length === 1) {
-        // There is only one mutant related to the typescript error so we can add it to the errorsRelatedToMutant
-        const mutantId = mutantsRelatedToError[0]!.id
-        if (errorsMap[mutantId]) {
-          errorsMap[mutantId]!.push(error)
-        } else {
-          errorsMap[mutantId] = [error]
-        }
-      } else {
-        // If there are more than one mutants related to the error we should check them individually
-        for (const mutant of mutantsRelatedToError) {
-          mutantsThatCouldNotBeTestedInGroups.add(mutant)
-        }
-      }
-    }
-
-    if (mutantsThatCouldNotBeTestedInGroups.size) {
-      // Because at this point the filesystem contains all the mutants from the group we need to reset back
-      // to the original state of the files to make it possible to test the first mutant
-      // if we wouldn't do this the first mutant would not be noticed by the compiler because it was already in the filesystem
-      await this.tsCompiler.check([])
-    }
-    for (const mutant of mutantsThatCouldNotBeTestedInGroups) {
-      if (errorsMap[mutant.id]) continue
-      await this.checkErrors([mutant], errorsMap, nodes)
-    }
-
-    return errorsMap
-  }
-
-  private createErrorText(errors: Diagnostic[]): string {
-    return errors
-      .map((error) => this.formatDiagnostic(error))
-      .join(EOL)
-  }
-
-  private formatDiagnostic(error: Diagnostic): string {
-    const severity = error.category === DiagnosticCategory.Error
-      ? 'error'
-      : error.category === DiagnosticCategory.Warning
-      ? 'warning'
-      : error.category === DiagnosticCategory.Suggestion
-      ? 'suggestion'
-      : 'message'
-
-    let location = ''
-    if (error.fileName) {
-      const lineAndCharacter = this.tsCompiler.getLineAndCharacterOfPosition(error.fileName, error.pos)
-      const line = (lineAndCharacter?.line ?? 0) + 1
-      const character = (lineAndCharacter?.character ?? 0) + 1
-      location = `${error.fileName}(${line},${character}): `
-    }
-
-    return `${location}${severity} TS${error.code}: ${error.text}`
-  }
-}