@amritk/generate-validators 0.3.0 → 0.3.1

package/dist/index.js

@@ -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);
   }
@@ -569,29 +570,29 @@ 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)}`;
     }
@@ -600,20 +601,20 @@ var getUnbrandedType = (schema) => {
   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 += `
 `;
@@ -1262,34 +1265,50 @@ 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(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "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.5.0"
   },
   "devDependencies": {
     "@scalar/openapi-parser": "^0.26.1"

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

@@ -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

@@ -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(