feat: refine Zod schema validation

Author: hanna-skryl

packages/core/package.json

@@ -41,8 +41,7 @@
   "dependencies": {
     "@code-pushup/models": "0.57.0",
     "@code-pushup/utils": "0.57.0",
-    "ansis": "^3.3.0",
-    "zod-validation-error": "^3.4.0"
+    "ansis": "^3.3.0"
   },
   "peerDependencies": {
     "@code-pushup/portal-client": "^0.9.0"

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { describe, expect } from 'vitest';
-import { ConfigValidationError, readRcByPath } from './read-rc-file.js';
+import { readRcByPath } from './read-rc-file.js';
 
 describe('readRcByPath', () => {
   const configDirPath = path.join(
@@ -69,7 +69,7 @@ describe('readRcByPath', () => {
   it('should throw if the configuration is empty', async () => {
     await expect(
       readRcByPath(path.join(configDirPath, 'code-pushup.empty.config.js')),
-    ).rejects.toThrow(expect.any(ConfigValidationError));
+    ).rejects.toThrow(/invalid_type/);
   });
 
   it('should throw if the configuration is invalid', async () => {

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

@@ -1,31 +1,18 @@
-import { bold } from 'ansis';
 import path from 'node:path';
-import { fromError, isZodErrorLike } from 'zod-validation-error';
 import {
   CONFIG_FILE_NAME,
   type CoreConfig,
   SUPPORTED_CONFIG_FILE_FORMATS,
   coreConfigSchema,
 } from '@code-pushup/models';
-import {
-  fileExists,
-  importModule,
-  zodErrorMessageBuilder,
-} from '@code-pushup/utils';
+import { fileExists, importModule, parseSchema } from '@code-pushup/utils';
 
 export class ConfigPathError extends Error {
   constructor(configPath: string) {
     super(`Provided path '${configPath}' is not valid.`);
   }
 }
 
-export class ConfigValidationError extends Error {
-  constructor(configPath: string, message: string) {
-    const relativePath = path.relative(process.cwd(), configPath);
-    super(`Failed parsing core config in ${bold(relativePath)}.\n\n${message}`);
-  }
-}
-
 export async function readRcByPath(
   filepath: string,
   tsconfig?: string,
@@ -38,18 +25,16 @@ export async function readRcByPath(
     throw new ConfigPathError(filepath);
   }
 
-  const cfg = await importModule({ filepath, tsconfig, format: 'esm' });
+  const cfg: CoreConfig = await importModule({
+    filepath,
+    tsconfig,
+    format: 'esm',
+  });
 
-  try {
-    return coreConfigSchema.parse(cfg);
-  } catch (error) {
-    const validationError = fromError(error, {
-      messageBuilder: zodErrorMessageBuilder,
-    });
-    throw isZodErrorLike(error)
-      ? new ConfigValidationError(filepath, validationError.message)
-      : error;
-  }
+  return parseSchema(coreConfigSchema, cfg, {
+    schemaType: 'core config',
+    sourcePath: filepath,
+  });
 }
 
 export async function autoloadRc(tsconfig?: string): Promise<CoreConfig> {

packages/plugin-eslint/src/lib/config.ts

@@ -35,7 +35,18 @@ export type ESLintPluginRunnerConfig = {
 };
 
 const customGroupRulesSchema = z.union(
-  [z.array(z.string()).min(1), z.record(z.string(), z.number())],
+  [
+    z
+      .array(z.string())
+      .min(1, 'Custom group rules must contain at least 1 element'),
+    z.record(z.string(), z.number()).refine(
+      schema => Object.keys(schema).length > 0,
+      () => ({
+        code: 'too_small',
+        message: 'Custom group rules must contain at least 1 element',
+      }),
+    ),
+  ],
   {
     description:
       'Array of rule IDs with equal weights or object mapping rule IDs to specific weights',

packages/plugin-eslint/src/lib/eslint-plugin.integration.test.ts

@@ -71,15 +71,12 @@ describe('eslintPlugin', () => {
     );
   });
 
-  it('should initialize with plugin options for custom rules', async () => {
+  it('should initialize with plugin options for custom groups', async () => {
     cwdSpy.mockReturnValue(path.join(fixturesDir, 'nx-monorepo'));
     const plugin = await eslintPlugin(
       {
         eslintrc: './packages/nx-plugin/eslint.config.js',
-        patterns: [
-          'packages/nx-plugin/**/*.ts',
-          'packages/nx-plugin/**/*.json',
-        ],
+        patterns: ['packages/nx-plugin/**/*.ts'],
       },
       {
         groups: [
@@ -114,11 +111,36 @@ describe('eslintPlugin', () => {
     );
   });
 
+  it('should throw when custom group rules are empty', async () => {
+    await expect(
+      eslintPlugin(
+        {
+          eslintrc: './packages/nx-plugin/eslint.config.js',
+          patterns: ['packages/nx-plugin/**/*.ts'],
+        },
+        {
+          groups: [{ slug: 'type-safety', title: 'Type safety', rules: [] }],
+        },
+      ),
+    ).rejects.toThrow(/Custom group rules must contain at least 1 element/);
+    await expect(
+      eslintPlugin(
+        {
+          eslintrc: './packages/nx-plugin/eslint.config.js',
+          patterns: ['packages/nx-plugin/**/*.ts'],
+        },
+        {
+          groups: [{ slug: 'type-safety', title: 'Type safety', rules: {} }],
+        },
+      ),
+    ).rejects.toThrow(/Custom group rules must contain at least 1 element/);
+  });
+
   it('should throw when invalid parameters provided', async () => {
     await expect(
       // @ts-expect-error simulating invalid non-TS config
       eslintPlugin({ eslintrc: '.eslintrc.json' }),
-    ).rejects.toThrow('patterns');
+    ).rejects.toThrow(/Invalid input/);
   });
 
   it("should throw if eslintrc file doesn't exist", async () => {

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

@@ -2,6 +2,7 @@ import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { PluginConfig } from '@code-pushup/models';
+import { parseSchema } from '@code-pushup/utils';
 import {
   type ESLintPluginConfig,
   type ESLintPluginOptions,
@@ -36,10 +37,14 @@ export async function eslintPlugin(
   config: ESLintPluginConfig,
   options?: ESLintPluginOptions,
 ): Promise<PluginConfig> {
-  const targets = eslintPluginConfigSchema.parse(config);
+  const targets = parseSchema(eslintPluginConfigSchema, config, {
+    schemaType: 'ESLint plugin config',
+  });
 
   const customGroups = options
-    ? eslintPluginOptionsSchema.parse(options).groups
+    ? parseSchema(eslintPluginOptionsSchema, options, {
+        schemaType: 'ESLint plugin options',
+      }).groups
     : undefined;
 
   const { audits, groups } = await listAuditsAndGroups(targets, customGroups);

packages/utils/package.json

@@ -37,6 +37,7 @@
     "multi-progress-bars": "^5.0.3",
     "semver": "^7.6.0",
     "simple-git": "^3.20.0",
+    "zod": "^3.23.8",
     "zod-validation-error": "^3.4.0"
   }
 }

packages/utils/src/index.ts

@@ -123,4 +123,4 @@ export type {
   WithRequired,
 } from './lib/types.js';
 export { verboseUtils } from './lib/verbose-utils.js';
-export { zodErrorMessageBuilder } from './lib/zod-validation.js';
+export { parseSchema, SchemaValidationError } from './lib/zod-validation.js';

packages/utils/src/lib/zod-validation.ts

@@ -1,5 +1,33 @@
 import { bold, red } from 'ansis';
-import type { MessageBuilder } from 'zod-validation-error';
+import path from 'node:path';
+import type { z } from 'zod';
+import {
+  type MessageBuilder,
+  fromError,
+  isZodErrorLike,
+} from 'zod-validation-error';
+
+type SchemaValidationContext = {
+  schemaType: string;
+  sourcePath?: string;
+};
+
+export class SchemaValidationError extends Error {
+  constructor(
+    { schemaType, sourcePath }: SchemaValidationContext,
+    error: Error,
+  ) {
+    const validationError = fromError(error, {
+      messageBuilder: zodErrorMessageBuilder,
+    });
+    const pathDetails = sourcePath
+      ? ` in ${bold(path.relative(process.cwd(), sourcePath))}`
+      : '';
+    super(
+      `Failed parsing ${schemaType}${pathDetails}.\n\n${validationError.message}`,
+    );
+  }
+}
 
 export function formatErrorPath(errorPath: (string | number)[]): string {
   return errorPath
@@ -12,7 +40,7 @@ export function formatErrorPath(errorPath: (string | number)[]): string {
     .join('');
 }
 
-export const zodErrorMessageBuilder: MessageBuilder = issues =>
+const zodErrorMessageBuilder: MessageBuilder = issues =>
   issues
     .map(issue => {
       const formattedMessage = red(`${bold(issue.code)}: ${issue.message}`);
@@ -23,3 +51,18 @@ export const zodErrorMessageBuilder: MessageBuilder = issues =>
       return `${formattedMessage}\n`;
     })
     .join('\n');
+
+export function parseSchema<T extends z.ZodTypeAny>(
+  schema: T,
+  data: z.input<T>,
+  { schemaType, sourcePath }: SchemaValidationContext,
+): z.output<T> {
+  try {
+    return schema.parse(data);
+  } catch (error) {
+    if (isZodErrorLike(error)) {
+      throw new SchemaValidationError({ schemaType, sourcePath }, error);
+    }
+    throw error;
+  }
+}