@amritk/generate-parsers 0.1.0 → 0.3.0

package/src/generators/generate-schema-checks.test.ts

@@ -0,0 +1,322 @@
+import { describe, expect, it } from 'vitest'
+
+import { generateSchemaChecks } from './generate-schema-checks'
+
+describe('generate-schema-checks', () => {
+  it('returns empty checks for a schema without type and no inferrable keywords', () => {
+    const result = generateSchemaChecks('value', { description: 'no type' })
+    expect(result).toEqual([])
+  })
+
+  it.todo('infers object type from properties keyword', () => {
+    const result = generateSchemaChecks('value', {
+      properties: { id: { type: 'string' } },
+    })
+    expect(result).toEqual(['typeof value === "object" && value !== null && !Array.isArray(value)'])
+  })
+
+  it.todo('infers object type from required keyword', () => {
+    const result = generateSchemaChecks('value', {
+      required: ['id', 'name'],
+    })
+    expect(result).toEqual([
+      'typeof value === "object" && value !== null && !Array.isArray(value)',
+      '"id" in value',
+      '"name" in value',
+    ])
+  })
+
+  it.todo('infers array type from items keyword', () => {
+    const result = generateSchemaChecks('value', {
+      items: { type: 'string' },
+    })
+    expect(result).toEqual(['Array.isArray(value)'])
+  })
+
+  it.todo('infers array type from minItems/maxItems keywords', () => {
+    const result = generateSchemaChecks('value', {
+      minItems: 1,
+      maxItems: 10,
+    })
+    expect(result).toEqual(['Array.isArray(value)', 'value.length >= 1', 'value.length <= 10'])
+  })
+
+  it.todo('infers string type from minLength keyword', () => {
+    const result = generateSchemaChecks('value', {
+      minLength: 1,
+    })
+    expect(result).toEqual(['typeof value === "string"', 'value.length >= 1'])
+  })
+
+  it.todo('infers string type from pattern keyword', () => {
+    const result = generateSchemaChecks('value', {
+      pattern: '^[a-z]+$',
+    })
+    expect(result).toEqual(['typeof value === "string"', '/^[a-z]+$/.test(value)'])
+  })
+
+  it.todo('infers number type from minimum keyword', () => {
+    const result = generateSchemaChecks('value', {
+      minimum: 0,
+    })
+    expect(result).toEqual(['typeof value === "number"', 'value >= 0'])
+  })
+
+  it.todo('infers number type from multipleOf keyword', () => {
+    const result = generateSchemaChecks('value', {
+      multipleOf: 5,
+    })
+    expect(result).toEqual(['typeof value === "number"', 'value % 5 === 0'])
+  })
+
+  it.todo('infers boolean type from const boolean value', () => {
+    const result = generateSchemaChecks('value', {
+      const: true,
+    })
+    expect(result).toEqual(['typeof value === "boolean"'])
+  })
+
+  it.todo('infers null type from const null value', () => {
+    const result = generateSchemaChecks('value', {
+      const: null,
+    })
+    expect(result).toEqual(['value === null'])
+  })
+
+  it.todo('infers null type from all-null enum', () => {
+    const result = generateSchemaChecks('value', {
+      enum: [null, null],
+    })
+    expect(result).toEqual(['[null,null].includes(value as never)'])
+  })
+
+  // When object and array keywords tie, object wins (matches inferSchemaType priority)
+  it.todo('prefers object over array when keyword scores tie', () => {
+    const result = generateSchemaChecks('value', {
+      minProperties: 1,
+      minItems: 1,
+    })
+    expect(result).toContain('typeof value === "object" && value !== null && !Array.isArray(value)')
+    expect(result).not.toContain('Array.isArray(value)')
+  })
+
+  // Array keywords outnumber string keywords so array wins
+  it.todo('selects highest scoring type when multiple keyword categories present', () => {
+    const result = generateSchemaChecks('value', {
+      minItems: 1,
+      maxItems: 3,
+      minLength: 2,
+    })
+    expect(result).toContain('Array.isArray(value)')
+    expect(result).not.toContain('typeof value === "string"')
+  })
+
+  it.todo('applies inferred type constraints alongside explicit enum check', () => {
+    const result = generateSchemaChecks('value', {
+      minimum: 0,
+      maximum: 10,
+      enum: [0, 5, 10],
+    })
+    expect(result).toContain('typeof value === "number"')
+    expect(result).toContain('value >= 0')
+    expect(result).toContain('value <= 10')
+    expect(result).toContain('[0,5,10].includes(value as never)')
+  })
+
+  it('returns empty checks for a boolean schema', () => {
+    const result = generateSchemaChecks('value', true)
+    expect(result).toEqual([])
+  })
+
+  it('generates typeof check for string type', () => {
+    const result = generateSchemaChecks('value', { type: 'string' })
+    expect(result).toEqual(['typeof value === "string"'])
+  })
+
+  it('generates string check with pattern', () => {
+    const result = generateSchemaChecks('value', { type: 'string', pattern: '^[a-z]+$' })
+    expect(result).toEqual(['typeof value === "string"', '/^[a-z]+$/.test(value)'])
+  })
+
+  it('generates string check with minLength', () => {
+    const result = generateSchemaChecks('value', { type: 'string', minLength: 1 })
+    expect(result).toEqual(['typeof value === "string"', 'value.length >= 1'])
+  })
+
+  it('generates string check with maxLength', () => {
+    const result = generateSchemaChecks('value', { type: 'string', maxLength: 100 })
+    expect(result).toEqual(['typeof value === "string"', 'value.length <= 100'])
+  })
+
+  it('generates string check with both min and max length', () => {
+    const result = generateSchemaChecks('value', { type: 'string', minLength: 1, maxLength: 50 })
+    expect(result).toEqual(['typeof value === "string"', 'value.length >= 1', 'value.length <= 50'])
+  })
+
+  it('generates typeof check for number type', () => {
+    const result = generateSchemaChecks('value', { type: 'number' })
+    expect(result).toEqual(['typeof value === "number"'])
+  })
+
+  it('generates number check with minimum', () => {
+    const result = generateSchemaChecks('value', { type: 'number', minimum: 0 })
+    expect(result).toEqual(['typeof value === "number"', 'value >= 0'])
+  })
+
+  it('generates number check with maximum', () => {
+    const result = generateSchemaChecks('value', { type: 'number', maximum: 100 })
+    expect(result).toEqual(['typeof value === "number"', 'value <= 100'])
+  })
+
+  it('generates number check with exclusiveMinimum', () => {
+    const result = generateSchemaChecks('value', { type: 'number', exclusiveMinimum: 0 })
+    expect(result).toEqual(['typeof value === "number"', 'value > 0'])
+  })
+
+  it('generates number check with exclusiveMaximum', () => {
+    const result = generateSchemaChecks('value', { type: 'number', exclusiveMaximum: 100 })
+    expect(result).toEqual(['typeof value === "number"', 'value < 100'])
+  })
+
+  it('generates number check with multipleOf', () => {
+    const result = generateSchemaChecks('value', { type: 'number', multipleOf: 5 })
+    expect(result).toEqual(['typeof value === "number"', 'value % 5 === 0'])
+  })
+
+  it('generates typeof check for integer type', () => {
+    const result = generateSchemaChecks('value', { type: 'integer' })
+    expect(result).toEqual(['typeof value === "number"'])
+  })
+
+  it('generates integer check with all numeric constraints', () => {
+    const result = generateSchemaChecks('value', {
+      type: 'integer',
+      minimum: 1,
+      maximum: 10,
+      exclusiveMinimum: 0,
+      exclusiveMaximum: 11,
+      multipleOf: 2,
+    })
+    expect(result).toEqual([
+      'typeof value === "number"',
+      'value >= 1',
+      'value <= 10',
+      'value > 0',
+      'value < 11',
+      'value % 2 === 0',
+    ])
+  })
+
+  it('generates typeof check for boolean type', () => {
+    const result = generateSchemaChecks('value', { type: 'boolean' })
+    expect(result).toEqual(['typeof value === "boolean"'])
+  })
+
+  it('generates Array.isArray check for array type', () => {
+    const result = generateSchemaChecks('value', { type: 'array' })
+    expect(result).toEqual(['Array.isArray(value)'])
+  })
+
+  it('generates array check with minItems', () => {
+    const result = generateSchemaChecks('value', { type: 'array', minItems: 1 })
+    expect(result).toEqual(['Array.isArray(value)', 'value.length >= 1'])
+  })
+
+  it('generates array check with maxItems', () => {
+    const result = generateSchemaChecks('value', { type: 'array', maxItems: 10 })
+    expect(result).toEqual(['Array.isArray(value)', 'value.length <= 10'])
+  })
+
+  it('generates array check with uniqueItems true', () => {
+    const result = generateSchemaChecks('value', { type: 'array', uniqueItems: true })
+    expect(result).toEqual(['Array.isArray(value)', 'new Set(value).size === value.length'])
+  })
+
+  it('does not add uniqueItems check when uniqueItems is false', () => {
+    const result = generateSchemaChecks('value', { type: 'array', uniqueItems: false })
+    expect(result).toEqual(['Array.isArray(value)'])
+  })
+
+  it('generates object type check', () => {
+    const result = generateSchemaChecks('value', { type: 'object' })
+    expect(result).toEqual(['typeof value === "object" && value !== null && !Array.isArray(value)'])
+  })
+
+  it('generates object check with required properties', () => {
+    const result = generateSchemaChecks('value', {
+      type: 'object',
+      required: ['name', 'age'],
+    })
+    expect(result).toEqual([
+      'typeof value === "object" && value !== null && !Array.isArray(value)',
+      '"name" in value',
+      '"age" in value',
+    ])
+  })
+
+  it('generates object check with minProperties', () => {
+    const result = generateSchemaChecks('value', { type: 'object', minProperties: 1 })
+    expect(result).toEqual([
+      'typeof value === "object" && value !== null && !Array.isArray(value)',
+      'Object.keys(value).length >= 1',
+    ])
+  })
+
+  it('generates object check with maxProperties', () => {
+    const result = generateSchemaChecks('value', { type: 'object', maxProperties: 5 })
+    expect(result).toEqual([
+      'typeof value === "object" && value !== null && !Array.isArray(value)',
+      'Object.keys(value).length <= 5',
+    ])
+  })
+
+  it('generates object check with additionalProperties false', () => {
+    const result = generateSchemaChecks('value', {
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      additionalProperties: false,
+    })
+    expect(result).toEqual([
+      'typeof value === "object" && value !== null && !Array.isArray(value)',
+      'Object.keys(value).every(k => ["name"].includes(k))',
+    ])
+  })
+
+  it('does not add additionalProperties check when additionalProperties is true', () => {
+    const result = generateSchemaChecks('value', {
+      type: 'object',
+      properties: { name: { type: 'string' } },
+      additionalProperties: true,
+    })
+    expect(result).toEqual(['typeof value === "object" && value !== null && !Array.isArray(value)'])
+  })
+
+  it('does not add additionalProperties check when no properties defined', () => {
+    const result = generateSchemaChecks('value', {
+      type: 'object',
+      additionalProperties: false,
+    })
+    expect(result).toEqual(['typeof value === "object" && value !== null && !Array.isArray(value)'])
+  })
+
+  it('skips required check when required array is empty', () => {
+    const result = generateSchemaChecks('value', { type: 'object', required: [] })
+    expect(result).toEqual(['typeof value === "object" && value !== null && !Array.isArray(value)'])
+  })
+
+  it('appends enum check regardless of type', () => {
+    const result = generateSchemaChecks('value', { type: 'string', enum: ['a', 'b'] })
+    expect(result).toContain('typeof value === "string"')
+    expect(result).toContain('["a","b"].includes(value as never)')
+  })
+
+  it('does not append enum check when enum is empty', () => {
+    const result = generateSchemaChecks('value', { type: 'string', enum: [] })
+    expect(result).toEqual(['typeof value === "string"'])
+  })
+
+  it('uses the provided accessor in all checks', () => {
+    const result = generateSchemaChecks('input?.name', { type: 'string', minLength: 1 })
+    expect(result).toEqual(['typeof input?.name === "string"', 'input?.name.length >= 1'])
+  })
+})

