refactor(models): add meta.title to all named schemas

Author: matejchalk

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

@@ -30,7 +30,10 @@ export const auditDetailsSchema = z
       .meta({ description: 'Findings in tree structure' })
       .optional(),
   })
-  .meta({ description: 'Detailed information' });
+  .meta({
+    title: 'AuditDetails',
+    description: 'Detailed information',
+  });
 export type AuditDetails = z.infer<typeof auditDetailsSchema>;
 
 export const auditOutputSchema = z
@@ -42,14 +45,19 @@ export const auditOutputSchema = z
     scoreTarget: scoreTargetSchema,
     details: auditDetailsSchema.optional(),
   })
-  .meta({ description: 'Audit information' });
+  .meta({
+    title: 'AuditOutput',
+    description: 'Audit information',
+  });
 
 export type AuditOutput = z.infer<typeof auditOutputSchema>;
 
 export const auditOutputsSchema = z
   .array(auditOutputSchema)
   .check(createDuplicateSlugsCheck('Audit'))
-  .describe(
-    'List of JSON formatted audit output emitted by the runner process of a plugin',
-  );
+  .meta({
+    title: 'AuditOutputs',
+    description:
+      'List of JSON formatted audit output emitted by the runner process of a plugin',
+  });
 export type AuditOutputs = z.infer<typeof auditOutputsSchema>;

packages/models/src/lib/audit.ts

@@ -14,11 +14,15 @@ export const auditSchema = z
       description: 'List of scorable metrics for the given plugin',
       isSkippedDescription: 'Indicates whether the audit is skipped',
     }).shape,
-  );
+  )
+  .meta({ title: 'Audit' });
 
 export type Audit = z.infer<typeof auditSchema>;
 export const pluginAuditsSchema = z
   .array(auditSchema)
   .min(1)
   .check(createDuplicateSlugsCheck('Audit'))
-  .meta({ description: 'List of audits maintained in a plugin' });
+  .meta({
+    title: 'PluginAudits',
+    description: 'List of audits maintained in a plugin',
+  });

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

@@ -12,19 +12,24 @@ export const cacheConfigObjectSchema = z
       .default(false),
   })
   .meta({
+    title: 'CacheConfigObject',
     description: 'Cache configuration object for read and/or write operations',
   });
 export type CacheConfigObject = z.infer<typeof cacheConfigObjectSchema>;
 
 export const cacheConfigShorthandSchema = z.boolean().meta({
+  title: 'CacheConfigShorthand',
   description:
     'Cache configuration shorthand for both, read and write operations',
 });
 export type CacheConfigShorthand = z.infer<typeof cacheConfigShorthandSchema>;
 
 export const cacheConfigSchema = z
   .union([cacheConfigShorthandSchema, cacheConfigObjectSchema])
-  .meta({ description: 'Cache configuration for read and write operations' })
+  .meta({
+    title: 'CacheConfig',
+    description: 'Cache configuration for read and write operations',
+  })
   .default(false);
 
 export type CacheConfig = z.infer<typeof cacheConfigSchema>;

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

