chore: refine preset

Author: John Doe

code-pushup.preset.ts

@@ -100,16 +100,12 @@ export const eslintCategories: CategoryConfig[] = [
 export function getJsDocsCategories(
   config: JsDocsPluginConfig,
 ): CategoryConfig[] {
-  const filterOptions =
-    typeof config === 'string' || Array.isArray(config)
-      ? {}
-      : { onlyAudits: config.onlyAudits, skipAudits: config.skipAudits };
   return [
     {
       slug: 'docs',
       title: 'Documentation',
       description: 'Measures how much of your code is **documented**.',
-      refs: filterGroupsByOnlyAudits(groups, filterOptions).map(group => ({
+      refs: filterGroupsByOnlyAudits(groups, config).map(group => ({
         weight: 1,
         type: 'group',
         plugin: PLUGIN_SLUG,
@@ -163,13 +159,12 @@ export const jsDocsCoreConfig = (
 
 export const eslintCoreConfigNx = async (
   projectName?: string,
-  options?: { exclude?: string[] },
 ): Promise<CoreConfig> => ({
   plugins: [
     await eslintPlugin(
       await (projectName
         ? eslintConfigFromNxProject(projectName)
-        : eslintConfigFromAllNxProjects(options)),
+        : eslintConfigFromAllNxProjects()),
     ),
   ],
   categories: eslintCategories,
@@ -183,42 +178,18 @@ export const typescriptPluginConfig = async (
 });
 
 export const coverageCoreConfigNx = async (
-  projectOrConfig?:
-    | string
-    | {
-        projectName: string;
-        targetNames: string[];
-      },
-  options?: { exclude?: string[] },
+  projectName?: string,
 ): Promise<CoreConfig> => {
-  const projectName =
-    typeof projectOrConfig === 'string'
-      ? projectOrConfig
-      : projectOrConfig?.projectName;
-  const targetNames =
-    typeof projectOrConfig === 'object' && projectOrConfig?.targetNames?.length
-      ? projectOrConfig.targetNames
-      : ['unit-test', 'int-test'];
-
   if (projectName) {
     throw new Error('coverageCoreConfigNx for single projects not implemented');
   }
-
-  const targetArgs = ['-t', ...targetNames];
-
-  // Compute projects list and apply exclude for efficient run-many execution
-  const { createProjectGraphAsync } = await import('@nx/devkit');
-  const { nodes } = await createProjectGraphAsync({ exitOnError: false });
-  const projectsWithTargets = Object.values(nodes).filter(node =>
-    targetNames.some(t => node.data.targets && t in node.data.targets),
-  );
-  const filteredProjects = options?.exclude?.length
-    ? projectsWithTargets.filter(node => !options.exclude!.includes(node.name))
-    : projectsWithTargets;
-  const projectsArg = `--projects=${filteredProjects
-    .map(p => p.name)
-    .join(',')}`;
-
+  const targetNames = ['unit-test', 'int-test'];
+  const targetArgs = [
+    '-t',
+    ...targetNames,
+    '--coverage.enabled',
+    '--skipNxCache',
+  ];
   return {
     plugins: [
       await coveragePlugin({
@@ -228,10 +199,9 @@ export const coverageCoreConfigNx = async (
             'nx',
             projectName ? `run --project ${projectName}` : 'run-many',
             ...targetArgs,
-            projectsArg,
           ],
         },
-        reports: await getNxCoveragePaths(targetNames, false, options?.exclude),
+        reports: await getNxCoveragePaths(targetNames),
       }),
     ],
     categories: coverageCategories,

packages/plugin-coverage/src/lib/nx/coverage-paths.ts

@@ -18,7 +18,6 @@ import type { CoverageResult } from '../config.js';
 export async function getNxCoveragePaths(
   targets: string[] = ['test'],
   verbose?: boolean,
-  exclude?: string[],
 ): Promise<CoverageResult[]> {
   if (verbose) {
     ui().logger.info(
@@ -35,12 +34,8 @@ export async function getNxCoveragePaths(
         hasNxTarget(graph, target),
       );
 
-      const filteredNodes = exclude?.length
-        ? relevantNodes.filter(node => !exclude.includes(node.name))
-        : relevantNodes;
-
       return await Promise.all(
-        filteredNodes.map<Promise<CoverageResult>>(async ({ name, data }) => {
+        relevantNodes.map<Promise<CoverageResult>>(async ({ name, data }) => {
           const coveragePaths = await getCoveragePathsForTarget(data, target);
           if (verbose) {
             ui().logger.info(`- ${name}: ${target}`);