@amritk/generate-validators 0.3.0 → 0.4.0

package/dist/generators/build-schema.d.ts

@@ -27,4 +27,4 @@ export type GeneratedFile = {
  * // files → [{ filename: 'document.ts', content: '...' }, { filename: 'info.ts', ... }, ...]
  * ```
  */
-export declare const buildValidatorSchema: (rootSchema: JSONSchema, rootTypeName: string) => Promise<GeneratedFile[]>;
+export declare const buildValidatorSchema: (rootSchema: JSONSchema, rootTypeName: string, typeSuffix?: string) => Promise<GeneratedFile[]>;

package/dist/generators/collect-validator-imports.d.ts

@@ -13,6 +13,11 @@ type CollectValidatorImportsOptions = {
      * are excluded from the import list (they were never generated as files).
      */
     readonly rootSchema?: Record<string, unknown> | undefined;
+    /**
+     * Suffix appended to every type/validator name derived from a `$ref`. Must
+     * match the suffix used when generating the referenced files. Defaults to `''`.
+     */
+    readonly typeSuffix?: string;
 };
 /**
  * Collects import statements for all $ref dependencies of a schema.
@@ -22,7 +27,7 @@ type CollectValidatorImportsOptions = {
  * ```typescript
  * const schema = { properties: { contact: { $ref: '#/$defs/contact' } } }
  * collectValidatorImports(schema)
- * // ["import { type ContactObject, validateContactObject } from './contact-object'"]
+ * // ["import { type Contact, validateContact } from './contact'"]
  * ```
  */
 export declare const collectValidatorImports: (schema: JSONSchema, options?: CollectValidatorImportsOptions) => string[];

package/dist/generators/generate-files.d.ts

@@ -12,6 +12,11 @@ type GenerateValidatorFileOptions = {
      * The root schema document. Used to filter out unresolvable refs.
      */
     readonly rootSchema?: Record<string, unknown>;
+    /**
+     * Suffix appended to every type/validator name derived from a `$ref`.
+     * Defaults to `''` (no suffix).
+     */
+    readonly typeSuffix?: string;
 };
 /**
  * Generates a complete TypeScript validator file from a JSON Schema.

package/dist/generators/generate-validator-function.d.ts

@@ -21,4 +21,4 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * // }
  * ```
  */
-export declare const generateValidatorFunction: (schema: JSONSchema, typeName: string) => string;
+export declare const generateValidatorFunction: (schema: JSONSchema, typeName: string, suffix?: string) => string;

package/dist/index.js

@@ -132,15 +132,15 @@ var refToFilename2 = (ref) => {
   }
   return filename;
 };
