feat: update to zod v4

package.json

@@ -46,8 +46,7 @@
     "vscode-material-icons": "^0.1.1",
     "yaml": "^2.5.1",
     "yargs": "^17.7.2",
-    "zod": "^3.23.8",
-    "zod-validation-error": "^3.4.0"
+    "zod": "^4.0.5"
   },
   "devDependencies": {
     "@beaussan/nx-knip": "^0.0.5-15",
@@ -118,7 +117,7 @@
     "verdaccio": "^5.32.2",
     "vite": "^5.4.8",
     "vitest": "1.3.1",
-    "zod2md": "^0.1.7"
+    "zod2md": "^0.2.4"
   },
   "optionalDependencies": {
     "@esbuild/darwin-arm64": "^0.19.12",

packages/ci/package.json

@@ -31,6 +31,6 @@
     "glob": "^11.0.1",
     "simple-git": "^3.20.0",
     "yaml": "^2.5.1",
-    "zod": "^3.22.1"
+    "zod": "^4.0.5"
   }
 }

packages/ci/src/lib/cli/persist.unit.test.ts

@@ -114,7 +114,7 @@ describe('parsePersistConfig', () => {
     await expect(
       parsePersistConfig({ persist: { format: ['json', 'html'] } }),
     ).rejects.toThrow(
-      /^Invalid persist config - ZodError:.*Invalid enum value. Expected 'json' \| 'md', received 'html'/s,
+      /^Invalid persist config - ZodError:.*Invalid option: expected one of \\"json\\"\|\\"md\\"/s,
     );
   });
 });

packages/cli/src/lib/yargs-cli.ts

@@ -155,9 +155,9 @@ function validatePersistFormat(persist: PersistConfig) {
     return true;
   } catch {
     throw new Error(
-      `Invalid persist.format option. Valid options are: ${Object.values(
-        formatSchema.Values,
-      ).join(', ')}`,
+      `Invalid persist.format option. Valid options are: ${formatSchema.options.join(
+        ', ',
+      )}`,
     );
   }
 }

packages/core/src/lib/implementation/execute-plugin.unit.test.ts

@@ -134,21 +134,11 @@ describe('executePlugins', () => {
         ] satisfies PluginConfig[],
         { progress: false },
       ),
-    ).rejects.toThrow(`Executing 1 plugin failed.\n\nError: - Plugin ${bold(
-      title,
-    )} (${bold(slug)}) produced the following error:
-  - Audit output is invalid: [
-  {
-    "validation": "regex",
-    "code": "invalid_string",
-    "message": "The slug has to follow the pattern [0-9a-z] followed by multiple optional groups of -[0-9a-z]. e.g. my-slug",
-    "path": [
-      0,
-      "slug"
-    ]
-  }
-]
-`);
+    ).rejects.toThrow(
+      `Executing 1 plugin failed.\n\nError: - Plugin ${bold(
+        title,
+      )} (${bold(slug)}) produced the following error:\n  - Audit output is invalid`,
+    );
   });
 
   it('should throw for one failing plugin', async () => {

packages/core/src/lib/implementation/read-rc-file.int.test.ts

@@ -69,12 +69,12 @@ describe('readRcByPath', () => {
   it('should throw if the configuration is empty', async () => {
     await expect(
       readRcByPath(path.join(configDirPath, 'code-pushup.empty.config.js')),
-    ).rejects.toThrow(/invalid_type/);
+    ).rejects.toThrow('Invalid input');
   });
 
   it('should throw if the configuration is invalid', async () => {
     await expect(
       readRcByPath(path.join(configDirPath, 'code-pushup.invalid.config.ts')),
-    ).rejects.toThrow(/refs are duplicates/);
+    ).rejects.toThrow('has duplicate references');
   });
 });

packages/models/package.json

@@ -27,7 +27,7 @@
   },
   "type": "module",
   "dependencies": {
-    "zod": "^3.22.1",
+    "zod": "^4.0.5",
     "vscode-material-icons": "^0.1.0"
   }
 }

packages/models/src/lib/audit-output.ts

@@ -1,67 +1,49 @@
 import { z } from 'zod';
+import { createDuplicateSlugsCheck } from './implementation/checks.js';
 import {
   nonnegativeNumberSchema,
   scoreSchema,
   slugSchema,
 } from './implementation/schemas.js';
-import { errorItems, hasDuplicateStrings } from './implementation/utils.js';
 import { issueSchema } from './issue.js';
 import { tableSchema } from './table.js';
 import { treeSchema } from './tree.js';
 
 export const auditValueSchema =
   nonnegativeNumberSchema.describe('Raw numeric value');
 export const auditDisplayValueSchema = z
