feat: add isSkipped to audits and groups for filtering

Author: hanna-skryl

packages/models/src/lib/audit.ts

@@ -12,6 +12,7 @@ export const auditSchema = z
       descriptionDescription: 'Description (markdown)',
       docsUrlDescription: 'Link to documentation (rationale)',
       description: 'List of scorable metrics for the given plugin',
+      isSkippedDescription: 'Indicates whether the audit is skipped',
     }),
   );
 

packages/models/src/lib/group.ts

@@ -22,6 +22,7 @@ export const groupMetaSchema = metaSchema({
   descriptionDescription: 'Description of the group (markdown)',
   docsUrlDescription: 'Group documentation site',
   description: 'Group metadata',
+  isSkippedDescription: 'Indicates whether the group is skipped',
 });
 export type GroupMeta = z.infer<typeof groupMetaSchema>;
 

packages/models/src/lib/implementation/schemas.ts

@@ -69,6 +69,9 @@ export const scoreSchema = z
   .min(0)
   .max(1);
 
+/** Schema for a property indicating whether an entity is filtered out */
+export const isSkippedSchema = z.boolean().optional();
+
 /**
  * Used for categories, plugins and audits
  * @param options
@@ -78,12 +81,14 @@ export function metaSchema(options?: {
   descriptionDescription?: string;
   docsUrlDescription?: string;
   description?: string;
+  isSkippedDescription?: string;
 }) {
   const {
     descriptionDescription,
     titleDescription,
     docsUrlDescription,
     description,
+    isSkippedDescription,
   } = options ?? {};
   return z.object(
     {
@@ -96,6 +101,9 @@ export function metaSchema(options?: {
       docsUrl: docsUrlDescription
         ? docsUrlSchema.describe(docsUrlDescription)
         : docsUrlSchema,
+      isSkipped: isSkippedDescription
+        ? isSkippedSchema.describe(isSkippedDescription)
+        : isSkippedSchema,
     },
     { description },
   );

packages/plugin-lighthouse/src/lib/lighthouse-plugin.ts

@@ -8,7 +8,7 @@ import {
 } from './runner/constants.js';
 import { createRunnerFunction } from './runner/runner.js';
 import type { LighthouseOptions } from './types.js';
-import { filterAuditsAndGroupsByOnlyOptions } from './utils.js';
+import { markSkippedAuditsAndGroups } from './utils.js';
 
 export function lighthousePlugin(
   url: string,
@@ -17,7 +17,7 @@ export function lighthousePlugin(
   const { skipAudits, onlyAudits, onlyCategories, ...unparsedFlags } =
     normalizeFlags(flags ?? {});
 
-  const { audits, groups } = filterAuditsAndGroupsByOnlyOptions(
+  const { audits, groups } = markSkippedAuditsAndGroups(
     LIGHTHOUSE_NAVIGATION_AUDITS,
     LIGHTHOUSE_GROUPS,
     { skipAudits, onlyAudits, onlyCategories },

packages/plugin-lighthouse/src/lib/lighthouse-plugin.unit.test.ts

@@ -17,47 +17,36 @@ describe('lighthousePlugin-config-object', () => {
     ]);
   });
 
-  it('should filter audits by onlyAudits string "first-contentful-paint"', () => {
+  it('should mark audits in onlyAudits as not skipped', () => {
     const pluginConfig = lighthousePlugin('https://code-pushup-portal.com', {
       onlyAudits: ['first-contentful-paint'],
     });
 
     expect(() => pluginConfigSchema.parse(pluginConfig)).not.toThrow();
-
-    expect(pluginConfig.audits[0]).toEqual(
+    expect(
+      pluginConfig.audits.find(({ slug }) => slug === 'first-contentful-paint'),
+    ).toEqual(
       expect.objectContaining({
-        slug: 'first-contentful-paint',
+        isSkipped: false,
       }),
     );
   });
 
-  it('should filter groups by onlyAudits string "first-contentful-paint"', () => {
+  it('should mark groups referencing audits in onlyAudits as not skipped', () => {
     const pluginConfig = lighthousePlugin('https://code-pushup-portal.com', {
       onlyAudits: ['first-contentful-paint'],
     });
 
     expect(() => pluginConfigSchema.parse(pluginConfig)).not.toThrow();
-    expect(pluginConfig.groups).toHaveLength(1);
-
-    const refs = pluginConfig.groups?.[0]?.refs;
-    expect(refs).toHaveLength(1);
 
-    expect(refs).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          slug: 'first-contentful-paint',
-        }),
-      ]),
+    const group = pluginConfig.groups?.find(({ refs }) =>
+      refs.some(ref => ref.slug === 'first-contentful-paint'),
     );
-  });
-
-  it('should throw when filtering groups by zero-weight onlyAudits', () => {
-    const pluginConfig = lighthousePlugin('https://code-pushup-portal.com', {
-      onlyAudits: ['csp-xss'],
-    });
 
-    expect(() => pluginConfigSchema.parse(pluginConfig)).toThrow(
-      'In a category, there has to be at least one ref with weight > 0. Affected refs: csp-xss',
+    expect(group).toEqual(
+      expect.objectContaining({
+        isSkipped: false,
+      }),
     );
   });
 });

packages/plugin-lighthouse/src/lib/utils.ts

@@ -1,5 +1,5 @@
 import type { Audit, CategoryRef, Group } from '@code-pushup/models';
-import { filterItemRefsBy, toArray } from '@code-pushup/utils';
+import { toArray } from '@code-pushup/utils';
 import { LIGHTHOUSE_PLUGIN_SLUG } from './constants.js';
 import type { LighthouseCliFlags } from './runner/types.js';
 
@@ -70,7 +70,8 @@ export type FilterOptions = Partial<
   Pick<LighthouseCliFlags, 'onlyAudits' | 'onlyCategories' | 'skipAudits'>
 >;
 
-export function filterAuditsAndGroupsByOnlyOptions(
+// eslint-disable-next-line max-lines-per-function
+export function markSkippedAuditsAndGroups(
   audits: Audit[],
   groups: Group[],
   options?: FilterOptions,
@@ -84,45 +85,57 @@ export function filterAuditsAndGroupsByOnlyOptions(
     onlyCategories = [],
   } = options ?? {};
 
-  // category wins over audits
+  if (
+    onlyCategories.length === 0 &&
+    onlyAudits.length === 0 &&
+    skipAudits.length === 0
+  ) {
+    return { audits, groups };
+  }
+
   if (onlyCategories.length > 0) {
     validateOnlyCategories(groups, onlyCategories);
+  }
 
-    const categorySlugs = new Set(onlyCategories);
-    const filteredGroups: Group[] = groups.filter(({ slug }) =>
-      categorySlugs.has(slug),
-    );
-    const auditSlugsFromRemainingGroups = new Set(
-      filteredGroups.flatMap(({ refs }) => refs.map(({ slug }) => slug)),
-    );
-    return {
-      audits: audits.filter(({ slug }) =>
-        auditSlugsFromRemainingGroups.has(slug),
-      ),
-      groups: filteredGroups,
-    };
-  } else if (onlyAudits.length > 0 || skipAudits.length > 0) {
+  if (onlyAudits.length > 0 || skipAudits.length > 0) {
     validateAudits(audits, onlyAudits);
     validateAudits(audits, skipAudits);
-    const onlyAuditSlugs = new Set(onlyAudits);
-    const skipAuditSlugs = new Set(skipAudits);
-    const filterAudits = ({ slug }: Pick<Audit, 'slug'>) =>
-      !(
-        // audit is NOT in given onlyAuditSlugs
-        (
-          (onlyAudits.length > 0 && !onlyAuditSlugs.has(slug)) ||
-          // audit IS in given skipAuditSlugs
-          (skipAudits.length > 0 && skipAuditSlugs.has(slug))
-        )
-      );
-    return {
-      audits: audits.filter(filterAudits),
-      groups: filterItemRefsBy(groups, filterAudits),
-    };
   }
-  // return unchanged
+
+  const onlyGroupSlugs = new Set(onlyCategories);
+  const onlyAuditSlugs = new Set(onlyAudits);
+  const skipAuditSlugs = new Set(skipAudits);
+
+  const markedGroups: Group[] = groups.map(group => ({
+    ...group,
+    isSkipped: onlyCategories.length > 0 && !onlyGroupSlugs.has(group.slug),
+  }));
+
+  const validGroupAuditSlugs = new Set(
+    markedGroups
+      .filter(group => !group.isSkipped)
+      .flatMap(group => group.refs.map(ref => ref.slug)),
+  );
+
+  const markedAudits = audits.map(audit => ({
+    ...audit,
+    isSkipped:
+      (onlyAudits.length > 0 && !onlyAuditSlugs.has(audit.slug)) ||
+      (skipAudits.length > 0 && skipAuditSlugs.has(audit.slug)) ||
+      (validGroupAuditSlugs.size > 0 && !validGroupAuditSlugs.has(audit.slug)),
+  }));
+
+  const fullyMarkedGroups = markedGroups.map(group => ({
+    ...group,
+    isSkipped:
+      group.isSkipped ||
+      group.refs.every(ref =>
+        markedAudits.some(audit => audit.slug === ref.slug && audit.isSkipped),
+      ),
+  }));
+
   return {
-    audits,
-    groups,
+    audits: markedAudits,
+    groups: fullyMarkedGroups,
   };
 }