package/src/generators/generate-schema-checks.ts

@@ -0,0 +1,114 @@
+import {
+  hasAdditionalProperties,
+  hasEnum,
+  hasExclusiveMaximum,
+  hasExclusiveMinimum,
+  hasMaxItems,
+  hasMaximum,
+  hasMaxLength,
+  hasMaxProperties,
+  hasMinItems,
+  hasMinimum,
+  hasMinLength,
+  hasMinProperties,
+  hasMultipleOf,
+  hasPattern,
+  hasProperties,
+  hasRequired,
+  hasType,
+  hasUniqueItems,
+} from '@amritk/helpers/schema-guards'
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
+
+import { generateEnumCheck } from './generate-enum-check'
+
+/**
+ * Generates validation checks for a single schema (used in union validation).
+ */
+export const generateSchemaChecks = (accessor: string, schema: JSONSchema): string[] => {
+  const checks: string[] = []
+
+  if (!hasType(schema)) {
+    return checks
+  }
+
+  switch (schema.type) {
+    case 'string': {
+      checks.push(`typeof ${accessor} === "string"`)
+      if (hasPattern(schema)) {
+        checks.push(`/${schema.pattern.replace(/\//g, '\\/')}/.test(${accessor})`)
+      }
+      if (hasMinLength(schema)) {
+        checks.push(`${accessor}.length >= ${schema.minLength}`)
+      }
+      if (hasMaxLength(schema)) {
+        checks.push(`${accessor}.length <= ${schema.maxLength}`)
+      }
+      break
+    }
+    case 'number':
+    case 'integer':
+      checks.push(`typeof ${accessor} === "number"`)
+      if (hasMinimum(schema)) {
+        checks.push(`${accessor} >= ${schema.minimum}`)
+      }
+      if (hasMaximum(schema)) {
+        checks.push(`${accessor} <= ${schema.maximum}`)
+      }
+      if (hasExclusiveMinimum(schema)) {
+        checks.push(`${accessor} > ${schema.exclusiveMinimum}`)
+      }
+      if (hasExclusiveMaximum(schema)) {
+        checks.push(`${accessor} < ${schema.exclusiveMaximum}`)
+      }
+      if (hasMultipleOf(schema)) {
+        checks.push(`${accessor} % ${schema.multipleOf} === 0`)
+      }
+      break
+    case 'boolean':
+      checks.push(`typeof ${accessor} === "boolean"`)
+      break
+    case 'array':
+      checks.push(`Array.isArray(${accessor})`)
+      if (hasMinItems(schema)) {
+        checks.push(`${accessor}.length >= ${schema.minItems}`)
+      }
+      if (hasMaxItems(schema)) {
+        checks.push(`${accessor}.length <= ${schema.maxItems}`)
+      }
+      if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+        checks.push(`new Set(${accessor}).size === ${accessor}.length`)
+      }
+      break
+    case 'object': {
+      checks.push(`typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`)
+      // Check required properties exist
+      if (hasRequired(schema) && schema.required.length > 0) {
+        for (const requiredKey of schema.required) {
+          checks.push(`"${requiredKey}" in ${accessor}`)
+        }
+      }
+      // Check minProperties
+      if (hasMinProperties(schema)) {
+        checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`)
+      }
+      // Check maxProperties
+      if (hasMaxProperties(schema)) {
+        checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`)
+      }
+      // Check additionalProperties
+      if (hasAdditionalProperties(schema) && schema.additionalProperties === false && hasProperties(schema)) {
+        const allowedKeys = Object.keys(schema.properties)
+        const allowedKeysStr = JSON.stringify(allowedKeys)
+        checks.push(`Object.keys(${accessor}).every(k => ${allowedKeysStr}.includes(k))`)
+      }
+      break
+    }
+  }
+
+  if (hasEnum(schema) && schema.enum.length > 0) {
+    checks.push(generateEnumCheck(accessor, schema.enum))
+  }
+
+  return checks
+}