-  .string({ description: "Formatted value (e.g. '0.9 s', '2.1 MB')" })
-  .optional();
+  .string()
+  .optional()
+  .describe("Formatted value (e.g. '0.9 s', '2.1 MB')");
 
-export const auditDetailsSchema = z.object(
-  {
-    issues: z
-      .array(issueSchema, { description: 'List of findings' })
-      .optional(),
+export const auditDetailsSchema = z
+  .object({
+    issues: z.array(issueSchema).describe('List of findings').optional(),
     table: tableSchema('Table of related findings').optional(),
     trees: z
-      .array(treeSchema, { description: 'Findings in tree structure' })
+      .array(treeSchema)
+      .describe('Findings in tree structure')
       .optional(),
-  },
-  { description: 'Detailed information' },
-);
+  })
+  .describe('Detailed information');
 export type AuditDetails = z.infer<typeof auditDetailsSchema>;
 
-export const auditOutputSchema = z.object(
-  {
+export const auditOutputSchema = z
+  .object({
     slug: slugSchema.describe('Reference to audit'),
     displayValue: auditDisplayValueSchema,
     value: auditValueSchema,
     score: scoreSchema,
     details: auditDetailsSchema.optional(),
-  },
-  { description: 'Audit information' },
-);
+  })
+  .describe('Audit information');
 
 export type AuditOutput = z.infer<typeof auditOutputSchema>;
 
 export const auditOutputsSchema = z
-  .array(auditOutputSchema, {
-    description:
-      'List of JSON formatted audit output emitted by the runner process of a plugin',
-  })
-  // audit slugs are unique
-  .refine(
-    audits => !getDuplicateSlugsInAudits(audits),
-    audits => ({ message: duplicateSlugsInAuditsErrorMsg(audits) }),
+  .array(auditOutputSchema)
+  .check(createDuplicateSlugsCheck('Audit'))
+  .describe(
+    'List of JSON formatted audit output emitted by the runner process of a plugin',
   );
 export type AuditOutputs = z.infer<typeof auditOutputsSchema>;
-
-// helper for validator: audit slugs are unique
-function duplicateSlugsInAuditsErrorMsg(audits: AuditOutput[]) {
-  const duplicateRefs = getDuplicateSlugsInAudits(audits);
-  return `In plugin audits the slugs are not unique: ${errorItems(
-    duplicateRefs,
-  )}`;
-}
-
-function getDuplicateSlugsInAudits(audits: AuditOutput[]) {
-  return hasDuplicateStrings(audits.map(({ slug }) => slug));
-}

packages/models/src/lib/audit-output.unit.test.ts

@@ -179,6 +179,8 @@ describe('auditOutputsSchema', () => {
           score: 0.75,
         },
       ] satisfies AuditOutputs),
-    ).toThrow('slugs are not unique: total-blocking-time');
+    ).toThrow(
+      String.raw`Audit slugs must be unique, but received duplicates: \"total-blocking-time\"`,
+    );
   });
 });

packages/models/src/lib/audit.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
+import { createDuplicateSlugsCheck } from './implementation/checks.js';
 import { metaSchema, slugSchema } from './implementation/schemas.js';
-import { errorItems, hasDuplicateStrings } from './implementation/utils.js';
 
 export const auditSchema = z
   .object({
@@ -18,28 +18,7 @@ export const auditSchema = z
 
 export type Audit = z.infer<typeof auditSchema>;
 export const pluginAuditsSchema = z
-  .array(auditSchema, {
-    description: 'List of audits maintained in a plugin',
-  })
+  .array(auditSchema)
   .min(1)
-  // audit slugs are unique
-  .refine(
-    auditMetadata => !getDuplicateSlugsInAudits(auditMetadata),
-    auditMetadata => ({
-      message: duplicateSlugsInAuditsErrorMsg(auditMetadata),
-    }),
-  );
-
-// =======================
-
-// helper for validator: audit slugs are unique
-function duplicateSlugsInAuditsErrorMsg(audits: Audit[]) {
-  const duplicateRefs = getDuplicateSlugsInAudits(audits);
-  return `In plugin audits the following slugs are not unique: ${errorItems(
-    duplicateRefs,
-  )}`;
-}
-
-function getDuplicateSlugsInAudits(audits: Audit[]) {
-  return hasDuplicateStrings(audits.map(({ slug }) => slug));
-}
+  .check(createDuplicateSlugsCheck('Audit'))
+  .describe('List of audits maintained in a plugin');

packages/models/src/lib/audit.unit.test.ts

@@ -74,6 +74,8 @@ describe('pluginAuditsSchema', () => {
           title: 'Jest unit tests results.',
         },
       ] satisfies Audit[]),
-    ).toThrow('slugs are not unique: jest-unit-test-results');
+    ).toThrow(
+      String.raw`Audit slugs must be unique, but received duplicates: \"jest-unit-test-results\"`,
+    );
   });
 });

