@amritk/generate-parsers 0.7.2 → 0.8.0

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

@@ -1,330 +0,0 @@
-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'])
-  })
-
-  it('returns an instanceof check for an x-mjst instanceOf node', () => {
-    expect(generateSchemaChecks('value', { 'x-mjst': { instanceOf: 'Date' } })).toEqual(['value instanceof Date'])
-  })
-
-  it('returns a typeof check for an x-mjst bigint node', () => {
-    expect(generateSchemaChecks('value', { 'x-mjst': { primitive: 'bigint' } })).toEqual(['typeof value === "bigint"'])
-  })
-})

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

@@ -1,128 +0,0 @@
-import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern'
-import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension'
-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[] = []
-
-  // x-mjst instanceOf nodes validate purely by instance check (no native type).
-  const instanceOf = getMjstInstanceOf(schema)
-  if (instanceOf) {
-    return [`${accessor} instanceof ${instanceOf}`]
-  }
-
-  // x-mjst primitive nodes (e.g. bigint) validate purely by typeof check.
-  const primitive = getMjstPrimitive(schema)
-  if (primitive) {
-    return [`typeof ${accessor} === "${primitive}"`]
-  }
-
-  if (!hasType(schema)) {
-    return checks
-  }
-
-  switch (schema.type) {
-    case 'string': {
-      checks.push(`typeof ${accessor} === "string"`)
-      if (hasPattern(schema)) {
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.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.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { generateObjectStrictAssertion, generateScalarStrictAssertion } from './generate-strict-assertion'
-
-describe('generate-strict-assertion x-mjst instanceOf', () => {
-  it('asserts instanceof for a required Date property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { createdAt: { 'x-mjst': { instanceOf: 'Date' } } },
-      required: ['createdAt'],
-    }
-    const lines = generateObjectStrictAssertion(schema, 'Event').join('\n')
-
-    expect(lines).toContain('missing required property "createdAt"')
-    expect(lines).toContain('!(input.createdAt instanceof Date)')
-    expect(lines).toContain('field "createdAt" must be Date')
-  })
-
-  it('guards undefined before asserting instanceof for an optional Date property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { createdAt: { 'x-mjst': { instanceOf: 'Date' } } },
-    }
-    const lines = generateObjectStrictAssertion(schema, 'Event').join('\n')
-
-    expect(lines).toContain('input.createdAt !== undefined && !(input.createdAt instanceof Date)')
-  })
-
-  it('asserts instanceof for a top-level Date schema', () => {
-    const line = generateScalarStrictAssertion({ 'x-mjst': { instanceOf: 'Date' } }, 'When')
-
-    expect(line).toContain('!(input instanceof Date)')
-    expect(line).toContain('expected Date')
-  })
-})
-
-describe('generate-strict-assertion x-mjst primitive', () => {
-  it('asserts typeof bigint for a required property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { balance: { 'x-mjst': { primitive: 'bigint' } } },
-      required: ['balance'],
-    }
-    const lines = generateObjectStrictAssertion(schema, 'Account').join('\n')
-
-    expect(lines).toContain('missing required property "balance"')
-    expect(lines).toContain('typeof input.balance !== "bigint"')
-    expect(lines).toContain('field "balance" must be bigint')
-  })
-
-  it('guards undefined before asserting typeof for an optional bigint property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { balance: { 'x-mjst': { primitive: 'bigint' } } },
-    }
-    const lines = generateObjectStrictAssertion(schema, 'Account').join('\n')
-
-    expect(lines).toContain('input.balance !== undefined && typeof input.balance !== "bigint"')
-  })
-
-  it('asserts typeof for a top-level bigint schema', () => {
-    const line = generateScalarStrictAssertion({ 'x-mjst': { primitive: 'bigint' } }, 'Big')
-
-    expect(line).toContain('typeof input !== "bigint"')
-    expect(line).toContain('expected bigint')
-  })
-})