refactor(models): use schema title from meta registry

Author: matejchalk

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

@@ -15,27 +15,24 @@ export class ConfigPathError extends Error {
 }
 
 export async function readRcByPath(
-  filepath: string,
+  filePath: string,
   tsconfig?: string,
 ): Promise<CoreConfig> {
-  if (filepath.length === 0) {
+  if (filePath.length === 0) {
     throw new Error('The path to the configuration file is empty.');
   }
 
-  if (!(await fileExists(filepath))) {
-    throw new ConfigPathError(filepath);
+  if (!(await fileExists(filePath))) {
+    throw new ConfigPathError(filePath);
   }
 
   const cfg: CoreConfig = await importModule({
-    filepath,
+    filepath: filePath,
     tsconfig,
     format: 'esm',
   });
 
-  return validate(coreConfigSchema, cfg, {
-    schemaType: 'core config',
-    sourcePath: filepath,
-  });
+  return validate(coreConfigSchema, cfg, { filePath });
 }
 
 export async function autoloadRc(tsconfig?: string): Promise<CoreConfig> {

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

@@ -1,36 +1,39 @@
-import { bold } from 'ansis';
+import ansis from 'ansis';
 import path from 'node:path';
-import { ZodError, z } from 'zod';
+import { ZodError, type ZodType, z } from 'zod';
 
 type SchemaValidationContext = {
-  schemaType: string;
-  sourcePath?: string;
+  filePath?: string;
 };
 
 export class SchemaValidationError extends Error {
   constructor(
-    { schemaType, sourcePath }: SchemaValidationContext,
     error: ZodError,
+    schema: ZodType,
+    { filePath }: SchemaValidationContext,
   ) {
     const formattedError = z.prettifyError(error);
-    const pathDetails = sourcePath
-      ? ` in ${bold(path.relative(process.cwd(), sourcePath))}`
-      : '';
-    super(`Failed parsing ${schemaType}${pathDetails}.\n\n${formattedError}`);
+    const schemaTitle = z.globalRegistry.get(schema)?.title;
+    const summary = [
+      'Invalid',
+      schemaTitle ? ansis.bold(schemaTitle) : 'data',
+      filePath &&
+        `in ${ansis.bold(path.relative(process.cwd(), filePath))} file`,
+    ]
+      .filter(Boolean)
+      .join(' ');
+    super(`${summary}\n${formattedError}\n`);
   }
 }
 
-export function validate<T extends z.ZodTypeAny>(
+export function validate<T extends ZodType>(
   schema: T,
   data: z.input<T>,
-  { schemaType, sourcePath }: SchemaValidationContext,
+  context: SchemaValidationContext = {},
 ): z.output<T> {
-  try {
-    return schema.parse(data);
-  } catch (error) {
-    if (error instanceof ZodError) {
-      throw new SchemaValidationError({ schemaType, sourcePath }, error);
-    }
-    throw error;
+  const result = schema.safeParse(data);
+  if (result.success) {
+    return result.data;
   }
+  throw new SchemaValidationError(result.error, schema, context);
 }

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

@@ -35,19 +35,13 @@ export async function eslintPlugin(
   config: ESLintPluginConfig,
   options?: ESLintPluginOptions,
 ): Promise<PluginConfig> {
-  const targets = validate(eslintPluginConfigSchema, config, {
-    schemaType: 'ESLint plugin config',
-  });
+  const targets = validate(eslintPluginConfigSchema, config);
 
   const {
     groups: customGroups,
     artifacts,
     scoreTargets,
-  } = options
-    ? validate(eslintPluginOptionsSchema, options, {
-        schemaType: 'ESLint plugin options',
-      })
-    : {};
+  } = options ? validate(eslintPluginOptionsSchema, options) : {};
 
   const { audits, groups } = await listAuditsAndGroups(targets, customGroups);