@amritk/generate-validators 0.5.1 → 0.6.0

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

@@ -1 +1 @@
-{"version":3,"file":"generate-validator-function.d.ts","sourceRoot":"","sources":["../../src/generators/generate-validator-function.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAqajE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,yBAAyB,WAAY,UAAU,YAAY,MAAM,sBAAgB,MAM7F,CAAA"}
+{"version":3,"file":"generate-validator-function.d.ts","sourceRoot":"","sources":["../../src/generators/generate-validator-function.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AA+ejE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,yBAAyB,WAAY,UAAU,YAAY,MAAM,sBAAgB,MAM7F,CAAA"}

package/dist/generators/generate-validator-function.js

@@ -1,6 +1,7 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
 import { refToName } from '@amritk/helpers/ref-to-name';
-import { hasAdditionalProperties, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { hasAdditionalProperties, hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasType, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
 /**
  * Derives the validator function name from a type name.
  * e.g. "InfoObject" → "validateInfoObject"
@@ -14,6 +15,18 @@ const typeofString = (type) => {
         return 'number';
     return type;
 };
+/**
+ * Generates the inline condition that is TRUE when `accessor` does NOT equal the
+ * `const` value. Primitives compare with `!==`; objects/arrays compare by their
+ * canonical JSON serialization (sufficient for the literal, fixed shapes `const`
+ * is used for).
+ */
+const constMismatchCondition = (accessor, value) => {
+    if (value === null || typeof value !== 'object') {
+        return `${accessor} !== ${JSON.stringify(value)}`;
+    }
+    return `JSON.stringify(${accessor}) !== ${JSON.stringify(JSON.stringify(value))}`;
+};
 /**
  * Generates the inline condition that is TRUE when a value is the wrong type.
  */
@@ -98,6 +111,24 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
         }
         return lines;
     }
+    // const — value must equal the fixed value exactly
+    if (hasConst(propSchema)) {
+        const mismatch = constMismatchCondition(raw, propSchema.const);
+        const msg = JSON.stringify(`must be ${JSON.stringify(propSchema.const)}`);
+        if (isRequired) {
+            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  } else if (${mismatch}) {`);
+            lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
+            lines.push(`  }`);
+        }
+        else {
+            lines.push(`  if (${raw} !== undefined && ${mismatch}) {`);
+            lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
+            lines.push(`  }`);
+        }
+        return lines;
+    }
     // enum
     if (hasEnum(propSchema)) {
         const allowed = JSON.stringify(propSchema.enum);
@@ -138,8 +169,10 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
         // String constraints
         if (t === 'string') {
             if (hasPattern(propSchema)) {
-                lines.push(`  if (typeof ${raw} === 'string' && !/${propSchema.pattern}/.test(${raw})) {`);
-                lines.push(`    errors.push({ message: 'must match pattern ${propSchema.pattern}', path: ${path} })`);
+                const re = escapeRegexPattern(propSchema.pattern);
+                const msg = JSON.stringify(`must match pattern ${propSchema.pattern}`);
+                lines.push(`  if (typeof ${raw} === 'string' && !/${re}/.test(${raw})) {`);
+                lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
                 lines.push(`  }`);
             }
             if (hasMinLength(propSchema)) {
@@ -236,6 +269,30 @@ const generateObjectValidator = (schema, typeName, suffix) => {
         propertyLines.push(`    if (_r !== true) errors.push(..._r.errors)`);
         propertyLines.push(`  }`);
     }
+    // dependentRequired — when a trigger property is present, its dependencies must be too.
+    if (hasDependentRequired(schema)) {
+        for (const [trigger, deps] of Object.entries(schema.dependentRequired)) {
+            if (!Array.isArray(deps))
+                continue;
+            for (const dep of deps) {
+                const msg = JSON.stringify(`must have property '${dep}' when '${trigger}' is present`);
+                propertyLines.push(`  if (${JSON.stringify(trigger)} in obj && !(${JSON.stringify(dep)} in obj)) {`);
+                propertyLines.push(`    errors.push({ message: ${msg}, path: _path })`);
+                propertyLines.push(`  }`);
+            }
+        }
+    }
+    // propertyNames with a pattern — every key must match. (Only the pattern form
+    // is emitted; a $ref/complex propertyNames schema is left to runtime validation.)
+    if (hasPropertyNames(schema) && isSchemaObject(schema.propertyNames) && hasPattern(schema.propertyNames)) {
+        const re = escapeRegexPattern(schema.propertyNames.pattern);
+        const msg = JSON.stringify(`property name must match pattern ${schema.propertyNames.pattern}`);
+        propertyLines.push(`  for (const _name of Object.keys(obj)) {`);
+        propertyLines.push(`    if (!/${re}/.test(_name)) {`);
+        propertyLines.push(`      errors.push({ message: ${msg}, path: \`\${_path}/\${_name}\` })`);
+        propertyLines.push(`    }`);
+        propertyLines.push(`  }`);
+    }
     const body = propertyLines.length > 0 ? '\n' + propertyLines.join('\n') + '\n' : '';
     return [
         `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
@@ -291,6 +348,19 @@ const generateScalarValidator = (schema, typeName, suffix) => {
             `}`,
         ].join('\n');
     }
+    // Top-level const
+    if (hasConst(schema)) {
+        const mismatch = constMismatchCondition('input', schema.const);
+        const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `  if (${mismatch}) {`,
+            `    return { valid: false, errors: [{ message: ${msg}, path: _path }] }`,
+            `  }`,
+            `  return true`,
+            `}`,
+        ].join('\n');
+    }
     // Top-level enum
     if (hasEnum(schema)) {
         const allowed = JSON.stringify(schema.enum);
@@ -330,8 +400,10 @@ const generateScalarValidator = (schema, typeName, suffix) => {
         const constraintLines = [];
         if (t === 'string') {
             if (hasPattern(schema)) {
-                constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`);
-                constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`);
+                const re = escapeRegexPattern(schema.pattern);
+                const msg = JSON.stringify(`must match pattern ${schema.pattern}`);
+                constraintLines.push(`  if (typeof input === 'string' && !/${re}/.test(input)) {`);
+                constraintLines.push(`    errors.push({ message: ${msg}, path: _path })`);
                 constraintLines.push(`  }`);
             }
             if (hasMinLength(schema)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.5.1",
+  "version": "0.6.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.7.1"
+    "@amritk/helpers": "0.8.0"
   },
   "devDependencies": {
     "@scalar/openapi-parser": "^0.26.1"

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

@@ -104,6 +104,77 @@ describe('generate-validator-function', () => {
     expect(code).toContain('.test(')
   })
 
+  it('escapes forward slashes in a pattern so the emitted regex literal compiles', () => {
+    const schema = {
+      type: 'object' as const,
+      properties: { date: { type: 'string' as const, pattern: '^\\d{4}/\\d{2}/\\d{2}$' } },
+      required: ['date'],
+    }
+    const code = generateValidatorFunction(schema, 'Event')
+
+    // The bare slashes are escaped (\/) and the digit classes keep their single
+    // backslash, so the literal is valid and means what the pattern says.
+    expect(code).toContain('!/^\\d{4}\\/\\d{2}\\/\\d{2}$/.test(')
+    // Sanity check: the emitted regex source actually parses and matches.
+    const emitted = /!\/(.+)\/\.test\(/.exec(code)?.[1]
+    expect(emitted).toBeDefined()
+    expect(new RegExp(emitted as string).test('2024/01/02')).toBe(true)
+  })
+
+  it('checks a const property for an exact value', () => {
+    const schema = {
+      type: 'object' as const,
+      properties: { kind: { const: 'user' }, version: { const: 2 } },
+      required: ['kind'],
+    }
+    const code = generateValidatorFunction(schema, 'Record')
+
+    expect(code).toContain('obj["kind"] !== "user"')
+    expect(code).toContain('obj["version"] !== 2')
+    expect(code).toContain('must be \\"user\\"')
+  })
+
+  it('checks a const object property by canonical JSON', () => {
+    const schema = {
+      type: 'object' as const,
+      properties: { meta: { const: { a: 1 } } },
+    }
+    const code = generateValidatorFunction(schema, 'Record')
+
+    expect(code).toContain('JSON.stringify(obj["meta"]) !== ')
+  })
+
+  it('generates a top-level const validator', () => {
+    const code = generateValidatorFunction({ const: 'fixed' }, 'Tag')
+
+    expect(code).toContain('input !== "fixed"')
+    expect(code).toContain('must be \\"fixed\\"')
+  })
+
+  it('generates dependentRequired presence checks', () => {
+    const schema = {
+      type: 'object' as const,
+      properties: { creditCard: { type: 'number' as const }, billingAddress: { type: 'string' as const } },
+      dependentRequired: { creditCard: ['billingAddress'] },
+    }
+    const code = generateValidatorFunction(schema, 'Payment')
+
+    expect(code).toContain('"creditCard" in obj && !("billingAddress" in obj)')
+    expect(code).toContain("must have property 'billingAddress' when 'creditCard' is present")
+  })
+
+  it('generates a propertyNames pattern check over every key', () => {
+    const schema = {
+      type: 'object' as const,
+      propertyNames: { pattern: '^[a-z]+$' },
+    }
+    const code = generateValidatorFunction(schema, 'Dict')
+
+    expect(code).toContain('for (const _name of Object.keys(obj))')
+    expect(code).toContain('!/^[a-z]+$/.test(_name)')
+    expect(code).toContain('property name must match pattern')
+  })
+
   it('generates min/maxLength checks', () => {
     const schema = {
       type: 'object' as const,
@@ -153,7 +224,9 @@ describe('generate-validator-function', () => {
 
     // 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 match pattern')
+    // The pattern body keeps its backslash (\d), so the emitted literal is a digit class.
+    expect(code).toContain('!/^\\d+$/.test(input)')
     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')

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

@@ -1,7 +1,10 @@
+import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern'
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension'
 import { refToName } from '@amritk/helpers/ref-to-name'
 import {
   hasAdditionalProperties,
+  hasConst,
+  hasDependentRequired,
   hasEnum,
   hasExclusiveMaximum,
   hasExclusiveMinimum,
@@ -14,6 +17,7 @@ import {
   hasOneOf,
   hasPattern,
   hasProperties,
+  hasPropertyNames,
   hasRef,
   hasRequired,
   hasType,
@@ -36,6 +40,19 @@ const typeofString = (type: string): string => {
   return type
 }
 
+/**
+ * Generates the inline condition that is TRUE when `accessor` does NOT equal the
+ * `const` value. Primitives compare with `!==`; objects/arrays compare by their
+ * canonical JSON serialization (sufficient for the literal, fixed shapes `const`
+ * is used for).
+ */
+const constMismatchCondition = (accessor: string, value: unknown): string => {
+  if (value === null || typeof value !== 'object') {
+    return `${accessor} !== ${JSON.stringify(value)}`
+  }
+  return `JSON.stringify(${accessor}) !== ${JSON.stringify(JSON.stringify(value))}`
+}
+
 /**
  * Generates the inline condition that is TRUE when a value is the wrong type.
  */
@@ -123,6 +140,24 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
     return lines
   }
 
+  // const — value must equal the fixed value exactly
+  if (hasConst(propSchema)) {
+    const mismatch = constMismatchCondition(raw, propSchema.const)
+    const msg = JSON.stringify(`must be ${JSON.stringify(propSchema.const)}`)
+    if (isRequired) {
+      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`)
+      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`)
+      lines.push(`  } else if (${mismatch}) {`)
+      lines.push(`    errors.push({ message: ${msg}, path: ${path} })`)
+      lines.push(`  }`)
+    } else {
+      lines.push(`  if (${raw} !== undefined && ${mismatch}) {`)
+      lines.push(`    errors.push({ message: ${msg}, path: ${path} })`)
+      lines.push(`  }`)
+    }
+    return lines
+  }
+
   // enum
   if (hasEnum(propSchema)) {
     const allowed = JSON.stringify(propSchema.enum)
@@ -165,8 +200,10 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
     // String constraints
     if (t === 'string') {
       if (hasPattern(propSchema)) {
-        lines.push(`  if (typeof ${raw} === 'string' && !/${propSchema.pattern}/.test(${raw})) {`)
-        lines.push(`    errors.push({ message: 'must match pattern ${propSchema.pattern}', path: ${path} })`)
+        const re = escapeRegexPattern(propSchema.pattern)
+        const msg = JSON.stringify(`must match pattern ${propSchema.pattern}`)
+        lines.push(`  if (typeof ${raw} === 'string' && !/${re}/.test(${raw})) {`)
+        lines.push(`    errors.push({ message: ${msg}, path: ${path} })`)
         lines.push(`  }`)
       }
       if (hasMinLength(propSchema)) {
@@ -278,6 +315,31 @@ const generateObjectValidator = (schema: JSONSchema, typeName: string, suffix: s
     propertyLines.push(`  }`)
   }
 
+  // dependentRequired — when a trigger property is present, its dependencies must be too.
+  if (hasDependentRequired(schema)) {
+    for (const [trigger, deps] of Object.entries(schema.dependentRequired)) {
+      if (!Array.isArray(deps)) continue
+      for (const dep of deps) {
+        const msg = JSON.stringify(`must have property '${dep}' when '${trigger}' is present`)
+        propertyLines.push(`  if (${JSON.stringify(trigger)} in obj && !(${JSON.stringify(dep)} in obj)) {`)
+        propertyLines.push(`    errors.push({ message: ${msg}, path: _path })`)
+        propertyLines.push(`  }`)
+      }
+    }
+  }
+
+  // propertyNames with a pattern — every key must match. (Only the pattern form
+  // is emitted; a $ref/complex propertyNames schema is left to runtime validation.)
+  if (hasPropertyNames(schema) && isSchemaObject(schema.propertyNames) && hasPattern(schema.propertyNames)) {
+    const re = escapeRegexPattern(schema.propertyNames.pattern)
+    const msg = JSON.stringify(`property name must match pattern ${schema.propertyNames.pattern}`)
+    propertyLines.push(`  for (const _name of Object.keys(obj)) {`)
+    propertyLines.push(`    if (!/${re}/.test(_name)) {`)
+    propertyLines.push(`      errors.push({ message: ${msg}, path: \`\${_path}/\${_name}\` })`)
+    propertyLines.push(`    }`)
+    propertyLines.push(`  }`)
+  }
+
   const body = propertyLines.length > 0 ? '\n' + propertyLines.join('\n') + '\n' : ''
 
   return [
@@ -342,6 +404,20 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string, suffix: s
     ].join('\n')
   }
 
+  // Top-level const
+  if (hasConst(schema)) {
+    const mismatch = constMismatchCondition('input', schema.const)
+    const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`)
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (${mismatch}) {`,
+      `    return { valid: false, errors: [{ message: ${msg}, path: _path }] }`,
+      `  }`,
+      `  return true`,
+      `}`,
+    ].join('\n')
+  }
+
   // Top-level enum
   if (hasEnum(schema)) {
     const allowed = JSON.stringify(schema.enum)
@@ -385,8 +461,10 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string, suffix: s
 
     if (t === 'string') {
       if (hasPattern(schema)) {
-        constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`)
-        constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`)
+        const re = escapeRegexPattern(schema.pattern)
+        const msg = JSON.stringify(`must match pattern ${schema.pattern}`)
+        constraintLines.push(`  if (typeof input === 'string' && !/${re}/.test(input)) {`)
+        constraintLines.push(`    errors.push({ message: ${msg}, path: _path })`)
         constraintLines.push(`  }`)
       }
       if (hasMinLength(schema)) {