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

package/src/typescript-compiler.ts

@@ -1,412 +0,0 @@
-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 { Either } from 'effect'
-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,
-  parseTsConfig,
-  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 = parseTsConfig(current, content)
-      if (Either.isLeft(parsed)) {
-        this.log.warn(
-          `Could not parse tsconfig file "%s": %s. Compiler-option overrides and project-reference walking were skipped for this file, so mutants may be misreported as compile errors.`,
-          current,
-          parsed.left.reason,
-        )
-        tsConfigOverrides.set(current, content)
-        continue
-      }
-      tsConfigOverrides.set(current, overrideOptions(parsed.right, buildModeEnabled))
-
-      for (
-        const referenced of retrieveReferencedProjects(
-          parsed.right,
-          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"`,
-      )
-    }
-  }
-}

package/test/integration/e2e-plugin-entry.it.spec.ts

@@ -1,153 +0,0 @@
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-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 } from '@stryker-mutator/api/plugin'
-import type { Injector, PluginContext } from '@stryker-mutator/api/plugin'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import { HybridFileSystem } from '../../src/fs/hybrid-file-system.js'
-import { createTypescriptChecker } from '../../src/index.js'
-import * as pluginTokens from '../../src/plugin-tokens.js'
-import { TypescriptChecker } from '../../src/typescript-checker.js'
-import { TypescriptCompiler } from '../../src/typescript-compiler.js'
-
-const resolveTestResource = path.resolve.bind(
-  path,
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  'testResources',
-  'single-project',
-) as unknown as typeof path.resolve
-
-function createLogger(): Logger {
-  return {
-    isTraceEnabled: () => false,
-    isDebugEnabled: () => false,
-    isInfoEnabled: () => false,
-    isWarnEnabled: () => false,
-    isErrorEnabled: () => false,
-    isFatalEnabled: () => false,
-    trace: () => {},
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    fatal: () => {},
-  }
-}
-
-interface InjectableFunctionWithTokens {
-  inject?: readonly string[]
-  (...args: unknown[]): unknown
-}
-
-interface InjectableClassWithTokens {
-  inject?: readonly string[]
-  new(...args: unknown[]): unknown
-}
-
-function createInjector(tsconfigFile: string): Injector<PluginContext> {
-  const context: Record<string, unknown> = {
-    [commonTokens.getLogger]: (): Logger => createLogger(),
-    [commonTokens.logger]: createLogger(),
-    [commonTokens.options]: {
-      tsconfigFile,
-      typescriptChecker: { prioritizePerformanceOverAccuracy: true },
-    } as unknown as StrykerOptions,
-    [commonTokens.target]: undefined,
-    [commonTokens.injector]: undefined,
-  }
-
-  const resolveToken = (token: string): unknown => {
-    if (!(token in context)) {
-      throw new Error(`Missing injection token: ${token}`)
-    }
-    return context[token]
-  }
-
-  const injectArgs = (inject: readonly string[]): unknown[] => inject.map(resolveToken)
-
-  const self: Injector<PluginContext> = {
-    provideFactory: (token, factory, _scope) => {
-      const f = factory as InjectableFunctionWithTokens
-      context[token] = f(...injectArgs(f.inject ?? []))
-      return self
-    },
-    provideClass: (token, Class, _scope) => {
-      const C = Class as InjectableClassWithTokens
-      context[token] = new C(...injectArgs(C.inject ?? []))
-      return self
-    },
-    injectClass: (Class) => {
-      const C = Class as InjectableClassWithTokens
-      return new C(...injectArgs(C.inject ?? [])) as never
-    },
-    injectFunction: (fn) => {
-      const f = fn as InjectableFunctionWithTokens
-      return f(...injectArgs(f.inject ?? [])) as never
-    },
-    resolve: (token) => resolveToken(token as string) as never,
-    provideValue: (token, value) => {
-      context[token] = value
-      return self
-    },
-    createChildInjector: () => self,
-    dispose: async () => {},
-  }
-
-  return self
-}
-
-interface ClosableChecker {
-  tsCompiler: { close(): void }
-}
-
-const todoSource =
-  'export interface ITodo {\n  name: string;\n  description: string;\n  completed: boolean;\n}\n\nclass Todo implements ITodo {\n  constructor(public name: string, public description: string, public completed: boolean) { }\n}\n\nexport class TodoList {\n  public static allTodos: Todo[] = [];\n  createTodoItem(name: string, description: string) {\n    let newItem = new Todo(name, description, false);\n    let totalCount: number = TodoList.allTodos.push(newItem);\n    return totalCount;\n  }\n\n  allTodoItems(): ITodo[] {\n    return TodoList.allTodos;\n  }\n}\n\n'
-
-function createMutant(replacement: string, id: string): Mutant {
-  const findText = 'TodoList.allTodos.push(newItem)'
-  const lines = todoSource.split('\n')
-  const lineNumber = lines.findIndex((line) => line.includes(findText))
-  const textColumn = lines[lineNumber]!.indexOf(findText)
-  return {
-    id,
-    fileName: resolveTestResource('src', 'todo.ts'),
-    mutatorName: 'foo-mutator',
-    location: {
-      start: { line: lineNumber, column: textColumn },
-      end: { line: lineNumber, column: textColumn + findText.length },
-    },
-    replacement,
-  } as unknown as Mutant
-}
-
-describe('Typescript checker plugin entry', () => {
-  let sut: TypescriptChecker
-
-  beforeEach(() => {
-    const injector = createInjector(resolveTestResource('tsconfig.json'))
-    sut = createTypescriptChecker(injector)
-    return sut.init()
-  })
-
-  afterEach(() => {
-    ;(sut as unknown as ClosableChecker).tsCompiler.close()
-  })
-
-  it('should report Passed for a mutant without compile errors', async () => {
-    const mutant = createMutant('newItem ? 42 : 43', 'e2e-pass')
-    const actual = await sut.check([mutant])
-    expect(actual).toEqual({ 'e2e-pass': { status: CheckStatus.Passed } })
-  })
-
-  it('should report CompileError for a mutant that introduces a type error', async () => {
-    const mutant = createMutant('TodoList.allTodos.push("invalid")', 'e2e-fail')
-    const actual = await sut.check([mutant])
-    expect(actual['e2e-fail']?.status).toBe(CheckStatus.CompileError)
-  })
-})

