fix: handle skipped audits and groups

packages/cli/src/lib/implementation/filter.middleware.ts

@@ -1,48 +1,72 @@
-import type { CoreConfig } from '@code-pushup/models';
+import type {
+  CategoryConfig,
+  CoreConfig,
+  PluginConfig,
+} from '@code-pushup/models';
 import { filterItemRefsBy } from '@code-pushup/utils';
+import {
+  applyFilters,
+  extractSkippedItems,
+  filterPluginsFromCategories,
+  filterSkippedItems,
+  isValidCategoryRef,
+} from './filter.middleware.utils.js';
 import type { FilterOptions, Filterables } from './filter.model.js';
 import {
   handleConflictingOptions,
   validateFilterOption,
   validateFinalState,
+  validateSkippedCategories,
 } from './validate-filter-options.utils.js';
 
+// eslint-disable-next-line max-lines-per-function
 export function filterMiddleware<T extends FilterOptions>(
   originalProcessArgs: T,
 ): T {
   const {
-    plugins,
-    categories,
+    categories: rcCategories,
+    plugins: rcPlugins,
     skipCategories = [],
     onlyCategories = [],
     skipPlugins = [],
     onlyPlugins = [],
     verbose = false,
   } = originalProcessArgs;
 
+  const plugins = filterSkippedInPlugins(rcPlugins);
+  const categories = filterSkippedCategories(rcCategories, plugins);
+
   if (
     skipCategories.length === 0 &&
     onlyCategories.length === 0 &&
     skipPlugins.length === 0 &&
     onlyPlugins.length === 0
   ) {
-    return originalProcessArgs;
+    if (rcCategories && categories) {
+      validateSkippedCategories(rcCategories, categories, verbose);
+    }
+    return {
+      ...originalProcessArgs,
+      ...(categories && { categories }),
+      plugins,
+    };
   }
 
   handleConflictingOptions('categories', onlyCategories, skipCategories);
   handleConflictingOptions('plugins', onlyPlugins, skipPlugins);
 
+  const skippedPlugins = extractSkippedItems(rcPlugins, plugins);
+  const skippedCategories = extractSkippedItems(rcCategories, categories);
+
   const filteredCategories = applyCategoryFilters(
     { categories, plugins },
-    skipCategories,
-    onlyCategories,
-    verbose,
+    skippedCategories,
+    { skipCategories, onlyCategories, verbose },
   );
   const filteredPlugins = applyPluginFilters(
     { categories: filteredCategories, plugins },
-    skipPlugins,
-    onlyPlugins,
-    verbose,
+    skippedPlugins,
+    { skipPlugins, onlyPlugins, verbose },
   );
   const finalCategories = filteredCategories
     ? filterItemRefsBy(filteredCategories, ref =>
@@ -52,7 +76,7 @@
 
   validateFinalState(
     { categories: finalCategories, plugins: filteredPlugins },
-    { categories, plugins },
+    { categories: rcCategories, plugins: rcPlugins },
   );
 
   return {
@@ -62,53 +86,37 @@
   };
 }
 
-function applyFilters<T>(
-  items: T[],
-  skipItems: string[],
-  onlyItems: string[],
-  key: keyof T,
-): T[] {
-  return items.filter(item => {
-    const itemKey = item[key] as unknown as string;
-    return (
-      !skipItems.includes(itemKey) &&
-      (onlyItems.length === 0 || onlyItems.includes(itemKey))
-    );
-  });
-}
-
 function applyCategoryFilters(
   { categories, plugins }: Filterables,
-  skipCategories: string[],
-  onlyCategories: string[],
-  verbose: boolean,
+  skippedCategories: string[],
+  options: Pick<FilterOptions, 'skipCategories' | 'onlyCategories' | 'verbose'>,
 ): CoreConfig['categories'] {
+  const { skipCategories = [], onlyCategories = [], verbose = false } = options;
   if (
     (skipCategories.length === 0 && onlyCategories.length === 0) ||
-    !categories ||
-    categories.length === 0
+    ((!categories || categories.length === 0) && skippedCategories.length === 0)
   ) {
     return categories;
   }
   validateFilterOption(
     'skipCategories',
     { plugins, categories },
-    { itemsToFilter: skipCategories, verbose },
+    { itemsToFilter: skipCategories, skippedItems: skippedCategories, verbose },
   );
   validateFilterOption(
     'onlyCategories',
     { plugins, categories },
-    { itemsToFilter: onlyCategories, verbose },
+    { itemsToFilter: onlyCategories, skippedItems: skippedCategories, verbose },
   );
-  return applyFilters(categories, skipCategories, onlyCategories, 'slug');
+  return applyFilters(categories ?? [], skipCategories, onlyCategories, 'slug');
 }
 
 function applyPluginFilters(
   { categories, plugins }: Filterables,
-  skipPlugins: string[],
-  onlyPlugins: string[],
-  verbose: boolean,
+  skippedPlugins: string[],
+  options: Pick<FilterOptions, 'skipPlugins' | 'onlyPlugins' | 'verbose'>,
 ): CoreConfig['plugins'] {
+  const { skipPlugins = [], onlyPlugins = [], verbose = false } = options;
   const filteredPlugins = filterPluginsFromCategories({
     categories,
     plugins,
@@ -119,25 +127,43 @@
   validateFilterOption(
     'skipPlugins',
     { plugins: filteredPlugins, categories },
-    { itemsToFilter: skipPlugins, verbose },
+    { itemsToFilter: skipPlugins, skippedItems: skippedPlugins, verbose },
   );
   validateFilterOption(
     'onlyPlugins',
     { plugins: filteredPlugins, categories },
-    { itemsToFilter: onlyPlugins, verbose },
+    { itemsToFilter: onlyPlugins, skippedItems: skippedPlugins, verbose },
   );
   return applyFilters(filteredPlugins, skipPlugins, onlyPlugins, 'slug');
 }
 
-function filterPluginsFromCategories({
-  categories,
-  plugins,
-}: Filterables): CoreConfig['plugins'] {
-  if (!categories || categories.length === 0) {
-    return plugins;
-  }
-  const validPluginSlugs = new Set(
-    categories.flatMap(category => category.refs.map(ref => ref.plugin)),
-  );
-  return plugins.filter(plugin => validPluginSlugs.has(plugin.slug));
+export function filterSkippedInPlugins(
+  plugins: PluginConfig[],
+): PluginConfig[] {
+  return plugins.map((plugin: PluginConfig) => {
+    const filteredAudits = filterSkippedItems(plugin.audits);
+    return {
+      ...plugin,
+      ...(plugin.groups && {
+        groups: filterItemRefsBy(filterSkippedItems(plugin.groups), ref =>
+          filteredAudits.some(({ slug }) => slug === ref.slug),
+        ),
+      }),
+      audits: filteredAudits,
+    };
+  });
+}
+
+export function filterSkippedCategories(
+  categories: CoreConfig['categories'],
+  plugins: CoreConfig['plugins'],
+): CoreConfig['categories'] {
+  return categories
+    ?.map(category => {
+      const validRefs = category.refs.filter(ref =>
+        isValidCategoryRef(ref, plugins),
+      );
+      return validRefs.length > 0 ? { ...category, refs: validRefs } : null;
+    })
+    .filter((category): category is CategoryConfig => category != null);
 }