@toptal/davinci-monorepo 8.1.4-alpha-CRT-5891-create-coverage-command-0a4adac5.7 → 8.1.4-alpha-CRT-5891-create-coverage-command-5071adf7.9

package/bin/davinci-monorepo.js

@@ -7,7 +7,7 @@ import { createGraphGenerateCommand } from '../src/commands/graph-generate.js'
 import metricsCommand from '../src/commands/metrics.js'
 // eslint-disable-next-line no-restricted-syntax
 import codeownersCommand from '../src/commands/codeowners/index.js'
-import { coverageCommand } from '../src/commands/coverage-command/index.js'
+import { createCoverageCommand } from '../src/commands/coverage-command/index.js'
 
 cliEngine.loadCommands(
   [
@@ -15,7 +15,7 @@ cliEngine.loadCommands(
     createGraphGenerateCommand,
     metricsCommand,
     codeownersCommand,
-    coverageCommand,
+    createCoverageCommand,
   ],
   'davinci-monorepo'
 )

package/docs/coverage.md

@@ -4,18 +4,12 @@ Streamline code coverage analysis and reporting by organizing coverage reports b
 
 #### `group-coverage-by-codeowners`
 
-Reads code coverage reports for Jest and Cypress, groups the coverage data based on code owners, and writes separate coverage reports for each team
-
-The command utilizes the Codeowners class, which is responsible for identifying the code owners associated with each file.
-
 ```sh
 codeowners group-coverage-by-codeowners
 ```
 
 #### `generage-team-coverage`
 
-Generates team-specific coverage reports by copying and processing coverage data from Jest and Cypress reports. The resulting coverage reports provide insights into the code coverage metrics for each team.
-
 ```sh
 coverage generage-team-coverage [options]
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toptal/davinci-monorepo",
-  "version": "8.1.4-alpha-CRT-5891-create-coverage-command-0a4adac5.7+0a4adac5",
+  "version": "8.1.4-alpha-CRT-5891-create-coverage-command-5071adf7.9+5071adf7",
   "description": "Monorepo utility tools",
   "publishConfig": {
     "access": "public"
@@ -35,10 +35,9 @@
   "dependencies": {
     "@nodelib/fs.walk": "^1.2.6",
     "@oclif/core": "^1.16.1",
-    "@toptal/davinci-cli-shared": "2.3.1-alpha-CRT-5891-create-coverage-command-0a4adac5.39+0a4adac5",
+    "@toptal/davinci-cli-shared": "2.3.1-alpha-CRT-5891-create-coverage-command-5071adf7.41+5071adf7",
     "chalk": "^4.1.2",
     "codeowners": "5.1.1",
-    "commander": "^10.0.0",
     "dependency-cruiser": "^12.5.0",
     "ervy": "^1.0.7",
     "execa": "^5.1.1",
@@ -55,5 +54,5 @@
   "devDependencies": {
     "@jest/globals": "^29.4.2"
   },
-  "gitHead": "0a4adac5650c666f07b97522a76b2f30dd604738"
+  "gitHead": "5071adf786fc0f9eaf34275fe751c75f403dacfa"
 }

package/src/commands/codeowners/commands/list.js

@@ -1,3 +1,5 @@
+import { asyncCodeownersImport } from '../services/async-codeowners-import/async-codeowners-import.js'
+
 const list = program => {
   return program
     .command('list <paths...>')
@@ -9,19 +11,13 @@ const list = program => {
       'CODEOWNERS'
     )
     .action(async (pathsToCheck, options) => {
-      let codeowners
       const rootPath = process.cwd()
-      const { default: CodeOwnersTool } = await import(
-        'codeowners/codeowners.js'
+
+      const codeowners = await asyncCodeownersImport(
+        rootPath,
+        options.codeownersFilename
       )
 
-      // instantiate new Codeowners obj
-      try {
-        codeowners = new CodeOwnersTool(rootPath, options.codeownersFilename)
-      } catch (e) {
-        console.error(e.message)
-        process.exit(1)
-      }
       let owners = []
 
       // iterates over all paths and returns owners

package/src/commands/codeowners/core/codeowners/codeowners.js

@@ -1,4 +1,3 @@
-// @ts-check
 import fs from 'fs'
 import ignore from 'ignore'
 

package/src/commands/codeowners/core/process-codebase.js

@@ -1,4 +1,3 @@
-/* eslint-disable import/no-extraneous-dependencies */
 import path from 'path'
 
 import { PackageInfo } from './package-info/package-info.js'
@@ -6,6 +5,7 @@ import readFiles from './read-files.js'
 import { NO_OWNER } from '../config.js'
 import fileNameToPackage from './utils/file-name-to-package.js'
 import OwnerToPackages from './owners-info/owner-to-packages.js'
+import { asyncCodeownersImport } from '../services/async-codeowners-import/async-codeowners-import.js'
 
 const processGroupedByPackage = (
   groupedByPackageName,
@@ -39,17 +39,9 @@ const processGroupedByOwner = (groupedByOwnerName, owners, packageName) => {
 }
 
 const processCodeBase = async options => {
-  let codeowners
-
   const rootPath = process.cwd()
-  const { default: CodeOwnersTool } = await import('codeowners/codeowners.js')
 
-  try {
-    codeowners = new CodeOwnersTool(rootPath, options.codeownersFilename)
-  } catch (e) {
-    console.error(e.message)
-    process.exit(1)
-  }
+  const codeowners = await asyncCodeownersImport()
 
   const filesToTeams = new Map()
   const groupedByPackageName = {}

package/src/commands/codeowners/index.js

@@ -22,4 +22,6 @@ const codeownersCommand = program => {
   return codeowners
 }
 
+export { asyncCodeownersImport } from './services/async-codeowners-import/async-codeowners-import.js'
+
 export default codeownersCommand

package/src/commands/codeowners/services/async-codeowners-import/async-codeowners-import.js

@@ -0,0 +1,22 @@
+import getWorkspaceRoot from 'find-yarn-workspace-root'
+
+/**
+ * @param {string} cwd
+ * @param {string} fileName
+ * @return {Promise}
+ */
+export const asyncCodeownersImport = async (cwd, fileName) => {
+  const workspaceRoot = getWorkspaceRoot()
+
+  let codeowners
+  const { default: CodeOwnersTool } = await import('codeowners/codeowners.js')
+
+  try {
+    codeowners = new CodeOwnersTool(cwd ?? workspaceRoot, fileName)
+  } catch (e) {
+    console.error(e.message)
+    process.exit(1)
+  }
+
+  return codeowners
+}

package/src/commands/coverage-command/{generate-team-coverage.js → create-generate-team-coverage-command.js}

@@ -1,29 +1,38 @@
 import path from 'path'
 import execa from 'execa'
-import fs from 'fs'
 import { print } from '@toptal/davinci-cli-shared'
-import getWorkspaceRoot from 'find-yarn-workspace-root'
+import { readFile, writeFile, mkdir, cp, rm } from 'fs/promises'
 
-// eslint-disable-next-line no-restricted-syntax
-import Codeowners from '../codeowners/core/codeowners/codeowners.js'
 import { sanitizeTeamName } from './services/sanitize-team-name/sanitize-team-name.js'
-import {
-  CYPRESS_COVERAGE_PATH,
-  JEST_COVERAGE_PATH,
-  TEAMS_COVERAGE_PATH,
-} from './config.js'
+import { JEST_COVERAGE_PATH, TEAMS_COVERAGE_PATH } from './config.js'
 import { getUniqueTeams } from './services/get-unique-teams/get-unique-teams.js'
-
-const workspaceRoot = getWorkspaceRoot()
+import { asyncCodeownersImport } from '../codeowners/index.js'
 
 const sanitizeNycPercentage = percentage =>
   percentage === 'Unknown' ? 0 : percentage
 
-const getCoverageSummary = (type, teamPath) => {
+const generateNycReport = async ({
+  type,
+  sanitizedTeamPath,
+  sanitizedTeam,
+}) => {
+  await mkdir(`${sanitizedTeamPath}/${type}`)
+
+  await cp(
+    `${JEST_COVERAGE_PATH}/coverage-final-${sanitizedTeam}.json`,
+    `${sanitizedTeamPath}/${type}/coverage-final.json`
+  )
+
+  await execa.command(
+    `yarn nyc report --temp-dir ${sanitizedTeamPath}/${type} --reporter json-summary --reporter html --report-dir ${sanitizedTeamPath}/${type}`
+  )
+}
+
+const getCoverageSummary = async (type, teamPath) => {
   const result = {}
 
   const coverageSummary = JSON.parse(
-    fs.readFileSync(`${teamPath}/${type}/coverage-summary.json`, 'utf8')
+    await readFile(`${teamPath}/${type}/coverage-summary.json`, 'utf8')
   )
 
   result[`${type}_lines_coverage`] = sanitizeNycPercentage(
@@ -42,15 +51,17 @@ const getCoverageSummary = (type, teamPath) => {
   return result
 }
 
-// eslint-disable-next-line max-statements
 const generateTeamCoverage = async options => {
   print.header('Generating team coverage')
 
-  const codeowners = new Codeowners(workspaceRoot)
+  const codeowners = await asyncCodeownersImport()
+
   const teams = getUniqueTeams(codeowners.ownerEntries)
 
-  await execa.command(`rm -rf ${TEAMS_COVERAGE_PATH}`)
-  await execa.command(`mkdir ${TEAMS_COVERAGE_PATH}`)
+  print.grey('Teams: ', teams)
+
+  await rm(TEAMS_COVERAGE_PATH, { recursive: true, force: true })
+  await mkdir(TEAMS_COVERAGE_PATH, { recursive: true })
 
   for await (const team of teams) {
     print.grey('Team coverage: ', team)
@@ -58,23 +69,20 @@ const generateTeamCoverage = async options => {
     const sanitizedTeam = sanitizeTeamName(team)
     const sanitizedTeamPath = path.join(TEAMS_COVERAGE_PATH, sanitizedTeam)
 
-    await execa.command(`mkdir ${sanitizedTeamPath}`)
-    await execa.command(`mkdir ${sanitizedTeamPath}/jest`)
-    await execa.command(`mkdir ${sanitizedTeamPath}/cypress`)
-
-    await execa.command(
-      `cp ${JEST_COVERAGE_PATH}/coverage-final-${sanitizedTeam}.json ${sanitizedTeamPath}/jest/coverage-final.json`
-    )
-    await execa.command(
-      `yarn nyc report --temp-dir ${sanitizedTeamPath}/jest --reporter json-summary --reporter html --report-dir ${sanitizedTeamPath}/jest`
-    )
-
-    await execa.command(
-      `cp ${CYPRESS_COVERAGE_PATH}/coverage-final-${sanitizedTeam}.json ${sanitizedTeamPath}/cypress/coverage-final.json`
-    )
-    await execa.command(
-      `yarn nyc report --temp-dir ${sanitizedTeamPath}/cypress --reporter json-summary --reporter html --report-dir ${sanitizedTeamPath}/cypress`
-    )
+    await mkdir(sanitizedTeamPath, { recursive: true })
+
+    await Promise.all([
+      generateNycReport({
+        type: 'jest',
+        sanitizedTeamPath,
+        sanitizedTeam,
+      }),
+      generateNycReport({
+        type: 'cypress',
+        sanitizedTeamPath,
+        sanitizedTeam,
+      }),
+    ])
   }
 
   const results = []
@@ -84,30 +92,30 @@ const generateTeamCoverage = async options => {
     const sanitizedTeam = sanitizeTeamName(team)
     const sanitizedTeamPath = path.join(TEAMS_COVERAGE_PATH, sanitizedTeam)
 
-    const jestCoverageSummary = getCoverageSummary('jest', sanitizedTeamPath)
-    const cypressCoverageSummary = getCoverageSummary(
-      'cypress',
-      sanitizedTeamPath
-    )
+    const [jestCoverageSummary, cypressCoverageSummary] = await Promise.all([
+      getCoverageSummary('jest', sanitizedTeamPath),
+      getCoverageSummary('cypress', sanitizedTeamPath),
+    ])
 
-    const result = {
+    results.push({
       created_at,
       team,
       repo: options.repository,
       ...jestCoverageSummary,
       ...cypressCoverageSummary,
-    }
-
-    results.push(result)
+    })
   }
 
-  fs.writeFileSync(options.outputFileName, JSON.stringify(results, null, 2))
+  return writeFile(options.outputFileName, JSON.stringify(results, null, 2))
 }
 
-export const generateTeamCoverageCommand = program =>
+export const createGenerateTeamCoverageCommand = program =>
   program
     .command('generate-team-coverage')
-    .description('Generate team-specific coverage reports')
+    .description(
+      `Generates team-specific coverage reports by copying and processing coverage data from Jest and Cypress reports.
+The resulting coverage reports provide insights into the code coverage metrics for each team.`
+    )
     .requiredOption(
       '-r, --repository <repository_name>',
       'specify repository name'

package/src/commands/coverage-command/create-group-coverage-by-codeowners-command.js

@@ -0,0 +1,95 @@
+import path from 'path'
+import { print } from '@toptal/davinci-cli-shared'
+import getWorkspaceRoot from 'find-yarn-workspace-root'
+import { readFile, writeFile } from 'fs/promises'
+
+import { CYPRESS_COVERAGE_PATH, JEST_COVERAGE_PATH } from './config.js'
+import { sanitizeTeamName } from './services/sanitize-team-name/sanitize-team-name.js'
+import { getUniqueTeams } from './services/get-unique-teams/get-unique-teams.js'
+import { asyncCodeownersImport } from '../codeowners/index.js'
+
+const workspaceRoot = getWorkspaceRoot()
+
+const readCoverageReport = async reportPathName => {
+  const data = await readFile(path.join(workspaceRoot, reportPathName), 'utf8')
+
+  return JSON.parse(data)
+}
+
+const splitReportIntoTeams = async ({
+  report,
+  teams,
+  codeowners,
+  coveragePath,
+}) => {
+  const teamsReport = {}
+
+  for (const [reportPathKey, reportValue] of Object.entries(report)) {
+    const filePath = reportValue.path
+    const relativeWorkspacePath = path.relative(workspaceRoot, filePath)
+    const owners = codeowners.getOwner(relativeWorkspacePath)
+
+    owners.forEach(owner => {
+      teamsReport[owner] = {
+        ...teamsReport[owner],
+        [reportPathKey]: reportValue,
+      }
+    })
+  }
+
+  for await (const team of teams) {
+    const teamReport = teamsReport[team] || {}
+    const sanitizedTeamPath = sanitizeTeamName(team)
+
+    const reportPath = path.join(
+      workspaceRoot,
+      coveragePath,
+      `coverage-final-${sanitizedTeamPath}.json`
+    )
+
+    return writeFile(reportPath, JSON.stringify(teamReport, null, 2))
+  }
+}
+
+const groupCoverageByCodeowners = async () => {
+  print.header('Grouping coverage by codeowners')
+
+  const [jestReport, cypressReport] = await Promise.all([
+    readCoverageReport(
+      path.join(JEST_COVERAGE_PATH, 'coverage-final-jest.json')
+    ),
+    readCoverageReport(
+      path.join(CYPRESS_COVERAGE_PATH, 'coverage-final-cypress.json')
+    ),
+  ])
+
+  const codeowners = await asyncCodeownersImport()
+
+  const teams = getUniqueTeams(codeowners.ownerEntries)
+
+  print.grey('Teams: ', teams)
+
+  return Promise.all([
+    splitReportIntoTeams({
+      report: jestReport,
+      teams,
+      codeowners,
+      coveragePath: JEST_COVERAGE_PATH,
+    }),
+    splitReportIntoTeams({
+      report: cypressReport,
+      teams,
+      codeowners,
+      coveragePath: CYPRESS_COVERAGE_PATH,
+    }),
+  ])
+}
+
+export const createGroupCoverageByCodeownersCommand = program =>
+  program
+    .command('group-coverage-by-codeowners')
+    .description(
+      `Reads code coverage reports for Jest and Cypress, groups the coverage data based on code owners, and writes separate coverage reports for each team.
+The command utilizes the Codeowners class, which is responsible for identifying the code owners associated with each file.`
+    )
+    .action(groupCoverageByCodeowners)

package/src/commands/coverage-command/index.js

@@ -1,15 +1,15 @@
-import { generateTeamCoverageCommand } from './generate-team-coverage.js'
-import { groupCoverageByCodeownersCommand } from './group-coverage-by-codeowners.js'
+import { createGroupCoverageByCodeownersCommand } from './create-group-coverage-by-codeowners-command.js'
+import { createGenerateTeamCoverageCommand } from './create-generate-team-coverage-command.js'
 
-export const coverageCommand = program => {
-  const coverage = program
+export const createCoverageCommand = program => {
+  const coverageCommand = program
     .createCommand('coverage')
     .description(
       'Provides code coverage analysis, including organizing coverage reports by code owners and generating team-specific reports'
     )
 
-  groupCoverageByCodeownersCommand(coverage)
-  generateTeamCoverageCommand(coverage)
+  createGroupCoverageByCodeownersCommand(coverageCommand)
+  createGenerateTeamCoverageCommand(coverageCommand)
 
-  return coverage
+  return coverageCommand
 }

package/src/commands/coverage-command/services/get-unique-teams/get-unique-teams.js

@@ -1,11 +1,5 @@
-import { print } from '@toptal/davinci-cli-shared'
-
 export const getUniqueTeams = teams => {
-  const uniqueTeams = teams
-    .flatMap(entry => entry.usernames)
-    .filter((teamName, index, allTeams) => allTeams.indexOf(teamName) === index)
-
-  print.grey('Teams: ', uniqueTeams)
+  const allTeams = teams.flatMap(entry => entry.usernames)
 
-  return uniqueTeams
+  return [...new Set(allTeams)]
 }

package/src/commands/coverage-command/services/get-unique-teams/get-unique-teams.test.js

@@ -1,21 +1,6 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import { jest } from '@jest/globals'
-
 import { getUniqueTeams } from './get-unique-teams'
 
-jest.unstable_mockModule('@toptal/davinci-cli-shared', () => ({
-  print: {
-    grey: jest.fn(),
-  },
-}))
-
-const { print } = await import('@toptal/davinci-cli-shared')
-
 describe('getUniqueTeams', () => {
-  beforeEach(() => {
-    print.grey.mockImplementation(jest.fn())
-  })
-
   it.each([
     [
       [

package/src/commands/coverage-command/services/sanitize-team-name/sanitize-team-name.js

@@ -1 +1,2 @@
-export const sanitizeTeamName = team => team.replace('/', '-').replace('@', '')
+export const sanitizeTeamName = team =>
+  team.replace(/\//g, '-').replace(/@/g, '')

package/src/index.js

@@ -2,7 +2,7 @@ import detectCircularityCommandCreator from './commands/detect-circularity.js'
 import metricsCommandCreator from './commands/metrics.js'
 import { createGraphGenerateCommand } from './commands/graph-generate.js'
 import codeownersCommand from './commands/codeowners/index.js'
-import { coverageCommand } from './commands/coverage-command/index.js'
+import { createCoverageCommand } from './commands/coverage-command/index.js'
 import checkIfMonorepo from './utils/check-if-monorepo.js'
 import getPackages from './utils/get-packages.js'
 
@@ -16,7 +16,7 @@ export const commands = [
   metricsCommandCreator,
   createGraphGenerateCommand,
   codeownersCommand,
-  coverageCommand,
+  createCoverageCommand,
 ]
 
 export default {

package/src/commands/coverage-command/group-coverage-by-codeowners.js

@@ -1,82 +0,0 @@
-import path from 'path'
-import fs from 'fs'
-import { print } from '@toptal/davinci-cli-shared'
-import getWorkspaceRoot from 'find-yarn-workspace-root'
-
-// eslint-disable-next-line no-restricted-syntax
-import Codeowners from '../codeowners/core/codeowners/codeowners.js'
-import { CYPRESS_COVERAGE_PATH, JEST_COVERAGE_PATH } from './config.js'
-import { sanitizeTeamName } from './services/sanitize-team-name/sanitize-team-name.js'
-import { getUniqueTeams } from './services/get-unique-teams/get-unique-teams.js'
-
-const workspaceRoot = getWorkspaceRoot()
-
-const readCoverageReport = reportPathName => {
-  const jestCoverageReportPath = path.join(workspaceRoot, reportPathName)
-  const data = fs.readFileSync(jestCoverageReportPath, 'utf8')
-
-  return JSON.parse(data)
-}
-
-const splitReportIntoTeams = ({ report, teams, codeowners, coveragePath }) => {
-  const teamsReport = {}
-
-  Object.entries(report).forEach(([reportPathKey, reportValue]) => {
-    const filePath = reportValue.path
-    const relativeWorkspacePath = path.relative(workspaceRoot, filePath)
-    const owners = codeowners.getOwner(relativeWorkspacePath)
-
-    owners.forEach(owner => {
-      teamsReport[owner] = {
-        ...teamsReport[owner],
-        [reportPathKey]: reportValue,
-      }
-    })
-  })
-
-  teams.map(team => {
-    const teamReport = teamsReport[team] || {}
-    const sanitizedTeamPath = sanitizeTeamName(team)
-
-    const reportPath = path.join(
-      workspaceRoot,
-      coveragePath,
-      `coverage-final-${sanitizedTeamPath}.json`
-    )
-
-    fs.writeFileSync(reportPath, JSON.stringify(teamReport, null, 2))
-  })
-}
-
-const groupCoverageByCodeowners = async () => {
-  print.header('Grouping coverage by codeowners')
-
-  const jestReport = readCoverageReport(
-    path.join(JEST_COVERAGE_PATH, 'coverage-final-jest.json')
-  )
-  const cypressReport = readCoverageReport(
-    path.join(CYPRESS_COVERAGE_PATH, 'coverage-final-cypress.json')
-  )
-
-  const codeowners = new Codeowners(workspaceRoot)
-  const teams = getUniqueTeams(codeowners.ownerEntries)
-
-  splitReportIntoTeams({
-    report: jestReport,
-    teams,
-    codeowners,
-    coveragePath: JEST_COVERAGE_PATH,
-  })
-  splitReportIntoTeams({
-    report: cypressReport,
-    teams,
-    codeowners,
-    coveragePath: CYPRESS_COVERAGE_PATH,
-  })
-}
-
-export const groupCoverageByCodeownersCommand = program =>
-  program
-    .command('group-coverage-by-codeowners')
-    .description('Group the coverage data based on code owners')
-    .action(groupCoverageByCodeowners)