package/test/integration/nodenext-project.it.spec.ts

@@ -1,101 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-import { CheckStatus } from '@stryker-mutator/api/check'
-import type { Location, Mutant, StrykerOptions } from '@stryker-mutator/api/core'
-import type { Logger } from '@stryker-mutator/api/logging'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import { HybridFileSystem } from '../../src/fs/hybrid-file-system.js'
-import { TypescriptChecker } from '../../src/typescript-checker.js'
-import { TypescriptCompiler } from '../../src/typescript-compiler.js'
-
-const resolveTestResource = path.resolve.bind(
-  path,
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  'testResources',
-  'nodenext-project',
-) as unknown as typeof path.resolve
-
-function createLogger(): Logger {
-  return {
-    isTraceEnabled: () => false,
-    isDebugEnabled: () => false,
-    isInfoEnabled: () => false,
-    isWarnEnabled: () => false,
-    isErrorEnabled: () => false,
-    isFatalEnabled: () => false,
-    trace: () => {},
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    fatal: () => {},
-  }
-}
-
-function createChecker(tsconfigFile: string): TypescriptChecker {
-  const options = {
-    tsconfigFile,
-    typescriptChecker: { prioritizePerformanceOverAccuracy: true },
-  } as unknown as StrykerOptions
-  const logger = createLogger()
-  const fileSystem = new HybridFileSystem()
-  const compiler = new TypescriptCompiler(logger, options, fileSystem)
-  return new TypescriptChecker(logger, options, compiler)
-}
-
-const utilSource = fs.readFileSync(resolveTestResource('src', 'util.ts'), 'utf8')
-
-function createMutant(
-  findText: string,
-  replacement: string,
-  id: string,
-): Mutant {
-  const lines = utilSource.split('\n')
-  const lineNumber = lines.findIndex((line) => line.includes(findText))
-  if (lineNumber === -1) {
-    throw new Error(`Cannot find ${findText} in util.ts`)
-  }
-  const column = lines[lineNumber]!.indexOf(findText)
-  const location: Location = {
-    start: { line: lineNumber, column },
-    end: { line: lineNumber, column: column + findText.length },
-  }
-  return {
-    id,
-    fileName: resolveTestResource('src', 'util.ts'),
-    mutatorName: 'test-mutator',
-    location,
-    replacement,
-  }
-}
-
-describe('Typescript checker on a NodeNext project targeting es2024', () => {
-  let sut: TypescriptChecker
-
-  beforeEach(() => {
-    sut = createChecker(resolveTestResource('tsconfig.json'))
-    return sut.init()
-  })
-
-  afterEach(() => {
-    // @ts-expect-error private close method
-    sut.tsCompiler.close()
-  })
-
-  it('should validate a mutant that keeps the project compiling', async () => {
-    const mutant = createMutant('value % 2 === 0', 'value % 2 !== 0', 'passing')
-    const actual = await sut.check([mutant])
-    expect(actual).toEqual({ passing: { status: CheckStatus.Passed } })
-  })
-
-  it('should invalidate a mutant that violates the declared return type', async () => {
-    const mutant = createMutant("'even'", '42', 'breaking')
-    const actual = await sut.check([mutant])
-    expect(actual['breaking']!.status).toBe(CheckStatus.CompileError)
-  })
-})