@systemfsoftware/stryker-js-typescript-checker 0.1.0

package/src/typescript-checker.ts

@@ -0,0 +1,223 @@
+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}`
+  }
+}

package/src/typescript-compiler.ts

@@ -0,0 +1,406 @@
+import { readFileSync } from 'fs'
+import path from 'path'
+
+import type { Mutant, StrykerOptions } from '@stryker-mutator/api/core'
+import type { Logger } from '@stryker-mutator/api/logging'
+import { commonTokens, tokens } from '@stryker-mutator/api/plugin'
+import { type SourceFile, SyntaxKind } from 'typescript/unstable/ast'
+import type { FileSystem } from 'typescript/unstable/fs'
+import { API, type Diagnostic, type DocumentIdentifier, type Program, type Snapshot } from 'typescript/unstable/sync'
+
+import { HybridFileSystem } from './fs/index.js'
+import { TSFileNode } from './grouping/ts-file-node.js'
+import * as pluginTokens from './plugin-tokens.js'
+import {
+  determineBuildModeEnabled,
+  getSourceMappingURL,
+  guardTSVersion,
+  overrideOptions,
+  parseConfigFileTextToJson,
+  retrieveReferencedProjects,
+  toPosixFileName,
+} from './tsconfig-helpers.js'
+
+export interface ITypescriptCompiler {
+  init(): Promise<Diagnostic[]>
+  check(mutants: Mutant[]): Promise<Diagnostic[]>
+}
+
+export interface IFileRelationCreator {
+  get nodes(): Map<string, TSFileNode>
+}
+
+export type SourceFiles = Map<
+  string,
+  {
+    fileName: string
+    imports: Set<string>
+  }
+>
+
+export class TypescriptCompiler implements ITypescriptCompiler, IFileRelationCreator {
+  public static inject = tokens(
+    commonTokens.logger,
+    commonTokens.options,
+    pluginTokens.fs,
+  )
+
+  private readonly allTSConfigFiles: Set<string>
+  private readonly tsconfigFile: string
+  private api?: API
+  private snapshot?: Snapshot
+  private readonly sourceFiles: SourceFiles = new Map()
+  private readonly _nodes = new Map<string, TSFileNode>()
+  private lastMutants: Mutant[] = []
+  private lastMutatedFileNames: string[] = []
+
+  constructor(
+    private readonly log: Logger,
+    private readonly options: StrykerOptions,
+    private readonly fs: HybridFileSystem,
+  ) {
+    this.tsconfigFile = toPosixFileName(
+      path.resolve(toPosixFileName(this.options.tsconfigFile)),
+    )
+    this.allTSConfigFiles = new Set<string>([this.tsconfigFile])
+  }
+
+  public async init(): Promise<Diagnostic[]> {
+    guardTSVersion()
+    this.guardTSConfigFileExists()
+    const buildModeEnabled = determineBuildModeEnabled(this.tsconfigFile)
+
+    this.collectAllTSConfigFiles(buildModeEnabled)
+    this.api = new API({ fs: this.fs as FileSystem })
+    this.snapshot = this.api.updateSnapshot({
+      openProjects: [...this.allTSConfigFiles],
+    })
+
+    const programs = this.getPrograms()
+    this.buildDependencyGraph(programs)
+
+    return this.check([])
+  }
+
+  public async check(mutants: Mutant[]): Promise<Diagnostic[]> {
+    // Reset previous mutations
+    for (const mutant of this.lastMutants) {
+      this.fs.resetFile(mutant.fileName)
+    }
+
+    // Apply new mutations
+    for (const mutant of mutants) {
+      const file = this.fs.getFile(mutant.fileName)
+      if (!file) {
+        throw new Error(
+          `Tried to check file "${mutant.fileName}" (which is part of your typescript project), but it could not be found.`,
+        )
+      }
+      file.mutate(mutant)
+    }
+
+    const mutatedFileNames = [
+      ...new Set(mutants.map((m) => toPosixFileName(m.fileName))),
+    ]
+
+    const changedFiles = [
+      ...new Set([...this.lastMutatedFileNames, ...mutatedFileNames]),
+    ]
+
+    if (this.api && this.snapshot) {
+      const oldSnapshot = this.snapshot
+      this.snapshot = this.api.updateSnapshot({
+        openProjects: [...this.allTSConfigFiles],
+        fileChanges: { changed: changedFiles },
+      })
+      oldSnapshot.dispose()
+    }
+
+    this.lastMutants = mutants
+    this.lastMutatedFileNames = mutatedFileNames
+
+    const programs = this.getPrograms()
+    return programs.flatMap((program) => [
+      ...program.getConfigFileParsingDiagnostics(),
+      ...program.getSemanticDiagnostics(),
+      ...program.getProgramDiagnostics(),
+    ])
+  }
+
+  public get nodes(): Map<string, TSFileNode> {
+    if (!this._nodes.size) {
+      // create nodes
+      for (const [fileName] of this.sourceFiles) {
+        const node = new TSFileNode(fileName, [], [])
+        this._nodes.set(fileName, node)
+      }
+
+      // set children
+      for (const [fileName, file] of this.sourceFiles) {
+        const node = this._nodes.get(fileName)
+        if (node == null) {
+          throw new Error(
+            `Node for file '${fileName}' could not be found. This should not happen.`,
+          )
+        }
+
+        node.children = [...file.imports]
+          .map((importName) => this._nodes.get(importName))
+          .filter((n): n is TSFileNode => n != null)
+      }
+
+      // set parents
+      for (const [, node] of this._nodes) {
+        node.parents = []
+        for (const [, n] of this._nodes) {
+          if (n.children.includes(node)) {
+            node.parents.push(n)
+          }
+        }
+      }
+    }
+
+    return this._nodes
+  }
+
+  public close(): void {
+    this.snapshot?.dispose()
+    this.api?.close()
+  }
+
+  public getLineAndCharacterOfPosition(
+    fileName: string,
+    position: number,
+  ): { line: number; character: number } | undefined {
+    for (const program of this.getPrograms()) {
+      const sourceFile = program.getSourceFile(fileName as DocumentIdentifier)
+      if (sourceFile) {
+        return sourceFile.getLineAndCharacterOfPosition(position)
+      }
+    }
+    return undefined
+  }
+
+  private getPrograms(): Program[] {
+    if (!this.snapshot) {
+      throw new Error('TypescriptCompiler not initialized')
+    }
+    const projects = this.snapshot.getProjects()
+    if (projects.length === 0) {
+      throw new Error(`No projects found for ${this.tsconfigFile}`)
+    }
+    return projects.map((project) => project.program)
+  }
+
+  private collectAllTSConfigFiles(buildModeEnabled: boolean): void {
+    const tsConfigOverrides = new Map<string, string>()
+    const toProcess = [this.tsconfigFile]
+    const processed = new Set<string>()
+
+    while (toProcess.length > 0) {
+      const current = toProcess.pop()
+      if (!current || processed.has(current)) {
+        continue
+      }
+      processed.add(current)
+
+      const content = readFileSync(current, 'utf-8')
+      const parsed = parseConfigFileTextToJson(current, content)
+      if (parsed.error) {
+        tsConfigOverrides.set(current, content)
+        continue
+      }
+      tsConfigOverrides.set(current, overrideOptions(parsed, buildModeEnabled))
+
+      for (
+        const referenced of retrieveReferencedProjects(
+          parsed,
+          path.dirname(current),
+        )
+      ) {
+        this.allTSConfigFiles.add(referenced)
+        toProcess.push(referenced)
+      }
+    }
+
+    this.fs.tsConfigOverrides = tsConfigOverrides
+  }
+
+  private buildDependencyGraph(programs: Program[]): void {
+    for (const program of programs) {
+      for (const fileName of program.getSourceFileNames()) {
+        if (
+          fileName.endsWith('.d.ts') ||
+          fileName.includes('node_modules')
+        ) {
+          continue
+        }
+        const normalized = toPosixFileName(fileName)
+        this.sourceFiles.set(normalized, {
+          fileName: normalized,
+          imports: new Set(),
+        })
+      }
+    }
+
+    for (const [fileName] of this.sourceFiles) {
+      const sourceFile = programs
+        .map((p) => p.getSourceFile(fileName as DocumentIdentifier))
+        .find((sf) => sf != null)
+      if (!sourceFile) {
+        continue
+      }
+      const imports = this.extractImports(sourceFile)
+      for (const specifier of imports) {
+        const resolved = this.resolveModuleSpecifier(fileName, specifier)
+        if (resolved) {
+          const sourceFileName = this.resolveTSInputFile(resolved)
+          if (this.sourceFiles.has(sourceFileName)) {
+            this.sourceFiles.get(fileName)?.imports.add(sourceFileName)
+          }
+        }
+      }
+    }
+  }
+
+  private extractImports(sourceFile: SourceFile): string[] {
+    const result: string[] = []
+
+    for (const statement of sourceFile.statements) {
+      if (statement.kind === SyntaxKind.ImportDeclaration) {
+        let spec: SourceFile['imports'][number] | undefined
+        statement.forEachChild((child) => {
+          if (child.kind === SyntaxKind.StringLiteral) {
+            spec = child
+          }
+        })
+        if (spec) {
+          result.push(spec.getText(sourceFile))
+        }
+      } else if (statement.kind === SyntaxKind.ImportEqualsDeclaration) {
+        statement.forEachChild((child) => {
+          if (child.kind === SyntaxKind.ExternalModuleReference) {
+            child.forEachChild((refChild) => {
+              if (refChild.kind === SyntaxKind.StringLiteral) {
+                result.push(refChild.getText(sourceFile))
+              }
+            })
+          }
+        })
+      }
+    }
+
+    for (const ref of sourceFile.referencedFiles) {
+      result.push(ref.fileName)
+    }
+    for (const ref of sourceFile.typeReferenceDirectives) {
+      result.push(ref.fileName)
+    }
+
+    return result
+  }
+
+  private resolveModuleSpecifier(
+    sourceFileName: string,
+    specifier: string,
+  ): string | undefined {
+    const cleaned = specifier.replace(/^['"]|['"]$/g, '')
+    if (!cleaned.startsWith('./') && !cleaned.startsWith('../')) {
+      return undefined
+    }
+    const baseDir = path.dirname(sourceFileName)
+    const resolved = toPosixFileName(path.resolve(baseDir, cleaned))
+
+    const candidates = this.getResolutionCandidates(resolved)
+    for (const candidate of candidates) {
+      if (this.sourceFiles.has(candidate)) {
+        return candidate
+      }
+    }
+
+    return undefined
+  }
+
+  private getResolutionCandidates(resolved: string): string[] {
+    const extension = path.extname(resolved)
+    if (extension) {
+      const withoutExt = resolved.slice(0, -extension.length)
+      return [
+        resolved,
+        `${withoutExt}.ts`,
+        `${withoutExt}.tsx`,
+        `${withoutExt}.d.ts`,
+        `${withoutExt}.js`,
+        `${withoutExt}.jsx`,
+        `${withoutExt}.mjs`,
+        `${withoutExt}.cjs`,
+      ]
+    }
+    return [
+      resolved,
+      `${resolved}.ts`,
+      `${resolved}.tsx`,
+      `${resolved}.d.ts`,
+      `${resolved}/index.ts`,
+      `${resolved}/index.tsx`,
+      `${resolved}/index.d.ts`,
+      `${resolved}.js`,
+      `${resolved}.jsx`,
+      `${resolved}.mjs`,
+      `${resolved}.cjs`,
+      `${resolved}/index.js`,
+      `${resolved}/index.jsx`,
+      `${resolved}/index.mjs`,
+      `${resolved}/index.cjs`,
+    ]
+  }
+
+  private resolveTSInputFile(dependencyFileName: string): string {
+    if (!dependencyFileName.endsWith('.d.ts')) {
+      return dependencyFileName
+    }
+
+    const file = this.fs.getFile(dependencyFileName)
+    if (!file) {
+      return dependencyFileName
+    }
+
+    const sourceMappingURL = getSourceMappingURL(file.content)
+    if (!sourceMappingURL) {
+      return dependencyFileName
+    }
+
+    const sourceMapFileName = toPosixFileName(
+      path.resolve(path.dirname(dependencyFileName), sourceMappingURL),
+    )
+    const sourceMap = this.fs.getFile(sourceMapFileName)
+    if (!sourceMap) {
+      this.log.warn(`Could not find sourcemap ${sourceMapFileName}`)
+      return dependencyFileName
+    }
+
+    const sourceMapParsed = JSON.parse(sourceMap.content) as {
+      sources?: string[]
+    }
+    const sources = sourceMapParsed.sources
+
+    if (sources?.length === 1) {
+      const [sourcePath] = sources
+      return toPosixFileName(
+        path.resolve(path.dirname(sourceMapFileName), sourcePath!),
+      )
+    }
+
+    return dependencyFileName
+  }
+
+  private guardTSConfigFileExists(): void {
+    try {
+      readFileSync(this.tsconfigFile, 'utf-8')
+    } catch {
+      throw new Error(
+        `The tsconfig file does not exist at: "${this.tsconfigFile}". Please configure the tsconfig file in your stryker.conf file using "tsconfigFile"`,
+      )
+    }
+  }
+}