@form8ion/codecov 7.6.0 → 7.6.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@form8ion/codecov",
   "description": "code coverage service plugin for form8ion",
   "license": "MIT",
-  "version": "7.6.0",
+  "version": "7.6.1",
   "type": "module",
   "engines": {
     "node": "^20.19.0 || >=22.14.0"
@@ -47,7 +47,8 @@
   },
   "files": [
     "example.js",
-    "lib/"
+    "lib/",
+    "src/"
   ],
   "publishConfig": {
     "access": "public",

package/src/badge/index.js

@@ -0,0 +1 @@
+export {scaffold} from './scaffolder.js';

package/src/badge/repository-details-fetcher.js

@@ -0,0 +1,10 @@
+import got from 'got';
+
+export default async function fetchRepositoryDetails({vcs, apiAccessToken}) {
+  const {body: {repo}} = await got(
+    `https://codecov.io/api/gh/${vcs.owner}/${vcs.name}`,
+    {headers: {Authorization: apiAccessToken}, responseType: 'json'}
+  );
+
+  return repo;
+}

package/src/badge/repository-details-fetcher.test.js

@@ -0,0 +1,33 @@
+import got from 'got';
+
+import {expect, describe, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import fetchRepositoryDetails from './repository-details-fetcher.js';
+
+vi.mock('got');
+
+describe('repository-details-fetcher', () => {
+  it('should fetch repository details from the codecov api', async () => {
+    const apiAccessToken = any.string();
+    const vcsHost = any.word();
+    const vcsOwner = any.word();
+    const vcsName = any.word();
+    const vcs = {
+      ...any.simpleObject(),
+      host: vcsHost,
+      owner: vcsOwner,
+      name: vcsName
+    };
+    const repoDetails = any.simpleObject();
+    when(got)
+      .calledWith(
+        `https://codecov.io/api/gh/${vcsOwner}/${vcsName}`,
+        {headers: {Authorization: apiAccessToken}, responseType: 'json'}
+      )
+      .thenResolve({body: {repo: repoDetails}});
+
+    expect(await fetchRepositoryDetails({vcs, apiAccessToken})).toEqual(repoDetails);
+  });
+});

package/src/badge/scaffolder.js

@@ -0,0 +1,21 @@
+import fetchRepositoryDetails from './repository-details-fetcher.js';
+
+export async function scaffold({vcs, apiAccessToken}) {
+  return {
+    ...['github', 'gitlab', 'bitbucket'].includes(vcs?.host) && {
+      badges: {
+        status: {
+          coverage: {
+            img: `https://img.shields.io/codecov/c/${vcs.host}/${vcs.owner}/${vcs.name}?logo=codecov${
+              apiAccessToken
+                ? `&token=${(await fetchRepositoryDetails({vcs, apiAccessToken})).image_token}`
+                : ''
+            }`,
+            link: `https://codecov.io/${vcs.host}/${vcs.owner}/${vcs.name}`,
+            text: 'Codecov'
+          }
+        }
+      }
+    }
+  };
+}

package/src/badge/scaffolder.test.js

@@ -0,0 +1,53 @@
+import {it, vi, describe, expect} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import fetchRepositoryDetails from './repository-details-fetcher.js';
+import {scaffold} from './scaffolder.js';
+
+vi.mock('./repository-details-fetcher.js');
+
+describe('badge scaffolder', () => {
+  const vcsHost = any.fromList(['github', 'gitlab', 'bitbucket']);
+  const vcsOwner = any.word();
+  const vcsName = any.word();
+  const vcs = {
+    ...any.simpleObject(),
+    host: vcsHost,
+    owner: vcsOwner,
+    name: vcsName
+  };
+
+  it('should scaffold badge details for supported vcs hosts', async () => {
+    const {badges} = await scaffold({vcs});
+
+    expect(badges.status.coverage).toEqual({
+      img: `https://img.shields.io/codecov/c/${vcsHost}/${vcsOwner}/${vcsName}?logo=codecov`,
+      link: `https://codecov.io/${vcsHost}/${vcsOwner}/${vcsName}`,
+      text: 'Codecov'
+    });
+  });
+
+  it('should include the image token in the img url', async () => {
+    const apiAccessToken = any.string();
+    const token = any.word();
+    when(fetchRepositoryDetails).calledWith({vcs, apiAccessToken}).thenResolve({image_token: token});
+
+    const {badges} = await scaffold({vcs, apiAccessToken});
+
+    expect(badges.status.coverage.img)
+      .toEqual(`https://img.shields.io/codecov/c/${vcsHost}/${vcsOwner}/${vcsName}?logo=codecov&token=${token}`);
+  });
+
+  it('should not define the badge if shields.io badge does not support the host', async () => {
+    const {badges} = await scaffold({vcs: {host: any.word()}});
+
+    expect(badges).toBe(undefined);
+  });
+
+  it('should not define the badge if vcs details are not defined', async () => {
+    const {badges} = await scaffold({});
+
+    expect(badges).toBe(undefined);
+  });
+});

package/src/config/index.js

@@ -0,0 +1 @@
+export {default as scaffold} from './scaffolder.js';

package/src/config/scaffolder.js

@@ -0,0 +1,10 @@
+import {fileTypes, writeConfigFile} from '@form8ion/core';
+
+export default async function scaffoldConfig({projectRoot}) {
+  await writeConfigFile({
+    format: fileTypes.YAML,
+    path: projectRoot,
+    name: '.codecov',
+    config: {comment: {layout: 'reach,diff,flags,tree'}}
+  });
+}

package/src/config/scaffolder.test.js

@@ -0,0 +1,23 @@
+import {fileTypes, writeConfigFile} from '@form8ion/core';
+
+import {describe, it, expect, vi} from 'vitest';
+import any from '@travi/any';
+
+import scaffoldConfig from './scaffolder.js';
+
+vi.mock('@form8ion/core');
+
+describe('config scaffolder', () => {
+  it('should create the config file', async () => {
+    const projectRoot = any.string();
+
+    await scaffoldConfig({projectRoot});
+
+    expect(writeConfigFile).toHaveBeenCalledWith({
+      format: fileTypes.YAML,
+      path: projectRoot,
+      name: '.codecov',
+      config: {comment: {layout: 'reach,diff,flags,tree'}}
+    });
+  });
+});

package/src/index.js

@@ -0,0 +1,4 @@
+export {scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';
+export {lift} from './lifter.js';
+export {default as remove} from './remover.js';

package/src/lifter.js

@@ -0,0 +1,15 @@
+import deepmerge from 'deepmerge';
+
+import {scaffold as scaffoldConfig} from './config/index.js';
+import {scaffold as scaffoldBadge} from './badge/index.js';
+import {lift as liftReporting} from './reporter/index.js';
+
+export async function lift({projectRoot, packageManager, vcs}) {
+  const [reportingResults, badgeResults] = await Promise.all([
+    liftReporting({projectRoot, packageManager}),
+    scaffoldBadge({vcs}),
+    scaffoldConfig({projectRoot})
+  ]);
+
+  return deepmerge.all([reportingResults, badgeResults]);
+}

package/src/lifter.test.js

@@ -0,0 +1,33 @@
+import deepmerge from 'deepmerge';
+
+import {expect, it, vi, describe} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {scaffold as scaffoldConfig} from './config/index.js';
+import {scaffold as scaffoldBadge} from './badge/index.js';
+import {lift as liftReporting} from './reporter/index.js';
+import {lift} from './lifter.js';
+
+vi.mock('deepmerge');
+vi.mock('./config/index.js');
+vi.mock('./badge/index.js');
+vi.mock('./reporter/index.js');
+
+describe('lifter', () => {
+  it('should lift the reporting process', async () => {
+    const projectRoot = any.string();
+    const packageManager = any.word();
+    const vcs = any.simpleObject();
+    const reportingResults = any.simpleObject();
+    const badgeResults = any.simpleObject();
+    const mergedResults = any.simpleObject();
+    when(liftReporting).calledWith({projectRoot, packageManager}).thenResolve(reportingResults);
+    when(scaffoldBadge).calledWith({vcs}).thenResolve(badgeResults);
+    when(deepmerge.all).calledWith([reportingResults, badgeResults]).thenReturn(mergedResults);
+
+    expect(await lift({projectRoot, packageManager, vcs})).toEqual(mergedResults);
+
+    expect(scaffoldConfig).toHaveBeenCalledWith({projectRoot});
+  });
+});

package/src/predicates.js

@@ -0,0 +1,3 @@
+export function coverageShouldBeReportedToCodecov({vcs, visibility, apiAccessToken}) {
+  return !!('Public' === visibility || (apiAccessToken && 'github' === vcs.host));
+}

package/src/predicates.test.js

@@ -0,0 +1,31 @@
+import {expect, it, describe} from 'vitest';
+import any from '@travi/any';
+
+import {coverageShouldBeReportedToCodecov} from './predicates.js';
+
+describe('predicates', () => {
+  it('should determine that coverage should be reported when the project is public', () => {
+    expect(coverageShouldBeReportedToCodecov({visibility: 'Public'})).toBe(true);
+  });
+
+  it(
+    'should determine that coverage should be reported when an API token is provided and GitHub is the VCS host',
+    async () => {
+      expect(coverageShouldBeReportedToCodecov({apiAccessToken: any.word(), vcs: {host: 'github'}})).toBe(true);
+    }
+  );
+
+  it(
+    'should determine that coverage should not be reported when the project is not public and no API token is provided',
+    async () => {
+      expect(coverageShouldBeReportedToCodecov({})).toBe(false);
+    }
+  );
+
+  it(
+    "should determine that coverage should not be reported when an API token is provided but the VCS host isn't GitHub",
+    async () => {
+      expect(coverageShouldBeReportedToCodecov({apiAccessToken: any.word(), vcs: {host: any.word()}})).toBe(false);
+    }
+  );
+});

package/src/remover.js

@@ -0,0 +1,9 @@
+import {remove as removeAction, test as githubWorkflowExists} from './reporter/ci-providers/github-workflows/index.js';
+
+export default async function removeCodecov({projectRoot}) {
+  if (await githubWorkflowExists({projectRoot})) {
+    await removeAction({projectRoot});
+  }
+
+  return {};
+}

package/src/remover.test.js

@@ -0,0 +1,27 @@
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {remove as removeAction, test as githubWorkflowExists} from './reporter/ci-providers/github-workflows/index.js';
+import remove from './remover.js';
+
+vi.mock(('./reporter/ci-providers/github-workflows/index.js'));
+
+describe('remover', () => {
+  const projectRoot = any.string();
+
+  it('should remove the various parts', async () => {
+    when(githubWorkflowExists).calledWith({projectRoot}).thenResolve(true);
+
+    expect(await remove({projectRoot})).toEqual({});
+    expect(removeAction).toHaveBeenCalledWith({projectRoot});
+  });
+
+  it('should not remove the action if there is no GitHub Actions workflow', async () => {
+    when(githubWorkflowExists).calledWith({projectRoot}).thenResolve(false);
+
+    await remove({projectRoot});
+
+    expect(removeAction).not.toHaveBeenCalled();
+  });
+});

package/src/reporter/ci-providers/github-workflows/action/constants.js

@@ -0,0 +1 @@
+export const ACTION_NAME = 'codecov/codecov-action';

package/src/reporter/ci-providers/github-workflows/action/index.js

@@ -0,0 +1,4 @@
+export {default as scaffold} from './scaffolder.js';
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';
+export {default as remove} from './remover.js';

package/src/reporter/ci-providers/github-workflows/action/lifter.js

@@ -0,0 +1,12 @@
+export default function liftAction(action) {
+  return {
+    name: 'Upload unit test coverage to Codecov',
+    ...action,
+    with: {
+      // eslint-disable-next-line no-template-curly-in-string
+      token: '${{ secrets.CODECOV_TOKEN }}',
+      flags: 'unit',
+      report_type: 'coverage'
+    }
+  };
+}

package/src/reporter/ci-providers/github-workflows/action/lifter.test.js

@@ -0,0 +1,21 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import liftAction from './lifter.js';
+
+describe('action lifter', () => {
+  it('should expose the token secret to the action', async () => {
+    const existingAction = any.simpleObject();
+
+    expect(liftAction(existingAction)).toEqual({
+      name: 'Upload unit test coverage to Codecov',
+      ...existingAction,
+      with: {
+        // eslint-disable-next-line no-template-curly-in-string
+        token: '${{ secrets.CODECOV_TOKEN }}',
+        flags: 'unit',
+        report_type: 'coverage'
+      }
+    });
+  });
+});

package/src/reporter/ci-providers/github-workflows/action/remover.js

@@ -0,0 +1,6 @@
+import {removeActionFromJobs} from '@form8ion/github-workflows-core';
+import {ACTION_NAME} from './constants.js';
+
+export default function removeCodecovActionFrom(jobs) {
+  return removeActionFromJobs(jobs, ACTION_NAME);
+}

package/src/reporter/ci-providers/github-workflows/action/remover.test.js

@@ -0,0 +1,22 @@
+import {removeActionFromJobs} from '@form8ion/github-workflows-core';
+
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import removeCodecovActionFrom from './remover.js';
+import {ACTION_NAME} from './constants.js';
+
+vi.mock('@form8ion/github-workflows-core');
+
+describe('codecov action', () => {
+  describe('remove from jobs', () => {
+    it('should remove the codecov action from the provided jobs', async () => {
+      const jobs = any.listOf(any.simpleObject);
+      const updatedJobs = any.listOf(any.simpleObject);
+      when(removeActionFromJobs).calledWith(jobs, ACTION_NAME).thenReturn(updatedJobs);
+
+      expect(removeCodecovActionFrom(jobs)).toEqual(updatedJobs);
+    });
+  });
+});

package/src/reporter/ci-providers/github-workflows/action/scaffolder.js

@@ -0,0 +1,14 @@
+import {ACTION_NAME} from './constants.js';
+
+export default function scaffoldAction() {
+  return {
+    name: 'Upload unit test coverage to Codecov',
+    uses: `${ACTION_NAME}@v5.5.2`,
+    with: {
+      // eslint-disable-next-line no-template-curly-in-string
+      token: '${{ secrets.CODECOV_TOKEN }}',
+      flags: 'unit',
+      report_type: 'coverage'
+    }
+  };
+}

package/src/reporter/ci-providers/github-workflows/action/scaffolder.test.js

@@ -0,0 +1,19 @@
+import {describe, it, expect} from 'vitest';
+
+import scaffoldAction from './scaffolder.js';
+import {ACTION_NAME} from './constants.js';
+
+describe('codecov action scaffolder', () => {
+  it('should scaffold the codecov action', async () => {
+    expect(scaffoldAction()).toEqual({
+      name: 'Upload unit test coverage to Codecov',
+      uses: `${ACTION_NAME}@v5.5.2`,
+      with: {
+        // eslint-disable-next-line no-template-curly-in-string
+        token: '${{ secrets.CODECOV_TOKEN }}',
+        flags: 'unit',
+        report_type: 'coverage'
+      }
+    });
+  });
+});

package/src/reporter/ci-providers/github-workflows/action/tester.js

@@ -0,0 +1,9 @@
+import {ACTION_NAME} from './constants.js';
+
+export default function stepIsCodecovAction(step) {
+  if (!step.uses) return false;
+
+  const [actionName] = step.uses.split('@');
+
+  return ACTION_NAME === actionName;
+}

package/src/reporter/ci-providers/github-workflows/action/tester.test.js

@@ -0,0 +1,23 @@
+import {describe, it, expect} from 'vitest';
+import any from '@travi/any';
+
+import stepIsCodecovAction from './tester.js';
+import {ACTION_NAME} from './constants.js';
+
+describe('action tester', () => {
+  it('should return `false` if the step does not use an action', async () => {
+    expect(stepIsCodecovAction(any.simpleObject())).toBe(false);
+  });
+
+  it('should return `false` if the step does not use the CodeCov action', async () => {
+    const otherAction = {...any.simpleObject(), uses: 'something-else@v1.2.3'};
+
+    expect(stepIsCodecovAction(otherAction)).toBe(false);
+  });
+
+  it('should return `true` if the step uses the CodeCov action', async () => {
+    const codecovAction = {...any.simpleObject(), uses: `${ACTION_NAME}@v5.5.2`};
+
+    expect(stepIsCodecovAction(codecovAction)).toBe(true);
+  });
+});

package/src/reporter/ci-providers/github-workflows/index.js

@@ -0,0 +1,3 @@
+export {lift} from './lifter.js';
+export {default as remove} from './remover.js';
+export {default as test} from './predicate.js';

package/src/reporter/ci-providers/github-workflows/lifter.js

@@ -0,0 +1,25 @@
+import {loadWorkflowFile, writeWorkflowFile} from '@form8ion/github-workflows-core';
+
+import {lift as liftSteps} from './steps/index.js';
+
+export async function lift({projectRoot}) {
+  const ciWorkflowName = 'node-ci';
+
+  const workflowDetails = await loadWorkflowFile({projectRoot, name: ciWorkflowName});
+  const {jobs: {verify: {steps}}} = workflowDetails;
+
+  await writeWorkflowFile({
+    projectRoot,
+    name: ciWorkflowName,
+    config: {
+      ...workflowDetails,
+      jobs: {
+        ...workflowDetails.jobs,
+        verify: {
+          ...workflowDetails.jobs.verify,
+          steps: liftSteps(steps)
+        }
+      }
+    }
+  });
+}

package/src/reporter/ci-providers/github-workflows/lifter.test.js

@@ -0,0 +1,47 @@
+import {loadWorkflowFile, writeWorkflowFile} from '@form8ion/github-workflows-core';
+
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {lift as liftSteps} from './steps/index.js';
+import {lift as configureGithubWorkflow} from './lifter.js';
+
+vi.mock('@form8ion/github-workflows-core');
+vi.mock('./steps/index.js');
+
+describe('github workflow lifter', () => {
+  const projectRoot = any.string();
+  const ciWorkflowName = 'node-ci';
+  const liftedSteps = any.listOf(any.simpleObject);
+
+  it('should add the codecov action to the verify job', async () => {
+    const otherTopLevelProperties = any.simpleObject();
+    const otherJobs = any.simpleObject();
+    const otherVerifyProperties = any.simpleObject();
+    const existingVerifySteps = any.listOf(any.simpleObject);
+    const existingWorkflowContents = {
+      ...otherTopLevelProperties,
+      jobs: {...otherJobs, verify: {...otherVerifyProperties, steps: existingVerifySteps}}
+    };
+    when(loadWorkflowFile).calledWith({projectRoot, name: ciWorkflowName}).thenResolve(existingWorkflowContents);
+    when(liftSteps).calledWith(existingVerifySteps).thenReturn(liftedSteps);
+
+    await configureGithubWorkflow({projectRoot});
+
+    expect(writeWorkflowFile).toHaveBeenCalledWith({
+      projectRoot,
+      name: ciWorkflowName,
+      config: {
+        ...otherTopLevelProperties,
+        jobs: {
+          ...otherJobs,
+          verify: {
+            ...otherVerifyProperties,
+            steps: liftedSteps
+          }
+        }
+      }
+    });
+  });
+});

package/src/reporter/ci-providers/github-workflows/predicate.js

@@ -0,0 +1,5 @@
+import {workflowFileExists} from '@form8ion/github-workflows-core';
+
+export default function ciWorkflowExists({projectRoot}) {
+  return workflowFileExists({projectRoot, name: 'node-ci'});
+}

package/src/reporter/ci-providers/github-workflows/predicate.test.js

@@ -0,0 +1,20 @@
+import {workflowFileExists} from '@form8ion/github-workflows-core';
+
+import {expect, describe, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import ciWorkflowExists from './predicate.js';
+
+vi.mock('@form8ion/github-workflows-core');
+
+describe('github workflows predicate', () => {
+  const projectRoot = any.string();
+
+  it('should determine whether the verification workflow exists', async () => {
+    const workflowExists = any.boolean();
+    when(workflowFileExists).calledWith({projectRoot, name: 'node-ci'}).thenResolve(workflowExists);
+
+    expect(await ciWorkflowExists({projectRoot})).toEqual(workflowExists);
+  });
+});

package/src/reporter/ci-providers/github-workflows/remover.js

@@ -0,0 +1,9 @@
+import {loadWorkflowFile, writeWorkflowFile} from '@form8ion/github-workflows-core';
+import {remove as removeCodecovActionFrom} from './action/index.js';
+
+export default async function removeCodecovAction({projectRoot}) {
+  const existingConfig = await loadWorkflowFile({projectRoot, name: 'node-ci'});
+  existingConfig.jobs = removeCodecovActionFrom(existingConfig.jobs);
+
+  await writeWorkflowFile({projectRoot, name: 'node-ci', config: existingConfig});
+}

package/src/reporter/ci-providers/github-workflows/remover.test.js

@@ -0,0 +1,30 @@
+import {loadWorkflowFile, writeWorkflowFile} from '@form8ion/github-workflows-core';
+
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {remove as removeCodecovActionFrom} from './action/index.js';
+import remove from './remover.js';
+
+vi.mock('@form8ion/github-workflows-core');
+vi.mock('./action/index.js');
+
+describe('action remover', () => {
+  it('should remove the action from the workflow', async () => {
+    const projectRoot = any.string();
+    const updatedJobs = any.simpleObject();
+    const ciWorkflowName = 'node-ci';
+    const existingWorkflowDefinition = {...any.simpleObject(), jobs: any.simpleObject()};
+    when(loadWorkflowFile).calledWith({projectRoot, name: ciWorkflowName}).thenResolve(existingWorkflowDefinition);
+    when(removeCodecovActionFrom).calledWith(existingWorkflowDefinition.jobs).thenReturn(updatedJobs);
+
+    await remove({projectRoot});
+
+    expect(writeWorkflowFile).toHaveBeenCalledWith({
+      projectRoot,
+      name: ciWorkflowName,
+      config: {...existingWorkflowDefinition, jobs: updatedJobs}
+    });
+  });
+});

package/src/reporter/ci-providers/github-workflows/steps/index.js

@@ -0,0 +1,2 @@
+export {default as test} from './tester.js';
+export {default as lift} from './lifter.js';

package/src/reporter/ci-providers/github-workflows/steps/lifter.js

@@ -0,0 +1,16 @@
+import {scaffold as scaffoldAction, lift as liftAction, test as stepIsCodecovAction} from '../action/index.js';
+import codecovActionExistsInSteps from './tester.js';
+
+export default function liftSteps(steps) {
+  if (!codecovActionExistsInSteps(steps)) {
+    const stepsWithLegacyReportingRemoved = steps.filter(({run}) => 'npm run coverage:report' !== run);
+
+    return [...stepsWithLegacyReportingRemoved, scaffoldAction()];
+  }
+
+  return steps.map(step => {
+    if (stepIsCodecovAction(step)) return liftAction(step);
+
+    return step;
+  });
+}

package/src/reporter/ci-providers/github-workflows/steps/lifter.test.js

@@ -0,0 +1,48 @@
+import {describe, it, expect, vi} from 'vitest';
+import any from '@travi/any';
+import {when} from 'vitest-when';
+
+import {scaffold as scaffoldAction, lift as liftAction, test as stepIsCodecovAction} from '../action/index.js';
+import codecovActionExistsInSteps from './tester.js';
+import liftSteps from './lifter.js';
+
+vi.mock('../action/index.js');
+vi.mock('./tester.js');
+
+describe('steps lifter', () => {
+  const codecovAction = any.simpleObject();
+
+  it('should append the CodeCov step if it doesnt already exist', async () => {
+    const steps = any.listOf(any.simpleObject);
+    when(codecovActionExistsInSteps).calledWith(steps).thenReturn(false);
+    when(scaffoldAction).calledWith().thenReturn(codecovAction);
+
+    expect(liftSteps(steps)).toEqual([...steps, codecovAction]);
+  });
+
+  it('should remove the legacy reporting step, if present', async () => {
+    const stepsBeforeLegacy = any.listOf(any.simpleObject);
+    const stepsAfterLegacy = any.listOf(any.simpleObject);
+    const steps = [
+      ...stepsBeforeLegacy,
+      {...any.simpleObject(), run: 'npm run coverage:report'},
+      ...stepsAfterLegacy
+    ];
+    when(codecovActionExistsInSteps).calledWith(steps).thenReturn(false);
+    when(scaffoldAction).calledWith().thenReturn(codecovAction);
+
+    expect(liftSteps(steps)).toEqual([...stepsBeforeLegacy, ...stepsAfterLegacy, codecovAction]);
+  });
+
+  it('should lift the existing action, if present', async () => {
+    const stepsBeforeExisting = any.listOf(any.simpleObject);
+    const stepsAfterExisting = any.listOf(any.simpleObject);
+    const existingAction = any.simpleObject();
+    const steps = [...stepsBeforeExisting, existingAction, ...stepsAfterExisting];
+    when(codecovActionExistsInSteps).calledWith(steps).thenReturn(true);
+    when(stepIsCodecovAction).calledWith(existingAction).thenReturn(true);
+    when(liftAction).calledWith(existingAction).thenReturn(codecovAction);
+
+    expect(liftSteps(steps)).toEqual([...stepsBeforeExisting, codecovAction, ...stepsAfterExisting]);
+  });
+});

package/src/reporter/ci-providers/github-workflows/steps/tester.js

@@ -0,0 +1,5 @@
+import {test as stepIsCodecovAction} from '../action/index.js';
+
+export default function codecovActionExistsInSteps(steps) {
+  return !!steps.find(step => stepIsCodecovAction(step));
+}

package/src/reporter/ci-providers/github-workflows/steps/tester.test.js

@@ -0,0 +1,25 @@
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {test as stepIsCodecovAction} from '../action/index.js';
+import codecovActionExistsInSteps from './tester.js';
+
+vi.mock('../action/index.js');
+
+describe('codecov action tester', () => {
+  it('should return `true` if the codecov action is found in the list of provided steps', async () => {
+    const codecovAction = any.simpleObject();
+    when(stepIsCodecovAction).calledWith(codecovAction).thenReturn(true);
+
+    expect(codecovActionExistsInSteps([
+      ...any.listOf(any.simpleObject),
+      codecovAction,
+      ...any.listOf(any.simpleObject)
+    ])).toBe(true);
+  });
+
+  it('should return `false` if no codecov action is found in the list of provided steps', async () => {
+    expect(codecovActionExistsInSteps(any.listOf(any.simpleObject))).toBe(false);
+  });
+});

package/src/reporter/ci-providers/index.js

@@ -0,0 +1 @@
+export {lift, test} from './github-workflows/index.js';

package/src/reporter/index.js

@@ -0,0 +1 @@
+export {default as lift} from './lifter.js';

package/src/reporter/lifter.js

@@ -0,0 +1,38 @@
+import {promises as fs} from 'node:fs';
+import {writePackageJson} from '@form8ion/javascript-core';
+
+import {execa} from 'execa';
+import {lift as liftCiProvider, test as ciProviderIsLiftable} from './ci-providers/index.js';
+
+export default async function liftReporter({projectRoot, packageManager}) {
+  const pathToPackageJson = `${projectRoot}/package.json`;
+
+  const [ciProviderCanBeLifted, existingPackageContents] = await Promise.all([
+    ciProviderIsLiftable({projectRoot}),
+    fs.readFile(pathToPackageJson, 'utf-8')
+  ]);
+  const parsedPackageContents = JSON.parse(existingPackageContents);
+  const {scripts} = parsedPackageContents;
+  const {'coverage:report': reportCoverageScript, ...otherScripts} = scripts;
+
+  if (ciProviderCanBeLifted) await liftCiProvider({projectRoot});
+
+  if (scripts['coverage:report']) {
+    parsedPackageContents.scripts = otherScripts;
+    await writePackageJson({projectRoot, config: parsedPackageContents});
+
+    await execa(packageManager, ['remove', 'codecov']);
+
+    return {
+      ...!ciProviderCanBeLifted && {
+        nextSteps: [{
+          summary: 'Configure modern reporting to Codecov on your CI service',
+          description: 'Configure the [Codecov Uploader](https://docs.codecov.com/docs/codecov-uploader) appropriately'
+            + ' for your CI Provider. If available for your provider, prefer one of the dedicated wrappers.'
+        }]
+      }
+    };
+  }
+
+  return {};
+}

package/src/reporter/lifter.test.js

@@ -0,0 +1,70 @@
+import {promises as fs} from 'node:fs';
+import {execa} from 'execa';
+import {writePackageJson} from '@form8ion/javascript-core';
+
+import {it, describe, vi, expect} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import {lift as liftCiProvider, test as ciProviderIsLiftable} from './ci-providers/index.js';
+import liftReporting from './lifter.js';
+
+vi.mock('node:fs');
+vi.mock('execa');
+vi.mock('@form8ion/javascript-core');
+vi.mock('./ci-providers/index.js');
+
+describe('reporting lifter', () => {
+  const projectRoot = any.string();
+  const packageManager = any.word();
+  const pathToPackageJson = `${projectRoot}/package.json`;
+
+  it('should remove the legacy node reporter', async () => {
+    const otherScripts = any.simpleObject();
+    const otherTopLevelProperties = any.simpleObject();
+    const existingPackageContents = {
+      ...otherTopLevelProperties,
+      scripts: {...otherScripts, 'coverage:report': any.string()}
+    };
+    when(fs.readFile).calledWith(pathToPackageJson, 'utf-8').thenResolve(JSON.stringify(existingPackageContents));
+    when(ciProviderIsLiftable).calledWith({projectRoot}).thenResolve(false);
+
+    const {nextSteps} = await liftReporting({projectRoot, packageManager});
+
+    expect(nextSteps).toEqual([{
+      summary: 'Configure modern reporting to Codecov on your CI service',
+      description: 'Configure the [Codecov Uploader](https://docs.codecov.com/docs/codecov-uploader) appropriately'
+        + ' for your CI Provider. If available for your provider, prefer one of the dedicated wrappers.'
+    }]);
+
+    expect(execa).toHaveBeenCalledWith(packageManager, ['remove', 'codecov']);
+    expect(writePackageJson).toHaveBeenCalledWith({
+      projectRoot,
+      config: {...otherTopLevelProperties, scripts: otherScripts}
+    });
+    expect(liftCiProvider).not.toHaveBeenCalled();
+  });
+
+  it('should lift the ci provider when supported', async () => {
+    when(fs.readFile)
+      .calledWith(pathToPackageJson, 'utf-8')
+      .thenResolve(JSON.stringify({
+        ...any.simpleObject(),
+        scripts: {...any.simpleObject(), 'coverage:report': any.string()}
+      }));
+    when(ciProviderIsLiftable).calledWith({projectRoot}).thenResolve(true);
+
+    const {nextSteps} = await liftReporting({projectRoot, packageManager});
+
+    expect(liftCiProvider).toHaveBeenCalledWith({projectRoot});
+    expect(nextSteps).toBeUndefined();
+  });
+
+  it('should not update the `package.json` if it did not contain a `coverage:report` script', async () => {
+    const existingPackageContents = {...any.simpleObject(), scripts: any.simpleObject()};
+    when(fs.readFile).calledWith(pathToPackageJson, 'utf-8').thenResolve(JSON.stringify(existingPackageContents));
+
+    expect(await liftReporting({projectRoot})).toEqual({});
+    expect(writePackageJson).not.toHaveBeenCalled();
+  });
+});

package/src/scaffolder.js

@@ -0,0 +1,7 @@
+import {scaffold as scaffoldConfig} from './config/index.js';
+
+export async function scaffold({projectRoot}) {
+  await scaffoldConfig({projectRoot});
+
+  return {};
+}

package/src/scaffolder.test.js

@@ -0,0 +1,18 @@
+import {describe, expect, it, vi} from 'vitest';
+import any from '@travi/any';
+
+import {scaffold as scaffoldConfig} from './config/index.js';
+import {scaffold} from './scaffolder.js';
+
+vi.mock('./config/index.js');
+
+describe('scaffolder', () => {
+  it('should simply return empty results', async () => {
+    const projectRoot = any.string();
+
+    const results = await scaffold({projectRoot});
+
+    expect(results).toEqual({});
+    expect(scaffoldConfig).toHaveBeenCalledWith({projectRoot});
+  });
+});

package/src/tester.js

@@ -0,0 +1,5 @@
+import {fileExists} from '@form8ion/core';
+
+export default async function codecovInUse({projectRoot}) {
+  return fileExists(`${projectRoot}/.codecov.yml`);
+}

package/src/tester.test.js

@@ -0,0 +1,25 @@
+import {fileExists} from '@form8ion/core';
+
+import {describe, expect, it, vi} from 'vitest';
+import {when} from 'vitest-when';
+import any from '@travi/any';
+
+import codecovInUse from './tester.js';
+
+vi.mock('@form8ion/core');
+
+describe('codecov predicate', () => {
+  const projectRoot = any.string();
+
+  it('should return `true` if the config file exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.codecov.yml`).thenResolve(true);
+
+    expect(await codecovInUse({projectRoot})).toBe(true);
+  });
+
+  it('should return `false` if the config file exists', async () => {
+    when(fileExists).calledWith(`${projectRoot}/.codecov.yml`).thenResolve(false);
+
+    expect(await codecovInUse({projectRoot})).toBe(false);
+  });
+});