index.ts

import Module from "module"
import * as path from "path"
import * as fs from "fs"
import { getInput, setFailed } from "@actions/core"
import { reporter } from "./reporter"
import type { CompilerOptions, Diagnostic, ParsedCommandLine } from "typescript"

type TS = typeof import("typescript")

async function main() {
  try {
    const project = getInput("project") || "tsconfig.json"

    const projectPath = resolveProjectPath(path.resolve(process.cwd(), project))

    if (projectPath == null) {
      throw new Error(
        `No valid typescript project was not found at: ${projectPath}`
      )
    }

    typecheck(projectPath)
  } catch (error) {
    console.error(error)
    setFailed(error as Error)
  }
}

/**
 * Attempts to resolve ts config file and returns either path to it or `null`.
 */
const resolveProjectPath = (projectPath: string) => {
  try {
    if (fs.statSync(projectPath).isFile()) {
      return projectPath
    } else {
      const configPath = path.resolve(projectPath, "tsconfig.json")
      return fs.statSync(configPath).isFile() ? configPath : null
    }
  } catch {
    return null
  }
}

const typecheck = (projectPath: string) => {
  const ts = loadTS(projectPath)
  const json = ts.readConfigFile(projectPath, ts.sys.readFile)
  const config = ts.parseJsonConfigFileContent(
    json.config,
    ts.sys,
    path.dirname(projectPath),
    undefined,
    path.basename(projectPath)
  )

  const errors = isIncrementalCompilation(config.options)
    ? performIncrementalCompilation(ts, projectPath)
    : performCompilation(ts, config)

  const errThreshold = Number(getInput("error_fail_threshold") || 0)
  const logString = `Found ${errors} errors!`
  console.log(logString)
  if (errors > errThreshold) {
    setFailed(logString)
  }
}

const performIncrementalCompilation = (ts: TS, projectPath: string) => {
  const report = reporter(ts)

  const host = ts.createSolutionBuilderHost(ts.sys, undefined, report, report)
  const builder = ts.createSolutionBuilder(host, [projectPath], {
    noEmit: true,
  })
  return builder.build()
}

const performCompilation = (ts: TS, config: ParsedCommandLine) => {
  const report = reporter(ts)
  const host = ts.createCompilerHost(config.options)
  const program = ts.createProgram({
    rootNames: config.fileNames,
    options: config.options,
    projectReferences: config.projectReferences,
    configFileParsingDiagnostics: ts.getConfigFileParsingDiagnostics(config),
  })

  const configuration = program.getConfigFileParsingDiagnostics()
  let all: Diagnostic[] = [...program.getSyntacticDiagnostics()]
  if (all.length === 0) {
    all = [
      ...program.getOptionsDiagnostics(),
      ...program.getGlobalDiagnostics(),
    ]

    if (all.length == 0) {
      all = [...program.getSemanticDiagnostics()]
    }
  }
  const diagnostics = ts.sortAndDeduplicateDiagnostics(all)
  diagnostics.forEach(report)

  return all.length
}

const isIncrementalCompilation = (options: CompilerOptions) =>
  options.incremental || options.composite

const loadTS = (projectPath: string): TS => {
  try {
    const require = Module.createRequire(projectPath)
    const ts = require("typescript")
    return ts
  } catch (error) {
    throw Object.assign(
      new Error(`Failed to find project specific typescript at ${projectPath}`),
      { cause: error }
    )
  }
}

main()