-var kebabToPascal = (kebab) => {
+var kebabToPascal = (kebab, suffix) => {
   const words = kebab.split("-");
   let pascalCase = "";
   for (const word of words) {
     pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
   }
-  return pascalCase + "Object";
+  return pascalCase + suffix;
 };
-var refToName = (ref) => kebabToPascal(refToFilename2(ref));
+var refToName = (ref, suffix = "") => kebabToPascal(refToFilename2(ref), suffix);
 
 // ../helpers/dist/resolve-dynamic-refs.js
 var resolveDynamicRefs = (schema, dynamicRefMap) => {
@@ -415,15 +415,15 @@ var refToFilename4 = (ref) => {
   }
   return filename;
 };
-var kebabToPascal2 = (kebab) => {
+var kebabToPascal2 = (kebab, suffix) => {
   const words = kebab.split("-");
   let pascalCase = "";
   for (const word of words) {
     pascalCase += word.charAt(0).toUpperCase() + word.slice(1);
   }
-  return pascalCase + "Object";
+  return pascalCase + suffix;
 };
-var refToName2 = (ref) => kebabToPascal2(refToFilename4(ref));
+var refToName2 = (ref, suffix = "") => kebabToPascal2(refToFilename4(ref), suffix);
 var JS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 var safeKey = (key) => {
   if (JS_IDENTIFIER.test(key)) {
@@ -516,12 +516,13 @@ var buildJsDocBlock = (title, description, commentUrl) => {
 `;
   return block;
 };
-var getTypeScriptType = (schema) => {
-  const base = getUnbrandedType(schema);
+var getTypeScriptType = (schema, options = {}) => {
+  const base = getUnbrandedType(schema, options);
   const brand = getMjstBrand(schema);
   return brand ? `(${base} & { readonly __brand: '${brand}' })` : base;
 };
-var getUnbrandedType = (schema) => {
+var recordType = (keyType, valueType, options) => options.readonly ? `Readonly<Record<${keyType}, ${valueType}>>` : `Record<${keyType}, ${valueType}>`;
+var getUnbrandedType = (schema, options = {}) => {
   if (typeof schema === "boolean") {
     return getBooleanSubSchemaType(schema);
   }
@@ -540,13 +541,13 @@ var getUnbrandedType = (schema) => {
     if (!schema.$ref.startsWith("#")) {
       return "unknown";
     }
-    return refToName2(schema.$ref);
+    return refToName2(schema.$ref, options.typeSuffix);
   }
   if (schema.$dynamicRef) {
     if (schema.$dynamicRef === "#meta") {
-      return "Schema";
+      return `Schema${options.typeSuffix ?? ""}`;
     }
-    return refToName2(schema.$dynamicRef);
+    return refToName2(schema.$dynamicRef, options.typeSuffix);
   }
   if (schema.const !== undefined) {
     return JSON.stringify(schema.const);
@@ -569,51 +570,51 @@ var getUnbrandedType = (schema) => {
     return multiEnumUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-    let oneOfUnion = getTypeScriptType(schema.oneOf[0]);
+    let oneOfUnion = getTypeScriptType(schema.oneOf[0], options);
     for (let i = 1;i < schema.oneOf.length; i++) {
-      oneOfUnion += " | " + getTypeScriptType(schema.oneOf[i]);
+      oneOfUnion += " | " + getTypeScriptType(schema.oneOf[i], options);
     }
     return oneOfUnion;
   }
   if (schema.anyOf && Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
-    let anyOfUnion = getTypeScriptType(schema.anyOf[0]);
+    let anyOfUnion = getTypeScriptType(schema.anyOf[0], options);
     for (let i = 1;i < schema.anyOf.length; i++) {
-      anyOfUnion += " | " + getTypeScriptType(schema.anyOf[i]);
+      anyOfUnion += " | " + getTypeScriptType(schema.anyOf[i], options);
     }
     return anyOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-    let intersectionTypes = getTypeScriptType(schema.allOf[0]);
+    let intersectionTypes = getTypeScriptType(schema.allOf[0], options);
     for (let i = 1;i < schema.allOf.length; i++) {
-      intersectionTypes += " & " + getTypeScriptType(schema.allOf[i]);
+      intersectionTypes += " & " + getTypeScriptType(schema.allOf[i], options);
     }
     return intersectionTypes;
   }
   const conditionalResult = getConditionalObjectSchema(schema);
   if (conditionalResult) {
-    const baseType = getTypeScriptType(conditionalResult.schema);
+    const baseType = getTypeScriptType(conditionalResult.schema, options);
     if (conditionalResult.thenRef) {
-      return `(${baseType}) & ${refToName2(conditionalResult.thenRef)}`;
+      return `(${baseType}) & ${refToName2(conditionalResult.thenRef, options.typeSuffix)}`;
     }
     return baseType;
   }
   if (!schema.type) {
     if (schema.additionalProperties !== undefined) {
       if (typeof schema.additionalProperties === "boolean") {
-        return `Record<string, ${getBooleanSubSchemaType(schema.additionalProperties)}>`;
+        return recordType("string", getBooleanSubSchemaType(schema.additionalProperties), options);
       }
-      return `Record<string, ${getTypeScriptType(schema.additionalProperties)}>`;
+      return recordType("string", getTypeScriptType(schema.additionalProperties, options), options);
     }
     if (schema.patternProperties && typeof schema.patternProperties === "object") {
       const firstEntry = Object.entries(schema.patternProperties)[0];
       if (firstEntry) {
         const [pattern, value] = firstEntry;
         if (value !== undefined) {
-          const valueType = typeof value === "boolean" ? getBooleanSubSchemaType(value) : getTypeScriptType(value);
+          const valueType = typeof value === "boolean" ? getBooleanSubSchemaType(value) : getTypeScriptType(value, options);
           if (pattern === "^x-") {
-            return `Record<\`x-\${string}\`, ${valueType}>`;
+            return recordType("`x-${string}`", valueType, options);
           }
-          return `Record<string, ${valueType}>`;
+          return recordType("string", valueType, options);
         }
       }
     }
@@ -666,41 +667,42 @@ var getUnbrandedType = (schema) => {
       return "boolean";
     case "array":
       if (schema.items) {
-        const itemType = getTypeScriptType(schema.items);
+        const itemType = getTypeScriptType(schema.items, options);
         const wrappedItemType = itemType.includes(" | ") ? `(${itemType})` : itemType;
-        return `${wrappedItemType}[]`;
+        return options.readonly ? `readonly ${wrappedItemType}[]` : `${wrappedItemType}[]`;
       }
-      return "unknown[]";
+      return options.readonly ? "readonly unknown[]" : "unknown[]";
     case "object":
       if (schema.properties) {
+        const readonlyPrefix = options.readonly ? "readonly " : "";
         let properties = "";
         let first = true;
         for (const key in schema.properties) {
           const propSchema = schema.properties[key];
           const isRequired = schema.required?.includes(key) ?? false;
           const optional = isRequired ? "" : "?";
-          const propType = getTypeScriptType(propSchema);
+          const propType = getTypeScriptType(propSchema, options);
           if (!first)
             properties += "; ";
-          properties += safeKey(key) + optional + ": " + propType;
+          properties += readonlyPrefix + safeKey(key) + optional + ": " + propType;
           first = false;
         }
         return "{ " + properties + " }";
       }
       if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-        const additionalPropType = getTypeScriptType(schema.additionalProperties);
-        return `Record<string, ${additionalPropType}>`;
+        const additionalPropType = getTypeScriptType(schema.additionalProperties, options);
+        return recordType("string", additionalPropType, options);
       }
       if (schema.patternProperties && typeof schema.patternProperties === "object") {
         const firstEntry = Object.entries(schema.patternProperties)[0];
         if (firstEntry) {
           const [pattern, patternVal] = firstEntry;
           if (patternVal) {
-            const valueType = getTypeScriptType(patternVal);
+            const valueType = getTypeScriptType(patternVal, options);
             if (pattern === "^x-") {
-              return `Record<\`x-\${string}\`, ${valueType}>`;
+              return recordType("`x-${string}`", valueType, options);
             }
-            return `Record<string, ${valueType}>`;
+            return recordType("string", valueType, options);
           }
         }
       }
@@ -709,9 +711,10 @@ var getUnbrandedType = (schema) => {
       return "unknown";
   }
 };
