ts-node utilities for frontend

merge-coverage.ts

#!/usr/bin/env ts-node

import * as fs from 'fs'
import * as path from 'path'
import * as glob from 'glob'

const CWD = process.cwd()

// describe coverage-final.json file
type Statement = {
  start: {
    line: number
    column: number
  }
  end: {
    line: number
    column: number
  }
}
type FnMap = {
  name: string
  decl: Statement
  line: number
}
type BranchMap = {
  loc: Statement
  line: number
  type: string
  locations: Statement[]
}

type CoverageFile = {
  path: string
  statementMap: Record<string, Statement>
  fnMap: Record<string, FnMap>
  branchMap: Record<string, BranchMap>
  s: Record<string, number>
  f: Record<string, number>
  b: Record<string, number>
  _coverageSchema: string
  hash: string
}

type CoverageFinal = Record<string, CoverageFile>

function mergeAllReportInTheMonoRepo(): CoverageFinal {
  // do not take root coverage files
  const coveragePattern = path.join(__dirname, '..', '*', '*', 'coverage', 'coverage-final.json')
  const coverageFiles = glob.sync(coveragePattern, {
    ignore: ['**/node_modules/**'],
  })
  const coverages: CoverageFinal[] = []
  coverageFiles.forEach(function (file) {
    const coverage = JSON.parse(fs.readFileSync(file, 'utf8')) as CoverageFinal
    coverages.push(coverage)
  })
  return coverages.reduce(function (acc, coverage) {
    Object.keys(coverage).forEach(function (key) {
      if (acc[key]) {
        console.log(`Key ${key} already exists in the merged report`)
        process.exit(1)
      }
      acc[key] = coverage[key]
    })
    return acc
  }, {} as CoverageFinal)
}

/**
 * "statementMap": { "0": { "start": { "line": 1, "column": 0 }, "end": { "line": 70, "column": 1 } } },
 * "s" show how many times each statement has been executed. If the value is 0, it means that the statement has never been executed; a value of 1 or more means that the statement has been executed at least once.
 * To compute the coverage percentage, we use this formula: (total number of executed statements / total number of statements) * 100.
 */
function logCoverage(mergedReport: CoverageFinal) {
  const coverages = Object.keys(mergedReport).map((key) => {
    const report = mergedReport[key]
    const totalStatements = Object.keys(report.s).length
    const executedStatements = Object.values(report.s).filter((value) => value > 0).length
    const coverage = (executedStatements / totalStatements) * 100
    if (isNaN(coverage)) {
      console.error('Coverage is NaN on', key)
      return 0
    }
    return coverage
  })
  const average =
    coverages.reduce((acc, value) => {
      if (isNaN(value)) {
        return acc
      }
      return acc + value
    }, 0) / coverages.length
  console.log(`MonoRepo All files | ${average}%`)
}

const ALL_REPORTS = mergeAllReportInTheMonoRepo()
logCoverage(ALL_REPORTS)