chore(models): rename AuditGroup entities to Group

Tlacenka · Tlacenka · commit 8d167192967d · 2024-01-08T18:20:24.000+01:00
diff --git a/examples/plugins/src/package-json/src/scoring.ts b/examples/plugins/src/package-json/src/scoring.ts
@@ -1,11 +1,11 @@
-import { AuditGroup, CategoryRef } from '@code-pushup/models';
+import { CategoryRef, Group } from '@code-pushup/models';
 import { pluginSlug } from './constants';
 import { dependenciesAuditMeta } from './integration/dependencies.audit';
 import { licenseAuditMeta } from './integration/license.audit';
 import { typeAuditInfoMeta } from './integration/type.audit';
 
 const documentationGroupSlug = 'documentation';
-export const documentationGroup: AuditGroup = {
+export const documentationGroup: Group = {
   slug: documentationGroupSlug,
   title: 'Documentation specific audits',
   description:
@@ -25,7 +25,7 @@ export const documentationGroupRef: CategoryRef = {
 };
 
 const performanceGroupSlug = 'performance';
-export const performanceGroup: AuditGroup = {
+export const performanceGroup: Group = {
   slug: performanceGroupSlug,
   title: 'Performance specific audits',
   description: 'A set of audits focusing on compile and runtime performance',
@@ -44,7 +44,7 @@ export const performanceGroupRef: CategoryRef = {
 };
 
 const versionControlGroupSlug = 'version-control';
-export const versionControlGroup: AuditGroup = {
+export const versionControlGroup: Group = {
   slug: versionControlGroupSlug,
   title: 'Version Control',
   description: 'A set of audits related to version control',
diff --git a/packages/cli/docs/custom-plugins.md b/packages/cli/docs/custom-plugins.md
@@ -501,21 +501,21 @@ async function runnerFunction(options: Options): Promise<AuditOutputs> {
 
 ### Audit groups
 
-As an optional property a plugin can maintain `groups` as an array of [`AuditGroup`s](@TODO).
+As an optional property a plugin can maintain `groups` as an array of [`Group`s](@TODO).
 While [categories](#plugins-and-categories) can score audits across plugins, groups are only targeting plugins within a plugin.
 For simple plugins this is not needed but it is beneficial in bigger plugins as audit groups also simplify the configuration.
 
 An audit group maintains:
 
-- metadata about the group [AuditGroupMeta](@TODO)
-- a list of referenced audits under `refs` as [AuditGroupRef](@TODO) array
+- metadata about the group [GroupMeta](@TODO)
+- a list of referenced audits under `refs` as [GroupRef](@TODO) array
 
 The minimum information of an audit group looks like this:
 
 ```typescript
-import { AuditGroup } from '@code-pushup/models';
+import { Group } from '@code-pushup/models';
 
-const myAuditGroup: AuditGroup = {
+const myGroup: Group = {
   slug: 'performance',
   refs: [
     {
diff --git a/packages/models/src/index.ts b/packages/models/src/index.ts
@@ -17,7 +17,7 @@ export {
   refineCoreConfig,
   unrefinedCoreConfigSchema,
 } from './lib/core-config';
-export { AuditGroup, AuditGroupRef, auditGroupSchema } from './lib/group';
+export { Group, GroupRef, groupSchema } from './lib/group';
 export {
   PERSIST_FILENAME,
   PERSIST_FORMAT,
diff --git a/packages/models/src/lib/group.ts b/packages/models/src/lib/group.ts
@@ -11,31 +11,31 @@ import {
   hasDuplicateStrings,
 } from './implementation/utils';
 
-export const auditGroupRefSchema = weightedRefSchema(
-  'Weighted references to audits',
-  "Reference slug to an audit within this plugin (e.g. 'max-lines')",
+export const groupRefSchema = weightedRefSchema(
+  'Weighted reference to a group',
+  "Reference slug to a group within this plugin (e.g. 'max-lines')",
 );
-export type AuditGroupRef = z.infer<typeof auditGroupRefSchema>;
+export type GroupRef = z.infer<typeof groupRefSchema>;
 
-export const auditGroupMetaSchema = metaSchema({
+export const groupMetaSchema = metaSchema({
   titleDescription: 'Descriptive name for the group',
   descriptionDescription: 'Description of the group (markdown)',
   docsUrlDescription: 'Group documentation site',
   description: 'Group metadata',
 });
-export type AuditGroupMeta = z.infer<typeof auditGroupMetaSchema>;
+export type GroupMeta = z.infer<typeof groupMetaSchema>;
 
-export const auditGroupSchema = scorableSchema(
-  'An audit group aggregates a set of audits into a single score which can be referenced from a category. ' +
+export const groupSchema = scorableSchema(
+  'A group aggregates a set of audits into a single score which can be referenced from a category. ' +
     'E.g. the group slug "performance" groups audits and can be referenced in a category',
-  auditGroupRefSchema,
+  groupRefSchema,
   getDuplicateRefsInGroups,
   duplicateRefsInGroupsErrorMsg,
-).merge(auditGroupMetaSchema);
-export type AuditGroup = z.infer<typeof auditGroupSchema>;
+).merge(groupMetaSchema);
+export type Group = z.infer<typeof groupSchema>;
 
-export const auditGroupsSchema = z
-  .array(auditGroupSchema, {
+export const groupsSchema = z
+  .array(groupSchema, {
     description: 'List of groups',
   })
   .optional()
@@ -49,26 +49,24 @@ export const auditGroupsSchema = z
 // ============
 
 // helper for validator: group refs are unique
-function duplicateRefsInGroupsErrorMsg(groupAudits: WeightedRef[]) {
-  const duplicateRefs = getDuplicateRefsInGroups(groupAudits);
-  return `In plugin groups the audit refs are not unique: ${errorItems(
+function duplicateRefsInGroupsErrorMsg(groups: WeightedRef[]) {
+  const duplicateRefs = getDuplicateRefsInGroups(groups);
+  return `In plugin groups the following references are not unique: ${errorItems(
     duplicateRefs,
   )}`;
 }
 
-function getDuplicateRefsInGroups(groupAudits: WeightedRef[]) {
-  return hasDuplicateStrings(
-    groupAudits.map(({ slug: ref }) => ref).filter(exists),
-  );
+function getDuplicateRefsInGroups(groups: WeightedRef[]) {
+  return hasDuplicateStrings(groups.map(({ slug: ref }) => ref).filter(exists));
 }
 
 // helper for validator: group refs are unique
-function duplicateSlugsInGroupsErrorMsg(groups: AuditGroup[] | undefined) {
+function duplicateSlugsInGroupsErrorMsg(groups: Group[] | undefined) {
   const duplicateRefs = getDuplicateSlugsInGroups(groups);
   return `In groups the slugs are not unique: ${errorItems(duplicateRefs)}`;
 }
 
-function getDuplicateSlugsInGroups(groups: AuditGroup[] | undefined) {
+function getDuplicateSlugsInGroups(groups: Group[] | undefined) {
   return Array.isArray(groups)
     ? hasDuplicateStrings(groups.map(({ slug }) => slug))
     : false;
diff --git a/packages/models/src/lib/group.unit.test.ts b/packages/models/src/lib/group.unit.test.ts
@@ -1,14 +1,14 @@
 import { describe, expect, it } from 'vitest';
 import { config } from '../../test';
-import { auditGroupSchema } from './group';
+import { groupSchema } from './group';
 
-describe('auditGroupSchema', () => {
+describe('groupSchema', () => {
   it('should throw if a group has duplicate audit refs', () => {
     const group = config().plugins[1].groups[0];
     group.refs = [...group.refs, group.refs[0]];
 
-    expect(() => auditGroupSchema.parse(group)).toThrow(
-      'In plugin groups the audit refs are not unique',
+    expect(() => groupSchema.parse(group)).toThrow(
+      'In plugin groups the following references are not unique',
     );
   });
 });
diff --git a/packages/models/src/lib/plugin-config.ts b/packages/models/src/lib/plugin-config.ts
@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { pluginAuditsSchema } from './audit';
-import { auditGroupsSchema } from './group';
+import { groupsSchema } from './group';
 import {
   materialIconSchema,
   metaSchema,
@@ -32,7 +32,7 @@ export type PluginMeta = z.infer<typeof pluginMetaSchema>;
 export const pluginDataSchema = z.object({
   runner: z.union([runnerConfigSchema, runnerFunctionSchema]),
   audits: pluginAuditsSchema,
-  groups: auditGroupsSchema,
+  groups: groupsSchema,
 });
 type PluginData = z.infer<typeof pluginDataSchema>;
 
diff --git a/packages/models/src/lib/report.ts b/packages/models/src/lib/report.ts
@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { auditSchema } from './audit';
 import { auditOutputSchema } from './audit-output';
 import { categoryConfigSchema } from './category-config';
-import { auditGroupSchema } from './group';
+import { groupSchema } from './group';
 import {
   executionMetaSchema,
   packageVersionSchema,
@@ -22,7 +22,7 @@ export const pluginReportSchema = pluginMetaSchema
   .merge(
     z.object({
       audits: z.array(auditReportSchema),
-      groups: z.array(auditGroupSchema).optional(),
+      groups: z.array(groupSchema).optional(),
     }),
   );
 export type PluginReport = z.infer<typeof pluginReportSchema>;
diff --git a/packages/models/test/fixtures/lighthouse-plugin.mock.ts b/packages/models/test/fixtures/lighthouse-plugin.mock.ts
@@ -1,10 +1,10 @@
 import { join } from 'path';
-import type { AuditGroup, PluginReport } from '../../src';
+import type { Group, PluginReport } from '../../src';
 import { Audit, PluginConfig } from '../../src';
 import { LIGHTHOUSE_AUDIT_REPORTS_MAP } from './lighthouse-audits.mock';
 import { echoRunnerConfig } from './runner-config.mock';
 
-const PLUGIN_GROUP_PERFORMANCE: AuditGroup = {
+const PLUGIN_GROUP_PERFORMANCE: Group = {
   slug: 'performance',
   title: 'Performance',
   refs: [
diff --git a/packages/plugin-eslint/src/lib/meta/groups.ts b/packages/plugin-eslint/src/lib/meta/groups.ts
@@ -1,13 +1,13 @@
 import type { Rule } from 'eslint';
-import type { AuditGroup, AuditGroupRef } from '@code-pushup/models';
+import type { Group, GroupRef } from '@code-pushup/models';
 import { objectToKeys, slugify } from '@code-pushup/utils';
 import { ruleIdToSlug } from './hash';
 import { type RuleData, parseRuleId } from './rules';
 
 type RuleType = NonNullable<Rule.RuleMetaData['type']>;
 
 // docs on meta.type: https://eslint.org/docs/latest/extend/custom-rules#rule-structure
-const typeGroups: Record<RuleType, Omit<AuditGroup, 'refs'>> = {
+const typeGroups: Record<RuleType, Omit<Group, 'refs'>> = {
   problem: {
     slug: 'problems',
     title: 'Problems',
@@ -28,7 +28,7 @@ const typeGroups: Record<RuleType, Omit<AuditGroup, 'refs'>> = {
   },
 };
 
-export function groupsFromRuleTypes(rules: RuleData[]): AuditGroup[] {
+export function groupsFromRuleTypes(rules: RuleData[]): Group[] {
   const allTypes = objectToKeys(typeGroups);
 
   const auditSlugsMap = rules.reduce<Partial<Record<RuleType, string[]>>>(
@@ -46,14 +46,13 @@ export function groupsFromRuleTypes(rules: RuleData[]): AuditGroup[] {
     .map(type => ({
       ...typeGroups[type],
       refs:
-        auditSlugsMap[type]?.map(
-          (slug): AuditGroupRef => ({ slug, weight: 1 }),
-        ) ?? [],
+        auditSlugsMap[type]?.map((slug): GroupRef => ({ slug, weight: 1 })) ??
+        [],
     }))
     .filter(group => group.refs.length);
 }
 
-export function groupsFromRuleCategories(rules: RuleData[]): AuditGroup[] {
+export function groupsFromRuleCategories(rules: RuleData[]): Group[] {
   const categoriesMap = rules.reduce<Record<string, Record<string, string[]>>>(
     (acc, { meta: { docs }, ruleId, options }) => {
       // meta.docs.category still used by some popular plugins (e.g. import, react, functional)
@@ -80,7 +79,7 @@ export function groupsFromRuleCategories(rules: RuleData[]): AuditGroup[] {
   return Object.entries(categoriesMap)
     .flatMap(([plugin, categories]) =>
       Object.entries(categories).map(
-        ([category, slugs]): AuditGroup => ({
+        ([category, slugs]): Group => ({
           slug: `${slugify(plugin)}-${slugify(category)}`,
           title: `${category} (${plugin})`,
           refs: slugs.map(slug => ({ slug, weight: 1 })),
diff --git a/packages/plugin-eslint/src/lib/meta/groups.unit.test.ts b/packages/plugin-eslint/src/lib/meta/groups.unit.test.ts
@@ -1,4 +1,4 @@
-import type { AuditGroup } from '@code-pushup/models';
+import type { Group } from '@code-pushup/models';
 import { groupsFromRuleCategories, groupsFromRuleTypes } from './groups';
 import type { RuleData } from './rules';
 
@@ -121,7 +121,7 @@ const eslintRules: RuleData[] = [
 
 describe('groupsFromRuleTypes', () => {
   it("should create groups based on rules' meta.type", () => {
-    expect(groupsFromRuleTypes(eslintRules)).toEqual<AuditGroup[]>([
+    expect(groupsFromRuleTypes(eslintRules)).toEqual<Group[]>([
       {
         slug: 'problems',
         title: 'Problems',
@@ -148,7 +148,7 @@ describe('groupsFromRuleTypes', () => {
 
 describe('groupsFromRuleCategories', () => {
   it("should create groups based on rules' meta.docs.category", () => {
-    expect(groupsFromRuleCategories(eslintRules)).toEqual<AuditGroup[]>([
+    expect(groupsFromRuleCategories(eslintRules)).toEqual<Group[]>([
       {
         slug: 'react-best-practices',
         title: 'Best Practices (react)',
diff --git a/packages/plugin-eslint/src/lib/meta/index.ts b/packages/plugin-eslint/src/lib/meta/index.ts
@@ -1,13 +1,13 @@
 import type { ESLint } from 'eslint';
-import type { Audit, AuditGroup } from '@code-pushup/models';
+import type { Audit, Group } from '@code-pushup/models';
 import { groupsFromRuleCategories, groupsFromRuleTypes } from './groups';
 import { listRules } from './rules';
 import { ruleToAudit } from './transform';
 
 export async function listAuditsAndGroups(
   eslint: ESLint,
   patterns: string | string[],
-): Promise<{ audits: Audit[]; groups: AuditGroup[] }> {
+): Promise<{ audits: Audit[]; groups: Group[] }> {
   const rules = await listRules(eslint, patterns);
 
   const audits = rules.map(ruleToAudit);
diff --git a/packages/utils/perf/score-report/optimized0.ts b/packages/utils/perf/score-report/optimized0.ts
@@ -1,12 +1,12 @@
-import { AuditGroupRef, CategoryRef, Report } from '@code-pushup/models';
+import { CategoryRef, GroupRef, Report } from '@code-pushup/models';
 import { ScoredReport } from '../../src';
 import {
   EnrichedAuditReport,
-  EnrichedScoredAuditGroup,
+  EnrichedScoredGroup,
 } from '../../src/lib/scoring';
 
 function groupRefToScore(audits: EnrichedAuditReport[]) {
-  return (ref: AuditGroupRef) => {
+  return (ref: GroupRef) => {
     const score = audits.find(audit => audit.slug === ref.slug)?.score;
     if (score == null) {
       throw new Error(
@@ -19,7 +19,7 @@ function groupRefToScore(audits: EnrichedAuditReport[]) {
 
 function categoryRefToScore(
   audits: EnrichedAuditReport[],
-  groups: EnrichedScoredAuditGroup[],
+  groups: EnrichedScoredGroup[],
 ) {
   return (ref: CategoryRef) => {
     let audit;
diff --git a/packages/utils/perf/score-report/optimized2.ts b/packages/utils/perf/score-report/optimized2.ts
@@ -1,4 +1,4 @@
-import { AuditGroupRef, CategoryRef, Report } from '@code-pushup/models';
+import { CategoryRef, GroupRef, Report } from '@code-pushup/models';
 import { ScoredReport } from '../../src';
 
 export function calculateScore<T extends { weight: number }>(
@@ -25,7 +25,7 @@ export function scoreReportOptimized2(report: Report): ScoredReport {
       }),
     );
 
-    function groupScoreFn(ref: AuditGroupRef) {
+    function groupScoreFn(ref: GroupRef) {
       const score = allScoredAuditsAndGroupsMap.get(
         `${plugin.slug}-${ref.slug}-audit`,
       )?.score;
diff --git a/packages/utils/perf/score-report/optimized3.ts b/packages/utils/perf/score-report/optimized3.ts
@@ -1,4 +1,4 @@
-import { AuditGroupRef, CategoryRef, Report } from '@code-pushup/models';
+import { CategoryRef, GroupRef, Report } from '@code-pushup/models';
 import { ScoredReport } from '../../src';
 
 export function calculateScore<T extends { weight: number }>(
@@ -47,7 +47,7 @@ export function scoreReportOptimized3(report: Report): ScoredReport {
       allScoredAuditsAndGroups.set(key, audit);
     });
 
-    function groupScoreFn(ref: AuditGroupRef) {
+    function groupScoreFn(ref: GroupRef) {
       const score = allScoredAuditsAndGroups.get(
         `${plugin.slug}-${ref.slug}-audit`,
       )?.score;
diff --git a/packages/utils/src/lib/report-to-md.ts b/packages/utils/src/lib/report-to-md.ts
@@ -39,7 +39,7 @@ import {
   sortCategoryAudits,
 } from './report';
 import {
-  EnrichedScoredAuditGroupWithAudits,
+  EnrichedScoredGroupWithAudits,
   ScoredReport,
   WeighedAuditReport,
 } from './scoring';
@@ -100,7 +100,7 @@ function reportToCategoriesSection(report: ScoredReport): string {
       (
         acc: {
           audits: WeighedAuditReport[];
-          groups: EnrichedScoredAuditGroupWithAudits[];
+          groups: EnrichedScoredGroupWithAudits[];
         },
         ref: CategoryRef,
       ) => ({
@@ -163,7 +163,7 @@ function auditItemToCategorySection(
 }
 
 function groupItemToCategorySection(
-  group: EnrichedScoredAuditGroupWithAudits,
+  group: EnrichedScoredGroupWithAudits,
   plugins: ScoredReport['plugins'],
 ): string {
   const pluginTitle = getPluginNameFromSlug(group.plugin, plugins);
diff --git a/packages/utils/src/lib/report.ts b/packages/utils/src/lib/report.ts
diff --git a/packages/utils/src/lib/scoring.ts b/packages/utils/src/lib/scoring.ts