-var generateTypeDefinition = (schema, typeName) => {
+var generateTypeDefinition = (schema, typeName, options = {}) => {
+  const readonlyPrefix = options.readonly ? "readonly " : "";
   if (!isObjectLikeSchema(schema)) {
-    const tsType = getTypeScriptType(schema);
+    const tsType = getTypeScriptType(schema, options);
     let result = "";
     if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
       result += buildJsDocBlock(typeName, schema.$comment);
@@ -739,23 +742,23 @@ var generateTypeDefinition = (schema, typeName) => {
       if (firstPatternProperty === undefined) {
         return `export type ${typeName} = Record<string, unknown>;`;
       }
-      const patternPropType = typeof firstPatternProperty === "boolean" ? getBooleanSubSchemaType(firstPatternProperty) : getTypeScriptType(firstPatternProperty);
+      const patternPropType = typeof firstPatternProperty === "boolean" ? getBooleanSubSchemaType(firstPatternProperty) : getTypeScriptType(firstPatternProperty, options);
       const keyType = firstPattern === "^x-" ? "`x-${string}`" : "string";
       let result2 = "";
       if (jsDocTitle && jsDocDescription) {
         result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
       }
-      result2 += `export type ${typeName} = Record<${keyType}, ${patternPropType}>;`;
+      result2 += `export type ${typeName} = ${recordType(keyType, patternPropType, options)};`;
       return result2;
     }
     if (!hasProperties2 && hasAdditionalProperties2 && normalizedSchema.additionalProperties) {
-      const additionalPropType = getTypeScriptType(normalizedSchema.additionalProperties);
+      const additionalPropType = getTypeScriptType(normalizedSchema.additionalProperties, options);
       let result2 = "";
       if (jsDocTitle && jsDocDescription) {
         result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
       }
       result2 += `export type ${typeName} = {
-  [key: string]: ${additionalPropType};
+  ${readonlyPrefix}[key: string]: ${additionalPropType};
 };`;
       return result2;
     }
@@ -766,8 +769,8 @@ var generateTypeDefinition = (schema, typeName) => {
       const propSchema = schemaProps[key];
       const isRequired = normalizedSchema.required?.includes(key) ?? false;
       const optional = isRequired ? "" : "?";
-      const propType = getTypeScriptType(propSchema);
-      const quotedKey = safeKey(key);
+      const propType = getTypeScriptType(propSchema, options);
+      const quotedKey = readonlyPrefix + safeKey(key);
       if (!isFirstProp)
         properties += `
 `;
@@ -784,12 +787,12 @@ var generateTypeDefinition = (schema, typeName) => {
     if (isSchemaObject2(schema) && Array.isArray(schema.allOf)) {
       for (const entry of schema.allOf) {
         if (isSchemaObject2(entry) && entry.$ref) {
-          allOfIntersections.push(refToName2(entry.$ref));
+          allOfIntersections.push(refToName2(entry.$ref, options.typeSuffix));
         }
       }
     }
     if (isSchemaObject2(schema) && typeof schema.$ref === "string" && schema.$ref.startsWith("#")) {
-      allOfIntersections.push(refToName2(schema.$ref));
+      allOfIntersections.push(refToName2(schema.$ref, options.typeSuffix));
     }
     let result = "";
     if (jsDocTitle && jsDocDescription) {
@@ -799,7 +802,7 @@ var generateTypeDefinition = (schema, typeName) => {
 ` + properties + `
 }`;
     if (conditionalThenRef) {
-      typeBody += " & " + refToName2(conditionalThenRef);
+      typeBody += " & " + refToName2(conditionalThenRef, options.typeSuffix);
     }
     for (const intersectionType of allOfIntersections) {
       typeBody += " & " + intersectionType;
@@ -873,9 +876,9 @@ var hasMultipleOf = (schema) => {
 };
 
 // src/generators/collect-validator-imports.ts
-var buildImport = (ref) => {
+var buildImport = (ref, suffix) => {
   const filename = refToFilename(ref);
-  const typeName = refToName(ref);
+  const typeName = refToName(ref, suffix);
   const validatorName = `validate${typeName}`;
   return `import { type ${typeName}, ${validatorName} } from './${filename}'`;
 };
@@ -920,6 +923,7 @@ var collectDirectRefs = (schema) => {
 var collectValidatorImports = (schema, options) => {
   const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : null;
   const rootSchema = options?.rootSchema;
+  const typeSuffix = options?.typeSuffix ?? "";
   const refs = collectDirectRefs(schema);
   const seen = new Set;
   const imports = [];
@@ -936,7 +940,7 @@ var collectValidatorImports = (schema, options) => {
     }
     seen.add(filename);
     const importRef = ref.endsWith("-or-reference") ? ref.replace("-or-reference", "") : ref;
-    imports.push(buildImport(importRef));
+    imports.push(buildImport(importRef, typeSuffix));
   }
   return imports;
 };
@@ -990,7 +994,7 @@ var wrongTypeCondition = (accessor, type) => {
       return "";
   }
 };
-var generatePropertyChecks = (key, propSchema, isRequired) => {
+var generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
   if (!isSchemaObject3(propSchema))
     return [];
   const raw = `obj[${JSON.stringify(key)}]`;
@@ -998,7 +1002,7 @@ var generatePropertyChecks = (key, propSchema, isRequired) => {
   const lines = [];
   if (hasRef(propSchema)) {
     const ref = propSchema.$ref;
-    const vName = validatorName(refToName(ref));
+    const vName = validatorName(refToName(ref, suffix));
     if (isRequired) {
       lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
       lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
@@ -1124,7 +1128,7 @@ var generatePropertyChecks = (key, propSchema, isRequired) => {
     if (t === "array" && hasItems(propSchema)) {
       const itemSchema = propSchema.items;
       if (hasRef(itemSchema)) {
-        const vName = validatorName(refToName(itemSchema.$ref));
+        const vName = validatorName(refToName(itemSchema.$ref, suffix));
         lines.push(`  if (Array.isArray(${raw})) {`);
         lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`);
         lines.push(`      const _ir = ${vName}(${raw}[_i], \`${path.slice(1, -1)}/${key}/\${_i}\`)`);
@@ -1148,19 +1152,19 @@ var generatePropertyChecks = (key, propSchema, isRequired) => {
   }
   return lines;
 };
-var generateObjectValidator = (schema, typeName) => {
+var generateObjectValidator = (schema, typeName, suffix) => {
   const vName = validatorName(typeName);
   const required = new Set(hasRequired(schema) ? schema.required : []);
   const properties = hasProperties(schema) ? schema.properties : {};
   const propertyLines = [];
   for (const [key, propSchema] of Object.entries(properties)) {
-    const checks = generatePropertyChecks(key, propSchema, required.has(key));
+    const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix);
     if (checks.length > 0) {
       propertyLines.push(...checks);
     }
   }
   if (hasAdditionalProperties(schema) && isSchemaObject3(schema.additionalProperties) && hasRef(schema.additionalProperties)) {
-    const vRefName = validatorName(refToName(schema.additionalProperties.$ref));
+    const vRefName = validatorName(refToName(schema.additionalProperties.$ref, suffix));
     propertyLines.push(`  for (const _key of Object.keys(obj)) {`);
     propertyLines.push(`    if (${JSON.stringify(Object.keys(properties))}.includes(_key)) continue`);
     propertyLines.push(`    const _r = ${vRefName}(obj[_key as keyof typeof obj], \`\${_path}/\${_key}\`)`);
@@ -1185,14 +1189,14 @@ var generateObjectValidator = (schema, typeName) => {
   ].join(`
 `);
 };
-var generateScalarValidator = (schema, typeName) => {
+var generateScalarValidator = (schema, typeName, suffix) => {
   const vName = validatorName(typeName);
   if (!isSchemaObject3(schema)) {
     return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`
 `);
   }
   if (hasRef(schema)) {
-    const delegateName = validatorName(refToName(schema.$ref));
+    const delegateName = validatorName(refToName(schema.$ref, suffix));
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  return ${delegateName}(input, _path)`,
@@ -1241,7 +1245,7 @@ var generateScalarValidator = (schema, typeName) => {
     const branches = schema.oneOf.map((branch, i) => {
       if (!hasRef(branch))
         return null;
-      const bName = validatorName(refToName(branch.$ref));
+      const bName = validatorName(refToName(branch.$ref, suffix));
       return `  const _r${i} = ${bName}(input, _path)
   if (_r${i} === true) return true`;
     }).filter(Boolean).join(`
@@ -1262,54 +1266,72 @@ var generateScalarValidator = (schema, typeName) => {
     if (t === "string") {
       if (hasPattern(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`);
-        constraintLines.push(`    return { valid: false, errors: [{ message: 'must match pattern ${schema.pattern}', path: _path }] }`);
+        constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`);
         constraintLines.push(`  }`);
       }
       if (hasMinLength(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && input.length < ${schema.minLength}) {`);
-        constraintLines.push(`    return { valid: false, errors: [{ message: 'must have at least ${schema.minLength} characters', path: _path }] }`);
+        constraintLines.push(`    errors.push({ message: 'must have at least ${schema.minLength} characters', path: _path })`);
         constraintLines.push(`  }`);
       }
       if (hasMaxLength(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && input.length > ${schema.maxLength}) {`);
-        constraintLines.push(`    return { valid: false, errors: [{ message: 'must have at most ${schema.maxLength} characters', path: _path }] }`);
+        constraintLines.push(`    errors.push({ message: 'must have at most ${schema.maxLength} characters', path: _path })`);
         constraintLines.push(`  }`);
       }
     }
-    const body = constraintLines.length > 0 ? `
-` + constraintLines.join(`
-`) + `
-` : "";
-    return wrongType ? [
+    if (!wrongType) {
+      return [
+        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+        `  return true`,
+        `}`
+      ].join(`
+`);
+    }
+    if (constraintLines.length === 0) {
+      return [
+        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `  if (${wrongType}) {`,
+        `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+        `  }`,
+        `  return true`,
+        `}`
+      ].join(`
+`);
+    }
+    return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (${wrongType}) {`,
       `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
       `  }`,
-      body,
-      `  return true`,
+      `  const errors: ValidationError[] = []`,
+      constraintLines.join(`
+`),
+      `  return errors.length > 0 ? { valid: false, errors } : true`,
       `}`
     ].join(`
-`) : [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`
 `);
   }
   return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`
 `);
 };
-var generateValidatorFunction = (schema, typeName) => {
+var generateValidatorFunction = (schema, typeName, suffix = "") => {
   if (isObjectSchema2(schema)) {
-    return generateObjectValidator(schema, typeName);
+    return generateObjectValidator(schema, typeName, suffix);
   }
-  return generateScalarValidator(schema, typeName);
+  return generateScalarValidator(schema, typeName, suffix);
 };
 
 // src/generators/generate-files.ts
 var generateValidatorFile = (schema, typeName, options) => {
+  const typeSuffix = options?.typeSuffix ?? "";
   const refImports = collectValidatorImports(schema, {
     selfRef: options?.selfRef,
-    rootSchema: options?.rootSchema
+    rootSchema: options?.rootSchema,
+    typeSuffix
   });
-  const typeDefinition = generateTypeDefinition(schema, typeName);
-  const validatorFunction = generateValidatorFunction(schema, typeName);
+  const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
+  const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix);
   let result = `import type { ValidationResult, ValidationError } from './validation-result'
 `;
   for (const imp of refImports) {
@@ -1346,7 +1368,7 @@ export type ValidationError = {
  */
 export type ValidationResult = true | { valid: false; errors: ValidationError[] }
 `;
-var buildValidatorSchema = async (rootSchema, rootTypeName) => {
+var buildValidatorSchema = async (rootSchema, rootTypeName, typeSuffix = "") => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
@@ -1355,7 +1377,8 @@ var buildValidatorSchema = async (rootSchema, rootTypeName) => {
   const dynamicRefMap = buildDynamicRefMap(rootSchema);
   const processedRootSchema = resolveDynamicRefs(rootSchema, dynamicRefMap);
   const rootContent = generateValidatorFile(processedRootSchema, rootTypeName, {
-    rootSchema
+    rootSchema,
+    typeSuffix
   });
   const rootFilename = rootTypeName.toLowerCase();
   if (rootFilename !== "validation-result") {
@@ -1374,12 +1397,13 @@ var buildValidatorSchema = async (rootSchema, rootTypeName) => {
       console.warn(`Warning: Could not resolve ref: ${ref}`);
       continue;
     }
-    const typeName = refToName(ref);
+    const typeName = refToName(ref, typeSuffix);
     const filename = refToFilename(ref);
     const processedSchema = resolveDynamicRefs(resolvedSchema, dynamicRefMap);
     const content = generateValidatorFile(processedSchema, typeName, {
       selfRef: ref,
-      rootSchema
+      rootSchema,
+      typeSuffix
     });
     if (filename !== "validation-result" && !processedFilenames.has(filename)) {
       processedFilenames.add(filename);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.4.0"
+    "@amritk/helpers": "0.6.0"
   },
   "devDependencies": {
     "@scalar/openapi-parser": "^0.26.1"

package/src/generators/build-schema.test.ts

@@ -74,7 +74,7 @@ describe('build-schema', () => {
     const documentFile = files.find((f) => f.filename === 'document.ts')
 
     expect(documentFile?.content).toContain("from './info'")
-    expect(documentFile?.content).toContain('validateInfoObject')
+    expect(documentFile?.content).toContain('validateInfo')
   })
 
   it('generates a valid index.ts with re-exports', async () => {
@@ -136,7 +136,7 @@ describe('build-schema', () => {
     const infoFile = files.find((f) => f.filename === 'info.ts')
 
     expect(documentFile?.content).toContain('validateDocument')
-    expect(infoFile?.content).toContain('validateInfoObject')
+    expect(infoFile?.content).toContain('validateInfo')
 
     // Cross-check: @scalar/openapi-parser says a complete document is valid
     const validDoc = { openapi: '3.1.0', info: { title: 'API', version: '1.0' }, paths: {} }

package/src/generators/build-schema.ts

@@ -55,7 +55,11 @@ export type ValidationResult = true | { valid: false; errors: ValidationError[]
  * // files → [{ filename: 'document.ts', content: '...' }, { filename: 'info.ts', ... }, ...]
  * ```
  */
-export const buildValidatorSchema = async (rootSchema: JSONSchema, rootTypeName: string): Promise<GeneratedFile[]> => {
+export const buildValidatorSchema = async (
+  rootSchema: JSONSchema,
+  rootTypeName: string,
+  typeSuffix = '',
+): Promise<GeneratedFile[]> => {
   rootSchema = upgradeDraft07Schema(rootSchema as Record<string, unknown>) as JSONSchema
 
   const files: GeneratedFile[] = []
@@ -69,6 +73,7 @@ export const buildValidatorSchema = async (rootSchema: JSONSchema, rootTypeName:
   const processedRootSchema = resolveDynamicRefs(rootSchema, dynamicRefMap)
   const rootContent = generateValidatorFile(processedRootSchema, rootTypeName, {
     rootSchema: rootSchema as Record<string, unknown>,
+    typeSuffix,
   })
   const rootFilename = rootTypeName.toLowerCase()
 
@@ -91,12 +96,13 @@ export const buildValidatorSchema = async (rootSchema: JSONSchema, rootTypeName:
       continue
     }
 
-    const typeName = refToName(ref)
+    const typeName = refToName(ref, typeSuffix)
     const filename = refToFilename(ref)
     const processedSchema = resolveDynamicRefs(resolvedSchema as JSONSchema, dynamicRefMap)
     const content = generateValidatorFile(processedSchema, typeName, {
       selfRef: ref,
       rootSchema: rootSchema as Record<string, unknown>,
+      typeSuffix,
     })
 
     if (filename !== 'validation-result' && !processedFilenames.has(filename)) {

package/src/generators/collect-validator-imports.ts

@@ -18,15 +18,20 @@ type CollectValidatorImportsOptions = {
    * are excluded from the import list (they were never generated as files).
    */
   readonly rootSchema?: Record<string, unknown> | undefined
+  /**
+   * Suffix appended to every type/validator name derived from a `$ref`. Must
+   * match the suffix used when generating the referenced files. Defaults to `''`.
+   */
+  readonly typeSuffix?: string
 }
 
 /**
  * Generates an import statement for a single $ref, importing both the type
  * and the validator function from the ref's generated file.
  */
-const buildImport = (ref: string): string => {
+const buildImport = (ref: string, suffix: string): string => {
   const filename = refToFilename(ref)
-  const typeName = refToName(ref)
+  const typeName = refToName(ref, suffix)
   const validatorName = `validate${typeName}`
   return `import { type ${typeName}, ${validatorName} } from './${filename}'`
 }
@@ -94,12 +99,13 @@ const collectDirectRefs = (schema: JSONSchema): string[] => {
  * ```typescript
  * const schema = { properties: { contact: { $ref: '#/$defs/contact' } } }
  * collectValidatorImports(schema)
- * // ["import { type ContactObject, validateContactObject } from './contact-object'"]
+ * // ["import { type Contact, validateContact } from './contact'"]
  * ```
  */
 export const collectValidatorImports = (schema: JSONSchema, options?: CollectValidatorImportsOptions): string[] => {
   const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : null
   const rootSchema = options?.rootSchema
+  const typeSuffix = options?.typeSuffix ?? ''
 
   const refs = collectDirectRefs(schema)
   const seen = new Set<string>()
@@ -121,7 +127,7 @@ export const collectValidatorImports = (schema: JSONSchema, options?: CollectVal
 
     // -or-reference unions import the base type's validator
     const importRef = ref.endsWith('-or-reference') ? ref.replace('-or-reference', '') : ref
-    imports.push(buildImport(importRef))
+    imports.push(buildImport(importRef, typeSuffix))
   }
 
   return imports

package/src/generators/generate-files.ts

@@ -17,6 +17,11 @@ type GenerateValidatorFileOptions = {
    * The root schema document. Used to filter out unresolvable refs.
    */
   readonly rootSchema?: Record<string, unknown>
+  /**
+   * Suffix appended to every type/validator name derived from a `$ref`.
+   * Defaults to `''` (no suffix).
+   */
+  readonly typeSuffix?: string
 }
 
 /**
@@ -46,13 +51,15 @@ export const generateValidatorFile = (
   typeName: string,
   options?: GenerateValidatorFileOptions,
 ): string => {
+  const typeSuffix = options?.typeSuffix ?? ''
   const refImports = collectValidatorImports(schema, {
     selfRef: options?.selfRef,
     rootSchema: options?.rootSchema,
+    typeSuffix,
   })
 
-  const typeDefinition = generateTypeDefinition(schema, typeName)
-  const validatorFunction = generateValidatorFunction(schema, typeName)
+  const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix })
+  const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix)
 
   let result = `import type { ValidationResult, ValidationError } from './validation-result'\n`
 

package/src/generators/generate-validator-function.test.ts

@@ -135,7 +135,7 @@ describe('generate-validator-function', () => {
     }
     const code = generateValidatorFunction(schema, 'Document')
 
-    expect(code).toContain('validateInfoObject(')
+    expect(code).toContain('validateInfo(')
     expect(code).toContain('"info" in obj')
   })
 
@@ -147,6 +147,18 @@ describe('generate-validator-function', () => {
     expect(code).toContain('must be string')
   })
 
+  it('accumulates all constraint errors for a scalar string schema', () => {
+    const schema = { type: 'string' as const, pattern: '^\\d+$', minLength: 2, maxLength: 4 }
+    const code = generateValidatorFunction(schema, 'Code')
+
+    // All three constraints push onto a shared errors array instead of returning early
+    expect(code).toContain('const errors: ValidationError[] = []')
+    expect(code).toContain("errors.push({ message: 'must match pattern")
+    expect(code).toContain("errors.push({ message: 'must have at least 2 characters'")
+    expect(code).toContain("errors.push({ message: 'must have at most 4 characters'")
+    expect(code).toContain('return errors.length > 0 ? { valid: false, errors } : true')
+  })
+
   it('returns true for empty object schemas', () => {
     const schema = { type: 'object' as const }
     const code = generateValidatorFunction(schema, 'Empty')

package/src/generators/generate-validator-function.ts

@@ -61,7 +61,7 @@ const wrongTypeCondition = (accessor: string, type: string): string => {
  * Generates validation lines for a single property in an object schema.
  * Handles $ref delegation, enum checks, type checks, and string/number constraints.
  */
-const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired: boolean): string[] => {
+const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired: boolean, suffix: string): string[] => {
   if (!isSchemaObject(propSchema)) return []
 
   const raw = `obj[${JSON.stringify(key)}]`
@@ -71,7 +71,7 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
   // $ref — delegate to the imported validator
   if (hasRef(propSchema)) {
     const ref = propSchema.$ref
-    const vName = validatorName(refToName(ref))
+    const vName = validatorName(refToName(ref, suffix))
 
     if (isRequired) {
       lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`)
@@ -218,7 +218,7 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
     if (t === 'array' && hasItems(propSchema)) {
       const itemSchema = propSchema.items
       if (hasRef(itemSchema)) {
-        const vName = validatorName(refToName(itemSchema.$ref))
+        const vName = validatorName(refToName(itemSchema.$ref, suffix))
         lines.push(`  if (Array.isArray(${raw})) {`)
         lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`)
         lines.push(`      const _ir = ${vName}(${raw}[_i], \`${path.slice(1, -1)}/${key}/\${_i}\`)`)
@@ -250,7 +250,7 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
  * Generates a validator function body for an object schema, checking each
  * property's presence and type and collecting all errors.
  */
-const generateObjectValidator = (schema: JSONSchema, typeName: string): string => {
+const generateObjectValidator = (schema: JSONSchema, typeName: string, suffix: string): string => {
   const vName = validatorName(typeName)
   const required = new Set(hasRequired(schema) ? schema.required : [])
   const properties = hasProperties(schema) ? schema.properties : {}
@@ -258,7 +258,7 @@ const generateObjectValidator = (schema: JSONSchema, typeName: string): string =
   const propertyLines: string[] = []
 
   for (const [key, propSchema] of Object.entries(properties)) {
-    const checks = generatePropertyChecks(key, propSchema as JSONSchema, required.has(key))
+    const checks = generatePropertyChecks(key, propSchema as JSONSchema, required.has(key), suffix)
     if (checks.length > 0) {
       propertyLines.push(...checks)
     }
@@ -270,7 +270,7 @@ const generateObjectValidator = (schema: JSONSchema, typeName: string): string =
     isSchemaObject(schema.additionalProperties) &&
     hasRef(schema.additionalProperties)
   ) {
-    const vRefName = validatorName(refToName(schema.additionalProperties.$ref))
+    const vRefName = validatorName(refToName(schema.additionalProperties.$ref, suffix))
     propertyLines.push(`  for (const _key of Object.keys(obj)) {`)
     propertyLines.push(`    if (${JSON.stringify(Object.keys(properties))}.includes(_key)) continue`)
     propertyLines.push(`    const _r = ${vRefName}(obj[_key as keyof typeof obj], \`\${_path}/\${_key}\`)`)
@@ -297,7 +297,7 @@ const generateObjectValidator = (schema: JSONSchema, typeName: string): string =
 /**
  * Generates a validator function for a non-object schema (primitive, array, enum, $ref).
  */
-const generateScalarValidator = (schema: JSONSchema, typeName: string): string => {
+const generateScalarValidator = (schema: JSONSchema, typeName: string, suffix: string): string => {
   const vName = validatorName(typeName)
 
   if (!isSchemaObject(schema)) {
@@ -308,7 +308,7 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
 
   // Top-level $ref — delegate entirely
   if (hasRef(schema)) {
-    const delegateName = validatorName(refToName(schema.$ref))
+    const delegateName = validatorName(refToName(schema.$ref, suffix))
     return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  return ${delegateName}(input, _path)`,
@@ -361,7 +361,7 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
     const branches = schema.oneOf
       .map((branch, i) => {
         if (!hasRef(branch)) return null
-        const bName = validatorName(refToName((branch as { $ref: string }).$ref))
+        const bName = validatorName(refToName((branch as { $ref: string }).$ref, suffix))
         return `  const _r${i} = ${bName}(input, _path)\n  if (_r${i} === true) return true`
       })
       .filter(Boolean)
@@ -386,42 +386,54 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
     if (t === 'string') {
       if (hasPattern(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`)
-        constraintLines.push(
-          `    return { valid: false, errors: [{ message: 'must match pattern ${schema.pattern}', path: _path }] }`,
-        )
+        constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`)
         constraintLines.push(`  }`)
       }
       if (hasMinLength(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && input.length < ${schema.minLength}) {`)
         constraintLines.push(
-          `    return { valid: false, errors: [{ message: 'must have at least ${schema.minLength} characters', path: _path }] }`,
+          `    errors.push({ message: 'must have at least ${schema.minLength} characters', path: _path })`,
         )
         constraintLines.push(`  }`)
       }
       if (hasMaxLength(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && input.length > ${schema.maxLength}) {`)
         constraintLines.push(
-          `    return { valid: false, errors: [{ message: 'must have at most ${schema.maxLength} characters', path: _path }] }`,
+          `    errors.push({ message: 'must have at most ${schema.maxLength} characters', path: _path })`,
         )
         constraintLines.push(`  }`)
       }
     }
 
-    const body = constraintLines.length > 0 ? '\n' + constraintLines.join('\n') + '\n' : ''
-
-    return wrongType
-      ? [
-          `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-          `  if (${wrongType}) {`,
-          `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
-          `  }`,
-          body,
-          `  return true`,
-          `}`,
-        ].join('\n')
-      : [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(
-          '\n',
-        )
+    if (!wrongType) {
+      return [
+        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+        `  return true`,
+        `}`,
+      ].join('\n')
+    }
+
+    if (constraintLines.length === 0) {
+      return [
+        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `  if (${wrongType}) {`,
+        `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+        `  }`,
+        `  return true`,
+        `}`,
+      ].join('\n')
+    }
+
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (${wrongType}) {`,
+      `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+      `  }`,
+      `  const errors: ValidationError[] = []`,
+      constraintLines.join('\n'),
+      `  return errors.length > 0 ? { valid: false, errors } : true`,
+      `}`,
+    ].join('\n')
   }
 
   return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(
@@ -451,10 +463,10 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
  * // }
  * ```
  */
-export const generateValidatorFunction = (schema: JSONSchema, typeName: string): string => {
+export const generateValidatorFunction = (schema: JSONSchema, typeName: string, suffix = ''): string => {
   if (isObjectSchema(schema)) {
-    return generateObjectValidator(schema, typeName)
+    return generateObjectValidator(schema, typeName, suffix)
   }
 
-  return generateScalarValidator(schema, typeName)
+  return generateScalarValidator(schema, typeName, suffix)
 }