@@ -15,15 +15,18 @@ 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`)',
-).extend({
-  type: z.enum(['audit', 'group']).meta({
-    description:
-      'Discriminant for reference kind, affects where `slug` is looked up',
-  }),
-  plugin: slugSchema.describe(
-    'Plugin slug (plugin should contain referenced audit or group)',
-  ),
-});
+)
+  .extend({
+    type: z.enum(['audit', 'group']).meta({
+      description:
+        'Discriminant for reference kind, affects where `slug` is looked up',
+    }),
+    plugin: slugSchema.describe(
+      'Plugin slug (plugin should contain referenced audit or group)',
+    ),
+  })
+  .meta({ title: 'CategoryRef' });
+
 export type CategoryRef = z.infer<typeof categoryRefSchema>;
 
 export const categoryConfigSchema = scorableSchema(
@@ -43,7 +46,8 @@ export const categoryConfigSchema = scorableSchema(
       description: 'Meta info for category',
     }).shape,
   )
-  .extend({ scoreTarget: scoreTargetSchema });
+  .extend({ scoreTarget: scoreTargetSchema })
+  .meta({ title: 'CategoryConfig' });
 
 export type CategoryConfig = z.infer<typeof categoryConfigSchema>;
 
@@ -69,4 +73,7 @@ function formatSerializedCategoryRefTargets(keys: string[]): string {
 export const categoriesSchema = z
   .array(categoryConfigSchema)
   .check(createDuplicateSlugsCheck('Category'))
-  .meta({ description: 'Categorization of individual audits' });
+  .meta({
+    title: 'Categories',
+    description: 'Categorization of individual audits',
+  });

packages/models/src/lib/commit.ts

@@ -15,6 +15,9 @@ export const commitSchema = z
       .meta({ description: 'Date and time when commit was authored' }),
     author: z.string().trim().meta({ description: 'Commit author name' }),
   })
-  .meta({ description: 'Git commit' });
+  .meta({
+    title: 'Commit',
+    description: 'Git commit',
+  });
 
 export type Commit = z.infer<typeof commitSchema>;

packages/models/src/lib/configuration.ts

@@ -4,19 +4,26 @@ import { globPathSchema } from './implementation/schemas.js';
 /**
  * Generic schema for a tool command configuration, reusable across plugins.
  */
-export const artifactGenerationCommandSchema = z.union([
-  z.string().min(1).meta({ description: 'Generate artifact files' }),
-  z.object({
-    command: z.string().min(1).meta({ description: 'Generate artifact files' }),
-    args: z.array(z.string()).optional(),
-  }),
-]);
+export const artifactGenerationCommandSchema = z
+  .union([
+    z.string().min(1).meta({ description: 'Generate artifact files' }),
+    z.object({
+      command: z
+        .string()
+        .min(1)
+        .meta({ description: 'Generate artifact files' }),
+      args: z.array(z.string()).optional(),
+    }),
+  ])
+  .meta({ title: 'ArtifactGenerationCommand' });
 
-export const pluginArtifactOptionsSchema = z.object({
-  generateArtifactsCommand: artifactGenerationCommandSchema.optional(),
-  artifactsPaths: z
-    .union([globPathSchema, z.array(globPathSchema).min(1)])
-    .meta({ description: 'File paths or glob patterns for artifact files' }),
-});
+export const pluginArtifactOptionsSchema = z
+  .object({
+    generateArtifactsCommand: artifactGenerationCommandSchema.optional(),
+    artifactsPaths: z
+      .union([globPathSchema, z.array(globPathSchema).min(1)])
+      .meta({ description: 'File paths or glob patterns for artifact files' }),
+  })
+  .meta({ title: 'PluginArtifactOptions' });
 
 export type PluginArtifactOptions = z.infer<typeof pluginArtifactOptionsSchema>;

packages/models/src/lib/group.ts

@@ -13,7 +13,7 @@ import { formatSlugsList } from './implementation/utils.js';
 export const groupRefSchema = weightedRefSchema(
   'Weighted reference to a group',
   "Reference slug to a group within this plugin (e.g. 'max-lines')",
-);
+).meta({ title: 'GroupRef' });
 export type GroupRef = z.infer<typeof groupRefSchema>;
 
 export const groupMetaSchema = metaSchema({
@@ -22,7 +22,7 @@ export const groupMetaSchema = metaSchema({
   docsUrlDescription: 'Group documentation site',
   description: 'Group metadata',
   isSkippedDescription: 'Indicates whether the group is skipped',
-});
+}).meta({ title: 'GroupMeta' });
 export type GroupMeta = z.infer<typeof groupMetaSchema>;
 
 export const groupSchema = scorableSchema(
@@ -34,12 +34,17 @@ export const groupSchema = scorableSchema(
     duplicates =>
       `Group has duplicate references to audits: ${formatSlugsList(duplicates)}`,
   ),
-).merge(groupMetaSchema);
+)
+  .merge(groupMetaSchema)
+  .meta({ title: 'Group' });
 
 export type Group = z.infer<typeof groupSchema>;
 
 export const groupsSchema = z
   .array(groupSchema)
   .check(createDuplicateSlugsCheck('Group'))
   .optional()
-  .meta({ description: 'List of groups' });
+  .meta({
+    title: 'Groups',
+    description: 'List of groups',
+  });

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

@@ -16,7 +16,9 @@ import { filenameRegex, slugRegex } from './utils.js';
 
 export const tableCellValueSchema = z
   .union([z.string(), z.number(), z.boolean(), z.null()])
-  .default(null);
+  .default(null)
+  .meta({ title: 'TableCellValue' });
+
 export type TableCellValue = z.infer<typeof tableCellValueSchema>;
 
 /**
@@ -47,17 +49,23 @@ export const slugSchema = z
   .max(MAX_SLUG_LENGTH, {
     message: `The slug can be max ${MAX_SLUG_LENGTH} characters long`,
   })
-  .meta({ description: 'Unique ID (human-readable, URL-safe)' });
+  .meta({
+    title: 'Slug',
+    description: 'Unique ID (human-readable, URL-safe)',
+  });
 
 /**  Schema for a general description property */
 export const descriptionSchema = z
   .string()
   .max(MAX_DESCRIPTION_LENGTH)
-  .meta({ description: 'Description (markdown)' })
+  .meta({
+    title: 'Description',
+    description: 'Description (markdown)',
+  })
   .optional();
 
 /* Schema for a URL */
-export const urlSchema = z.string().url();
+export const urlSchema = z.string().url().meta({ title: 'URL' });
 
 /**  Schema for a docsUrl */
 export const docsUrlSchema = urlSchema
@@ -79,23 +87,25 @@ export const docsUrlSchema = urlSchema
     }
     throw new ZodError(ctx.error.issues);
   })
-  .meta({ description: 'Documentation site' });
+  .meta({ title: 'DocsUrl', description: 'Documentation site' });
 
 /** Schema for a title of a plugin, category and audit */
-export const titleSchema = z
-  .string()
-  .max(MAX_TITLE_LENGTH)
-  .meta({ description: 'Descriptive name' });
+export const titleSchema = z.string().max(MAX_TITLE_LENGTH).meta({
+  title: 'Title',
+  description: 'Descriptive name',
+});
 
 /** Schema for score of audit, category or group */
-export const scoreSchema = z
-  .number()
-  .min(0)
-  .max(1)
-  .meta({ description: 'Value between 0 and 1' });
+export const scoreSchema = z.number().min(0).max(1).meta({
+  title: 'Score',
+  description: 'Value between 0 and 1',
+});
 
 /** Schema for a property indicating whether an entity is filtered out */
-export const isSkippedSchema = z.boolean().optional();
+export const isSkippedSchema = z
+  .boolean()
+  .optional()
+  .meta({ title: 'IsSkipped' });
 
 /**
  * Used for categories, plugins and audits
@@ -136,7 +146,8 @@ export function metaSchema(options?: {
 export const filePathSchema = z
   .string()
   .trim()
-  .min(1, { message: 'The path is invalid' });
+  .min(1, { message: 'The path is invalid' })
+  .meta({ title: 'FilePath' });
 
 /**
  * Regex for glob patterns - validates file paths and glob patterns
@@ -149,11 +160,9 @@ export const globPathSchema = z
   .string()
   .trim()
   .min(1, { message: 'The glob pattern is invalid' })
-  .regex(globRegex, {
-    message:
-      'The path must be a valid file path or glob pattern (supports *, **, {}, [], !, ?)',
-  })
+  .regex(globRegex)
   .meta({
+    title: 'GlobPath',
     description:
       'Schema for a glob pattern (supports wildcards like *, **, {}, !, etc.)',
   });
@@ -162,15 +171,21 @@ export const globPathSchema = z
 export const fileNameSchema = z
   .string()
   .trim()
-  .regex(filenameRegex, {
-    message: `The filename has to be valid`,
-  })
-  .min(1, { message: 'The file name is invalid' });
+  .regex(filenameRegex)
+  .min(1)
+  .meta({ title: 'FileName' });
 
 /** Schema for a positiveInt */
-export const positiveIntSchema = z.number().int().positive();
+export const positiveIntSchema = z
+  .number()
+  .int()
+  .positive()
+  .meta({ title: 'PositiveInt' });
 
-export const nonnegativeNumberSchema = z.number().nonnegative();
+export const nonnegativeNumberSchema = z
+  .number()
+  .nonnegative()
+  .meta({ title: 'NonnegativeNumber' });
 
 export function packageVersionSchema<
   TRequired extends boolean = false,
@@ -195,11 +210,15 @@ export function packageVersionSchema<
 /** Schema for a binary score threshold */
 export const scoreTargetSchema = nonnegativeNumberSchema
   .max(1)
-  .meta({ description: 'Pass/fail score threshold (0-1)' })
+  .meta({
+    title: 'ScoreTarget',
+    description: 'Pass/fail score threshold (0-1)',
+  })
   .optional();
 
 /** Schema for a weight */
 export const weightSchema = nonnegativeNumberSchema.meta({
+  title: 'Weight',
   description:
     'Coefficient for the given score (use weight 0 if only for display)',
 });
@@ -243,9 +262,10 @@ export function scorableSchema<T extends ReturnType<typeof weightedRefSchema>>(
     .describe(description);
 }
 
-export const materialIconSchema = z
-  .enum(MATERIAL_ICONS)
-  .meta({ description: 'Icon from VSCode Material Icons extension' });
+export const materialIconSchema = z.enum(MATERIAL_ICONS).meta({
+  title: 'MaterialIcon',
+  description: 'Icon from VSCode Material Icons extension',
+});
 export type MaterialIcon = z.infer<typeof materialIconSchema>;
 
 type Ref = { weight: number };
@@ -263,4 +283,7 @@ export const filePositionSchema = z
     endLine: positiveIntSchema.meta({ description: 'End line' }).optional(),
     endColumn: positiveIntSchema.meta({ description: 'End column' }).optional(),
   })
-  .meta({ description: 'Location in file' });
+  .meta({
+    title: 'FilePosition',
+    description: 'Location in file',
+  });