@toptal/davinci-monorepo 8.1.4-alpha-CRT-5891-create-coverage-command-e6e5bd51.7 → 8.1.4-alpha-CRT-5891-create-coverage-command-1b2c7953.12

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,20 +4,14 @@ 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.
+#### `generate-team-coverage`
 
 ```sh
-coverage generage-team-coverage [options]
+coverage generate-team-coverage [options]
 
 Options:
   -r, --repository <repository_name>         specify repository name

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toptal/davinci-monorepo",
-  "version": "8.1.4-alpha-CRT-5891-create-coverage-command-e6e5bd51.7+e6e5bd51",
+  "version": "8.1.4-alpha-CRT-5891-create-coverage-command-1b2c7953.12+1b2c7953",
   "description": "Monorepo utility tools",
   "publishConfig": {
     "access": "public"
@@ -35,7 +35,7 @@
   "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-e6e5bd51.39+e6e5bd51",
+    "@toptal/davinci-cli-shared": "2.3.1-alpha-CRT-5891-create-coverage-command-1b2c7953.44+1b2c7953",
     "chalk": "^4.1.2",
     "codeowners": "5.1.1",
     "dependency-cruiser": "^12.5.0",
@@ -54,5 +54,5 @@
   "devDependencies": {
     "@jest/globals": "^29.4.2"
   },
-  "gitHead": "e6e5bd5114c669c12d4b245907649d617b9fdd96"
+  "gitHead": "1b2c79534c7559b73b39c067ab0480eadccf0ebc"
 }

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/__snapshots__/create-generate-team-coverage-command.test.js.snap

@@ -0,0 +1,74 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`createGenerateTeamCoverageCommand has the correct command structure 1`] = `
+"{
+  "_events": {},
+  "_eventsCount": 2,
+  "commands": [],
+  "options": [
+    {
+      "flags": "-r, --repository <repository_name>",
+      "description": "specify repository name",
+      "required": true,
+      "optional": false,
+      "variadic": false,
+      "mandatory": true,
+      "short": "-r",
+      "long": "--repository",
+      "negate": false,
+      "hidden": false,
+      "conflictsWith": []
+    },
+    {
+      "flags": "-o, --output-file-name <output_file_name>",
+      "description": "specify output file name",
+      "required": true,
+      "optional": false,
+      "variadic": false,
+      "mandatory": true,
+      "short": "-o",
+      "long": "--output-file-name",
+      "negate": false,
+      "hidden": false,
+      "conflictsWith": []
+    }
+  ],
+  "parent": null,
+  "_allowUnknownOption": false,
+  "_allowExcessArguments": true,
+  "_args": [],
+  "args": [],
+  "rawArgs": [],
+  "processedArgs": [],
+  "_scriptPath": null,
+  "_name": "generate-team-coverage",
+  "_optionValues": {},
+  "_optionValueSources": {},
+  "_storeOptionsAsProperties": false,
+  "_executableHandler": false,
+  "_executableFile": null,
+  "_executableDir": null,
+  "_defaultCommandName": null,
+  "_exitCallback": null,
+  "_aliases": [],
+  "_combineFlagAndOptionalValue": true,
+  "_description": "Generates team-specific coverage reports by copying and processing coverage data from Jest and Cypress reports.\\nThe resulting coverage reports provide insights into the code coverage metrics for each team.",
+  "_summary": "",
+  "_enablePositionalOptions": false,
+  "_passThroughOptions": false,
+  "_lifeCycleHooks": {},
+  "_showHelpAfterError": false,
+  "_showSuggestionAfterError": true,
+  "_outputConfiguration": {},
+  "_hidden": false,
+  "_hasHelpOption": true,
+  "_helpFlags": "-h, --help",
+  "_helpDescription": "display help for command",
+  "_helpShortFlag": "-h",
+  "_helpLongFlag": "--help",
+  "_helpCommandName": "help",
+  "_helpCommandnameAndArgs": "help [command]",
+  "_helpCommandDescription": "display help for command",
+  "_helpConfiguration": {}
+}"
+`;

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

@@ -0,0 +1,47 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`createGroupCoverageByCodeownersCommand has the correct command structure 1`] = `
+"{
+  "_events": {},
+  "_eventsCount": 0,
+  "commands": [],
+  "options": [],
+  "parent": null,
+  "_allowUnknownOption": false,
+  "_allowExcessArguments": true,
+  "_args": [],
+  "args": [],
+  "rawArgs": [],
+  "processedArgs": [],
+  "_scriptPath": null,
+  "_name": "group-coverage-by-codeowners",
+  "_optionValues": {},
+  "_optionValueSources": {},
+  "_storeOptionsAsProperties": false,
+  "_executableHandler": false,
+  "_executableFile": null,
+  "_executableDir": null,
+  "_defaultCommandName": null,
+  "_exitCallback": null,
+  "_aliases": [],
+  "_combineFlagAndOptionalValue": true,
+  "_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.\\nThe command utilizes the Codeowners class, which is responsible for identifying the code owners associated with each file.",
+  "_summary": "",
+  "_enablePositionalOptions": false,
+  "_passThroughOptions": false,
+  "_lifeCycleHooks": {},
+  "_showHelpAfterError": false,
+  "_showSuggestionAfterError": true,
+  "_outputConfiguration": {},
+  "_hidden": false,
+  "_hasHelpOption": true,
+  "_helpFlags": "-h, --help",
+  "_helpDescription": "display help for command",
+  "_helpShortFlag": "-h",
+  "_helpLongFlag": "--help",
+  "_helpCommandName": "help",
+  "_helpCommandnameAndArgs": "help [command]",
+  "_helpCommandDescription": "display help for command",
+  "_helpConfiguration": {}
+}"
+`;

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

@@ -0,0 +1,141 @@
+import path from 'path'
+import execa from 'execa'
+import { print } from '@toptal/davinci-cli-shared'
+import { readFile, writeFile, mkdir, cp, rm } from 'fs/promises'
+import { existsSync } from 'fs'
+
+import { sanitizeTeamName } from './services/sanitize-team-name/sanitize-team-name.js'
+import { TEAMS_COVERAGE_PATH } from './config.js'
+import { getUniqueTeams } from './services/get-unique-teams/get-unique-teams.js'
+import { asyncCodeownersImport } from '../codeowners/index.js'
+
+const sanitizeNycPercentage = percentage =>
+  percentage === 'Unknown' ? 0 : percentage
+
+const generateNycReport = async ({
+  type,
+  sanitizedTeamPath,
+  sanitizedTeam,
+}) => {
+  const sanitizedTeamPathWithType = path.join(sanitizedTeamPath, type)
+
+  await mkdir(sanitizedTeamPathWithType)
+
+  const fullCoverageTeamPath = path.join(
+    'coverage',
+    type,
+    `coverage-final-${sanitizedTeam}.json`
+  )
+
+  if (!existsSync(fullCoverageTeamPath)) {
+    print.red(`Make sure that '${fullCoverageTeamPath}' exists`)
+    process.exit(1)
+  }
+
+  await cp(
+    path.join(fullCoverageTeamPath),
+    path.join(sanitizedTeamPathWithType, 'coverage-final.json')
+  )
+
+  await execa.command(
+    `yarn nyc report --temp-dir ${sanitizedTeamPathWithType} --reporter json-summary --reporter html --report-dir ${sanitizedTeamPathWithType}`
+  )
+}
+
+const getCoverageSummary = async (type, teamPath) => {
+  const result = {}
+
+  const coverageSummary = JSON.parse(
+    await readFile(path.join(teamPath, type, 'coverage-summary.json'), 'utf8')
+  )
+
+  result[`${type}_lines_coverage`] = sanitizeNycPercentage(
+    coverageSummary.total.lines.pct
+  )
+  result[`${type}_statements_coverage`] = sanitizeNycPercentage(
+    coverageSummary.total.statements.pct
+  )
+  result[`${type}_functions_coverage`] = sanitizeNycPercentage(
+    coverageSummary.total.functions.pct
+  )
+  result[`${type}_branches_coverage`] = sanitizeNycPercentage(
+    coverageSummary.total.branches.pct
+  )
+
+  return result
+}
+
+const generateTeamCoverage = async options => {
+  print.header('Generating team coverage')
+
+  const codeowners = await asyncCodeownersImport()
+
+  const teams = getUniqueTeams(codeowners.ownerEntries)
+
+  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)
+
+    const sanitizedTeam = sanitizeTeamName(team)
+    const sanitizedTeamPath = path.join(TEAMS_COVERAGE_PATH, sanitizedTeam)
+
+    await mkdir(sanitizedTeamPath, { recursive: true })
+
+    await Promise.all([
+      generateNycReport({
+        type: 'jest',
+        sanitizedTeamPath,
+        sanitizedTeam,
+      }),
+      generateNycReport({
+        type: 'cypress',
+        sanitizedTeamPath,
+        sanitizedTeam,
+      }),
+    ])
+  }
+
+  const results = []
+  const created_at = new Date().toISOString()
+
+  for await (const team of teams) {
+    const sanitizedTeam = sanitizeTeamName(team)
+    const sanitizedTeamPath = path.join(TEAMS_COVERAGE_PATH, sanitizedTeam)
+
+    const [jestCoverageSummary, cypressCoverageSummary] = await Promise.all([
+      getCoverageSummary('jest', sanitizedTeamPath),
+      getCoverageSummary('cypress', sanitizedTeamPath),
+    ])
+
+    results.push({
+      created_at,
+      team,
+      repo: options.repository,
+      ...jestCoverageSummary,
+      ...cypressCoverageSummary,
+    })
+  }
+
+  return writeFile(options.outputFileName, JSON.stringify(results, null, 2))
+}
+
+export const createGenerateTeamCoverageCommand = program =>
+  program
+    .createCommand('generate-team-coverage')
+    .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'
+    )
+    .requiredOption(
+      '-o, --output-file-name <output_file_name>',
+      'specify output file name'
+    )
+    .action(generateTeamCoverage)

package/src/commands/coverage-command/create-generate-team-coverage-command.test.js

@@ -0,0 +1,25 @@
+import { jest } from '@jest/globals'
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Command } from 'commander'
+
+const { createGenerateTeamCoverageCommand } = await import(
+  './create-generate-team-coverage-command.js'
+)
+
+describe('createGenerateTeamCoverageCommand', () => {
+  let program
+
+  beforeEach(() => {
+    program = new Command()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('has the correct command structure', () => {
+    const command = createGenerateTeamCoverageCommand(program)
+
+    expect(JSON.stringify(command, null, 2)).toMatchSnapshot()
+  })
+})

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

@@ -0,0 +1,103 @@
+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 { existsSync } from 'fs'
+
+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 fullPath = path.join(workspaceRoot, reportPathName)
+
+  if (!existsSync(fullPath)) {
+    print.red(`Make sure that '${fullPath}' exists`)
+    process.exit(1)
+  }
+
+  const data = await readFile(fullPath, '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
+    .createCommand('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/create-group-coverage-by-codeowners-command.test.js

@@ -0,0 +1,25 @@
+import { jest } from '@jest/globals'
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { Command } from 'commander'
+
+const { createGroupCoverageByCodeownersCommand } = await import(
+  './create-group-coverage-by-codeowners-command.js'
+)
+
+describe('createGroupCoverageByCodeownersCommand', () => {
+  let program
+
+  beforeEach(() => {
+    program = new Command()
+  })
+
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('has the correct command structure', () => {
+    const command = createGroupCoverageByCodeownersCommand(program)
+
+    expect(JSON.stringify(command, null, 2)).toMatchSnapshot()
+  })
+})

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

@@ -1,15 +1,11 @@
-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 =>
+  program
     .createCommand('coverage')
     .description(
       'Provides code coverage analysis, including organizing coverage reports by code owners and generating team-specific reports'
     )
-
-  groupCoverageByCodeownersCommand(coverage)
-  generateTeamCoverageCommand(coverage)
-
-  return coverage
-}
+    .addCommand(createGroupCoverageByCodeownersCommand(program))
+    .addCommand(createGenerateTeamCoverageCommand(program))

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

@@ -1,4 +1,5 @@
-export const getUniqueTeams = teams =>
-  teams
-    .flatMap(entry => entry.usernames)
-    .filter((teamName, index, allTeams) => allTeams.indexOf(teamName) === index)
+export const getUniqueTeams = teams => {
+  const allTeams = teams.flatMap(entry => entry.usernames)
+
+  return [...new Set(allTeams)]
+}

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/generate-team-coverage.js

@@ -1,131 +0,0 @@
-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 { sanitizeTeamName } from './services/sanitize-team-name/sanitize-team-name.js'
-import {
-  CYPRESS_COVERAGE_PATH,
-  JEST_COVERAGE_PATH,
-  TEAMS_COVERAGE_PATH,
-} from './config.js'
-import { getUniqueTeams } from './services/get-unique-teams/get-unique-teams.js'
-
-const workspaceRoot = getWorkspaceRoot()
-
-const sanitizeNycPercentage = percentage =>
-  percentage === 'Unknown' ? 0 : percentage
-
-const getCoverageSummary = (type, teamPath) => {
-  const result = {}
-
-  const coverageSummary = JSON.parse(
-    fs.readFileSync(`${teamPath}/${type}/coverage-summary.json`, 'utf8')
-  )
-
-  result[`${type}_lines_coverage`] = sanitizeNycPercentage(
-    coverageSummary.total.lines.pct
-  )
-  result[`${type}_statements_coverage`] = sanitizeNycPercentage(
-    coverageSummary.total.statements.pct
-  )
-  result[`${type}_functions_coverage`] = sanitizeNycPercentage(
-    coverageSummary.total.functions.pct
-  )
-  result[`${type}_branches_coverage`] = sanitizeNycPercentage(
-    coverageSummary.total.branches.pct
-  )
-
-  return result
-}
-
-// eslint-disable-next-line max-statements
-const generateTeamCoverage = async options => {
-  print.header('Generating team coverage')
-
-  let codeowners
-  const { default: CodeOwnersTool } = await import(
-    // eslint-disable-next-line no-restricted-syntax
-    'codeowners/codeowners.js'
-  )
-
-  try {
-    codeowners = new CodeOwnersTool(workspaceRoot)
-  } catch (e) {
-    console.error(e.message)
-    process.exit(1)
-  }
-
-  const teams = getUniqueTeams(codeowners.ownerEntries)
-
-  print.grey('Teams: ', teams)
-
-  await execa.command(`rm -rf ${TEAMS_COVERAGE_PATH}`)
-  await execa.command(`mkdir ${TEAMS_COVERAGE_PATH}`)
-
-  for await (const team of teams) {
-    print.grey('Team coverage: ', team)
-
-    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`
-    )
-  }
-
-  const results = []
-  const created_at = new Date().toISOString()
-
-  for await (const team of teams) {
-    const sanitizedTeam = sanitizeTeamName(team)
-    const sanitizedTeamPath = path.join(TEAMS_COVERAGE_PATH, sanitizedTeam)
-
-    const jestCoverageSummary = getCoverageSummary('jest', sanitizedTeamPath)
-    const cypressCoverageSummary = getCoverageSummary(
-      'cypress',
-      sanitizedTeamPath
-    )
-
-    const result = {
-      created_at,
-      team,
-      repo: options.repository,
-      ...jestCoverageSummary,
-      ...cypressCoverageSummary,
-    }
-
-    results.push(result)
-  }
-
-  fs.writeFileSync(options.outputFileName, JSON.stringify(results, null, 2))
-}
-
-export const generateTeamCoverageCommand = program =>
-  program
-    .command('generate-team-coverage')
-    .description('Generate team-specific coverage reports')
-    .requiredOption(
-      '-r, --repository <repository_name>',
-      'specify repository name'
-    )
-    .requiredOption(
-      '-o, --output-file-name <output_file_name>',
-      'specify output file name'
-    )
-    .action(generateTeamCoverage)

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

@@ -1,94 +0,0 @@
-import path from 'path'
-import fs from 'fs'
-import { print } from '@toptal/davinci-cli-shared'
-import getWorkspaceRoot from 'find-yarn-workspace-root'
-
-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')
-  )
-
-  let codeowners
-  const { default: CodeOwnersTool } = await import(
-    // eslint-disable-next-line no-restricted-syntax
-    'codeowners/codeowners.js'
-  )
-
-  try {
-    codeowners = new CodeOwnersTool(workspaceRoot)
-  } catch (e) {
-    console.error(e.message)
-    process.exit(1)
-  }
-
-  const teams = getUniqueTeams(codeowners.ownerEntries)
-
-  print.grey('Teams: ', teams)
-
-  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)