package/src/generators/generate-strict-assertion.ts

@@ -0,0 +1,210 @@
+import { safeAccessor } from '@amritk/helpers/safe-accessor'
+import {
+  hasEnum,
+  hasExclusiveMaximum,
+  hasExclusiveMinimum,
+  hasMaximum,
+  hasMaxLength,
+  hasMinimum,
+  hasMinLength,
+  hasMultipleOf,
+  hasPattern,
+  hasProperties,
+  hasRef,
+  hasRequired,
+  hasType,
+  isSchemaObject,
+} from '@amritk/helpers/schema-guards'
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
+
+/**
+ * Returns the inline condition that is true when `accessor` is the wrong type
+ * for the given JSON Schema primitive type.
+ */
+const wrongTypeCondition = (accessor: string, type: string): string | null => {
+  switch (type) {
+    case 'string':
+      return `typeof ${accessor} !== "string"`
+    case 'number':
+    case 'integer':
+      return `typeof ${accessor} !== "number"`
+    case 'boolean':
+      return `typeof ${accessor} !== "boolean"`
+    case 'array':
+      return `!Array.isArray(${accessor})`
+    case 'object':
+      return `!isObject(${accessor})`
+    default:
+      return null
+  }
+}
+
+/**
+ * Maps a JSON Schema type to the label used in error messages.
+ * `integer` collapses to `number` since both are validated via `typeof === "number"`.
+ */
+const typeLabel = (type: string): string => (type === 'integer' ? 'number' : type)
+
+/**
+ * Escapes special regex characters in a pattern string for use in a regex literal.
+ */
+const escapeRegexPattern = (pattern: string): string => {
+  return pattern.replace(/\\/g, '\\\\').replace(/\//g, '\\/')
+}
+
+/**
+ * Generates strict-mode constraint checks for a typed property
+ * (pattern, length, min/max, multipleOf).
+ */
+const generateConstraintChecks = (acc: string, propSchema: JSONSchema, typeName: string, key: string): string[] => {
+  if (!isSchemaObject(propSchema) || !hasType(propSchema)) return []
+  const t = propSchema.type as string
+  const lines: string[] = []
+
+  if (t === 'string') {
+    if (hasPattern(propSchema)) {
+      const pattern = escapeRegexPattern(propSchema.pattern)
+      lines.push(
+        `  if (typeof ${acc} === "string" && !/${pattern}/.test(${acc})) throw new Error('[${typeName}] field "${key}" must match pattern ${propSchema.pattern}');`,
+      )
+    }
+    if (hasMinLength(propSchema)) {
+      lines.push(
+        `  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) throw new Error('[${typeName}] field "${key}" must have at least ${propSchema.minLength} characters');`,
+      )
+    }
+    if (hasMaxLength(propSchema)) {
+      lines.push(
+        `  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) throw new Error('[${typeName}] field "${key}" must have at most ${propSchema.maxLength} characters');`,
+      )
+    }
+  }
+
+  if (t === 'number' || t === 'integer') {
+    if (hasMinimum(propSchema)) {
+      lines.push(
+        `  if (typeof ${acc} === "number" && ${acc} < ${propSchema.minimum}) throw new Error('[${typeName}] field "${key}" must be >= ${propSchema.minimum}');`,
+      )
+    }
+    if (hasMaximum(propSchema)) {
+      lines.push(
+        `  if (typeof ${acc} === "number" && ${acc} > ${propSchema.maximum}) throw new Error('[${typeName}] field "${key}" must be <= ${propSchema.maximum}');`,
+      )
+    }
+    if (hasExclusiveMinimum(propSchema)) {
+      lines.push(
+        `  if (typeof ${acc} === "number" && ${acc} <= ${propSchema.exclusiveMinimum}) throw new Error('[${typeName}] field "${key}" must be > ${propSchema.exclusiveMinimum}');`,
+      )
+    }
+    if (hasExclusiveMaximum(propSchema)) {
+      lines.push(
+        `  if (typeof ${acc} === "number" && ${acc} >= ${propSchema.exclusiveMaximum}) throw new Error('[${typeName}] field "${key}" must be < ${propSchema.exclusiveMaximum}');`,
+      )
+    }
+    if (hasMultipleOf(propSchema)) {
+      lines.push(
+        `  if (typeof ${acc} === "number" && ${acc} % ${propSchema.multipleOf} !== 0) throw new Error('[${typeName}] field "${key}" must be a multiple of ${propSchema.multipleOf}');`,
+      )
+    }
+  }
+
+  return lines
+}
+
+/**
+ * Generates strict-mode lines for a single property of an object schema.
+ * Properties with a `$ref` are skipped here — the nested parser handles its own
+ * strict check when called from the parent's slow path.
+ */
+const generatePropertyAssertion = (
+  key: string,
+  propSchema: JSONSchema,
+  isRequired: boolean,
+  typeName: string,
+): string[] => {
+  const acc = safeAccessor('input', key)
+  const lines: string[] = []
+
+  if (isRequired) {
+    lines.push(
+      `  if (!(${JSON.stringify(key)} in input)) throw new Error('[${typeName}] missing required property "${key}"');`,
+    )
+  }
+
+  if (!isSchemaObject(propSchema)) return lines
+  if (hasRef(propSchema)) return lines
+
+  if (hasEnum(propSchema)) {
+    const allowed = JSON.stringify(propSchema.enum)
+    const label = (propSchema.enum as unknown[]).map((v) => JSON.stringify(v)).join(', ')
+    if (isRequired) {
+      lines.push(
+        `  if (!(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`,
+      )
+    } else {
+      lines.push(
+        `  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`,
+      )
+    }
+    return lines
+  }
+
+  if (hasType(propSchema)) {
+    const t = propSchema.type as string
+    const wrongType = wrongTypeCondition(acc, t)
+    if (wrongType) {
+      if (isRequired) {
+        lines.push(
+          `  if (${wrongType}) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`,
+        )
+      } else {
+        lines.push(
+          `  if (${acc} !== undefined && (${wrongType})) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`,
+        )
+      }
+    }
+    lines.push(...generateConstraintChecks(acc, propSchema, typeName, key))
+  }
+
+  return lines
+}
+
+/**
+ * Generates strict-mode assertions for the body of an object parser.
+ * Throws on:
+ *   - non-object input
+ *   - missing required property
+ *   - property of the wrong primitive type
+ *   - enum / pattern / length / min / max / multipleOf violations
+ *
+ * Properties with a `$ref` are validated by the nested parser's own strict
+ * check when that parser is invoked downstream.
+ */
+export const generateObjectStrictAssertion = (schema: JSONSchema, typeName: string): string[] => {
+  const lines: string[] = []
+  lines.push(
+    `  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`,
+  )
+
+  if (!hasProperties(schema) || !isSchemaObject(schema)) return lines
+
+  const required = new Set<string>(hasRequired(schema) ? schema.required : [])
+
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    lines.push(...generatePropertyAssertion(key, propSchema, required.has(key), typeName))
+  }
+
+  return lines
+}
+
+/**
+ * Generates a single strict-mode assertion line for a non-object scalar parser.
+ * Returns null when the schema has no type information to assert on.
+ */
+export const generateScalarStrictAssertion = (schema: JSONSchema, typeName: string): string | null => {
+  if (!isSchemaObject(schema) || !hasType(schema)) return null
+  const t = schema.type as string
+  const wrongType = wrongTypeCondition('input', t)
+  if (!wrongType) return null
+  return `  if (${wrongType}) throw new Error(\`[${typeName}] expected ${typeLabel(t)}, got \${input === null ? "null" : typeof input}\`);`
+}