packages/models/src/lib/category-config.ts

@@ -1,21 +1,26 @@
 import { z } from 'zod';
+import {
+  createDuplicateSlugsCheck,
+  createDuplicatesCheck,
+} from './implementation/checks.js';
 import {
   metaSchema,
   scorableSchema,
   slugSchema,
   weightedRefSchema,
 } from './implementation/schemas.js';
-import { errorItems, hasDuplicateStrings } from './implementation/utils.js';
+import { formatRef } from './implementation/utils.js';
 
 export const categoryRefSchema = weightedRefSchema(
   'Weighted references to audits and/or groups for the category',
   'Slug of an audit or group (depending on `type`)',
 ).merge(
   z.object({
-    type: z.enum(['audit', 'group'], {
-      description:
+    type: z
+      .enum(['audit', 'group'])
+      .describe(
         'Discriminant for reference kind, affects where `slug` is looked up',
-    }),
+      ),
     plugin: slugSchema.describe(
       'Plugin slug (plugin should contain referenced audit or group)',
     ),
@@ -26,8 +31,11 @@ export type CategoryRef = z.infer<typeof categoryRefSchema>;
 export const categoryConfigSchema = scorableSchema(
   'Category with a score calculated from audits and groups from various plugins',
   categoryRefSchema,
-  getDuplicateRefsInCategoryMetrics,
-  duplicateRefsInCategoryMetricsErrorMsg,
+  createDuplicatesCheck(
+    serializeCategoryRefTarget,
+    duplicates =>
+      `Category has duplicate references: ${formatSerializedCategoryRefTargets(duplicates)}`,
+  ),
 )
   .merge(
     metaSchema({
@@ -40,49 +48,36 @@ export const categoryConfigSchema = scorableSchema(
   .merge(
     z.object({
       isBinary: z
-        .boolean({
-          description:
-            'Is this a binary category (i.e. only a perfect score considered a "pass")?',
-        })
+        .boolean()
+        .describe(
+          'Is this a binary category (i.e. only a perfect score considered a "pass")?',
+        )
         .optional(),
     }),
   );
 
 export type CategoryConfig = z.infer<typeof categoryConfigSchema>;
 
-// helper for validator: categories have unique refs to audits or groups
-export function duplicateRefsInCategoryMetricsErrorMsg(metrics: CategoryRef[]) {
-  const duplicateRefs = getDuplicateRefsInCategoryMetrics(metrics);
-  return `In the categories, the following audit or group refs are duplicates: ${errorItems(
-    duplicateRefs,
-  )}`;
-}
+const CATEGORY_REF_SEP = '||';
 
-function getDuplicateRefsInCategoryMetrics(metrics: CategoryRef[]) {
-  return hasDuplicateStrings(
-    metrics.map(({ slug, type, plugin }) => `${type} :: ${plugin} / ${slug}`),
-  );
+function serializeCategoryRefTarget(ref: CategoryRef): string {
+  return [ref.type, ref.plugin, ref.slug].join(CATEGORY_REF_SEP);
 }
 
-export const categoriesSchema = z
-  .array(categoryConfigSchema, {
-    description: 'Categorization of individual audits',
-  })
-  .refine(
-    categoryCfg => !getDuplicateSlugCategories(categoryCfg),
-    categoryCfg => ({
-      message: duplicateSlugCategoriesErrorMsg(categoryCfg),
-    }),
-  );
-
-// helper for validator: categories slugs are unique
-function duplicateSlugCategoriesErrorMsg(categories: CategoryConfig[]) {
-  const duplicateStringSlugs = getDuplicateSlugCategories(categories);
-  return `In the categories, the following slugs are duplicated: ${errorItems(
-    duplicateStringSlugs,
-  )}`;
+function formatSerializedCategoryRefTargets(keys: string[]): string {
+  return keys
+    .map(key => {
+      const [type, plugin, slug] = key.split(CATEGORY_REF_SEP) as [
+        'group' | 'audit',
+        string,
+        string,
+      ];
+      return formatRef({ type, plugin, slug });
+    })
+    .join(', ');
 }
 
-function getDuplicateSlugCategories(categories: CategoryConfig[]) {
-  return hasDuplicateStrings(categories.map(({ slug }) => slug));
-}
+export const categoriesSchema = z
+  .array(categoryConfigSchema)
+  .check(createDuplicateSlugsCheck('Category'))
+  .describe('Categorization of individual audits');